Integração Contínua: automatizando a entrega no Kubernetes

Planejamento - Apresentação

Olá! Eu sou o Leonardo Sartorello e serei o seu instrutor nesse curso da Alura.

Autodescrição: Sou branco, tenho cabelos e barba castanhos escuros e olhos azuis. Estou usando uma camiseta branca e atrás de mim há uma parede com fundo azul-claro.

Neste curso, vamos seguir acompanhando a jornada do Bruno, que faz parte da nossa empresa e está avançando cada vez mais na sua carreira.

O que vamos aprender?

Você vai aprender a conectar sua rotina a um cluster do Kubernetes. Além disso, aprenderemos como criar esse cluster de forma automática. E, por fim, como realizar o deploy da nossa aplicação para dentro desse cluster.

• Conectar a um cluster
• Criar uma infra automaticamente
• Realizar o deploy de uma aplicação

Quais ferramentas vamos usar?

• GitHub
• AWS (Amazon Web Services)

Usaremos principalmente o GitHub, mais especificamente o GitHub Actions, que é uma ferramenta de CI/CD do GitHub. Além do AWS, que vai prover toda infraestrutura que precisaremos ao longo do curso.

Para quem é esse curso?

Esse curso é para você que já fez os cursos que são pré-requisitos desse aqui e quer conhecer ainda mais sobre CI/CD e entrar um pouco na área de Kubernetes.

Fazendo esse curso...

Aprenderemos mais sobre a área de CI/CD. Usaremos coisas que não vimos nos cursos anteriores como comandos diretos da AWS CLI (Command Line Interface) para criarmos alguns arquivos de forma automática. E também vamos conhecer os segredos do Kubernetes. Sim, o Kubernetes também tem segredos, igual o GitHub Actions.

Vamos começar?

Planejamento - Planejamento

Olá! Nesse curso, continuaremos exatamente de onde paramos no curso anterior.

Agora, o Bruno teve algumas ideias. Ele sugeriu nossa saída de uma estrutura proprietária da AWS e passarmos para uma infraestrutura que utiliza apenas parte em código aberto.

Bruno trouxe essa ideia por uma boa razão. As plataformas de código aberto têm muita vantagem em relação às plataformas proprietárias, como é o caso da AWS.

Mas, afinal, qual plataforma vamos utilizar? E quais as principais vantagens para essa troca, que parece muito trabalhosa, valer a pena?

A plataforma que nós utilizaremos é a Kubernetes., que na Amazon é conhecida como EKS (Elastic Kubernetes Service), em português seria "Serviço elástico do Kubernetes". Para você, que já conhece um pouco de Kubernetes, também pode ser conhecido como K8S.

Lembrando que estamos saindo do ECS (Elastic Container Service), em português: "serviço elástico de contêineres", que é a plataforma proprietária na qual estamos atualmente.

Vantagens

Simplicidade na migração entre provedores

Ao usar Kubernetes, a primeira vantagem é que não ficamos mais presos a um único provedor, como é o caso do ECS dentro da AWS. Vários provedores fornecem o Kubernetes para podermos utilizar. Além da AWS, temos a Azure e o Google Cloud.

Então, se as condições não estiverem boas em um provedor, é fácil migrar de um provedor para outro. A migração é feita rapidamente.

Maior resistência a falhas

Outra vantagem é que existem muitos serviços que são gerenciados diretamente pelo Kubernetes. Como é o caso do balanceador de carga e o crescimento automático da aplicação utilizando mais instâncias, permitindo que seja possível atender mais clientes ao mesmo tempo. Isso também garante maior resistência a falhas.

Fácil organização do serviço com pods

Também temos a vantagem de conseguir organizar a aplicação em pods, que funcionam quase como um aglomerado de contêineres. Assim podemos criar aplicações complexas, com vários contêineres simples, e ter certeza de que a aplicação sempre terá todos os contêineres que ela precisa para funcionar corretamente.

Interligação entre provedores

