DEV Community: Kaike Castro

Construindo uma Pokédex Simples com Golang e a Poke API

Kaike Castro — Wed, 13 Sep 2023 02:16:47 +0000

Você já quis criar sua própria Pokédex digital para explorar os Pokémon? Neste tutorial, vamos explorar como criar uma Pokédex simples usando a linguagem de programação Golang e a Poke API. Vamos criar uma interface web onde você pode pesquisar e visualizar informações sobre seus Pokémon favoritos.

Pré-requisitos

Antes de começarmos, você precisará ter o Golang instalado em seu sistema. Certifique-se de que sua máquina atenda a esses requisitos e que você tenha um ambiente de desenvolvimento Golang configurado.

Configurando o ambiente

Primeiro, vamos criar uma nova pasta para nosso projeto e inicializar um módulo Go:

mkdir pokedex-golang
cd pokedex-golang
go mod init pokedex

Agora, vamos instalar algumas bibliotecas que iremos utilizar:

go get github.com/gorilla/mux
go get github.com/gorilla/handlers

Criando a estrutura do projeto

Crie os seguintes diretórios para organizar nosso projeto:

mkdir templates

Escrevendo o código

Aqui está o código para nossa aplicação em Golang:

// main.go
package main

import (
 "html/template"
 "net/http"
 "log"
 "github.com/gorilla/mux"
 "github.com/gorilla/handlers"
)

var tpl = template.Must(template.ParseFiles("templates/index.html"))

func IndexHandler(w http.ResponseWriter, r *http.Request) {
 tpl.Execute(w, nil)
}

func main() {
 r := mux.NewRouter()
 r.HandleFunc("/", IndexHandler)

 http.Handle("/", r)

 allowedOrigins := handlers.AllowedOrigins([]string{"*"})
 allowedMethods := handlers.AllowedMethods([]string{"GET", "POST", "OPTIONS"})

 log.Println("Server started on :8080...")
 http.ListenAndServe(":8080", handlers.CORS(allowedOrigins, allowedMethods)(r))
}

Aqui, estamos criando um servidor web simples usando o pacote gorilla/mux para roteamento e gorilla/handlers para permitir solicitações de diferentes origens.

Criando o template HTML

Agora, crie o arquivo index.html dentro da pasta templates:

<!-- templates/index.html -->
<!DOCTYPE html>
<html>
<head>
 <title>Pokédex</title>
</head>
<body>
 <h1>Pokédex</h1>
 <input type="text" id="pokemonName" placeholder="Digite o nome do Pokémon">
 <button onclick="searchPokemon()">Pesquisar</button>
 <div id="pokemonInfo"></div>

 <script>
  function searchPokemon() {
   const name = document.getElementById("pokemonName").value;
   fetch(`https://pokeapi.co/api/v2/pokemon/${name.toLowerCase()}`)
    .then(response => response.json())
    .then(data => {
     const pokemonInfo = document.getElementById("pokemonInfo");
     pokemonInfo.innerHTML = `
      <h2>${data.name}</h2>
      <img src="${data.sprites.front_default}" alt="${data.name}">
      <p>Tipo: ${data.types.map(type => type.type.name).join(', ')}</p>
      <p>Peso: ${data.weight} kg</p>
      <p>Altura: ${data.height} </p>
     `;
    })
    .catch(error => {
     console.error(error);
     alert("Pokémon não encontrado!");
    });
  }
 </script>
</body>
</html>

Este é o template HTML que cria a interface da Pokédex. Ele inclui um campo de pesquisa onde você pode digitar o nome do Pokémon e exibe as informações do Pokémon pesquisado.

Executando o aplicativo

Para iniciar o aplicativo, execute o seguinte comando na raiz do seu projeto:

go run main.go

Agora você pode acessar a Pokédex em seu navegador em http://localhost:8080 e começar a pesquisar seus Pokémon favoritos!

Conclusão

Neste tutorial, construímos uma Pokédex simples usando Golang e a Poke API. Você pode expandir este projeto adicionando mais recursos, como a capacidade de listar todos os Pokémon, salvar Pokémon favoritos ou até mesmo estilizar a interface para torná-la ainda mais parecida com a Pokédex original. Divirta-se explorando o mundo dos Pokémon!

Como criar um Filtro no Amazon SNS para enviar um evento específico para o Amazon SQS

Kaike Castro — Sun, 27 Aug 2023 23:55:07 +0000

Olá, pessoal! Hoje vamos explorar uma solução interessante utilizando os serviços da AWS. Vamos aprender a criar um filtro no Amazon Simple Notification Service (SNS) para filtrar eventos que possuam o status “Finalizado”. Além disso, vamos integrar esse filtro com o Amazon Simple Queue Service (SQS) e construir um leitor de fila utilizando a linguagem de programação Golang.

Configurando o Filtro no Amazon SNS

1.Acesse o Console de Gerenciamento da AWS e navegue até o serviço Amazon SNS.

Crie um novo tópico ou selecione um tópico existente para receber as notificações filtradas.
No tópico escolhido, vá para a aba “Subscrições” e clique em “Criar subscrição”.
Selecione o protocolo desejado para a subscrição (por exemplo, HTTPS, Email, SMS, etc.).
Em “Filtro de tópico avançado”, adicione a condição: {"status": ["Finalizado"]}. Isso fará com que apenas eventos com o status "Finalizado" sejam enviados para esta subscrição.

