DEV Community: .·. Felipe Paz .·.

Clonando repositório do Github sem senha

.·. Felipe Paz .·. — Mon, 03 Mar 2025 13:54:14 +0000

Como Configurar uma Chave SSH para o GitHub

Se você quer evitar digitar sua senha toda vez que interage com um repositório privado no GitHub ou precisa configurar uma deploy key para automação, esse guia vai te ajudar a fazer isso do jeito certo.

1️⃣ Criando a Chave SSH

Abra o terminal e rode:

ssh-keygen -t ed25519 -C "seu-email@example.com"

Vai aparecer algo assim:

Generating public/private ed25519 key pair.
Enter file in which to save the key (/home/seu-usuario/.ssh/id_ed25519):

Pressione Enter para salvar no local padrão ou defina outro caminho se quiser. Depois, pode ser que ele peça uma senha para a chave – é opcional.

2️⃣ Adicionando a Chave ao SSH-Agent

Agora, precisamos garantir que o SSH-Agent está rodando e adicionar a chave:

eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

Se a chave estiver salva em outro local, ajuste o caminho.

3️⃣ Adicionando a Chave ao GitHub

Copie sua chave pública para adicionar no GitHub:

cat ~/.ssh/id_ed25519.pub

Agora vá para o GitHub → Settings → SSH and GPG keys → New SSH Key, cole a chave e salve.

Se for uma Deploy Key (para um único repositório), vá até o repositório no GitHub, depois em Settings → Deploy Keys → Add Deploy Key, cole a chave e, se precisar de escrita, marque a opção Allow write access.

4️⃣ Testando a Conexão

Para garantir que tudo está configurado corretamente, rode:

ssh -T git@github.com

Se deu certo, você verá algo assim:

Hi <seu-usuario>! You've successfully authenticated, but GitHub does not provide shell access.

5️⃣ Alterando o `git remote` para SSH

Se você já clonou o repositório via HTTPS e quer mudar para SSH, rode:

git remote set-url origin git@github.com:SEU-USUARIO/SEU-REPOSITORIO.git

Para conferir se foi atualizado:

git remote -v

Agora teste se funciona:

git fetch

Se não deu erro, pronto! Agora suas interações com o GitHub serão feitas via SSH. 🚀

6️⃣ Configurando Múltiplos Usuários no GitHub

Se você trabalha com mais de uma conta do GitHub (exemplo: pessoal e trabalho), pode configurar múltiplas chaves SSH e usá-las de acordo com o repositório. Para isso, siga os passos:

Criar outra chave SSH

Gere uma nova chave para a segunda conta:

ssh-keygen -t ed25519 -C "email-da-outra-conta@example.com" -f ~/.ssh/id_ed25519_outro_usuario

Adicione a nova chave ao SSH-Agent:

ssh-add ~/.ssh/id_ed25519_outro_usuario

Agora copie a chave pública e adicione na outra conta do GitHub:

cat ~/.ssh/id_ed25519_outro_usuario.pub

Configurar o arquivo `~/.ssh/config`

Crie (ou edite) o arquivo ~/.ssh/config para diferenciar os usuários:

Host github-pessoal
    HostName github.com
    User git
    IdentityFile ~/.ssh/id_ed25519

Host github-trabalho
    HostName github.com
    User git
    IdentityFile ~/.ssh/id_ed25519_outro_usuario

Alterar a URL do `git remote`

Para um repositório da conta pessoal, use:

git remote set-url origin git@github-pessoal:SEU-USUARIO/SEU-REPOSITORIO.git

Para um repositório da conta do trabalho, use:

git remote set-url origin git@github-trabalho:EMPRESA/REPOSITORIO.git

Agora, toda vez que interagir com um repositório, o Git saberá qual chave usar! 🎯

Implemeting GitOps with Argocd

.·. Felipe Paz .·. — Thu, 25 Jul 2024 20:23:40 +0000

This project aims to demonstrate how to integrate GitOps concepts using GitHub Actions, ArgoCD, and Kubernetes.

Through this guide, you’ll be able to trigger changes automatically via GitHub Actions and ArgoCD. In this example, we will run Kubernetes and ArgoCD through Minikube.

Prerequisites

External setup

Navigate to your Dockerhub panel and create a personal token

Create a fork of this project and navigate to the project's settings page.

Click on Secrets and variables > Actions and create 3 variables:

DOCKER_USERNAME - Your Dockerhub username
DOCKER_REGISTRY - docker.io
DOCKER_PASSWORD - Personal token created in the previous step

Local setup

Initalize docker
Initialize minikube



minikube start

Once minikube is ready and running, install two project's dependencies:

Argocd
Skater Reloader

Installing Argocd

Navigate to the folder infra/k8s and run the follwing:



kubectl apply -k kustomization.yaml

Installing Skater Reloader

Stakater Reloader can be applied using its remote configuration. To do that, run the following command:



kubectl apply -f https://raw.githubusercontent.com/stakater/Reloader/master/deployments/kubernetes/reloader.yaml

Configuring Argocd

First of all, you need to access the Argocd console. To do that, run the command:



minikube service argocd-server -n argocd --url

The output will be something like this:



http://127.0.0.1:55643

Now, you can access the Argocd console using the link above.

By default, Argocd has the admin user enabled and a default password. To visualize this password you need to:

Identify the pod responsible for argocd-server



kubectl get pods -n argocd

The output will be something like this

NAME	READY	STATUS	AGE
argocd-application-controller-0	1/1	Running	125m
argocd-applicationset-controller-86fc5c85-bgt82	1/1	Running	125m
argocd-dex-server-7f4689df5-p8fwx	1/1	Running	125m
argocd-notifications-controller-59f78959c8-m2fsh	1/1	Running	125m
argocd-redis-74cb89f466-t549k	1/1	Running	125m
argocd-repo-server-6578ccfc67-txds5	1/1	Running	125m
argocd-server-854c79df45-ff5zs	1/1	Running	125m

