Criando um Pipeline Multi-Branch no Jenkins para 11 Microserviços no AWS EKS

Quer configurar um pipeline de integração contínua e entrega contínua (CI/CD para microserviços) para sua aplicação? Se alguns desses termos parecem complicados, relaxe! Este guia vai te mostrar tudo passo a passo, explicando cada detalhe do processo e o porquê de cada ação. Vamos construir um sistema automatizado que pega o código dos desenvolvedores, empacota em containers e envia para a nuvem, tudo com o mínimo de intervenção manual. Ao final, você terá um pipeline de nível profissional, usado por muitas empresas de tecnologia.

O que vamos construir

Vamos configurar um pipeline automatizado para um aplicativo de e-commerce composto por 11 microsserviços. Cada um deles cuida de uma função específica, trabalhando juntos para criar uma experiência de compra completa. Veja alguns dos principais serviços:

• Interface do Cliente (Frontend): É o site que os clientes veem e usam. Ele se conecta aos serviços de backend para mostrar os produtos, processar as ações dos usuários e cuidar dos pedidos.
• Serviço de Carrinho (Gerenciamento do Carrinho de Compras): Acompanha os itens que o cliente adiciona ao carrinho antes de finalizar a compra, garantindo que os dados sejam armazenados e atualizados em tempo real.
• Serviço de Pagamento (Processamento de Transações): Processa os pagamentos dos clientes de forma segura, interagindo com os gateways de pagamento para confirmar as transações.
• Serviço de Envio (Logística de Pedidos): Gerencia os detalhes de envio, calcula os prazos de entrega e rastreia os pedidos após saírem do armazém.
• Serviço de E-mail (Notificações e Comunicação): Envia confirmações de pedido, atualizações de envio e e-mails promocionais aos clientes.

Outros microsserviços, como Catálogo de Produtos, Serviço de Recomendação e Serviço de Checkout, ajudam a completar a experiência de compra, cuidando dos anúncios de produtos, recomendações personalizadas e processamento final dos pedidos.

O legal dos microsserviços é que dá para atualizar uma parte do aplicativo sem mexer nas outras. Pense neles como luzes de Natal: se uma queima, você troca só ela, sem precisar trocar o resto do pisca-pisca. Cada luz funciona sozinha, mas juntas criam uma experiência completa!

Por que isso é importante?

Antes de entrarmos nos detalhes técnicos, vamos entender por que essa abordagem é tão valiosa:

1. Desenvolvimento e Implantação Independentes: Cada microsserviço pode ser desenvolvido, testado e implantado separadamente, permitindo que as equipes trabalhem em diferentes partes sem afetar o aplicativo inteiro.
2. Escalabilidade: Os microsserviços podem ser escalados individualmente, conforme a demanda. Se uma parte do sistema recebe muito tráfego, só ela precisa ser escalada, economizando recursos e custos.
3. Flexibilidade Tecnológica: As equipes podem usar diferentes linguagens de programação, bancos de dados e frameworks, escolhendo o que for melhor para cada serviço, em vez de ficarem presas a uma única tecnologia.
4. Isolamento de Falhas e Resiliência: Se um microsserviço falha, não derruba o sistema todo. A falha fica isolada, aumentando a confiabilidade e disponibilidade do sistema.
5. Desenvolvimento e Inovação Mais Rápidos: Serviços menores e independentes permitem ciclos de desenvolvimento mais rápidos, com atualizações e novos recursos lançados com mais frequência.
6. Melhor Manutenção: Como cada serviço tem um código menor e um objetivo claro, fica mais fácil atualizar, corrigir erros e refatorar sem afetar outras partes do sistema.
7. Segurança e Conformidade Aprimoradas: Dados confidenciais e regras de negócio podem ser isolados em microsserviços específicos, facilitando a aplicação de políticas de segurança e o cumprimento de normas.

Ferramentas que usaremos no CI/CD para microserviços

Vamos usar várias ferramentas importantes:

• GitHub: Para guardar nosso código.
• Jenkins: Para automatizar nossos processos de construção e implantação.
• Docker: Para empacotar nossos aplicativos em containers.
• Kubernetes (EKS): Para gerenciar como nossos containers rodam na nuvem.
• AWS: Para fornecer a infraestrutura de nuvem onde tudo vai rodar.

