DEV Community: Thiago Rodrigues

Criando um serviço de processamento de arquivos na AWS

Thiago Rodrigues — Sat, 04 May 2024 02:08:00 +0000

Hoje vamos estudar um caso sobre uma empresa que está enfrentando sérios problemas com sua infraestrutura atual para processar arquivos largos de CSV.

O problema:

"Olá, somos a empresa Marcão Soldas, especializada em soldas e esquadrias.

Atualmente, nosso setor financeiro utiliza planilhas do Excel para gerenciar as folhas de pagamento de funcionários, prestadores de serviços e contas a pagar.

Nossa equipe está habituada ao Excel e não deseja migrar para outro sistema devido a algumas comodidades oferecidas pelas planilhas.

No entanto, percebemos que, devido ao aumento no número de funcionários, as rotinas de pagamento estão se tornando longas e cansativas, podendo levar até 2 dias para concluirmos todos os pagamentos. Isso resulta em alguns funcionários recebendo antes que outros, causando insatisfação.

Precisamos de um sistema onde possamos enviar nossa planilha do Excel com o valor que cada funcionário deve receber, juntamente com sua chave PIX, para realizar os pagamentos automaticamente.

Não queremos gerenciar nenhum aspecto da aplicação, seja em nuvem ou na tecnologia escolhida. Vocês estão livres para escolher a melhor opção, mas não queremos gastar muito com custos de nuvem."

Após ler esse grande problema da Marcão Soldas, temos alguns pontos para resolver:

Criar um sistema que possibilite o envio de planilhas.
Um sistema que gerencie pagamentos e um gateway de pagamentos que possa realizar PIX.
Precisamos nos atentar aos custos que essa aplicação terá, já que nosso cliente não quer gastar muito.

Bom, tendo em vista todos esses requisitos, vamos parar para analisar alguns serviços de computação em nuvem da AWS.

Temos o EC2 e o Lambda. Porém, não queremos ter o trabalho de ficar orquestrando contêineres ou usar o Kubernetes para isso. Do outro lado, temos o Lambda, que executa pequenas funções em máquinas dedicadas e são auto-gerenciáveis, ou seja, não precisamos nos preocupar com infraestrutura ou escalabilidade.

Vamos usar também o API Gateway para receber o arquivo e salvá-lo em nosso bucket S3. Além disso, vamos utilizar o serviço de fila SQS para gerenciar os arquivos a serem processados e o SNS para ser um mensageiro quando precisarmos fazer um pagamento.

Então, nossa infraestrutura ficaria assim:

Vamos entender o que está acontecendo acima:

Nosso cliente envia seu arquivo para uma rota em nosso API Gateway, que salva esse arquivo em um bucket S3.
O Lambda recebe a notificação da criação desse arquivo e salva no DynamoDB algumas informações do arquivo, para servir como uma espécie de log.
Via DynamoDB Stream, enviamos uma notificação para outro Lambda, que será responsável por notificar nosso SQS para gerenciar uma fila de processamento de arquivos.
Nossa Lambda processa linha por linha do arquivo e captura as informações do recebedor, criando um tópico no SNS.
O SNS recebe a notificação e a envia para o Lambda responsável por criar a solicitação de pagamento no gateway.

Criando um cassino com AWS: Criando um ambiente de CI/CD

Thiago Rodrigues — Tue, 09 Apr 2024 20:10:50 +0000

Seja bem-vindo à nossa primeira etapa sobre como criar um cassino com a Amazon AWS. Ao final desta série, você aprenderá a utilizar serviços da AWS como Lambda, API Gateway, IAM, SNS e DynamoDB.

Iremos construir um cassino totalmente serverless, utilizando Lambda e API Gateway para gerenciar todas as nossas funções.

No próximo post, exploraremos um pouco mais sobre esse universo serverless. Mas, nesse primeiro momento, iremos aprender a configurar nosso ambiente de deploy, pois ele será inteiramente responsável por automatizar as coisas nos bastidores.

Para esta série de conteúdos, você precisará de:

Uma conta no Github
Uma conta na AWS

Configurando nosso ambiente de CI/CD

Vamos começar do princípio. Nosso ambiente de CI/CD é crucial para este tutorial, pois, como utilizaremos serverless para nossas funções, poderíamos ter uma carga muito pesada de funções para fazer deploy manualmente. Imagine ter que fazer uma por uma manualmente? Seria um trabalhão. Por isso, iremos configurar um ambiente de pipeline com as seguintes etapas:

Encontrar os nomes das funções dentro da pasta lambda_functions.
Configurar nosso ambiente de desenvolvimento com Python 3.9.
Instalar todas as dependências individuais de cada projeto.
Compactar e atualizar as funções Lambda.

Segue a estrutura do projeto:

