DEV Community: Nelson Hernández

How to send emails with FastAPI

Nelson Hernández — Wed, 18 Jan 2023 16:09:57 +0000

In this example we will send an email through a POST type endpoint that will receive the information from the recipient

pip install fastapi uvicorn

# main.py
from fastapi import FastAPI
from fastapi.exceptions import HTTPException
from pydantic import BaseModel
from smtplib import SMTP_SSL
from email.mime.text import MIMEText

app = FastAPI()

OWN_EMAIL = "hello@example.com"
OWN_EMAIL_PASSWORD = "your-password"

class EmailBody(BaseModel):
    to: str
    subject: str
    message: str

@app.post("/email")
async def send_email(body: EmailBody):
    try:
        msg = MIMEText(body.message, "html")
        msg['Subject'] = body.subject
        msg['From'] = f'Denolyrics <{OWN_EMAIL}>'
        msg['To'] = body.to

        port = 465  # For SSL

        # Connect to the email server
        server = SMTP_SSL("mail.privateemail.com", port)
        server.login(OWN_EMAIL, OWN_EMAIL_PASSWORD)

        # Send the email
        server.send_message(msg)
        server.quit()
        return {"message": "Email sent successfully"}

    except Exception as e:
        raise HTTPException(status_code=500, detail=e)

Run project

uvicorn main:app --reload --port 8000

How to reusing workflows with Gitlab CI/CD

Nelson Hernández — Sun, 11 Dec 2022 02:53:22 +0000

To reuse a workflow in GitLab CI/CD, you can use the include keyword in your .gitlab-ci.yml file. This keyword allows you to include the contents of another .gitlab-ci.yml file in your current file, effectively allowing you to reuse a workflow across multiple projects or repositories.

To use the include keyword, you first need to create a file containing the workflow you want to reuse. This file should contain the .gitlab-ci.yml syntax for defining your workflow, including any jobs, stages, and dependencies.

.gitlab-ci/node.yml

test:
  image: node:latest
  stage: test
  rules:
    - if: $CI_PIPELINE_SOURCE == "push"
  script:
    - node index.js

.gitlab-ci.yml

stages:
  - test
  - build

include:
  - local: /.gitlab-ci/node.yml

build:
  image: python:latest
  stage: build
  rules:
    - if: $CI_PIPELINE_SOURCE == "push"
  script:
    - python main.py

How to run Azure CLI with Docker

Nelson Hernández — Sun, 11 Dec 2022 02:39:33 +0000

To run the Azure CLI in a Docker container, you can use the following command:

Azure CLI

docker run -it --rm -v ${PWD}:/work -w /work --entrypoint /bin/sh mcr.microsoft.com/azure-cli:latest

Login to Azure

az login
az account list

Output

[
  {
    "cloudName": "AzureCloud",
    "id": "00000000-0000-0000-0000-000000000000",
    "isDefault": true,
    "name": "PAYG Subscription",
    "state": "Enabled",
    "tenantId": "00000000-0000-0000-0000-000000000000",
    "user": {
      "name": "user@example.com",
      "type": "user"
    }
  }
]

Set suscription

az account set --subscription="00000000-0000-0000-0000-000000000000"

How to update ECS Cluster automatically to new version task definition

Nelson Hernández — Sun, 11 Dec 2022 02:19:21 +0000

ECS is the Amazon Elastic Container Service, which allows you to run and manage Docker containers in the cloud. An ECS cluster is a group of EC2 instances that are running the ECS service and are used to host your Docker containers.

To update the version of a task definition in an ECS cluster, you can use the update-service command in the AWS CLI. This command allows you to specify a new task definition for a service and deploy it to your ECS cluster. For example, to update the task definition for a service named my-service with a new task definition named my-new-task-definition, you can use the following command:

aws ecs update-service --cluster my-cluster --service my-service --task-definition my-new-task-definition --force-new-deployment

This will update the task definition for the my-service service in the my-cluster cluster to use the my-new-task-definition task definition. The new task definition will be automatically deployed to the cluster, and the service will be updated to use the new task definition.

You can also specify additional options with the update-service command, such as the number of tasks to run for the service, or the deployment configuration for the service. For more information about the update-service command and all of its available options, see the AWS CLI documentation for ECS.

CRUD with Google Calendar API & Python

Nelson Hernández — Thu, 11 Aug 2022 02:02:00 +0000