Configurando a Integração com Amazon SQS

1.Ainda no Console do Amazon SNS, crie um novo tópico ou selecione um tópico existente.
2.No tópico escolhido, vá para a aba “Subscrições” e clique em “Criar subscrição”.
3.Selecione o protocolo SQS e escolha uma fila do SQS existente ou crie uma nova fila.

Criando o Leitor de Fila com Golang

Agora que temos as notificações filtradas sendo enviadas para a fila SQS, vamos criar um programa em Golang para ler essa fila e processar as mensagens.

package main

import (
 "fmt"
 "log"
 "os"
 "time"

 "github.com/aws/aws-sdk-go/aws"
 "github.com/aws/aws-sdk-go/aws/session"
 "github.com/aws/aws-sdk-go/service/sqs"
)

func main() {
 sess := session.Must(session.NewSessionWithOptions(session.Options{
  Config: aws.Config{Region: aws.String("us-east-1")}, 
 }))

 sqsClient := sqs.New(sess)

 queueURL := "URL_DA_FILA_SQS"

 for {
  result, err := sqsClient.ReceiveMessage(&sqs.ReceiveMessageInput{
   QueueUrl:            &queueURL,
   MaxNumberOfMessages: aws.Int64(10), // Número máximo de mensagens a serem recebidas de uma vez
  })

  if err != nil {
   log.Println("Erro ao receber mensagens da fila:", err)
   continue
  }

  for _, msg := range result.Messages {
   fmt.Println("Mensagem:", *msg.Body)

   _, err := sqsClient.DeleteMessage(&sqs.DeleteMessageInput{
    QueueUrl:      &queueURL,
    ReceiptHandle: msg.ReceiptHandle,
   })

   if err != nil {
    log.Println("Erro ao apagar mensagem da fila:", err)
   }
  }

  // Espera um tempo antes de receber mais mensagens (para evitar excesso de requisições)
  time.Sleep(5 * time.Second)
 }
}

Conclusão

Com esses passos, você criou um filtro no Amazon SNS para eventos “Finalizados” e integrou esse filtro com o Amazon SQS. Além disso, criou um leitor de fila em Golang para processar essas mensagens. Essa solução pode ser escalada e personalizada de acordo com as suas necessidades. Divirta-se explorando mais possibilidades com os serviços da AWS e programação em Golang!

Explorando o Amazon Athena na AWS e usando o Athena Express

Kaike Castro — Thu, 24 Aug 2023 01:30:20 +0000

Descubra os Segredos dos Seus Dados com Facilidade

Você já imaginou ter uma maneira rápida e eficiente de analisar grandes volumes de dados armazenados em seu ambiente na nuvem? Bem, a Amazon Web Services (AWS) oferece uma solução poderosa para isso: o Amazon Athena. Neste post, vamos explorar o que é o Amazon Athena, como ele funciona e como você pode utilizar a biblioteca athena-express para simplificar suas consultas. Além disso, faremos um exemplo prático de uma consulta que traz resultados de um conjunto de livros e seus autores

Amazon Athena: Uma Visão Geral

O Amazon Athena é um serviço de consulta interativa que permite analisar dados diretamente no Amazon S3 usando SQL padrão. Ele elimina a necessidade de configurar e manter infraestrutura complexa de banco de dados ou servidores para executar consultas. Em vez disso, você pode simplesmente definir suas tabelas, estruturadas ou semi estruturadas, e começar a executar consultas para obter insights valiosos.

O Athena usa um mecanismo de consulta sob demanda, o que significa que os dados não precisam ser carregados em um banco de dados para serem consultados. Isso proporciona flexibilidade e agilidade, permitindo que você analise seus dados de maneira eficiente, sem as preocupações tradicionais de gerenciamento de banco de dados.

Athena Express: Facilitando Suas Consultas

A biblioteca athena-express é uma ferramenta de código aberto que simplifica a interação com o Amazon Athena ao proporcionar uma interface mais fácil de usar. Ela oferece uma camada de abstração sobre a API do Athena, permitindo que você execute consultas diretamente em seu aplicativo Node.js, sem a necessidade de lidar diretamente com os detalhes de autenticação e comunicação com o serviço.

Exemplo Prático: Consultando Livros e Autores

Agora, vamos dar uma olhada em um exemplo prático de como usar a biblioteca athena-express para consultar um conjunto de dados fictício de livros e seus autores. Suponha que temos os seguintes dados em um array de objetos JavaScript:

const books = [
  { title: 'Aventura Fantástica', author: 'Alice Silva' },
  { title: 'Segredos do Abismo', author: 'Bob Santos' },
  { title: 'Viagem Estelar', author: 'Alice Silva' },
  { title: 'Caminhos Sombrios', author: 'Eva Ribeiro' }
];

Vamos realizar uma consulta usando o athena-express para obter os autores dos livros escritos por 'Alice Silva':

const AthenaExpress = require('athena-express');
const aws = require('aws-sdk');

const awsConfig = {
  region: 'us-east-1', // Região da AWS
};

const athenaExpressConfig = {
  aws,
  awsConfig,
};