The pod we need is the pod argocd-server-854c79df45-ff5zs. Once you have identified the pod, run the following command to get the default password:



kubectl exec -it argocd-server-854c79df45-ff5zs -n argocd -- argocd admin initial-password

The output will be something like:



Sqfjox8ceceIosuW



kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath="{.data.password}" | base64 -d

The output will be something like:



Sqfjox8ceceIosuW%

Ignore the final %

Given that, now you need to access the Argocd console. Go to the url created by minikube and enter admin as username and the password displayed by the command above.

As soon as you signin you will see a page like this

In your project, it will be blank as you are creating this project from scratch. In my screenshot, I have already created the application and because of that you can see it listed in the image.

Navigate to the Settings > Repositories

Click on Connect Repo. In this step, you will need to create a ssh key and connect Argocd to your Github repository via ssh.

Run the following command:



ssh-keygen -t ed25519 -C "<your_email_here>" -f gitops-argocd -P ""

The output will be something like:



Generating public/private ed25519 key pair.
Your identification has been saved in gitops-argocd
Your public key has been saved in gitops-argocd.pub
The key fingerprint is:
SHA256:7FXbnyKfvckbD1eMhXvTDfyPqaS23sVCa0WGlBsK7UY <your_email_here>
The key's randomart image is:
+--[ED25519 256]--+
|         .  ..   |
|        . E.oo . |
|         + .oo* .|
|       .  +..= Bo|
|        S.. o =.B|
|       . . . + ==|
|        .  .=.*o+|
|          .=o+=o+|
|         o+.oo *+|
+----[SHA256]-----+

Copy the key with .pub extension



cat gitops-argocd.pub

Navigate to your Github repository and click on Settings > Deploy keys > Add deploy key

Name it and paste the copied key.

Now, go back to the Argocd console and click on Connect Repo. Paste the key you generated and click on Connect.

You will see the repository listed. Ensure you can see the status Successful

Click on the 3 dots to open the menu and then Create Application

You'll be redirected to the dashboard page where you'll be able to create the application.

For Project field you need to select default.

Scroll down until Source section

Fill the fields as follows:

Revision: the branch you wanna sync, in this example we are syncing main
Path: the folder location where Argocd can find the kubernetes manifests. In this project, we are pointing to infra/k8s

For Destination section, fill out the fields with the follwing values:

Repository URL: select in the combo box
Namespace: defautl

Scroll to the last section and make sure you have Directory selected.

In the exclude field, add kustomization.yaml. This is to avoid Argocd to recreate itself again.

Once it's done, click on Create at the top of the modal and voilà, your application is almost done.

Click on App Details, scroll until "SYNC POLICY" and in AUTOMATED click on SYNC. This will be enough to keep Argocd monitoring the repository / branch / path.

Finally, your application will look like this:

If you can't see this, just click on the SYNC button at the top of the page and Argocd will sync with your repository.

As you have enabled the auto sync in the previous step, Argocd will watch the repository every 3 minutes. You can disable this just hitting the button App Details and disabling it in the POLICY SYNC section.

Every time you want to sync your application, just click on SYNC and Argocd will update your manifests inside the kubernetes.

How to test it?

There are three ways to run this project:

Making any change in the src folder
Creating a new tag
Change kubernetes manifests in the infra/k8s

Making any change in the src folder

This is the easiest way to test it. Just make any change in the src folder and commit it. Open a PR and merge the changes into the main branch. This will trigger the pipeline and create the new docker image. It will push the image to the container registry, in this example we are using docker.io.

THe pipeline will push the image to the docker registry and update the file infra/k8s/deployment.yaml and the main branch with the new image name.

Argocd will detect the change and update the kubernetes deployment with the new image. The image tag name will be always latest

Creating a new tag

This is the second way to test it. Just create a new tag and push it. The process will follow the same previous flow, however, the image will take the tag as its tag's name.

Change kubernetes manifests in the infra/k8s

This is the third way to test it. Just make any change in the infra/k8s folder and push it to the repository. In this case, the Github Actions won't be triggered and Argocd will update whatever you changed.

For example, let's assume you've changed a value in the configmap. Argocd will identify this and update only the configmap, as this is the only manifest updated.

How to visualize the application?

This project has a NodeJs appliaction showing a simples index.html page. In the configmap, there's a variable COLOR. This variable reflects to the index.html

COLOR will afect the title "GitOps - ArgoCD" and the "Check my Github".

Minikube needs to provide a port and url to access the service from your local machine. To do that, run the command:



minikube service argocd-server -n argocd --url

The output will be something like this:



http://127.0.0.1:55643

Open this URL in your browser and check the application. To see all the flow working, try to change the color in the configmap and push the changes to the main branch. Wait for a moment until Argocd regocnizes the changes and start making the changes. You can follow this operation by accessing the Argocd console.

Once the update is done, just refresh the express application's page and that's it. If you entered a valid color and followed this guide correctly, you will see the changes.

You can see the full project here

Circuit Breaker - Um apagador de fogo?

.·. Felipe Paz .·. — Thu, 27 Jun 2024 21:58:05 +0000

Um Apagador de Fogo?

E aí, pessoal! Já ouviram falar de Circuit Breakers no desenvolvimento de software? É um conceito super útil usado em microserviços para manter as coisas funcionando direitinho. Imagine que você está fazendo várias requisições para outro serviço, mas de repente esse serviço começa a falhar. Em vez de deixar todo o seu sistema desandar, um Circuit Breaker entra em ação e para de fazer requisições para o serviço com problema por um tempo. Isso ajuda o seu sistema a ficar estável e dá um tempinho para o serviço problemático se recuperar. Bem legal, né?

Por Que Usar um Circuit Breaker?

Então, por que vale a pena usar um Circuit Breaker? Aqui estão alguns benefícios top na hora de escolher por implementar ou não:

Mais Estabilidade: Parando as requisições para um serviço que está falhando, você evita que todo o sistema fique bagunçado.
Recuperação Mais Rápida: Dá um tempo para o serviço com problema se recuperar, o que significa que ele pode voltar a funcionar mais rápido.
Gestão de Recursos: Você economiza recursos do sistema ao não tentar infinitamente alcançar um serviço indisponível.
Melhor Experiência do Usuário: Em vez do seu app travar, os usuários recebem uma resposta rápida ou uma mensagem alternativa, mantendo todos felizes.

Maneiras Mais Comuns de Usar Circuit Breaker

Beleza, agora vamos falar sobre como você pode usar Circuit Breakers. Aqui estão alguns dos cenários mais comuns:

Chamadas de API: Quando seu app depende de APIs externas, um Circuit Breaker pode parar de acessar uma API com problemas até que ela se recupere.
Conexões de Banco de Dados: Se o seu banco de dados começar a dar problema, um Circuit Breaker pode interromper as operações até que a conexão estabilize.
Comunicação entre Microserviços: Em uma arquitetura de microserviços, os Circuit Breakers podem ajudar a gerenciar a comunicação entre os serviços e evitar falhas em cascata.
Serviços de Terceiros: Se você está integrando serviços de terceiros, um Circuit Breaker pode te salvar dos problemas de tempo de inatividade deles.

Esses são apenas alguns exemplos, mas, na real, qualquer lugar onde você faz chamadas de rede, um Circuit Breaker pode ser um salvador.

Onde Não Usar Circuit Breaker

Embora os Circuit Breakers sejam incríveis, eles nem sempre são a ferramenta certa para o trabalho. Aqui estão alguns cenários onde você pode querer evitá-los:

Operações Locais: Para operações que não envolvem chamadas de rede ou serviços externos, um Circuit Breaker não é necessário.
Requisitos em Tempo Real: Se você precisa de desempenho em tempo real sem atrasos, introduzir um Circuit Breaker pode adicionar uma latência indesejada.
Sistemas Simples: Em uma aplicação simples e monolítica sem dependências complexas, os Circuit Breakers podem adicionar complexidade desnecessária.

Lembre-se, os Circuit Breakers são melhores para gerenciar chamadas remotas e dependências externas. Se você não tem essas necessidades, provavelmente não precisa de um.

E é isso sobre Circuit Breakers! Eles são como apagadores de fogo para o seu código, entrando em ação para evitar que pequenos problemas se transformem em grandes desastres. Usando-os de forma inteligente, você pode tornar suas aplicações mais resilientes e confiáveis.

Se você ficou interessado em ver uma implementação prática, confira o projeto completo no GitHub: Circuit Breaker Example. O repositório inclui um guia passo a passo para configurar dois microserviços com Circuit Breakers usando Python (Flask) e Node.js (TypeScript e Express), todos gerenciados com Docker Compose.

E se você preferir ler em inglês, dá uma olhada na versão em inglês deste post: Circuit Breaker - A Fire Extinguisher for Your Code?.

Que a força com você esteja!

Circuit Breaker - A Fire Extinguisher for Your Code?

.·. Felipe Paz .·. — Thu, 27 Jun 2024 21:53:02 +0000

A Fire Extinguisher?

Hey there! Ever heard about Circuit Breakers in software development? It's a super handy concept used in microservices to keep things running smoothly. Imagine you're making tons of requests to another service, but suddenly that service starts failing. Instead of letting your entire system go down the drain, a Circuit Breaker steps in and stops making requests to the failing service for a bit. This helps your system stay stable and gives the troubled service some time to recover. Pretty cool, right?

Why Use a Circuit Breaker?

So, why should you bother using a Circuit Breaker? Well, there are some great benefits:

Improved Stability: By stopping requests to a failing service, you prevent your whole system from going haywire.
Faster Recovery: It gives the failing service a break to recover, which means it can get back on track quicker.
Resource Management: You save system resources by not endlessly trying to reach an unavailable service.
Better User Experience: Instead of your app crashing, users get a quick response or a fallback message, keeping them happy.

Common Ways to Use Circuit Breaker

Alright, now let's talk about how you can use Circuit Breakers. Here are some of the most common scenarios:

API Calls: When your app depends on external APIs, a Circuit Breaker can stop hitting a failing API until it's back up.
Database Connections: If your database starts acting up, a Circuit Breaker can halt operations until the connection stabilizes.
Microservices Communication: In a microservices architecture, Circuit Breakers can help manage the communication between services and prevent cascading failures.
Third-party Services: If you're integrating with third-party services, a Circuit Breaker can save you from their downtime issues.

These are just a few examples, but really, anywhere you're making network calls, a Circuit Breaker can be a lifesaver.

Where Not to Use a Circuit Breaker

While Circuit Breakers are awesome, they’re not always the right tool for the job. Here are some scenarios where you might want to avoid using them:

Local Operations: For operations that don’t involve network calls or external services, a Circuit Breaker isn’t needed.
Real-Time Requirements: If you need real-time performance without any delays, introducing a Circuit Breaker might add unwanted latency.
Simple Systems: In a simple, monolithic application without complex dependencies, Circuit Breakers can add unnecessary complexity.

Remember, Circuit Breakers are best for managing remote calls and external dependencies. If you don't have these, you probably don't need one.

And that's the lowdown on Circuit Breakers! They're like fire extinguishers for your code, stepping in to prevent small issues from turning into big disasters. By using them wisely, you can make your applications more resilient and reliable.

If you're interested in seeing a practical implementation, check out the complete project on GitHub: Circuit Breaker Example. The repository includes a step-by-step guide on setting up two microservices with Circuit Breakers using Python (Flask) and Node.js (TypeScript and Express), all managed with Docker Compose.

Also, check out the version of this post in Portuguese: Circuit Breaker - Um Apagador de Fogo?.

Happy coding!

Getting Started with RabbitMQ and Python: A Practical Guide

.·. Felipe Paz .·. — Fri, 21 Jun 2024 16:34:41 +0000