Install dependencies

requirements.txt

google-api-python-client 
google-auth-httplib2 
google-auth-oauthlib

pip install -r requirements.txt

get_service.py

from os import path
import pickle
from google.auth.transport.requests import Request
from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient.discovery import build

# IF YOU MODIFY THE SCOPE DELETE THE TOKEN.TXT FILE

SCOPES = ['https://www.googleapis.com/auth/calendar.events',
          'https://www.googleapis.com/auth/calendar']

# THE TOKEN.TXT FILE STORES THE USER'S UPGRADE AND ACCESS TOKENS

# creds.json -> Credentials in Oauth0

def get_crendetials_google():
    # OPEN THE BROWSER TO AUTHORIZE
    flow = InstalledAppFlow.from_client_secrets_file("creds.json", SCOPES)
    creds = flow.run_local_server(port=0)

    # SAVE CREDENTIALS
    pickle.dump(creds, open("token.txt", "wb"))
    return creds

def get_calendar_service():
    creds = None
    if path.exists("token.txt"):
        creds = pickle.load(open("token.txt", "rb"))
    # IF IT EXPIRED WE REFRESH THE CREDENTIALS
    if not creds or not creds.valid:
        if creds and creds.expired and creds.refresh_token:
            creds.refresh(Request())
        else:
            creds = get_crendetials_google()
    service = build("calendar", "v3", credentials=creds)
    return service

creds.json

{
  "web": {
    "client_id": "",
    "project_id": "",
    "auth_uri": "",
    "token_uri": "",
    "auth_provider_x509_cert_url": "",
    "client_secret": "",
    "redirect_uris": ["http://localhost/"]
  }
}

Template JSON

{
  "summary": "Important event!",
  "location": "virtual event (Slack)",
  "description": "this is a description",
  "start": {
    "dateTime": "2021-12-10T10:00:00",
    "timeZone": "America/El_Salvador"
  },
  "end": {
    "dateTime": "2021-12-10T11:00:00",
    "timeZone": "America/El_Salvador"
  },
  "attendees": [{ "email": "email@gmail.com" }],
  "reminders": {
    "useDefault": false,
    "overrides": [
      { "method": "email", "minutes": 30 },
      { "method": "popup", "minutes": 10 }
    ]
  }
}

CRUD Google Calendar

calendar.py

from functions.get_service import get_calendar_service
from responses.response_json import response_json


service = get_calendar_service()


def create_event(template: dict):
    try:
        response = service.events().insert(calendarId="primary", body=template).execute()
        return response
    except Exception as e:
        return e.message


def get_event(eventId: str):
    try:
        response = service.events().get(calendarId="primary", eventId=eventId).execute()
        return response
    except Exception as e:
        return e.message


def delete_event(eventId: str):
    try:
        response = service.events().delete(calendarId="primary", eventId=eventId).execute()
        return response
    except Exception as e:
        return e.message


def update_event(eventId: str, template: dict):
    try:
        response = service.events().update(calendarId='primary',
                                           eventId=eventId, body=template).execute()
        return response
    except Exception as e:
        return e.message

How to deploy React + Nginx on AWS ECS (FARGATE)

Nelson Hernández — Thu, 11 Aug 2022 01:15:00 +0000

For this example I will use Vite to create the React project



npm create vite@latest frontend -- --template react-ts

Project folders



├── Dockerfile

├── frontend

│   ├── index.html

│   ├── package.json

│   ├── public

│   │   └── vite.svg

│   ├── src

│   │   ├── App.css

│   │   ├── App.tsx

│   │   ├── assets

│   │   │   └── react.svg

│   │   ├── index.css

│   │   ├── main.tsx

│   │   └── vite-env.d.ts

│   ├── tsconfig.json

│   ├── tsconfig.node.json

│   └── vite.config.ts

└── task-definition.json

Dockerfile



FROM nginx:latest

EXPOSE 80

# Frontend with production files

COPY  ./frontend/dist /usr/share/nginx/html

Publish Image to Docker Hub



# BUILD FRONTEND

cd ./frontend && npm run build && cd ..

docker login -u $DOCKER_USER -p $DOCKER_PASSWORD

docker build . -t $DOCKER_USER/react-app:latest

docker push $DOCKER_USER/react-app:latest

Task Definition

task-definition.json