const athenaExpress = new AthenaExpress(athenaExpressConfig);

(async () => {
  const query = `
    SELECT author
    FROM books
    WHERE author = 'Alice Silva'
  `;

  try {
    const result = await athenaExpress.query(query);
    console.log('Autores dos livros de Alice Silva:', result.Items);
  } catch (error) {
    console.error('Erro ao executar a consulta:', error);
  }
})();

Neste exemplo, estamos usando a biblioteca athena-express para executar uma consulta SQL simples que seleciona os autores dos livros escritos por 'Alice Silva'. O resultado da consulta será exibido no console.

Conclusão

O Amazon Athena é uma ferramenta poderosa para análise de dados sob demanda, permitindo que você explore e obtenha insights valiosos de seus dados armazenados no Amazon S3. A biblioteca athena-express simplifica ainda mais o processo de consulta, tornando-o mais acessível em aplicativos Node.js. Com essa combinação, você pode explorar seus dados de forma eficiente e tomar decisões informadas com base em insights relevantes.

Introdução ao Step Functions e Exemplo em Golang: Processando Pagamentos de Compras

Kaike Castro — Mon, 21 Aug 2023 02:30:21 +0000

Se você está buscando uma maneira eficiente e escalável de coordenar fluxos de trabalho em suas aplicações, o AWS Step Functions é uma ferramenta poderosa a ser considerada. Neste post, vamos explorar o que é o Step Functions e como ele pode ser usado para gerenciar fluxos de trabalho complexos. Além disso, iremos apresentar um exemplo prático em Golang, demonstrando como você pode usar o Step Functions para validar um pagamento de uma compra.

O que é o AWS Step Functions?

O AWS Step Functions é um serviço de orquestração de fluxos de trabalho que permite coordenar e gerenciar a execução de várias etapas e serviços em uma aplicação. Ele ajuda a simplificar processos complexos, automatizando a coordenação entre diferentes componentes do sistema e permitindo a construção de fluxos de trabalho visuais e de fácil manutenção.

As principais características do Step Functions incluem:

Coordenação Simplificada: O serviço permite definir fluxos de trabalho como máquinas de estado, onde cada etapa é uma função ou um serviço executado em resposta a um evento.
Visibilidade: O Step Functions oferece visibilidade completa sobre o status e o progresso de cada etapa do fluxo de trabalho, tornando a depuração e o monitoramento mais fáceis.
Flexibilidade: É possível adicionar, remover ou modificar etapas do fluxo de trabalho sem a necessidade de reescrever todo o código. Isso facilita a evolução e a adaptação da aplicação.
Integração com AWS: O serviço é integrado com outros serviços da AWS, permitindo que você coordene facilmente os recursos da nuvem em seus fluxos de trabalho.

Exemplo : Validação de Pagamento

Imagine que você está construindo uma aplicação de comércio eletrônico e deseja automatizar o processo de pagamento. Vamos criar um exemplo em Golang usando o Step Functions para ilustrar como isso pode ser feito.

Definindo o Fluxo de Trabalho:

Primeiro, você define o fluxo de trabalho como uma máquina de estados. No AWS Step Functions, isso é feito através da definição do JSON que descreve as etapas do fluxo. Cada etapa pode ser uma função Lambda, um serviço da AWS, ou até mesmo um passo personalizado.


{
  "StartAt": "ProcessPayment",
  "States": {
    "ProcessPayment": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:REGION:ACCOUNT_ID:function:ProcessPaymentFunction",
      "End": true
    }
  }
}

Processando o Pagamento:

Crie uma função Lambda chamada ProcessPaymentFunction que recebe os detalhes do pagamento, valida-os e retorna o resultado.

package main

import (
 "fmt"
)

func ProcessPayment(paymentDetails map[string]interface{}) (string, error) {
 amount := paymentDetails["amount"].(float64)
 if amount > 0 {
  return "Payment approved", nil
 }

 return "Payment declined", fmt.Errorf("Payment amount is invalid")
}

func main() {
 paymentDetails := map[string]interface{}{
  "amount": 100.0,
  "card":   "1234-5678-9012-3456",
 }

 result, err := ProcessPayment(paymentDetails)
 if err != nil {
  fmt.Println("Error:", err)
 } else {
  fmt.Println(result)
 }
}

Nesse exemplo, a função ProcessPaymentFunction simplesmente valida se o valor do pagamento é maior que zero para aprovar o pagamento. Este é um exemplo muito básico e simplificado; em um ambiente real, você precisaria adicionar lógica mais robusta para validar os detalhes do pagamento e interagir com serviços externos, como provedores de pagamento ou bancos.

Rodando o Step Functions:

package main

import (
 "fmt"
 "github.com/aws/aws-sdk-go/aws"
 "github.com/aws/aws-sdk-go/aws/session"
 "github.com/aws/aws-sdk-go/service/sfn"
)