Por fim, podemos utilizar o Kubernetes em vários provedores diferentes e fazer uma espécie de integração entre os clusters dos vários provedores para termos uma maior margem de segurança caso tenhamos algum tipo de problema em um provedor.

Muitas vantagens, certo? Vamos para o próximo vídeo?

Planejamento - Preparando a rotina

Agora que já vimos as vantagens de usar o Kubernetes em vez de usar uma ferramenta proprietária como o serviço de contêineres da AWS, podemos começar a preparar a rotina que vai ajudar o Bruno e a equipe de devs no processo de deploy em homologação e, depois, em produção da nossa aplicação.

Tudo isso vai ajudar a acelerar o processo e manter todo o código integrado e verificado!

Para conseguirmos fazer todo esse processo, começaremos criando um arquivo para separar nossa rotina, mantendo assim a organização e tornando nosso código mais simples e, ao mesmo tempo, modular.

Para começar, vamos para o GitHub, no repositório do projeto inicial do curso. Entraremos na pasta ".github/workflow", é onde ficam as nossas rotinas.

Vamos criar um novo arquivo dentro da pasta ".github/workflow". Vamos nomear esse novo arquivo como EKS.yml. No caso, "EKS" é o serviço que vamos utilizar, o Elastic Kubernetes Services, e "yml" é a extensão do arquivo.

O que colocaremos nesse arquivo recém-criado? Vamos dar uma olhada nos outros arquivos do projeto para nos guiarmos sobre o que precisamos colocar nele.

Para não perder o que fizemos, vamos abrir em outra aba do navegador,a pasta "workflows".

Podemos entrar na rotina LoadTest.yml, aqui dentro já temos muita coisa do que utilizaremos. Vamos copiar o trecho que podemos usar no novo arquivo. Copiaremos desde a primeira linha até o bloco de código de jobs que usaremos como exemplo, até a parte em que configuramos as credenciais da AWS. Vamos copiar da linha 1 até o fim da linha 18 do arquivo LoadTest.yml.

name: Load Test

on:
  workflow_call:

jobs:

  loadtest:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3

    - name: configurando credenciais da AWS
      uses: aws-actions/configure-aws-credentials@v1
      with:
        aws-access-key-id: ${{ secrets.ID_CHAVE_ACESSO }}
        aws-secret-access-key: ${{ secrets.CHAVE_SECRETA }}
        aws-region: us-east-2

Agora podemos voltar ao recém-criado arquivo EKS.yml e colar o bloco de código que copiamos. Em seguida, faremos as edições necessárias.

O nome da rotina será kubernetes.

Ela deve ser executada sempre que alguma outra workflow chama por ela.

E qual será nosso job? O que deve ser executado dentro desse arquivo?

Vamos executar coisas relacionadas ao EKS, então mudaremos o nome do job de "loadtest" para "EKS". Ele roda na máquina ubuntu padrão. E o que ele vai rodar? O actions/checkout@v3 para prepararmos nosso ambiente; e vai configurar as credenciais da AWS.

name: kubernetes

on:
  workflow_call:

jobs:

  EKS:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3

    - name: configurando credenciais da AWS
      uses: aws-actions/configure-aws-credentials@v1
      with:
        aws-access-key-id: ${{ secrets.ID_CHAVE_ACESSO }}
        aws-secret-access-key: ${{ secrets.CHAVE_SECRETA }}
        aws-region: us-east-2

Beleza! Temos nosso arquivo EKS.yml. O próximo passo será subir a infraestrutura para esse arquivo.

Sobre o curso Integração Contínua: automatizando a entrega no Kubernetes

O curso Integração Contínua: automatizando a entrega no Kubernetes possui 105 minutos de vídeos, em um total de 46 atividades. Gostou? Conheça nossos outros cursos de Builds em DevOps, ou leia nossos artigos de DevOps.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Planejamento
• Terraform
• Acessando o Cluster
• Variáveis de ambiente
• Aplicação