Se você não conhece todas elas, não se preocupe! Vou explicar cada uma ao longo do caminho.

Passo 1: Configurando nosso servidor

Primeiro, precisamos de um computador na nuvem (uma instância EC2) que vai rodar o Jenkins e gerenciar nosso cluster Kubernetes.

Criando uma instância EC2

1. Acesse sua conta da AWS.
2. Vá para o serviço EC2.
3. Clique em “Launch Instance”.
4. Escolha um nome para sua instância (ex: “Jenkins-Kubernetes-Server”).
5. Selecione uma Amazon Machine Image (AMI) com Ubuntu.
6. Escolha o tipo de instância: t2.large (2 vCPUs, 8GB de memória).
7. Configure o armazenamento: mínimo de 20 GB.
8. Crie ou selecione um par de chaves para acesso SSH.
9. Inicie a instância.
10. Configure as regras de entrada da sua instância com as portas mostradas na imagem abaixo.

Passo 2: Configurando as permissões da AWS

Antes de criar nosso cluster Kubernetes, precisamos configurar as permissões certas.

Criando um usuário IAM para EKS

1. No console da AWS, vá para IAM (Identity and Access Management).
2. Crie um novo usuário chamado “eks-devops” (ou o nome que preferir).
3. Anexe as seguintes políticas de permissão:
   • AmazonEKSClusterPolicy
   • AmazonEKSServicePolicy
   • AmazonEC2FullAccess
   • AmazonS3FullAccess
   • IAMFullAccess
   • AmazonVPCFullAccess
4. Crie uma política inline com as permissões necessárias:

Gere chaves de acesso para este usuário e guarde-as em um lugar seguro.

Passo 3: Instalando as ferramentas essenciais no servidor

Agora, vamos nos conectar à nossa instância EC2 e instalar as ferramentas que precisamos.

Conectando à sua instância EC2

Você também pode se conectar ao EC2 usando o MobaXterm.

Depois de acessar sua instância EC2 via ssh, execute o seguinte comando:

Instalando o AWS CLI

Configurando o AWS CLI

Quando solicitado, digite:

• AWS Access Key ID: [Sua chave de acesso]
• AWS Secret Access Key: [Sua chave secreta]
• Default region name: af-south-1 (sua região preferida)
• Default output format: json

Instalando o kubectl

Para Iniciantes: kubectl é uma ferramenta de linha de comando que nos permite interagir e gerenciar um cluster Kubernetes. Pense nele como um controle remoto para sua configuração Kubernetes, permitindo que você implante aplicativos, verifique o status e faça alterações, tudo pelo terminal.

Instalando o eksctl

Para Iniciantes: eksctl é uma ferramenta feita especialmente para facilitar a criação de clusters Kubernetes na AWS.

Uma alternativa é criar um script para instalar todas as ferramentas.

Passo 4: Criando um cluster Kubernetes na AWS

Agora vamos criar nosso cluster Kubernetes, onde nosso aplicativo vai rodar.

Criando o cluster EKS

Para Iniciantes: Este comando cria um cluster Amazon EKS (Elastic Kubernetes Service).

Configurando a identidade e o acesso para Kubernetes

Para Iniciantes: Este comando configura uma relação de confiança segura entre seu cluster EKS e a AWS, permitindo que os aplicativos Kubernetes acessem os serviços da AWS com segurança, sem guardar credenciais de longo prazo.

Adicionando nós de trabalho ao nosso cluster

Para Iniciantes: Estamos adicionando máquinas de trabalho (nós) ao nosso cluster Kubernetes. Começamos com 3, mas o sistema pode ajustar automaticamente entre 2 e 4, dependendo da demanda.

Passo 5: Instalando o Jenkins no nosso servidor

O Jenkins vai organizar nosso pipeline de CI/CD para microserviços, construindo e implantando nosso código automaticamente.

Instalando o Java (necessário para o Jenkins)

Instalando o Jenkins

Iniciando o serviço Jenkins

Acessando o Jenkins

Abra um navegador e vá para:

Para pegar a senha de administrador inicial:

Para Iniciantes: O Jenkins vai construir, testar e implantar nosso código automaticamente sempre que houver mudanças.