func main() {
 // Configurar uma sessão AWS
 sess := session.Must(session.NewSessionWithOptions(session.Options{
  SharedConfigState: session.SharedConfigEnable,
 }))

 // Criar um cliente do AWS Step Functions
 svc := sfn.New(sess)

 // Definir a ARN do seu fluxo de trabalho do Step Functions
 stateMachineArn := "arn:aws:states:us-east-1:123456789012:stateMachine:ProcessPayment"

 // Definir a entrada para o fluxo de trabalho (no formato JSON)
 input := `{
  "paymentDetails": {
   "amount": 100.0,
   "card": "1234-5678-9012-3456"
  }
 }`

 // Iniciar o fluxo de trabalho
 startInput := &sfn.StartExecutionInput{
  StateMachineArn: aws.String(stateMachineArn),
  Input:           aws.String(input),
 }

 result, err := svc.StartExecution(startInput)
 if err != nil {
  fmt.Println("Error starting execution:", err)
  return
 }

 fmt.Println("Execution started with ARN:", aws.StringValue(result.ExecutionArn))
}

Certifique-se de que você tenha configurado as credenciais da AWS corretamente e instalado as dependências (github.com/aws/aws-sdk-go neste caso) usando um gerenciador de pacotes Go, como go get.

Conclusão:

O AWS Step Functions é uma ferramenta poderosa para coordenar e orquestrar fluxos de trabalho complexos em suas aplicações. Neste post, demos uma introdução ao conceito de Step Functions e como ele pode ser usado para gerenciar fluxos de trabalho. Além disso, apresentamos um exemplo prático em Golang que demonstra como validar um pagamento de uma compra usando o Step Functions.

Se você está lidando com processos complexos que envolvem várias etapas e serviços, o Step Functions pode ser uma solução valiosa para simplificar a coordenação e melhorar a eficiência de suas aplicações.

Criando Testes Unitários em Golang usando a Poke API

Kaike Castro — Tue, 01 Aug 2023 01:16:35 +0000

Olá, pessoal! Hoje vamos aprender como criar testes unitários em Golang utilizando a Poke API como exemplo. Os testes unitários são fundamentais para garantir a qualidade do código e facilitar a manutenção. Vamos lá!

Pré-requisitos:

Ter o Go (Golang) instalado no seu sistema.
Ter um editor de código de sua preferência (VSCode, GoLand, Sublime, etc.).

Passo 1: Configuração do Ambiente

Certifique-se de ter o ambiente de desenvolvimento Go configurado corretamente em sua máquina. Você pode verificar isso executando o comando go version no terminal.

Passo 2: Instalação das Dependências

Para realizar as requisições à Poke API, vamos utilizar a biblioteca "net/http" do Go. Certifique-se de que ela está instalada. Caso não esteja, execute o seguinte comando no terminal:

go get -u net/http

Passo 3: Criando o Código

Agora, vamos criar nosso código e testes. Vamos criar uma função que consulta a Poke API para obter informações sobre um Pokémon específico. O código para isso seria o seguinte (vamos supor que ele está no arquivo pokeapi.go):


package main

import (
    "encoding/json"
    "fmt"
    "net/http"
)

// Pokemon representa a estrutura de dados do Pokémon
type Pokemon struct {
    Name         string `json:"name"`
    Height       int    `json:"height"`
    Weight       int    `json:"weight"`
    BaseExperience int  `json:"base_experience"`
}

// GetPokemonInfo faz uma requisição à Poke API e retorna as informações de um Pokémon específico.
func GetPokemonInfo(pokemonName string) (*Pokemon, error) {
    url := fmt.Sprintf("https://pokeapi.co/api/v2/pokemon/%s", pokemonName)

    resp, err := http.Get(url)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("failed to get Pokemon info: %s", resp.Status)
    }

    var pokemon Pokemon
    if err := json.NewDecoder(resp.Body).Decode(&pokemon); err != nil {
        return nil, err
    }

    return &pokemon, nil
}

Passo 4: Criando os Testes Unitários

Agora vamos criar os testes unitários para a função GetPokemonInfo. Para isso, criaremos um novo arquivo chamado pokeapi_test.go:


package main

import (
    "testing"
)

func TestGetPokemonInfo(t *testing.T) {
    pokemonName := "pikachu"
    pokemon, err := GetPokemonInfo(pokemonName)

    if err != nil {
        t.Errorf("Error while getting Pokemon info: %v", err)
    }

    if pokemon.Name != pokemonName {
        t.Errorf("Expected Pokemon name '%s', but got '%s'", pokemonName, pokemon.Name)
    }

    // Aqui você pode adicionar mais verificações para os outros campos do Pokémon
}

Passo 5: Executando os Testes

Agora que os testes estão prontos, vamos executá-los para verificar se tudo está funcionando corretamente. No terminal, navegue até o diretório onde estão os arquivos pokeapi.go e pokeapi_test.go e execute o seguinte comando:

go test

Se tudo estiver correto, você verá uma mensagem indicando que os testes passaram. Caso algum teste falhe, a mensagem de erro detalhará o que aconteceu.

E pronto! Agora você aprendeu como criar testes unitários em Golang utilizando a Poke API como exemplo. Testes unitários são uma prática importante para garantir a robustez e confiabilidade de suas aplicações. Continue praticando e aprimorando suas habilidades em Go! 🚀

Como criar uma instância EC2 usando Terraform, adicionar um backend S3 e instalar o Docker

Kaike Castro — Mon, 17 Jul 2023 00:33:11 +0000

Neste tutorial, você aprenderá como criar uma instância EC2 (Elastic Compute Cloud) na AWS usando o Terraform, adicionar um backend S3 para armazenar o estado remoto do Terraform e, em seguida, como acessar a instância EC2 e instalar o Docker nela.