-- .github/workflows/deploy.yml
-- lambda_functions
   -- lambda_function_1
   -- lambda_function_2

Dentro da nossa pasta .github/workflows, iremos criar um arquivo chamado deploy.yml e colar o código abaixo:

name: Update Function Code

on:
  push:
    branches:
      - master

jobs:
  get-filenames:
    runs-on: ubuntu-latest
    outputs:
      lambdaArray: ${{ steps.lambda_functions.outputs.lambdas }}
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
      - name: Get functions filenames
        id: lambda_functions
        run: |
          directories=$(tree lambda_functions -d -L 1 -J | jq -j -c '.[0].contents | map(.name)')
          echo ::set-output name=lambdas::${directories}

  update-code:
    needs: get-filenames
    strategy:
      matrix:
        lambda: ${{ fromJson(needs.get-filenames.outputs.lambdaArray) }}
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Setup Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.9'
          cache: 'pip'

      - name: Zip And Install Lambda functions
        run: |
          cd lambda_functions/${{matrix.lambda}}
          pip install -r requirements.txt -t .
          zip -r ${{matrix.lambda}}.zip .

      - name: Set up AWS Credentials
        uses: aws-actions/configure-aws-credentials@v4
        with:
          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          aws-region: us-east-1

      - name: Update Lambdas code
        run: aws lambda update-function-code --function-name=${{matrix.lambda}} --zip-file=fileb://lambda_functions/${{matrix.lambda}}/${{matrix.lambda}}.zip
        env:
          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          AWS_REGION: us-east-1

O código YAML acima define um fluxo de trabalho (workflow) para automação de deploys usando o GitHub Actions. Ele consiste em duas etapas principais:

get-filenames: Esta etapa é responsável por encontrar os nomes das funções dentro da pasta lambda_functions. Utiliza a ferramenta tree para listar os diretórios e arquivos dentro de lambda_functions, em seguida usa jq para filtrar apenas os nomes das funções e armazená-los como saída para uso posterior.
update-code: Esta etapa depende da saída da etapa anterior e utiliza uma matriz para iterar sobre cada função encontrada. Para cada função, ela realiza as seguintes tarefas:
- Configura o ambiente Python.
- Instala as dependências de cada função.
- Compacta o código da função em um arquivo .zip.
- Configura as credenciais da AWS.
- Atualiza o código da função Lambda na AWS com o arquivo compactado.

Este fluxo de trabalho automatiza o processo de atualização do código das funções Lambda sempre que ocorrer um push para a branch master do repositório.

Criando uma chave secreta na AWS

O código YAML acima define um fluxo de trabalho (workflow) para automação de deploys usando o GitHub Actions. Ele consiste em duas etapas principais:

get-filenames: Esta etapa é responsável por encontrar os nomes das funções dentro da pasta lambda_functions. Utiliza a ferramenta tree para listar os diretórios e arquivos dentro de lambda_functions, em seguida usa jq para filtrar apenas os nomes das funções e armazená-los como saída para uso posterior.

update-code: Esta etapa depende da saída da etapa anterior e utiliza uma matriz para iterar sobre cada função encontrada. Para cada função, ela realiza as seguintes tarefas:

Configura o ambiente Python.
Instala as dependências de cada função.
Compacta o código da função em um arquivo .zip.
Configura as credenciais da AWS.
Atualiza o código da função Lambda na AWS com o arquivo compactado.
Este fluxo de trabalho automatiza o processo de atualização do código das funções Lambda sempre que ocorrer um push para a branch master do repositório.

IAM, ou Identity and Access Management (Gerenciamento de Identidade e Acesso), é um serviço da AWS que permite controlar o acesso aos recursos da AWS de forma segura. Com o IAM, você pode gerenciar usuários, grupos e permissões para conceder acesso apenas às ações necessárias dentro da sua conta AWS.

No contexto deste tutorial, ao criar uma chave secreta na AWS, estamos configurando as credenciais de acesso que serão usadas pelo GitHub Actions para interagir com os serviços da AWS, como Lambda. Essas credenciais são essenciais para garantir que o processo de deploy automatizado tenha permissão para atualizar o código das funções Lambda na sua conta AWS.

1- Na barra de pesquisa procure por IAM

2- Procure por users e clique sobre: Create user

3- Escolha um nome de usuário

4- Na parte de policy escolha por: Attach policies directly

5- Pesquise por Lambda e escolha a permissão: Lambda Full Access

6- Revise as informações e clique sobre criar usuário

7- De volta na nossa tela de usuários, clique sobre o nome de usuário que acabou de criar, e vá ate Security Credentials

8- Role a tela e procure a sessão de credentials keys e clique sobre Create Access Key

9- Escolha a opção Outside AWS

10- Clique sobre o botão create access key