Passo 6: Instalando o Docker no nosso servidor

O Docker vai empacotar nossos aplicativos em containers.

Dando permissão ao Jenkins para usar o Docker

Passo 7: Configurando o Jenkins para nosso pipeline

Agora vamos configurar o Jenkins para trabalhar com Docker e Kubernetes.

Instalando os plugins necessários

1. Vá para “Manage Jenkins” > “Plugins” > “Available Plugins”.
2. Procure e instale:
   • Docker Pipeline
   • Docker
   • Kubernetes
   • Kubernetes CLI
   • Multibranch Scan Webhook Trigger

Configurando o Docker no Jenkins

1. Vá para “Manage Jenkins” > “Tools”.
2. Role até “Docker installations”.
3. Clique em “Add Docker”.
4. Defina o nome como “docker” e marque “Install automatically”.
5. Salve.

Adicionando as credenciais do Docker Hub

1. Vá para “Manage Jenkins” > “Credentials” > “System” > “Global credentials”.
2. Clique em “Add Credentials”.
3. Escolha “Username with password”.
4. Coloque seu nome de usuário e senha do Docker Hub.
5. Defina o ID como "docker-cred".
6. Clique em “Create”.

Para Iniciantes: Estamos configurando o Jenkins com nossa conta do Docker Hub para que ele possa enviar nossas imagens de container para um repositório central.

Adicionando as credenciais do GitHub (opcional para repositórios públicos)

1. Vá para “Manage Jenkins” > “Credentials” > “System” > “Global credentials”.
2. Clique em “Add Credentials”.
3. Escolha “Username with password”.
4. Coloque seu nome de usuário do GitHub e o token de acesso pessoal.
5. Defina o ID como "github-cred".
6. Clique em “Create”.

Passo 8: Criando um pipeline Multibranch no Jenkins

É aqui que a mágica acontece! Vamos configurar o Jenkins para detectar e construir todos os nossos microsserviços automaticamente.

1. No painel do Jenkins, clique em “New Item”.
2. Digite um nome para seu pipeline (ex: Microservice-ecommerce).
3. Selecione “Multibranch Pipeline” e clique em “OK”.

1. Em “Branch Sources”, selecione “Git”.
2. Coloque a URL do seu repositório.
3. Defina as credenciais para "github-cred" (se estiver usando um repositório privado).
4. Em “Build Configuration”, defina “Mode” para “by Jenkinsfile”.
5. Defina “Script Path” para “Jenkinsfile”.
6. Clique em “Save”.

Configurando o Webhook para acionamentos automáticos

1. No Jenkins, vá para seu pipeline e clique em “Configure”.
2. Role para baixo e encontre “Scan by webhook”.
3. Marque a caixa e defina um token de acionamento (ex: “my-webhook-token”).
4. Salve a configuração.
5. No GitHub, vá para as configurações do seu repositório.
6. Clique em “Webhooks” > “Add webhook”.
7. Defina a Payload URL para: http://your-jenkins-url/multibranch-webhook-trigger/invoke?token=my-webhook-token.
8. Escolha “Content-type” como “application/json”.
9. Clique em “Add webhook”.

Para Iniciantes: Estamos conectando o Jenkins ao nosso repositório GitHub e configurando um acionador automático para que, sempre que o código for enviado, o Jenkins comece a construir automaticamente.

Passo 9: Entendendo o Jenkinsfile

Cada branch no nosso repositório tem um Jenkinsfile que define o que acontece quando o código muda. Aqui está um Jenkinsfile típico para nossos microsserviços:

Para Iniciantes: Este Jenkinsfile é como uma receita que diz ao Jenkins o que fazer com nosso código. Ele constrói um container Docker e envia para o Docker Hub.

Passo 10: Configurando o Kubernetes para implantação

Agora precisamos configurar o Kubernetes para que o Jenkins possa implantar nossos aplicativos.

Criando um Namespace

Para Iniciantes: Um namespace é como um cluster virtual dentro do nosso cluster Kubernetes. Ele nos ajuda a organizar nossos aplicativos.

Criando uma conta de serviço

Crie um arquivo chamado svc.yml:

Aplique-o:

Criando uma função com permissões

Crie um arquivo chamado role.yml:

Aplique-o:

Vinculando a função à conta de serviço

Crie um arquivo chamado bind.yml:

Aplique-o:

Para Iniciantes: Estamos criando uma conta especial (conta de serviço) para o Jenkins no Kubernetes e dando a ele permissões para implantar e gerenciar nossos aplicativos.

Criando um token para autenticação

Crie um arquivo chamado sec.yml:

Aplique-o:

Recupere o token:

Copie o valor do token mostrado na saída.

Passo 11: Criando um pipeline de implantação no Jenkins

Agora vamos configurar a peça final: um pipeline que implanta nossos aplicativos no Kubernetes.

1. No painel do Jenkins, clique em “New Item”.
2. Digite um nome (ex: “E-Commerce-Deployment“).
3. Selecione “Pipeline” e clique em “OK”.
4. Role para baixo até a seção “Pipeline”.
5. Clique em “Pipeline Syntax” para abrir o gerador de sintaxe.
6. Encontre "withKubeCredentials: Configure Kubernetes CLI".
7. Clique em “Add” > “Jenkins” > “Secret text”.
8. Cole seu token Kubernetes e defina o ID como "k8-token".
9. Coloque seu Kubernetes API Endpoint (encontrado no console EKS).
10. Defina o nome do Cluster como "eks-microservice" e o Namespace como "webapps". O nome do Cluster e o Namespace devem corresponder ao que você nomeou.
11. Clique em “Generate Pipeline Script” e copie a saída.
12. Use este script para criar seu Jenkinsfile no branch principal:

Para Iniciantes: Este pipeline pega nossos containers Docker e os implanta no Kubernetes, tornando nosso aplicativo disponível para os usuários.

Passo 12: Juntando tudo

Vamos recapitular como todo o sistema funciona:

1. Um desenvolvedor envia as mudanças de código para um branch no GitHub.
2. O webhook do GitHub aciona a construção do Jenkins para aquele microsserviço específico.
3. O Jenkins constrói um container Docker para o microsserviço.
4. O container é enviado para o Docker Hub.
5. O pipeline de implantação puxa o container mais recente e o implanta no Kubernetes.
6. Os usuários podem acessar o aplicativo atualizado sem nenhuma interrupção.

Acessando seu aplicativo implantado

Para ver seu aplicativo rodando:

Procure por serviços com TYPE LoadBalancer e use o EXTERNAL-IP para acessar seu aplicativo em um navegador.

Com o aumento da popularidade dos dispositivos móveis, os consumidores estão buscando por aparelhos mais rápidos e eficientes, com mais recursos e conectividade. Uma das melhores maneiras de aprender é com Inteligência Artificial Generativa e as Telecomunicações.

Se você pretende investir em 2025, aqui tem Principais Criptomoedas para Investir Hoje no Brasil.

Para quem gosta de jogos no celular, não perca a análise de Guitar Hero chega aos dispositivos móveis com novidades em IA

Confira a análise do Kobo Clara Colour: Vale a pena escolher este e-reader?

Veja também: Novidades e despedidas da Netflix em março de 2025

Parabéns! Você configurou com sucesso um pipeline de CI/CD para microserviços completo para um aplicativo na AWS EKS usando os pipelines multibranch do Jenkins. Essa configuração permite:

• Construção automática das mudanças de código.
• Containerização de aplicativos.
• Implantação em um cluster Kubernetes escalável e redundante.
• Atualização independente de microsserviços individuais.

Embora este guia cubra os passos essenciais, sempre há espaço para melhorias:

• Adicione testes automatizados antes da implantação.
• Implemente monitoramento e alertas.
• Configure implantações azul/verde para atualizações sem tempo de inatividade.
• Adicione varredura de segurança para seus containers.

Lembre-se, este sistema não é apenas uma conquista técnica, mas uma vantagem de negócios que permite uma inovação mais rápida e um serviço mais confiável para seus clientes.

Limpeza (quando necessário)

Se você quiser remover todo o sistema para evitar cobranças contínuas:

Nota: Isso vai apagar seu cluster Kubernetes e todos os aplicativos em execução.

Acesse seu console e apague sua instância EC2.

Este conteúdo foi auxiliado por Inteligência Artificial, mas escrito e revisado por um humano.

Via dev.to