Introduction

In this article, we will guide you through setting up and using RabbitMQ with Python. RabbitMQ is a powerful message broker that allows applications to communicate with each other via messages. This practical guide will show you how to connect to RabbitMQ, publish messages to a queue, and consume messages from a queue using Python. Additionally, we will use Docker to manage RabbitMQ in a containerized environment, ensuring a smooth and isolated setup. Whether you are new to message brokers or looking to integrate RabbitMQ into your Python projects, this guide will provide you with a solid foundation to get started.

Summary

In this article, we will cover the essentials of setting up and using RabbitMQ with Python. You will learn how to:

Set up your development environment.
Use Docker to run RabbitMQ in a container.
Connect to RabbitMQ from a Python application.
Publish messages to a queue.
Consume messages from a queue.
Access the RabbitMQ management console.

By the end of this guide, you will have a working example of a RabbitMQ setup with Python and Docker, and you will be ready to integrate these tools into your own projects.

Prerequisites

Before we begin, make sure you have the following tools and technologies installed on your system:

Python 3.8+: Ensure you have Python installed. You can download it from the official Python website.
Docker: Docker is required to run RabbitMQ in a containerized environment. You can download and install Docker from the official Docker website.
Docker Compose: Docker Compose is used to manage multi-container Docker applications. It is included with Docker Desktop.

Having these prerequisites installed will ensure a smooth setup and execution of the examples provided in this guide.

Environment Setup

To get started, follow these steps to set up your development environment:

Create and activate the virtual environment

Creating a virtual environment helps to isolate your project’s dependencies. Here’s how you can create and activate a virtual environment:

Create the virtual environment:
```
python -m venv .venv
```
Activate the virtual environment:
- On Windows:
```
.venv\Scripts\activate
```
- On macOS/Linux:
```
source .venv/bin/activate
```

Install the dependencies

Next, install the required Python packages. For this project, we will use the pika library to interact with RabbitMQ.

Install the required packages:
```
 pip install pika
```
Save the installed packages to requirements.txt:
```
pip freeze > requirements.txt
```

With the environment set up and dependencies installed, you’re ready to move on to the next steps in configuring RabbitMQ with Docker.

Docker Setup

In this section, we will configure and start RabbitMQ using Docker. This allows us to easily manage and isolate RabbitMQ in a containerized environment.

Create a docker-compose.yaml file

Create a file named docker-compose.yaml in the root of your project directory. Add the following content to the file:

version: '3.8'

services:
  rabbitmq:
    image: rabbitmq:3-management
    container_name: rabbitmq
    ports:
      - '5672:5672'
      - '15672:15672'
    environment:
      RABBITMQ_DEFAULT_USER: guest
      RABBITMQ_DEFAULT_PASS: guest

This configuration sets up RabbitMQ with the management plugin enabled, allowing you to access the RabbitMQ management console on port 15672.

Start the RabbitMQ container

Run the following command to build and start the RabbitMQ container:

docker-compose up -d

This command will download the RabbitMQ Docker image (if not already available locally), start the container, and run it in the background. The RabbitMQ server will be accessible at localhost:5672, and the management console will be available at http://localhost:15672.

With RabbitMQ running in a Docker container, you are ready to move on to the next steps of developing the application and integrating RabbitMQ with your Python code.

Application Development

In this section, we will develop the application that connects to RabbitMQ, publishes messages to a queue, and consumes messages from a queue. We’ll start by implementing a class to manage the connection and interactions with RabbitMQ.

Implement the RabbitMQ class

Create a file named rabbitmq.py in the root of your project directory. Add the following content to the file:

import pika
import os

class RabbitMQ:
    def __init__(self):
        self.user = os.getenv('RABBITMQ_USER', 'user')
        self.password = os.getenv('RABBITMQ_PASSWORD', 'password')
        self.host = os.getenv('RABBITMQ_HOST', 'localhost')
        self.port = int(os.getenv('RABBITMQ_PORT', 5672))
        self.connection = None
        self.channel = None
        self.connect()

    def connect(self):
        credentials = pika.PlainCredentials(self.user, self.password)
        parameters = pika.ConnectionParameters(host=self.host, port=self.port, credentials=credentials)
        self.connection = pika.BlockingConnection(parameters)
        self.channel = self.connection.channel()

    def close(self):
        if self.connection and not self.connection.is_closed:
            self.connection.close()

    def consume(self, queue_name, callback):
        if not self.channel:
            raise Exception("Connection is not established.")
        self.channel.basic_consume(queue=queue_name, on_message_callback=callback, auto_ack=True)
        self.channel.start_consuming()

    def publish(self, queue_name, message):
        if not self.channel:
            raise Exception("Connection is not established.")
        self.channel.queue_declare(queue=queue_name, durable=True)
        self.channel.basic_publish(exchange='',
                                   routing_key=queue_name,
                                   body=message,
                                   properties=pika.BasicProperties(
                                       delivery_mode=2,  # make message persistent
                                   ))
        print(f"Sent message to queue {queue_name}: {message}")

This class handles connecting to RabbitMQ, publishing messages to a queue, and consuming messages from a queue. The connection parameters are read from environment variables.

Create the main.py script

Create a file named main.py in the root of your project directory. Add the following content to the file:

from rabbitmq import RabbitMQ
import sys

def callback(ch, method, properties, body):
    print(f"Received message: {body}")

def main():
    rabbitmq = RabbitMQ()
    try:
        print("Connection to RabbitMQ established successfully.")
        rabbitmq.consume(queue_name='test_queue', callback=callback)
    except Exception as e:
        print(f"Failed to establish connection to RabbitMQ: {e}")
        sys.exit(1)
    finally:
        rabbitmq.close()

if __name__ == "__main__":
    main()

This script connects to RabbitMQ and starts consuming messages from a queue named test_queue.

Create the publisher.py script

Create a file named publisher.py in the root of your project directory. Add the following content to the file:

from rabbitmq import RabbitMQ

def publish_test_message():
    rabbitmq = RabbitMQ()
    try:
        rabbitmq.publish(queue_name='test_queue', message='Test message')
        print("Test message published successfully.")
    except Exception as e:
        print(f"Failed to publish test message: {e}")
    finally:
        rabbitmq.close()

if __name__ == "__main__":
    publish_test_message()

This script publishes a test message to the test_queue.

With these scripts in place, you are ready to run and test your application.

Running the Application

In this section, we will run the application to ensure everything is set up correctly and that we can successfully publish and consume messages using RabbitMQ.

Start the RabbitMQ server

Run the main.py script to start the RabbitMQ server and begin consuming messages from the test_queue:

python main.py

You should see a message indicating that the connection to RabbitMQ was established successfully. The script will continue running and wait for messages to consume from the test_queue.

Publish a test message

Open a new terminal window or tab, and run the publisher.py script to publish a test message to the test_queue:

python publisher.py

You should see a message indicating that the test message was published successfully. The main.py script should also display the received message, indicating that the message was successfully consumed from the test_queue.

Example Output

When you run main.py, you should see something like this:

Connection to RabbitMQ established successfully.
Received message: b'Test message'

When you run publisher.py, you should see something like this:

Sent message to queue test_queue: Test message
Test message published successfully.

Conclusion

In this guide, we covered the steps to set up and use RabbitMQ with Python. We demonstrated how to configure the development environment, run RabbitMQ in a Docker container, and create a simple application to publish and consume messages. This should give you a solid foundation to start integrating RabbitMQ into your own projects.

For more information and advanced usage of RabbitMQ, please refer to the official RabbitMQ documentation.

GitHub Repository

You can find the complete code for this project in the following GitHub repository: python-rabbitmq.

This repository contains all the scripts and configurations discussed in this article, including the docker-compose.yaml, rabbitmq.py, main.py, publisher.py, and the README.md with detailed setup instructions. Feel free to clone the repository and experiment with the code to further your understanding of RabbitMQ and Python integration.

Clustering Redis with Kubernetes

.·. Felipe Paz .·. — Wed, 18 Jan 2023 13:55:50 +0000

NodeJs and setTimeout

.·. Felipe Paz .·. — Fri, 01 Apr 2022 12:57:20 +0000

Everybody hello, me again here!!! =D =D =D

First of all, I actually realized that sometimes I look like Master Yoda speaking English. That's weird =( =D =( =D ...

Well, let's talk about what's really important.

Everybody knows that even if NodeJs interprets javascript, a lot of js functionalities don't work on the Node platform once they are compiled by browser engines;

Ok, ok... there's no news here!!!

But last night I was playing with Node and reading its documentation until I saw a package called timers.

Hummmmm, interesting. What does it do?

I kept my reading and noticed a function setTimeout. How so? Could be the same function that runs on wer browsers?

Let's check it out!!!

With this info, I created a simple express server with one single POST method and the body with json containing a timer key.

Annnnnnd yeeeeeees, Nodejs has a native setTimeout and it works like it runs on web browsers.

So, my example was like that:

const express = require('express');
const http = require('http');

const app = express();

app.use((req, res, next) => {
  res.header('Access-Control-Allow-Origin', '*');
  res.header('Access-Control-Allow-Headers', 'Content-Type');
  next();
});

app.use(express.json());
app.use(express.urlencoded({ extended: true }));

app.post('/', async (req, res) => {
  const { timer } = req.body;

  const promise = () => new Promise((resolve) => {
    setTimeout(function () {
      resolve(res.status(200).send("weeeeeeeeeeeee"));
    }, timer);
  });

  try {
    await promise();
  } catch (err) {
    res.status(500).send('my bad ...');
  }
});

const server = http.createServer(app);

server.listen(3000, () => console.log('running'));

And, our request should be like that:

curl -i -X POST localhost:3000 -H "Content-type: application/json" -d '{"timer": 1000}'

It's a pretty simple example but as we can see, in the body of request we have an object with the key timer and this is the time that express will take to respond the request.

So, yes... we have a way to use setTimeout on the Node engine.

Why should I use it? I don't know and it doesn't matter, I just know that it exists!!!!!!

See you next chapter when I'll use this same example to work with AbortController.

Trabalhando com Json e Go

.·. Felipe Paz .·. — Fri, 25 Mar 2022 14:33:03 +0000

Pra mim que vim do javascript onde o json é algo tão "banal", entender o funcionamento com Go foi um tanto quanto diferente.

O Go tem uma pegada muito grande com ponteiros e bytes, então, de primeiro momento, é meio cabuloso saber que uma variável que foi passada como parâmetro vai ter o retorno da função diretamente no local da memória em que ela foi alocada e por aí vai.

Em javascript, uma estrutura do tipo:

{
  "campo": "qualquer coisa",
  "numero": 10
}

é entendível na hora, contudo, em Go, a coisa não é bem assim.

Bora ver um exemplo prático e eu vou detalhar coisa por coisa.

package main

import (
    "encoding/json"
    "fmt"
)

type Car struct {
    Color string `json:"color"`
    Model string `json:"model"`
}

func main() {
    car := Car{"Black", "Lancer"}

    b, err := json.Marshal(car)

    if err != nil {
        fmt.Println(err)
    }

    fmt.Println(string(b))
}

Explicando:

package main

estou definindo que o conteúdo dese arquivo pertence ao pacote main. Por exemplo, se eu tivesse uma estrutura

app
   services
       main.go
   controllers
       main.go
       users.go
   main.go

Eu poderia dizer que services/main.go pertence ao pacote services, portanto, package services, controllers/main.go e controllers/users.go ao pacote controllers e por aí vai. Mas enfim, a ideia aqui é explicar json com go, outros detalhes eu vou abordar em outro capítulo. Prossigamos ...

type Car struct {
    Color string `json:"color"`
    Model string `json:"model"`
}