Configuração do ambiente

Certifique-se de ter o Terraform instalado no seu computador. Acesse o site oficial do Terraform para obter as instruções de instalação.

Criar um bucket no S3

Acesse o console da AWS e crie um novo bucket no serviço S3. Escolha um nome único e uma região para o bucket.

Segue uma breve explicação por que usamos o backend s3 no terraform.

Como funciona o backend S3 no Terraform

Estado remoto: Com o backend S3 configurado, o estado do Terraform (o arquivo "terraform.tfstate") será armazenado no bucket S3 que você especificou. Isso significa que, em vez de ser armazenado localmente, o estado será armazenado de forma remota em um local seguro e durável.
Colaboração em equipe: O uso de um backend remoto permite que várias pessoas trabalhem juntas em um mesmo projeto Terraform sem que ocorram conflitos no estado. Cada membro da equipe obtém a versão mais recente do estado do bucket S3 e pode trabalhar com segurança, sabendo que as alterações são mantidas consistentes.
Rastreamento de histórico: O backend S3 mantém um histórico de alterações no estado do Terraform, permitindo que você reverta ou veja o histórico de alterações ao longo do tempo.
Segurança e Durabilidade: A AWS oferece recursos de segurança e durabilidade para os buckets do S3, garantindo a integridade e a disponibilidade do estado do Terraform.

Criar um arquivo de configuração do Terraform

Crie um arquivo chamado "main.tf" e insira o seguinte conteúdo:

terraform {
  backend "s3" {
    bucket = "seu-bucket-terraform"  # Substitua pelo nome do bucket criado anteriormente
    key    = "terraform.tfstate"
    region = "us-east-1"  # Substitua pela região do bucket
  }
}

provider "aws" {
  region = "us-east-1"  # Substitua pela região desejada
}

resource "aws_instance" "ec2_instance" {
  ami           = "ami-0c55b159cbfafe1f0"  # AMI da região us-east-1 (Amazon Linux 2)
  instance_type = "t2.micro"  # Tipo da instância (pode ser alterado)

  tags = {
    Name = "MinhaEC2"
  }
}

Inicializar o Terraform

Abra um terminal ou prompt de comando, navegue até o diretório onde você criou o arquivo "main.tf" e execute os seguintes comandos:

terraform init

Aplicar a configuração

Após a inicialização do Terraform, execute o comando para aplicar a configuração:

terraform apply

Confirme a ação digitando "yes" quando solicitado.

Acessar a instância EC2

Após o Terraform concluir a criação da instância EC2, você receberá informações sobre a instância criada. Procure pelo atributo "public_ip" que contém o endereço IP público da instância.

Use um terminal SSH (se estiver no Linux ou macOS) ou um cliente SSH como o PuTTY (se estiver no Windows) para acessar a instância EC2. O comando para se conectar via SSH é:

ssh -i /caminho/para/sua/chave.pem ec2-user@seu_ip_publico

Lembre-se de substituir "/caminho/para/sua/chave.pem" pelo caminho para a chave privada (.pem) que você usou ao criar a instância e "seu_ip_publico" pelo endereço IP público da instância EC2.

Instalar o Docker

Agora que você está conectado à instância EC2 via SSH, vamos instalar o Docker:

sudo yum update -y
sudo amazon-linux-extras install docker
sudo service docker start
sudo usermod -a -G docker ec2-user

Após executar esses comandos, o Docker deve estar instalado e em execução na sua instância EC2.

Conclusão

Parabéns! Agora você aprendeu como criar uma instância EC2 usando o Terraform, adicionar um backend S3 para armazenar o estado remoto do Terraform, acessá-la através do SSH e instalar o Docker na instância. A partir desse ponto, você pode implantar e executar seus aplicativos Docker na instância EC2.

Lembre-se de desalocar os recursos quando não estiverem em uso para evitar custos não desejados. Para isso, você pode usar o Terraform para destruir os recursos criados:

terraform destroy

Espero que este tutorial tenha sido útil! Se tiver alguma dúvida ou sugestão, sinta-se à vontade para perguntar.

Criando um cluster do Kafka com Docker Compose e desenvolvendo um Consumer e Producer em Golang

Kaike Castro — Mon, 03 Jul 2023 03:33:50 +0000

Introdução:

O Apache Kafka é uma plataforma de streaming distribuída que permite o envio e a recepção de fluxos de eventos em tempo real. No contexto do Kafka, um Producer é responsável por enviar mensagens para um ou mais tópicos, enquanto um Consumer é responsável por receber essas mensagens e processá-las.

Neste tutorial, vamos explorar como configurar um cluster do Kafka usando Docker Compose e desenvolver um Consumer e um Producer usando a linguagem de programação Go (Golang). Essa combinação é ideal para construir aplicações escaláveis e de alto desempenho que podem se beneficiar do poder e da flexibilidade do Kafka.

Pré-requisitos:

Antes de começar, certifique-se de ter os seguintes itens instalados em sua máquina:

Docker: https://docs.docker.com/get-docker/
Docker Compose: https://docs.docker.com/compose/install/
Go (Golang): https://golang.org/doc/install