Configurando variáveis de ambiente no Github

1- Crie o seu projeto no github

2- Navegue ate em settings, no menu lateral escolha por Secrets and variables e escolha por Actions

3- Clique sobre o botão criar New Repository Secret

4- Crie a primeira variavel com o nome de AWS_ACCESS_KEY_ID, no console da AWS copie sua Access key

5- Logo após crie a variavel AWS_SECRET_ACCESS_KEYno console da AWS copie sua Secret access key

Pronto, nosso ambiente de deploy está configurado para realizar deploys automáticos para a AWS.

Automating Deployments to Heroku with GitHub Actions and Docker: Streamlining the Deployment Process

Thiago Rodrigues — Tue, 08 Aug 2023 14:43:11 +0000

Tutorial: Automating Heroku Deployments with GitHub Actions and Docker: Streamlining the Deployment Process

In this tutorial, we'll delve into the process of utilizing GitHub Actions to automate the deployment of Docker images to Heroku. By the end of this tutorial, you'll have the know-how to achieve continuous deployment for a Fastify + TypeScript application.

Dependencies

pnpm add -D typescript @types/node ts-node ts-node-dev
pnpm add fastify prisma @prisma/client

Script Configuration

{
  "scripts": {
    "dev": "ts-node-dev --respawn --transpile-only --ignore-watch node_modules src/index.ts",
    "start": "ts-node src/index.ts",
    "build": "tsc"
  }
}

Setting Up the Backend

We'll start by setting up a simple backend since our primary goal lies elsewhere.

import fastify from 'fastify';

const app = fastify();

app.get('/', async (request, reply) => {
  return { hello: 'world' };
});

export const createServer = async () => {
  const PORT: number = Number(process.env.PORT) || 3001;
  const HOST: string = process.env.HOST || '0.0.0.0';

  try {
    await app.listen(PORT, HOST);
    console.log(`Server is listening at ${HOST}:${PORT}`);
  } catch (error) {
    console.error('Error starting the server:', error);
    process.exit(1);
  }
};

createServer();

Dockerfile Creation

Next, let's craft a Dockerfile for our application. We'll employ the Docker multi-stage build approach, which allows us to create a production image that's considerably smaller than the development one, as we don't require all the development dependencies.

FROM node:16

WORKDIR /app

COPY package.json ./
COPY pnpm-lock.yaml ./
COPY tsconfig.json ./

COPY . .

RUN npm install -g pnpm
RUN pnpm install

RUN npx prisma generate

CMD ["pnpm", "run", "start"]

docker-compose.yml Setup

Now, we'll create a docker-compose file to facilitate development.

version: "3.9"
services:
  server_api:
    stdin_open: true
    build:
      context: .
      dockerfile: Dockerfile
    ports:
        - "3001:3001"
    container_name: server_api
    restart: always
    volumes:
      - .:/app

Understanding GitHub Actions

GitHub Actions is a powerful tool provided by GitHub that enables you to automate various workflows, including building, testing, and deploying applications. It allows you to define custom workflows using YAML files, which can be triggered by events such as pushes, pull requests, or even on a schedule.

Creating the Workflow

Let's proceed to establish the GitHub Actions workflow. For this, create a file named deploy.yml within the .github/workflows directory.

name: Deploy to Heroku

on:
  push:
    branches: [master]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v2
      - name: Build, Push and Release a Docker container to Heroku
        uses: gonuit/heroku-docker-deploy@v1.3.3
        with:
          email: ${{ secrets.HEROKU_EMAIL }}
          heroku_api_key: ${{ secrets.HEROKU_API_KEY }}
          heroku_app_name: ${{ secrets.HEROKU_APP_NAME }}
          dockerfile_directory: ./
          dockerfile_name: Dockerfile
          docker_options: "--no-cache"
          process_type: web

In this workflow:

We define the workflow's name and specify that it should trigger on pushes to the master branch.
The workflow runs on an ubuntu-latest virtual environment.
We set up Node.js using the actions/setup-node action.
Dependencies are installed using pnpm.
We build a Docker image for our Fastify app.
We log in to the Heroku container registry.
The Docker image is pushed to Heroku.
Finally, the Docker image is released on Heroku.

Remember to replace your-heroku-app-name with your actual Heroku app name.

Finalizing

In this tutorial, we've covered a comprehensive process for automating the deployment of a Dockerized Fastify + TypeScript application to Heroku using GitHub Actions. We started by setting up the backend, creating a Dockerfile, and configuring the docker-compose.yml file for easier development. We introduced GitHub Actions, explaining its significance in automating workflows. Finally, we created a GitHub Actions workflow that builds, pushes, and releases a Docker container to Heroku upon pushing changes to the master branch.