Aqui eu estou "definindo o meu objeto". Não sei se seria a melhor comparação, mas sabe o Type do typescript? Quase isso! Diferença que aqui eu consigo passar esse cara como ponteiro e trabalhar diretamente nele.

func main() {
    car := Car{"Black", "Lancer"}
//  car := Car{
//    Color: "Black",
//    Model: "Lancer",
//  }
        ...

Aqui eu to dizendo: cria a varíavel car e atribui à ela o tipo Car com os seguintes valores ....
Note que existem duas maneiras de atribuir uma struct à uma variável. Pode ser parecido como é em javascript, ou passar os valores diretamente na struct sem precisar inserir as chaves. Em structs mais simples é até viável, mas pensa num negócio gigante passar os valores sem saber o que é o que.

Ah, só uma observação: isso := é diferente de =.
No primeiro, eu estou criando a variável e reservando ela em memória, ou seja, dando vida à ela e lhe atribuindo um valor,
enquanto que no segundo, a variável já existe em memória e eu estou reatribuindo um valor à ela. 0.o

Continuando ...

Aqui o bicho pega

b, err := json.Marshal(car)

if err != nil {
   fmt.Println(err)
}

fmt.Println(string(b))

O go pode trazer mais de um retorno numa função. Uma espécie de tupla, por assim dizer.

E também em Go, as chamadas de funções geralmente são o nome do pacote e a função. No nosso exemplo, estamos chamando do pacote json a função Marshal.

A função Marshal retorna dois resultados: um slice de bytes (é praticamente um array mas sem limite como um array) e um erro. Como parâmetro, essa função espera uma variável do tipo struct que no nosso caso é car.

Logo após é feita a checagem pra garantir que não houve algum erro (lembrando que o foco aqui é json e não tratativas de erros, uso correto da linguagem nem nada).

E depois, por último, convertemos aqueles bytes em uma string para ser mostrado pelo Println, nosso console.log do Go.

E pah, a saída que teremos vai ser

{"color":"Black","model":"Lancer"}

Outras observações cabulosas do Go:

Quando se define uma struct, as "chaves" dela, para serem lidas por qualquer função ou algo do tipo, precisam ser em letras maiúsculas. Portanto, se eu tivesse:

type Car struct {
    color string `json:"color"`
    model string `json:"model"`
}

a saída seria simplesmente

{}

uma vez que os atributos dessa struct não foram exportados (implicitamente escrever iniciando em letra minúscula fala pro Go que o atributo daquela struct não é para ser exportado).

Mas fica estranho né, imagina uma api que esteja esperando esse objeto:

{
   "color": "black",
   "model": "Lancer"
}

mas estamos enviando "Color" e "Model" no body da request.

Para resolver isso, colocamos aquele json:"color" na frente do atributo da struct. Com isso estamos dizendo para o Go: Cara, a struct Car tem o atributo Color, então, internamente, a gente referencia Color mas externamente, ou seja, se formos enviar esse json pra fora do programa ou vamos receber esse json de algum outro lugar, ele vai ter o campo "color" e não "Color".

É, isso é Go ...

Essa é a primeira parte, transformando uma struct em um json. Vamos ter a segunda parte onde vamos transformar um json em uma struct.

Te espero lá!!!

Tags HTML pouco usadas

.·. Felipe Paz .·. — Wed, 01 Dec 2021 05:50:32 +0000

Precisa de um autocomplete? O HTML tem!

Precisa de um gauge para mostrar algum valor? O HTML tem!

Precisa de um collapse sem ser bootstrap? O HTML também tem!

Nesse breve resumo vou listar algumas tags que são raramente usadas ou até mesmo desconhecidas e que, na hora da construção de um blog, site ou até mesmo landing page pode ser de grande valia.

Datalist

A nossa primeira tag é datalist. Nada mais é do que um lista de opções que são atreladas a um input, e ao digitar, as opções são sugeridas numa espécie de autocomplete.

<form>
  <input list="browsers" name="browser" placeholder="Browsers">
  <datalist id="browsers">
    <option value="Internet Explorer">
    <option value="Firefox">
    <option value="Chrome">
    <option value="Safari">
  </datalist>
</form>

Progress

A nossa próxima tag é a progress. Sem tempo ou habilidade para fazer uma barra de progresso estilosa? Usa a do HTML mesmo!

<progress value="50" max="100"></progress>
<progress></progress>

Meter

Quero mostrar uma lista de habilidades e ter um gauge bonitinho.

<label for="meter">HTML</label>
<meter value="10" min="1" max="10" id="meter">10 de 10</meter>


<label for="meter">Javascript</label>
<meter value="8" min="1" max="10" id="meter">8 de 10</meter>

Details

Preciso de um collapse mas não quero usar Boostrap. O que eu faço? O HTML já tem isso!!! =D

 <details>
   <summary>Lista de linguagens</summary>
   <dt>
     <dd>Javascript</dd>
     <dd>Python</dd>
     <dd>Reust</dd>
   </dt>
 </details>

Uma coisa do details é que a tag summary vai ser o nosso cabeçalho e todo o restante vai ser o body do collapse. Sabe as tags fieldset e legend? Pois vai funcionar exatamente assim.

Tem umas outras bem bacaninhas como o map por exemplo.

Dá uma olhada lá no repo que eu disponibilizei. Vai ter essas e outras bem legais também! =D

Python e Redis: Utilizando Pub/Sub

.·. Felipe Paz .·. — Tue, 19 Oct 2021 05:48:09 +0000

Acredito que você já tenha ouvido falar sobre o conceito de publisher/subscriber, certo? E você sabia que o Redis possui essa comunicação nativamente?

De maneira muito sucinta, vou mostar um exemplo prático e simples utilizando Redis e Python usando a comunicação publish/subscriber.

O que preciso?

Para esse exemplo são necessárias três ferramentas instaladas na sua máquina:

Python 3.8 ou superior
pip
Redis

Os detalhes de instalação vou pular porque esse exemplo pode ser feito em qualquer SO. Basta seguir a documentação de instalação de cada item.

Por fim, uma vez instalado o pip, vamos instalar o redis (ah, para quem não sabe, o pip seria o npm do python) com o comando abaixo:

pip3 install redis

O Script

Crie um arquivo chamado app.py e cole esse script:

from redis import StrictRedis
from time import strftime, sleep

client = StrictRedis(host="localhost", port=6379)

subscriber = client.pubsub()
subscriber.psubscribe('channel_test')

while True:
    messages = subscriber.get_message()
    now = strftime('%d/%m/%Y:%H:%M:%S')

    if messages:
        print(f'{now} - {messages["data"]}')
    else:
        print(f'{now} - Nothing here!!!')
    sleep(1)

Explicando cada linha

Importação do redis para o projeto (obviously) , importação de formatação de data da classe time e também o sleep, que vai fazer com que nosso while sofra uma pausa de 1 segundo em cada iteração.

from redis import StrictRedis
from time import strftime, sleep

Conexão com o redis

client = StrictRedis(host="localhost", port=6379)

Especificando que vamos nos subscrever num canal chamado channel_test

subscriber = client.pubsub()
subscriber.psubscribe('channel_test')

Bloco while que vai ficar rodano sem parar o processo de subscribe. Uma vez que seja publicada alguma mensagem no canal channel_test, vai ser printado no console.

while True:
    messages = subscriber.get_message()
    now = strftime('%d/%m/%Y:%H:%M:%S')

    if messages:
        print(f'{now} - {messages["data"]}')
    else:
        print(f'{now} - Nothing here!!!')
    sleep(1)

Publicando no canal

Redis instalado? Tá na hora de usar esse carinha.
No terminal/prompt, rode o comando:

redis-cli

Se tudo tiver ocorrido bem na instalação e o redis estiver rodando, você deve estar com o shell do redis habilitado.

Para publicar, basta digitar:

publish channel_test "um conteúdo qualquer aqui"

Ah, a gente ainda não executou nosso script python. Pelo terminal, acesse o diretório de onde está nosso app.py e execute com o comando:

python app.py

Resultado

Script rodando? Redis rodando? Publish realizado?
Pah, a mágica acontece ...

Agora exercite sua criatividade e implemente outras coisas bacanas usando redis como publisher/subscriber e seja feliz =D =D =D

Dockerizando uma aplicação Node e Mongodb

.·. Felipe Paz .·. — Wed, 30 Jun 2021 19:56:58 +0000

E aí gurizada, tudo tranquilo? Muito se fala em container, docker, aplicação escalável e é por esses e outros motivos que eu resolvi demonstrar como poderíamos criar uma aplicação simples usando um ambiente em container com node e mongodb.

A ideia aqui é mostrar os princípios do docker de forma muito breve trazendo um pouquinho de clareza na hora de construir uma aplicação seja ela na linguagem que for.

Ao final desse tutorial, vamos conseguir fazer um CRUD sem ter "nada instalado na nossa máquina", único requisito que precisamos é ter o docker instalado no computador.

Instruções de instalação podem ser encontradas aqui

É preciso instalar também o docker-compose.

Alguns pontos extremamente importantes:

Não vamos falar sobre arquitetura de projetos. "Ah, mas tua aplicação tem um index e rotas e tudo nele". O objetivo é apenas mostrar o DOCKER em ação.
Não vamos abordar como o Node funciona.
Não vamos falar sobre segurança e boas práticas.
Não vamos falar sobre Docker detalhadamente, como funciona, ou detalhes mais aprofundados do docker-compose.

O projeto pode ser encontrado na minha página do github

Dito isso, bora pra prática!!!

Docker

O Docker é um cara que geralmente roda um Linux minimalista apenas para criar a imagem do que você precisa, ou seja, se você quiser rodar um banco MySQL, a imagem do MySQL vai conter o mínimo, do mínimo, do mínimo ... para poder rodar o banco. Diferente de uma VM onde vai precisar instalar um sistema operacional inteiro para poder rodar o banco. Mas como dito alhures, nosso intento aqui não é esplanar o Docker, deixamos para outra hora isso.

Para que essa mágica aconteça, temos alguns comandos do Docker que vão brilhar no nosso terminal.

No nosso exemplo, vamos baixar uma imagem do mysql e executar ela:

docker run -d --name mysql_container -p 3306:3306 -e MYSQL_ALLOW_EMPTY_PASSWORD=True mysql

e voilà, temos um banco mysql novinho em folha rodando na nossa máquina. Basicamente estamos falando o seguinte:

docker run -d docker, rode em background
--name mysql_container alguma coisa com o nome de mysql_container
-p 3306:3306 onde que a minha porta 3306 vai ser pareada com a porta 3306 desse alguma coisa que você vai rodar em background
-e MYSQL_ALLOW_EMPTY_PASSWORD=True e você também precisa criar essa variável de ambiente pro alguma coisa
mysql e esse alguma coisa é a imagem que vai ser baixada e executada, no caso, o mysql.

MYSQL_ALLOW_EMPTY_PASSWORD - variável de ambiente do mysql. Outra variáveis do MySQL que podem ser usadas também para docker podem ser encontradas aqui

Se você usar um mysql workbench, dbeaver ou outro client, vai ser possível conectar no mysql rodando na porta 3306, já que a máquina host está pareando a porta 3306 da imagem que está sendo mantida pelo docker.

Mas esse foi um exemplo super básico, de apenas um serviço. Aplicações profissionais podem ter vários containers se interligando e imagina rodar comandos para cada um desses containers. Diante disso, surgiu o docker-compose, que nada mais é um cara que vai "ler" um arquivo yaml e rodar os comandos que estiverem nele.

Então, se fôssemos converter os comandos do terminal para um arquivo chamado docker-compose.yaml, ficaria assim:

version: 3.8

services:
  mysql_service:
    image: mysql
    container_name: mysql_container
    ports:
      - "3306:3306"
    environment:
      - "MYSQL_ALLOW_EMPTY_PASSWORD=True"

e depois, basta rodar

docker-compose up -d

se tivéssemos mais de um arquivo yml, teríamos de informar para o docker-compose qual arquivo queremos executar. Por exemplo, dentro do diretório exemplo temos dois arquivos:
docker-compose-um.yml e outro_arquivo.yml.

Queremos executar o outro_arquivo.yml em background, ou seja, não vamos ver os logs que vão aparecer no terminal enquanto a imagem estiver sendo constrúida.

Para isso, digitamos:

docker-compose -f outro_arquivo.yml -d

E pronto, os comandos que estiverem dentro desse arquivo aí vão ser executados pelo docker-compose.

Mas agora sim, sem mais delongas, bora fazer nosso mongo e node se acharem nesse mundo de containers.

Nosso arquivo docker-compose.yaml vai ser o seguinte:

version: "3.3"

services:
  mongo_container:
    container_name: mongo
    image: mongo
    volumes:
      - dbdata:/data/db
    ports:
      - "27017:27017"

  node_container:
    depends_on:
      - mongo_container
    build: .
    container_name: api_node
    env_file: ./.env
    command: yarn dev
    ports:
      - "$PORT:$PORT"
    volumes:
      - ".:/source"
      - node_modules:/source/node_modules
    restart: always

volumes:
  dbdata: {}
  node_modules: {}

Rodou esse maluco aí? Então já pode testar usando curl, postman, insomnia ou qualquer outro aplicativo em http://localhost:porta_escolhida_via_env.

E era isso. Legal né?

Uma aplicação node com mongo via docker.

A explicação detalhada desse arquivo aí de cima vou deixar para outro post.

uhul!!!!

Creating a custom Array.prototype.filter in javascript

.·. Felipe Paz .·. — Fri, 11 Jun 2021 17:09:59 +0000

Javascript is a prototype-based language. It means that every native function can receive custom functions or having its original functions modified.

In this article, we will create a custom filter function. For who doesn't know, the filter function is an array prototype function that returns all elements that match against the callback passed as argument. For more information about filter you can check the MDN Doc.

So, without further ado, let's code!

const data = [1, 2, 3, 4, 5];

Array.prototype.myCustomFilter = function (fn) {
  const filtered = []; // it will receive all values that match to condition passed in fn callback.

  for (let i = 0; i < this.length; i++) {
    if (fn(this[i])) {
      filtered.push(this[i]);
    }
  }

  return filtered;
};

const filteredData = data.myCustomFilter(function (el) {
  if (el > 2) return el;
});

// using arrow function
// const filteredData = data.myCustomFilter(el => el > 2);

console.log(filteredData); // output [3,4,5]

Easy, no? But, what really happened here?

Understanding the function

The filter function receives a callback as a parameter. You can find more info about callback here.

Here, we're saying to Array: "Hey dude, you're gonna get a new function called myCustomFilter and it takes a callback function as parameter".

Array.prototype.myCustomFilter = function (fn) {...}

The method filter will return all values that match to condition passed in the callback function.

And here is where the magic happens:

...
for (let i = 0; i < this.length; i++) {
    if (fn(this[i])) {
      filtered.push(this[i]);
    }
  }
...

Once loop has finished, a new array as result is returned containing all values matched to the condition.

const filteredData = data.myCustomFilter(function (el) {
  if (el > 2) return el;
});

And finally our output will be:

console.log(filteredData); // output [3,4,5]

Using the original filter method, our function would become:

const originalFilteredData = data.filter(p => p > 2);
console.log(originalFilteredData); // output [3,4,5]

We cannot forget to mention it that we have some concepts not covered here as the context of this and arrow functions. These guys will be discussed in the future.

I hope you enjoy this article!!

That's all, folks!!!

trying to improve english skills too =D

DEV Community: .·. Felipe Paz .·.

Clonando repositório do Github sem senha

Como Configurar uma Chave SSH para o GitHub

1️⃣ Criando a Chave SSH

2️⃣ Adicionando a Chave ao SSH-Agent

3️⃣ Adicionando a Chave ao GitHub

4️⃣ Testando a Conexão

5️⃣ Alterando o git remote para SSH

6️⃣ Configurando Múltiplos Usuários no GitHub

Criar outra chave SSH

Configurar o arquivo ~/.ssh/config

Alterar a URL do git remote

Implemeting GitOps with Argocd

Prerequisites

External setup

Local setup

Installing Argocd

Installing Skater Reloader

Configuring Argocd

How to test it?

Making any change in the src folder

Creating a new tag

Change kubernetes manifests in the infra/k8s

How to visualize the application?

Circuit Breaker - Um apagador de fogo?

Um Apagador de Fogo?

Por Que Usar um Circuit Breaker?

Maneiras Mais Comuns de Usar Circuit Breaker

Onde Não Usar Circuit Breaker

Circuit Breaker - A Fire Extinguisher for Your Code?

A Fire Extinguisher?

Why Use a Circuit Breaker?

Common Ways to Use Circuit Breaker

Where Not to Use a Circuit Breaker

Getting Started with RabbitMQ and Python: A Practical Guide

Introduction

Summary

Prerequisites

Environment Setup

Docker Setup

Application Development

Running the Application

Example Output

Conclusion

GitHub Repository

Clustering Redis with Kubernetes

NodeJs and setTimeout

Trabalhando com Json e Go

Tags HTML pouco usadas

Datalist

Progress

Meter

Details

Python e Redis: Utilizando Pub/Sub

O que preciso?

O Script

Explicando cada linha

Publicando no canal

Resultado

Dockerizando uma aplicação Node e Mongodb

Docker

Creating a custom Array.prototype.filter in javascript

Understanding the function

5️⃣ Alterando o `git remote` para SSH

Configurar o arquivo `~/.ssh/config`

Alterar a URL do `git remote`