Configurando o Kafka com Docker Compose:

Comece criando um arquivo chamado docker-compose.yml no diretório de sua escolha e adicione o seguinte conteúdo:

version: '3'
services:
  zookeeper:
    image: confluentinc/cp-zookeeper:latest
    ports:
      - "2181:2181"
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181
      ZOOKEEPER_TICK_TIME: 2000

  kafka:
    image: confluentinc/cp-kafka:latest
    depends_on:
      - zookeeper
    ports:
      - "9092:9092"
    environment:
      KAFKA_BROKER_ID: 1
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: PLAINTEXT:PLAINTEXT,PLAINTEXT_HOST:PLAINTEXT
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:9092,PLAINTEXT_HOST://localhost:9092
      KAFKA_LISTENERS: PLAINTEXT://0.0.0.0:9092,PLAINTEXT_HOST://0.0.0.0:9092
      KAFKA_AUTO_CREATE_TOPICS_ENABLE: "true"
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
      KAFKA_GROUP_INITIAL_REBALANCE_DELAY_MS: 0

Neste arquivo, estamos configurando dois serviços: o ZooKeeper, que é necessário para o funcionamento do Kafka, e o Kafka em si. A porta 2181 é usada para se conectar ao ZooKeeper e a porta 9092 para se conectar ao Kafka. Note que definimos a propriedade KAFKA_ADVERTISED_LISTENERS para que o Kafka seja acessível tanto dentro do contêiner (PLAINTEXT://kafka:9092) quanto fora (PLAINTEXT_HOST://localhost:9092).

Para iniciar o cluster do Kafka, execute o seguinte comando na raiz do seu projeto:

docker-compose up -d

O papel do ZooKeeper no Kafka

O ZooKeeper é um serviço centralizado usado pelo Kafka para coordenar e gerenciar os nós do cluster. Ele é responsável por eleger um líder para cada partição do tópico, manter informações de configuração e status dos nós, além de auxiliar na detecção de falhas e no processo de failover.

No nosso exemplo, configuramos o ZooKeeper como um serviço separado no Docker Compose. O Kafka depende do ZooKeeper para registrar e manter as informações do cluster, garantindo que todos os nós estejam sincronizados.

Configurando o ambiente Go

Agora que o Kafka está em execução, vamos configurar nosso ambiente Go para desenvolver o Consumer e o Producer. Abra um terminal e crie um novo diretório para o projeto. Dentro dele, inicialize um módulo Go executando o seguinte comando:

go mod init kafka-tutorial

Isso criará um arquivo go.mod para gerenciar as dependências do projeto.

Vamos usar a lib Sarama
A lib Sarama é uma biblioteca cliente para interagir com o Apache Kafka em Go. Ela fornece uma API fácil de usar para criar produtores e consumidores de mensagens Kafka, bem como administrar tópicos, partições e offsets.

Para instalá-la, execute o seguinte comando:

go get github.com/Shopify/sarama

Criando o Consumer e o Producer:

Agora vamos criar os arquivos consumer.go e producer.go para implementar o Consumer e o Producer, respectivamente.

No consumer.go, adicione o seguinte código:

package main

import (
    "fmt"
    "log"

    "github.com/Shopify/sarama"
)

func main() {
    consumer, err := sarama.NewConsumer([]string{"localhost:9092"}, nil)
    if err != nil {
        log.Fatalln("Failed to start consumer:", err)
    }
    defer func() {
        if err := consumer.Close(); err != nil {
            log.Fatalln("Failed to close consumer:", err)
        }
    }()

    partitionConsumer, err := consumer.ConsumePartition("test-topic", 0, sarama.OffsetOldest)
    if err != nil {
        log.Fatalln("Failed to start partition consumer:", err)
    }
    defer func() {
        if err := partitionConsumer.Close(); err != nil {
            log.Fatalln("Failed to close partition consumer:", err)
        }
    }()

    for message := range partitionConsumer.Messages() {
        fmt.Printf("Received message: Key = %s, Value = %s\n", string(message.Key), string(message.Value))
    }
}

No producer.go, adicione o seguinte código:

package main

import (
    "log"

    "github.com/Shopify/sarama"
)

func main() {
    producer, err := sarama.NewSyncProducer([]string{"localhost:9092"}, nil)
    if err != nil {
        log.Fatalln("Failed to start producer:", err)
    }
    defer func() {
        if err := producer.Close(); err != nil {
            log.Fatalln("Failed to close producer:", err)
        }
    }()

    message := &sarama.ProducerMessage{
        Topic: "test-topic",
        Value: sarama.StringEncoder("Hello, Kafka!"),
    }

    partition, offset, err := producer.SendMessage(message)
    if err != nil {
        log.Fatalln("Failed to send message:", err)
    }

    log.Printf("Message sent! Partition = %d, Offset = %d\n", partition, offset)
}

No código acima, estamos no Consumer se conectando ao Kafka e consumindo mensagens do tópico "test-topic" a partir do offset mais antigo. No Producer, estamos enviando uma mensagem com o valor "Hello, Kafka!" para o tópico "test-topic".

Executando o Consumer e o Producer

Para executar o Producer, abra um terminal, navegue até o diretório do projeto e execute o seguinte comando:

go run producer.go

Para executar o Consumer, abra outro terminal, navegue até o diretório do projeto e execute o seguinte comando:

go run consumer.go

Agora você verá o Consumer recebendo a mensagem enviada pelo Producer.

Conclusão:

Neste tutorial, aprendemos como configurar um cluster do Kafka usando Docker Compose e como desenvolver um Consumer e um Producer usando a linguagem Go. O Kafka é uma poderosa plataforma de streaming que pode ser integrada a várias aplicações para processar eventos em tempo real. Com essa combinação, você está pronto para construir aplicações escaláveis

Criando APIs em Go e utilizando KrakenD para unir informações

Kaike Castro — Mon, 19 Jun 2023 02:49:45 +0000

Olá, pessoal! Hoje vou compartilhar com vocês como criar duas APIs em Go e utilizar o KrakenD para fazer o merge de informações. Vamos lá!

Configuração do ambiente

Certifique-se de ter o Go instalado em seu sistema. Você pode baixar a versão mais recente do site oficial. Além disso, vamos utilizar o KrakenD como nosso gateway API. Você pode encontrar o KrakenD em https://www.krakend.io/.

Criando as APIs

Vamos criar duas APIs simples em Go. Para fins de demonstração, uma API fornecerá informações de usuários e a outra fornecerá informações de produtos. Vamos chamá-las de "user-api" e "product-api", respectivamente.

Dentro do diretório do projeto, crie uma pasta chamada "user-api" e outra chamada "product-api". Em cada pasta, crie um arquivo "main.go" com o seguinte conteúdo:

user-api/main.go:

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
)