{

  "containerDefinitions": [

    {

      "essential": true,

      "name": "app",

      "image": "nelsoncode/react-app:latest",

      "portMappings": [

        {

          "containerPort": 80,

          "hostPort": 80,

          "protocol": "tcp"

        }

      ]

    }

  ],

  "cpu": "256",

  "family": "fargate-task-definition",

  "memory": "512",

  "networkMode": "awsvpc",

  "runtimePlatform": {

    "operatingSystemFamily": "LINUX"

  },

  "requiresCompatibilities": ["FARGATE"]

}

Register Task Definition



export AWS_ACCESS_KEY_ID=

export AWS_SECRET_ACCESS_KEY=

export AWS_DEFAULT_REGION=us-west-1

aws ecs register-task-definition --cli-input-json file://task-definition.json

Create cluster (FARGATE)

Cluster name and create VPC

Select Type, Task definition, service name and number tasks

Configure network

Verify status

App in production

GitHub Repository

https://github.com/NelsonCode/aws-ecs-fargate-nginx-react

How to monitor PostgreSQL with Prometheus and Grafana | Docker

Nelson Hernández — Sat, 12 Feb 2022 02:26:00 +0000

For this example we will use Docker compose to be able to run all the services.

1.Docker Compose



version: "3.9"
services:
  grafana:
    image: grafana/grafana
    ports:
      - 3000:3000

  prometheus:
    image: prom/prometheus
    ports:
      - 9090:9090
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml:ro

  postgres:
    image: postgres:12
    ports:
      - 5432:5432
    volumes:
      - ./backup:/var/lib/postgresql/data
    environment:
      POSTGRES_PASSWORD: postgrespassword
      POSTGRES_DB: shop

  postgres-exporter:
    image: prometheuscommunity/postgres-exporter
    ports:
      - 9187:9187
    environment:
      DATA_SOURCE_NAME: "postgresql://postgres:postgrespassword@postgres:5432/shop?sslmode=disable"
    links:
      - postgres
      - prometheus

2.Prometheus File Settings (prometheus.yml)



global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: prometheus
    static_configs:
      - targets: ["localhost:9090"]
  - job_name: postgres-exporter
    static_configs:
      - targets: ["postgres-exporter:9187"]

3.Run Docker Compose



docker-compose up

4.Check status of Prometheus and PostgreSQL Exporter



http://localhost:9090/targets

5.Visit Grafana Dashboard

Default

User: admin
Password: admin



http://localhost:3000

6.Add data source

Save and test

7.Import PostgreSQL Dashboard for Prometheus

For this we will use a Dashboard created by the community

https://grafana.com/grafana/dashboards/9628

8.Import JSON or code

Code: 9628

9.Dashboard

Code of example (GitHub Gist)

https://gist.github.com/nelsoncode019/1c0f7930aab755223de7f971f3aca94b

How to version Docker images with GitLab CI/CD

Nelson Hernández — Fri, 11 Feb 2022 16:29:43 +0000

For this example we will use GitLab Container Registry and we will version the images by commit

Variables of GitLab

CI_REGISTRY_USER: User actually of GitLab
CI_REGISTRY_PASSWORD: Password actually of GitLab
CI_REGISTRY: "registry.gitlab.com"
CI_PROJECT_PATH: "gitlab-example/my-project"
CI_COMMIT_SHORT_SHA: Recent commit ID

1.Docker Login (GitLab Container registry)



docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY

2.Build image with ID COMMIT SHA



docker build . -t $CI_REGISTRY/$CI_PROJECT_PATH/$IMAGE_NAME:$CI_COMMIT_SHORT_SHA

3.Get ID from previous image



IMAGE_ID=$(docker images | grep $CI_REGISTRY/$CI_PROJECT_PATH\/$IMAGE_NAME | awk '{print $3}')

4.Retag image latest with digest from previous image



docker tag $IMAGE_ID $CI_REGISTRY/$CI_PROJECT_PATH/$IMAGE_NAME:latest

5.Push image latest and commit sha



docker push $CI_REGISTRY/$CI_PROJECT_PATH/$IMAGE_NAME:$CI_COMMIT_SHORT_SHA
docker push $CI_REGISTRY/$CI_PROJECT_PATH/$IMAGE_NAME:latest

6.Pipeline