By embracing this automated deployment process, you can significantly enhance the efficiency and reliability of your application deployments, saving valuable time and minimizing manual errors.

Creating a Mixpanel Plugin with Fastify

Thiago Rodrigues — Mon, 07 Aug 2023 22:46:43 +0000

Tutorial: Creating a Mixpanel Plugin with Fastify

In this tutorial, you will learn how to create a Mixpanel plugin to track errors and request events in a Fastify application using JavaScript. Mixpanel is an analytics platform that allows you to track and analyze user events in applications.

Step 1: Environment Setup

Make sure you have Node.js installed on your system. If you haven't already, you can download it from nodejs.org.

Step 2: Initializing a Fastify Project

Open a terminal and create a new folder for your project. Navigate to this folder using the terminal and execute the following commands:

mkdir my-mixpanel-project
cd my-mixpanel-project
npm init -y
npm install fastify mixpanel

Step 3: Creating the Mixpanel Plugin

Create a new file called mixpanel-plugin.js in the root folder of your project. Open this file in a code editor and copy the following code:

// mixpanel-plugin.js
import mixpanel from 'mixpanel';
import fp from 'fastify-plugin';
import {
  FastifyError,
  FastifyInstance,
  FastifyPluginAsync,
  FastifyRequest,
} from 'fastify';

const mixpanelPlugin: FastifyPluginAsync = fp(
  async (fastify: FastifyInstance, _) => {
    const MIXPANEL_TOKEN: string = process.env.MIXPANEL_TOKEN || '';

    const mixpanelClient = mixpanel.init(MIXPANEL_TOKEN);

    fastify.addHook(
      'onError',
      async (request: FastifyRequest, _, error: FastifyError) => {
        mixpanelClient.track('Error', {
          error: error.message,
          stack: error.stack,
          url: request.url,
        });
      },
    );

    fastify.addHook('onRequest', async (request: FastifyRequest, _) => {
      const eventData = {
        url: request.url,
        params: request.params,
        query: request.query,
        body: request.body,
      };

      mixpanelClient.track(`Request URL ${request.url}`, eventData);
    });
  },
);

export default mixpanelPlugin;

Step 4: Creating the Fastify Application

Create a new file called app.js in the root folder of your project. Open this file in a code editor and copy the following code:

// app.js
import fastify from 'fastify';
import mixpanelPlugin from './mixpanel-plugin';

const app = fastify();

// Register the Mixpanel plugin
app.register(mixpanelPlugin);

// Define an example route
app.get('/', async (request, reply) => {
  reply.send({ message: 'Hello, world!' });
});

// Start the server
app.listen(3000, (err) => {
  if (err) {
    console.error('Error starting the server:', err);
  } else {
    console.log('Server started on port 3000');
  }
});

Step 5: Running the Application

In the terminal, execute the following command to start the Fastify server:

node app.js

If everything is set up correctly, you will see the message "Server started on port 3000". Now, your application is running, and the Mixpanel plugin will start tracking errors and request events.

Conclusion

Congratulations! You've created a Mixpanel plugin to track errors and request events in a Fastify application. Now you have a solid foundation for implementing analytics and event tracking in your projects.

Remember to replace MIXPANEL_TOKEN with your actual Mixpanel token and adjust the code according to your needs. This tutorial provided an introduction to the concept of plugins in Fastify and how to integrate Mixpanel for event tracking.

The Journey of an Artificial Intelligence Recommending Taylor Swift's Songs

Thiago Rodrigues — Mon, 07 Aug 2023 22:16:21 +0000

It's not exactly a thunderous revelation that in recent times we've all been practically run over by a name resonating like a musical tsunami: Taylor Swift. And I'll be honest, my obsession with her lyrical ability is so obvious that it would be easier to hide it in a packed stadium from The Eras than to search for all the hidden Easter eggs in "Look What You Made Me Do." It's as if she has a song ready for every micro-moment in life, whether you're in the dumps or at the peak of a wild party.

So, I got to thinking... could we create a kind of electronic guru, an artificial intelligence, that selects the perfect Taylor Swift soundtrack according to your current mood? And thus was born Dorothea AI, my modern version of a musical advisor, but with a healthy dose of technological cuteness. To train this beauty, I fed her with 233 songs, leaving aside the original versions and focusing solely on the editions stamped with the "taylor’s versions" seal (after all, we don't listen to stolen versions).

All of this wouldn't have been possible without the magic of TensorFlow and the hands-on approach of Python, which were the secret ingredients of the recipe. Now, if you want to take a peek at the result of this slightly crazy experiment, just click here.

Oh, and of course, if you're the curious type who likes to tinker with gears, the entire process is neatly stored in this digital vault. Who knows, maybe you'll be inspired to create the next AI that chooses songs based on the weather? The sky's the limit, my friend!