type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

func getUser(w http.ResponseWriter, r *http.Request) {
    user := User{
        ID:   1,
        Name: "John Doe",
    }

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(user)
}

func main() {
    http.HandleFunc("/user", getUser)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

product-api/main.go:

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
)

type Product struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

func getProduct(w http.ResponseWriter, r *http.Request) {
    product := Product{
        ID:   1,
        Name: "Sample Product",
    }

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(product)
}

func main() {
    http.HandleFunc("/product", getProduct)
    log.Fatal(http.ListenAndServe(":8081", nil))
}

Configurando o KrakenD

Agora, vamos configurar o KrakenD para fazer o merge das informações das duas APIs. Crie um arquivo chamado "krakend.json" na raiz do projeto com o seguinte conteúdo:

{
  "version": 2,
  "endpoints": [
    {
      "endpoint": "/user",
      "backend": [
        {
          "url_pattern": "/user",
          "host": ["http://localhost:8080"]
        }
      ]
    },
    {
      "endpoint": "/product",
      "backend": [
        {
          "url_pattern": "/product",
          "host": ["http://localhost:8081"]
        }
      ]
    }
  ]
}

Executando o KrakenD

Agora, vamos executar o KrakenD para iniciar nosso gateway API. Abra o terminal e navegue até o diretório raiz do projeto. Em seguida, execute o seguinte comando:

krakend run -c krakend.json

O KrakenD irá ler o arquivo de configuração e iniciar o servidor.

Testando a API

Agora, você pode testar a API acessando os seguintes endpoints:

http://localhost:8080/user: Retorna informações do usuário.
http://localhost:8081/product: Retorna informações do produto.

Além disso, você pode acessar as seguintes URLs através do KrakenD:

http://localhost:8082/user: Retorna informações do usuário através do KrakenD.
http://localhost:8082/product: Retorna informações do produto através do KrakenD.

O KrakenD irá fazer o merge das informações obtidas das APIs "user-api" e "product-api" e fornecer os dados combinados.

Conclusão

Espero que este tutorial tenha sido útil para você entender como criar APIs em Go e utilizar o KrakenD para unir informações de diferentes fontes. Divirta-se explorando as possibilidades que essa combinação oferece. Até a próxima!

Como testar o locust localmente com docker

Kaike Castro — Tue, 16 May 2023 22:37:43 +0000

Para subir o Locust usando o Docker Compose, siga os passos abaixo:

Instalação do Docker e Docker Compose: Certifique-se de ter o Docker e o Docker Compose instalados em seu sistema. Visite o site oficial do Docker e siga as instruções de instalação para o seu sistema operacional.

Criação do arquivo de script

Crie um arquivo script.py para definir o comportamento dos usuários simulados. Nesse arquivo, você precisará importar as classes FastHttpUser e Task do módulo locust e criar classes que herdem delas. Dentro dessas classes, você pode definir os diferentes comportamentos dos usuários e as tarefas que eles executarão.

Exemplo de um código que executa


from locust import task, constant
from locust.contrib.fasthttp import FastHttpUser

class TestCase(FastHttpUser):
    wait_time = constant(.01)
    weight = 1

    @task(1)
    def google(this):
        this.client.get("https://www.google.com.br/search?q=locust", name="Google")

Criação do arquivo Dockerfile

Crie um arquivo chamado Dockerfile (sem extensão) e abra-o em um editor de texto. Adicione o seguinte conteúdo ao arquivo:

FROM locustio/locust

RUN pip install gevent

Criação do arquivo Docker Compose.yml

Crie um arquivo chamado docker-compose.yml e abra-o em um editor de texto. Adicione o seguinte conteúdo ao arquivo:

version: '3'