build:
  image: docker:19.03.12
  stage: build
  services:
    - docker:19.03.12-dind
  rules:
    - if: $CI_PIPELINE_SOURCE == "push"
  variables:
    IMAGE_NAME: "my-app"
  script:
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY

    # BUILD IMAGE WITH COMMIT SHA

    - docker build . -t $CI_REGISTRY/$CI_PROJECT_PATH/$IMAGE_NAME:$CI_COMMIT_SHORT_SHA

    # RETAG IMAGE LATEST WITH DIGEST FROM PREVIOUS IMAGE 

    - IMAGE_ID=$(docker images | grep $CI_REGISTRY/$CI_PROJECT_PATH\/$IMAGE_NAME | awk '{print $3}')
    - docker tag $IMAGE_ID $CI_REGISTRY/$CI_PROJECT_PATH/$IMAGE_NAME:latest

    # PUSH IMAGE COMMIT SHA and LATEST

    - docker push $CI_REGISTRY/$CI_PROJECT_PATH/$IMAGE_NAME:$CI_COMMIT_SHORT_SHA
    - docker push $CI_REGISTRY/$CI_PROJECT_PATH/$IMAGE_NAME:latest

8.Images in Docker Registry

The latest image will always point to the latest version



68713c41   Published 1 minute ago
41.58 MiB  Digest: 2fd477a

latest     Published 1 minute ago
41.58 MiB  Digest: 2fd477a

How to monitor Redis with Prometheus and Grafana | Docker

Nelson Hernández — Sat, 05 Feb 2022 03:54:08 +0000

For this example we will use Docker compose to be able to run all the services

Docker Compose



version: "3.9"
services:
  grafana:
    image: grafana/grafana
    ports:
      - 3000:3000
  prometheus:
    image: prom/prometheus
    container_name: prometheus
    ports:
      - 9090:9090
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml:ro
  redis:
    image: "bitnami/redis:latest"
    ports:
      - 6379:6379
    environment:
      - REDIS_REPLICATION_MODE=master
      - REDIS_PASSWORD=my_master_password

  redis-exporter:
    image: oliver006/redis_exporter
    ports:
      - 9121:9121
    restart: unless-stopped
    environment:
      REDIS_ADDR: "redis:6379"
      REDIS_USER: null
      REDIS_PASSWORD: my_master_password
    links:
      - redis
      - prometheus

2.Prometheus File Settings (prometheus.yml)



global:
  scrape_interval:     15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: prometheus
    static_configs:
      - targets: ['localhost:9090']
  - job_name: redis-exporter
    static_configs:
      - targets: ['redis-exporter:9121']

3.Run Docker Compose



docker-compose up

4.Check status of Prometheus and Redis Exporter



http://localhost:9090/targets

5.Visit Grafana Dashboard

Default

User: admin
Password: admin



http://localhost:3000

6.Add data source

Save and test

7.Import Redis Dashboard for Prometheus

For this we will use a Dashboard created by the community

https://grafana.com/grafana/dashboards/763

8.Import JSON or code

Code: 763

JSON:
https://grafana.com/api/dashboards/763/revisions/3/download

9.Dashboard

Code of example (GitHub Gist)
https://gist.github.com/nelsoncode019/722727fdba11d846e39dc99f8064f7fe

AWS S3 with Python

Nelson Hernández — Thu, 03 Feb 2022 01:48:17 +0000

In this example we will see the basic operations that we can do with the cube and the files

Installation

pip install boto3

Connection

from boto3 import client
from os import getenv

clientS3 = client("s3",
                  aws_access_key_id=getenv("AWS_ACCESS_KEY_ID"),
                  aws_secret_access_key=getenv("AWS_SECRET_ACCESS_KEY"),
                  region_name=getenv("REGION_NAME")
                  )

Methods for buckets

Create bucket

from botocore.exceptions import ClientError

def create_bucket(bucket: str):
    try:
        response = clientS3.create_bucket(Bucket=bucket)
        return response
    except ClientError as e:
        return e.response["Error"]

Delete bucket

from botocore.exceptions import ClientError

def delete_bucket(bucket: str):
    try:
        response = clientS3.delete_bucket(Bucket=bucket)
        return response
    except ClientError as e:
        return e.response["Error"]

List all buckets

from botocore.exceptions import ClientError

def list_buckets():
    try:
        response = clientS3.list_buckets()
        return response
    except ClientError as e:
        return e.response["Error"]

Methods for files

Upload file

from typing import BinaryIO
from botocore.exceptions import ClientError