services:
  master:
    image: locust-master
    build: ./
    ports:
      - '8089:8089'
    volumes:
      - ./:/mnt/locust
    command: -f /mnt/locust/script.py --master -H http://master:8089

  worker1:
    image: locust-work
    build: ./
    volumes:
      - ./:/mnt/locust
    command: -f /mnt/locust/script.py --worker --master-host master

 worker2:
    image: locust-work
    build: ./
    volumes:
      - ./:/mnt/locust
    command: -f /mnt/locust/script.py --worker --master-host master

Neste arquivo definimos um cluster master que vai ficar responsável em mostrar a parte de host do locust e outro 2 workers para distribuir a carga para o sistema.

Execução

Abra um terminal e navegue até o diretório onde o arquivo docker-compose.yml está localizado. Execute o seguinte comando para iniciar o Locust:

docker-compose up

Isso iniciará o serviço Locust usando as configurações definidas no arquivo docker-compose.yml. A porta 8089 do contêiner será mapeada para a porta 8089 do seu sistema local, permitindo que você acesse a interface web do Locust.

Acesso à interface web: Abra um navegador da web e acesse http://localhost:8089. Você verá a interface web do Locust, onde poderá configurar o número de usuários virtuais a serem gerados e iniciar a simulação de carga.

Agora você pode usar o Locust em um ambiente Docker com o Docker Compose para realizar testes de carga e avaliar o desempenho do sistema. Lembre-se de ajustar as configurações de acordo com os requisitos do seu teste e interpretar corretamente os resultados obtidos.

Como subir uma aplicação com Terraform com Fargate

Kaike Castro — Fri, 12 May 2023 02:47:08 +0000

A seguir, você encontrará um guia passo a passo de como subir uma aplicação Fargate na AWS com Terraform:

Certifique-se de ter uma conta na AWS e um ambiente de desenvolvimento configurado em sua máquina.

Crie um arquivo de configuração do Terraform chamado "main.tf" e defina suas credenciais da AWS, a região e o provedor que você está usando:

provider "aws" {
  access_key = "SUA_ACCESS_KEY"
  secret_key = "SUA_SECRET_KEY"
  region     = "US-WEST-2"
}

Defina uma VPC (Virtual Private Cloud) onde sua aplicação será executada:

resource "aws_vpc" "my_vpc" {
  cidr_block = "10.0.0.0/16"
  tags = {
    Name = "My VPC"
  }
}

Em seguida, crie um sub-rede dentro da VPC:

resource "aws_subnet" "my_subnet" {
  vpc_id     = aws_vpc.my_vpc.id
  cidr_block = "10.0.1.0/24"
  tags = {
    Name = "My Subnet"
  }
}

Defina uma regra de segurança para a aplicação:

resource "aws_security_group" "my_security_group" {
  name_prefix = "my-security-group"
  vpc_id      = aws_vpc.my_vpc.id

  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

Crie um cluster ECS (Elastic Container Service) para a aplicação:

resource "aws_ecs_cluster" "my_cluster" {
  name = "My Cluster"
}

Em seguida, crie uma definição de tarefa ECS que será usada para executar sua aplicação:

data "template_file" "my_task_definition" {
  template = file("${path.module}/task_definition.json")

  vars = {
    image_name = "my-image-name"
    port       = "80"
  }
}

resource "aws_ecs_task_definition" "my_task_definition" {
  family                   = "my-task-definition"
  container_definitions    = data.template_file.my_task_definition.rendered
  requires_compatibilities = ["FARGATE"]
}

Crie um serviço ECS que irá executar a tarefa:

resource "aws_ecs_service" "my_service" {
  name            = "My Service"
  cluster         = aws_ecs_cluster.my_cluster.arn
  task_definition = aws_ecs_task_definition.my_task_definition.arn
  desired_count   = 1
  launch_type     = "FARGATE"

  network_configuration {
    subnets          = [aws_subnet.my_subnet.id]
    security_groups  = [aws_security_group.my_security_group.id]
    assign_public_ip = true
  }
}

Dicas

Ao iniciar instâncias Fargate elas não podem ter o mesmo numero de cpu e memória idênticos abaixo segue uma tabela de como definir cpu e memória

CPU value	Memory value	Operating systems supported for AWS Fargate
256 (.25 vCPU)	512 MiB, 1 GB, 2 GB	Linux
512 (.5 vCPU)	1 GB, 2 GB, 3 GB, 4 GB	Linux
1024 (1 vCPU)	2 GB, 3 GB, 4 GB, 5 GB, 6 GB, 7 GB, 8 GB	Linux, Windows
2048 (2 vCPU)	Between 4 GB and 16 GB in 1 GB increments	Linux, Windows
4096 (4 vCPU)	Between 8 GB and 30 GB in 1 GB increments	Linux, Windows
8192 (8 vCPU)	Between 16 GB and 60 GB in 4 GB increments	Linux
16384 (16vCPU)	Between 32 GB and 120 GB in 8 GB increments	Linux

Por fim, execute o comando "terraform init" para inicializar o projeto e "terraform apply" para criar a infraestrutura na AWS.
Este é um exemplo simples de como subir uma aplicação Fargate na AWS usando Terraform. Você pode personalizar e ajustar os recursos conforme necessário para atender às necessidades do seu aplicativo.