def upload_file(data: BinaryIO, bucket: str, filename: str):
    try:
        clientS3.upload_fileobj(Fileobj=data, Bucket=bucket, Key=filename)
        return "success"
    except ClientError as e:
        return e.response["Error"]

Get file

from typing import BinaryIO
from botocore.exceptions import ClientError

def get_file(bucket: str, filename: str):
    try:
        response = clientS3.get_object(Bucket=bucket, Key=filename)
        return response
    except ClientError as e:
        return e.response["Error"]

Delete file

from typing import BinaryIO
from botocore.exceptions import ClientError

def delete_file(bucket: str, filename: str):
    try:
        response = clientS3.delete_object(Bucket=bucket, Key=filename)
        return response
    except ClientError as e:
        return e.response["Error"]

Azure Blob Storage with JavaScript

Nelson Hernández — Wed, 05 Jan 2022 02:12:49 +0000

In this publication we will see the main methods to use with Azure Blob Storage this example was intended using Express JS



npm i @azure/storage-blob dotenv

Blob Service Client



import { BlobServiceClient } from "@azure/storage-blob";
import { config } from "dotenv";

config();

const blobService = BlobServiceClient.fromConnectionString(
  process.env.AZURE_STORAGE_CONNECTION_STRING
);

Connection String

Methods for blobs (Files)

Upload Blob



export const uploadBlob = async (req, res) => {
  try {
    const { container } = req.body;
    const { originalname, buffer } = req.file;

    const containerClient = blobService.getContainerClient(container);

    await containerClient.getBlockBlobClient(originalname).uploadData(buffer);

    res.json({ message: "success" });
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
};

Get Blob



export const getBlob = async (req, res) => {
  try {
    const { container, filename } = req.params;

    const containerClient = blobService.getContainerClient(container);

    res.header("Content-Type", "image/jpg");

    const response = await containerClient
      .getBlockBlobClient(filename)
      .downloadToBuffer();

    res.send(response);
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
};

Download Blob



export const downloadBlob = async (req, res) => {
  try {
    const { container, filename } = req.params;

    const containerClient = blobService.getContainerClient(container);

    const response = await containerClient
      .getBlockBlobClient(filename)
      .downloadToBuffer();

    res.send(response);
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
};

Delete Blob



export const deleteBlob = async (req, res) => {
  try {
    const { container, filename } = req.body;

    const containerClient = blobService.getContainerClient(container);

    const response = await containerClient
      .getBlockBlobClient(filename)
      .deleteIfExists();

    res.send(response);
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
};

Methods for Containers (Folders)

Create Container



export const createContainer = (req, res) => {
  try {
    const { container } = req.body;

    blobService.createContainer(container);

    res.json({ message: "success" });
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
};

Delete Container



export const deleteContainer = (req, res) => {
  try {
    const { container } = req.body;

    blobService.deleteContainer(container);

    res.json({ message: "success" });
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
};

List Containers



export const listContainer = async (req, res) => {
  try {
    let containers = [];
    for await (const container of blobService.listContainers()) {
      containers.push(container.name);
    }

    res.json({ containers });
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
};

Example in GitHub Gist
https://gist.github.com/nelsoncode019/5efaa894e26f0e7c8566ae3891dbb9a8

How to create Routing with Lit Library

Nelson Hernández — Tue, 14 Dec 2021 16:58:05 +0000

In this example we will see how to add a router with vaadin router

Vaadin router

A small, powerful and framework-agnostic client-side router for Web Components

npm i @vaadin/router

import { html, LitElement } from "lit";

export class Home extends LitElement {
  constructor() {
    super();
  }

  render() {
    return html`<div>
      <h1>Home</h1>
    </div>`;
  }
}
customElements.define("my-home", Home);

main.js

import { Router } from "@vaadin/router";

function initRouter() {
  const router = new Router(document.querySelector("#app"));

  router.setRoutes([
    {
      path: "/",
      component: "my-home",
      action: () => import("./pages/Home")
    },
    {
      path: "/about",
      component: "my-about",
      action: () => import("./pages/About"),
    },
  ]);
}

window.addEventListener("load", () => initRouter());

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <link rel="icon" type="image/svg+xml" href="/src/favicon.svg" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Vite + Lit App</title>
    <script type="module" src="src/main.js"></script>
  </head>
  <body>
    <div id="app"></div>
  </body>
</html>