Construindo um pipeline de CI/CD com AWS, K8S, Docker, Ansible, Git, Github, Apache Maven e Jenkins

Em meu artigo anterior, mergulhei no fascinante mundo dos microsserviços - Microservice Architecture Patterns Part 1: Decomposition Patterns . Este foi o início da minha série abrangente de artigos sobre microsserviços e seus padrões.

Embora o passo lógico seja continuar com a Parte 2 desta série, decidi que a próxima coisa que gostaria de explorar e falar é o processo vital de entrega desses microsserviços ao usuário final de maneira integrada.

Visão geral do conteúdo

• Motivação
• [Módulo 1]: Servidor Virtual AWS EC2
• [Módulo 2]: Servidor Jenkins
• [Módulo 3]: Git e Github
• [Módulo 4]: Apache Maven
• [Módulo 5]: Docker
• [Módulo 6]: Ansible
• [Módulo 7]: Kubernetes
• Conclusão
• Sobre o autor

Motivação

CI/CD é uma técnica para entregar aplicativos aos clientes, conseguida adicionando automação a diferentes estágios de desenvolvimento de aplicativos. Acredito que compreender CI/CD (Integração Contínua e Implantação Contínua) pode capacitar os desenvolvedores a obter uma melhor compreensão de como os artefatos de back-end do projeto existem além dos limites do repositório do projeto. Essa compreensão também pode criar uma mudança fundamental na perspectiva do desenvolvedor. Em vez de apenas verem o seu trabalho como linhas de código, eles podem começar a abraçar o contexto mais amplo do seu projeto como um produto valioso.

Neste artigo, pretendemos desmistificar o processo CI/CD através da aplicação prática. Apresentaremos um tutorial passo a passo, dividindo-o módulo por módulo, onde você construirá um pipeline de CI/CD manualmente. Para fazer isso, aproveitaremos o poder das ferramentas DevOps contemporâneas, como AWS, Docker, Kubernetes, Ansible, Git, Apache Maven e Jenkins . Então, vamos começar esta jornada!

[Módulo 1]: Servidor Virtual AWS EC2

Este módulo é dedicado à criação de uma instância de servidor virtual AWS EC2. Como parte deste artigo, você configurará três instâncias EC2 para Jenkins, Ansible e Kubernetes. Por enquanto, você pode prosseguir com os próximos módulos e revisitar este módulo nas seções "[módulo 2]: Jenkins", “[módulo 6]: Ansible" e "[módulo 7]: Kubernetes".

Etapa 1: crie uma conta AWS

Acesse https://aws.amazon.com.

Clique no botão Crie uma conta AWS .

Siga as instruções na página de criação de conta.

Etapa 2: faça login em sua conta AWS

Acesse https://console.aws.amazon.com/console/home. Clique no botão Entrar .

Insira todas as credenciais necessárias nesta página da web.

Etapa 3: Encontre o servidor virtual EC2

Encontre EC2 na caixa de pesquisa.

Escolha EC2 Virtual Server clicando em EC2 Service .

Clique no botão Iniciar instância .

Etapa 4: configurar a seção “Nome e tags”

Vá para a seção “Nome e tags” .

Forneça um nome para uma nova instância do servidor virtual AWS EC2 na seção “Nome” .

Você também pode adicionar tags adicionais ao seu servidor virtual clicando em “Adicionar tags adicionais” .

Etapa 5: configurar a seção “Imagens de aplicativo e sistema operacional (imagem de máquina Amazon)“

Vá para a seção "Imagens de aplicativos e sistema operacional (imagem de máquina Amazon)" .

Etapa 6: configurar a seção “Tipo de instância”

Vá para a seção “Tipo de instância” .

Etapa 7: configurar a seção “Configurar armazenamento”

Vá para a seção “Configurar armazenamento” .

Etapa 8: Configurar a seção “Configurações de rede“

Vá para a seção “Configurações de rede” .

Você precisa configurar a segurança do seu servidor virtual. Para fazer isso,

1. Clique no botão “Criar grupo de segurança” .
2. Adicione o nome do seu novo grupo de segurança na seção “Nome do grupo de segurança” .
3. Adicione uma descrição do seu novo grupo de segurança na seção “Descrição” .

Por padrão, seu servidor virtual é acessível via ( Tipo - SSH, Protocolo - TCP, Porta - 22 ). Se precisar de tipos de conexão adicionais, adicione-os adicionando regras adicionais de grupo de segurança de entrada.

Etapa 9: Configurar a seção “Par de chaves (login)“

Vá para a seção “Par de chaves (Login)” .

Crie um novo par de chaves se ainda não o tiver criado.

Se você ainda não criou o “par de chaves” :

1. Clique no botão “Criar novo par de chaves” .
2. Dê um nome ao seu novo par de chaves na seção “Nome do par de chaves” .
3. Selecione o tipo de par de chaves RSA ou ED25519 . Eu escolho o tipo RSA .
4. Selecione Formato de arquivo de chave privada. Escolha de .pem e .ppk . Eu escolho o formato .pem .
5. Clique no botão “Criar par de chaves” .
6. Você receberá uma janela pop-up solicitando que você baixe o arquivo da chave privada. Concorde e baixe o arquivo para o seu computador.

Etapa 10: iniciar a instância do servidor virtual EC2

Inicie a instância do EC2 Virtual Server clicando no botão “Iniciar instância” .

Após a conclusão do processo de criação da instância do EC2 Virtual Server, você verá o seguinte.

Então você deve ir para a seção “Instâncias” clicando no botão “Ver todas as instâncias” .

Agora você pode ver que sua instância do servidor virtual AWS EC2 está em execução.

[Módulo 2]: Servidor Jenkins

Agora, vamos configurar o JenkinsServer na instância do EC2 Virtual Server.

Etapa 1: criar uma instância do servidor virtual AWS EC2

Você precisa de um servidor virtual para executar o Jenkins.

Siga as instruções do [Módulo 1]: seção Servidor virtual AWS EC2 deste tutorial para concluir esta etapa e criar uma instância de servidor virtual EC2 com o nome JenkinsServer.

Etapa 2: conectar-se a uma instância do servidor virtual AWS EC2

Acesse a página inicial do Console AWS → Painel do Console de Gerenciamento EC2 → Instâncias.

Então você deve escolher JenkinsServer e clicar no botão “Conectar” .

Então você verá esta página da web. Você deve clicar novamente no botão “Conectar” .

Agora você pode ver o terminal online da instância do servidor virtual EC2.

Etapa 3: Baixe o repositório Jenkins

Agora você precisa baixar o Jenkins em sua instância de servidor virtual EC2.

Siga estas instruções:

1. Vá para a página de download do Jenkins.

2. Você pode ver as opções de versões estáveis (LTS) e regulares (semanais). Escolha a opção Red Hat/Fedora/Alma/Rocky/CentOS LTS.

   
   

Você verá esta página da web.

3. Copie o comando “sudo get..” e execute-o para baixar os arquivos Jenkins do repositório Jenkins na Internet e salvá-los no local especificado em sua instância de servidor virtual EC2.

 sudo wget -O /etc/yum.repos.d/jenkins.repo https://pkg.jenkins.io/redhat-stable/jenkins.repo

Agora o Jenkins foi baixado.

Etapa 4: importar a chave Jenkins

Para finalizar a instalação do Jenkins, precisamos importar a chave Jenkins.

Para importar a chave Jenkins precisamos copiar o comando “sudo rpm..” e executá-lo.

 sudo rpm --import https://pkg.jenkins.io/redhat-stable/jenkins.io-2023.key

Etapa 5: instale o Java

Para executar o Jenkins, precisamos instalar o Java em nossa instância de servidor virtual EC2.

Para instalar o Java , use este comando.

 sudo amazon-linux-extras install java-openjdk11 -y

Verifique se o Java foi instalado corretamente usando este comando:

 java -version

Você verá algo assim.

Etapa 6: instale o fontconfig

Para executar o Jenkins, você precisa instalar o fontconfig em nossa instância de servidor virtual EC2.

Use este comando.

 sudo yum install fontconfig java-11-openjdk -y

Etapa 7: Instale o Jenkins

Nas etapas anteriores, você configurou sua instância de servidor virtual EC2 para usar um repositório Jenkins específico e, em seguida, importou a chave GPG associada a esse repositório. Agora, você precisa executar o comando que irá pesquisar todos os repositórios que conhece, incluindo o Jenkins que você adicionou, para encontrar o pacote Jenkins. Assim que encontrar o pacote Jenkins no repositório Jenkins, ele fará o download e instalará.

Vamos executar este comando.

 sudo yum install jenkins -y

Etapa 8: inicie o Jenkins

Você pode iniciar o Jenkins usando este comando.

 sudo systemctl start jenkins

Para verificar se o Jenkins está em execução, use este comando.

 sudo systemctl status jenkins

Você verá a saída como está na imagem abaixo:

Jenkins agora deve estar instalado e funcionando.

Etapa 9: acesse o Jenkins

Para acessar o aplicativo Jenkins, abra qualquer navegador da web e insira o endereço IP público ou nome de domínio da sua instância EC2 seguido pela porta 8080.

 http://<your-ec2-ip>:8080

Na primeira vez que você acessar o Jenkins, ele será bloqueado com uma senha gerada automaticamente.

Você precisa exibir essa senha usando o seguinte comando.

 sudo cat /var/lib/jenkins/secrets/initialAdminPassword

Copie esta senha, volte ao seu navegador, cole-a no campo Senha do administrador e clique em “Continuar”.

Então você poderá ver esta página da web.

Agora você pode usar seu servidor Jenkins.

Etapa 10: Crie um novo pipeline Jenkins

Agora, como o Jenkins está funcionando bem, você pode começar a criar o pipeline do Jenkins. Para criar o pipeline Jenkins você precisa criar um novo “projeto Freestyle”. Para criar um novo “projeto Freestyle” você precisa ir ao painel do Jenkins e clicar no botão “Novo Item” .

Digite o nome do “projeto Freestyle” do Github (o nome do “pipeline” será usado posteriormente) e clique no botão “OK” .

Em seguida, forneça a descrição do pipeline.

Em seguida, clique no botão “Aplicar” e “Salvar”. Depois disso, significa que você criou a base do pipeline que será construído neste tutorial.

[Módulo 3]: Git e Github

Agora que o Jenkins está sendo executado na instância do servidor virtual AWS EC2, você pode configurar o Git com o pipeline.

O Git, como o sistema de controle de versão mais popular, nos permite extrair o código mais recente do repositório Github do seu projeto para a instância do servidor virtual EC2 onde o Jenkins está instalado.

Etapa 1: instalar o Git

Use este comando para instalar o Git.

 sudo yum install git -y

Agora verifique se o Git está funcionando, usando este comando.

 git --version

Agora o Git está funcionando bem na instância do EC2 Virtual Server.

Etapa 2: abra o painel do Jenkins

Como o Git está funcionando bem na instância do EC2 Virtual Server, podemos integrar o Jenkins ao Git agora.

Para iniciar esta integração vamos instalar o plugin Jenkins Github.

Vá para a seção do painel do Jenkins.

Etapa 3: abra o gerenciador de plug-ins Jenkins

Clique no botão “Gerenciar Jenkins” e depois clique no botão “Gerenciar Plugins” .

Etapa 4: Encontre o plugin Github Jenkins

Clique no botão “Plugins disponíveis” .

Encontre a caixa de pesquisa do plugin Github .

Selecione o plug-in do Github .

Etapa 5: instale o plug-in Github Jenkins

Selecione o plug-in do Github . E então clique no botão “Instalar sem reiniciar” .

Aguarde o término do download do plugin Github.

Sim! O plug-in Jenkins Github está instalado.

Etapa 6: configurar o plug-in Github Jenkins

Agora que o plugin GitHub Jenkins está instalado, você pode configurar este plugin para integrar Jenkins com Git finalmente. Para fazer isso você precisa retornar à página principal clicando no botão “Voltar ao topo da página”.

Em seguida, na página principal, você precisa clicar no botão “Gerenciar Jenkins” e a seguir clicar no botão “Configuração global da ferramenta” .

Em seguida, na página da web Global Tool Configuration, você deve ir para a seção Git.

Na seção Git, você precisa configurar o Git fornecendo o nome e o caminho do Git no computador.

Em seguida, clique nos botões “Aplicar” e “Salvar” **.**

Aqui, você concluiu a configuração do plugin Jenkins Github.

Etapa 7: Integrar o Git ao pipeline

Agora, como o plugin Jenkins Github está instalado e configurado, você pode utilizá-lo em seu pipeline. Isso permitirá que o pipeline criado no módulo 2 extraia o código do projeto do repositório GitHub especificado.

Bem, para integrar este plugin ao seu pipeline você precisa ir até a seção Source Code Management e escolher Git no seu pipeline. Então você precisa fornecer o URL do repositório do seu projeto. Se o repositório do seu projeto for público no Github, você não precisará fornecer credenciais. Se o repositório do projeto for privado no Github, você precisará fornecer credenciais.

Você pode usar meu projeto com o próximo URL do repositório: https://github.com/Sunagatov/Hello.git .

Basta copiar e colar na entrada “ URL do repositório” . Em seguida, clique nos botões “Aplicar” e “Salvar” para finalizar a integração do Git com o pipeline.

Etapa 8: testar o Git integrado ao pipeline

Agora você pode usar seu pipeline atualizado para extrair um projeto do Github. Para fazer isso você precisa clicar no botão **“Construir agora”**. Como resultado, você verá uma construção bem-sucedida no histórico de construção.

Abra a primeira compilação do histórico de compilação.

Agora você pode ver o resultado bem-sucedido do trabalho da primeira construção. Se você abrir seu terminal AWS EC2. Você pode verificar se o pipeline funciona bem.

Basta usar este comando.

 cd /var/lib/jenkins/workspace/{your pipeline name}

Dessa forma, você pode ver que seu projeto do Github foi transferido para a instância do servidor virtual AWS EC2.

[Módulo 4]: Apache Maven

Agora que integrou o Git ao pipeline, você pode aprimorá-lo ainda mais incorporando o Apache Maven, que permite construir, testar e empacotar seu projeto. Para fazer isso, você precisa instalar o Apache Maven na instância do servidor virtual AWS EC2 onde Jenkins e Git foram instalados.

Etapa 1: Baixe o Apache Maven

Para baixar o Apache Maven vá para o diretório “/opt” .

 cd /opt

E então use este comando.

 sudo wget https://dlcdn.apache.org/maven/maven-3/3.9.4/binaries/apache-maven-3.9.4-bin.tar.gz

Este comando irá baixar o Apache Maven oficial mais recente (verifique a versão mais recente no site oficial do Apache Maven). Para encontrar a versão oficial mais recente do Apache Maven, use o link https://maven.apache.org/download.cgi .

Etapa 2: Extraia o Apache Maven do arquivo

Use este comando para extrair o Apache Maven do arquivo baixado:

 sudo tar -xvzf apache-maven-*.tar.gz

Etapa 3: adicionar JAVA_HOME e M2_HOME

Vá para a pasta raiz usando este comando.

 cd ~

Edite o arquivo .bash_profile usando este comando.

 vi .bash_profile

Adicione variáveis JAVA_HOME e M2_HOME.

Atribua o caminho para JDK11 para JAVA_HOME e o caminho para o diretório maven para a variável M2_HOME .

Para encontrar o caminho do JDK, use este comando.

 sudo find / -name java 

Salve as alterações.

Em seguida, execute este comando para atualizar as variáveis do sistema.

 source .bash_profile

Para verificar $PATH , use este comando.

 echo $PATH

Para verificar o Apache Maven , use este comando.

 mvn -v

Se você fez tudo corretamente, poderá visualizar a versão do Apache Maven.

Etapa 4: instale o plug-in Apache Maven Jenkins

Como o Apache Maven pode ser usado em uma instância EC2, você pode instalar o plugin Apache Maven para integrá-lo ao pipeline.

Para conseguir isso, siga estas etapas:

1. Navegue até “Painel“ → “Gerenciar Jenkins“ → “Gerenciar plug-ins“ → “Disponível”.
2. Na caixa de pesquisa, digite “Maven” .
3. Escolha o plugin “Maven Integration” .

Aguarde o final do processo de download.

E então clique no botão “Voltar para a página inicial” .

Etapa 5: configurar o plug-in Apache Maven Jenkins

Com a instalação bem-sucedida do plugin Apache Maven Jenkins, agora você pode utilizar este plugin dentro do pipeline que criou e atualizou nos módulos 2 e 3.

Para fazer isso, siga estas etapas:

1. Vá para “Painel“ → “Gerenciar Jenkins“ → “Global Tool Coonfiguration“ → “JDK”
2. Clique no botão “Adicionar JDK”.
3. Desmarque “Instalar automaticamente”.

Em seguida, vá para a seção “Maven” . Clique no botão “Adicionar Maven” . Desmarque “Instalar automaticamente”.

Em seguida, adicione o nome e o caminho MAVEN_HOME .

Clique nos botões “Aplicar” e “Salvar” .

Aqui, você concluiu a configuração do plugin Apache Maven Jenkins.

Etapa 6: Integrar o Apache Maven ao pipeline

Agora que o plug-in Apache Maven GitHub está instalado e configurado, você pode utilizar o Apache Maven em seu pipeline. Isso permitirá que seu pipeline que você criou no “[módulo 2]: Jenkins Server” construa o código do seu projeto para criar um artefato jar.

Para integrar o Apache Maven ao pipeline, você precisa seguir estas etapas:

1. Navegue até “Painel“ → “CI_CD_Pipeline“ → “Configurar“ → “Etapas de construção”.
2. Clique no botão “Adicionar etapa de construção” .
3. Escolha a opção “Invocar destinos Maven de nível superior” .
4. Escolha “Apache-Maven” como “Versão Maven”.
5. Adicione o comando “pacote limpo” à entrada “Metas” .
6. Clique no botão “Avançado“ .
7. Adicione “pom.xml” à entrada “POM” .

Por fim, você deve clicar nos botões “Aplicar” e “Salvar” para finalizar a integração do Apache Maven com o pipeline.

Etapa 7: teste o Apache Maven integrado ao pipeline

Agora você pode usar seu pipeline atualizado para construir seu projeto no Github. Para fazer isso você precisa clicar no botão **“Construir agora”**. Como resultado, você verá um resultado de trabalho bem-sucedido no histórico de construção.

Se você abrir seu terminal AWS EC2. Você pode verificar se o pipeline funciona bem.

Basta usar este comando.

 cd /var/lib/jenkins/workspace/{your pipeline name}/target

Dessa forma, você pode ver o artefato JAR, indicando a construção bem-sucedida do seu projeto no GitHub.

[Módulo 5]: Docker

Agora vamos criar uma nova instância EC2 com o nome "Ansible Server" onde você irá instalar o Docker e o Ansible.

Etapa 1: iniciar uma instância do servidor virtual AWS EC2

Use as instruções da seção “ Iniciar uma instância do servidor virtual AWS EC2” deste tutorial para concluir esta etapa. Não se esqueça de adicionar uma configuração de grupo de segurança. Ele permite que Docker e SSH funcionem nas portas 8080 e 22, respectivamente.

Etapa 2: conectar-se a uma instância do servidor virtual AWS EC2

Clique no botão “Conectar”.

Agora você pode ver o terminal online da instância do EC2 Virtual Server.

 sudo chown ansible-admin:ansible-admin /opt/docker

Etapa 3: Instale o Docker no servidor virtual Ansible EC2.

Agora você precisa instalar o docker em sua instância do Ansible EC2. Para fazer isso, você precisa criar uma nova pasta docker.

 sudo mkdir /opt/docker

Em seguida, instale o docker executando o próximo comando.

 sudo yum install docker -y

Etapa 4: adicionar o usuário atual ao grupo Docker no servidor virtual Ansible EC2

Você precisa adicionar o usuário atual “ansible-admin” ao grupo Docker no servidor virtual EC2 “AnsibleServer” para conceder privilégios de administrador ao Docker.

 sudo usermod -a -G docker ansible-admin

Você precisará sair e fazer login novamente para que essas alterações tenham efeito.

Então você pode executar o próximo comando

 id ansible-admin

para ver se o novo usuário do docker existe.

Etapa 5: iniciar o Docker

Agora que o Docker está instalado na instância do Ansible EC2, você pode iniciá-lo executando o próximo comando.

 sudo systemctl start docker

Quando o Docker for iniciado, você pode executar o próximo comando

 sudo systemctl status docker

para ver se o docker está ativo e em execução agora.

Etapa 6: criar Dockerfile

Na versão final do pipeline, o processo envolverá a criação de uma nova imagem Docker a partir do seu projeto GitHub e o envio para o Docker Hub. Para fazer isso, seu projeto GitHub deve conter um Dockerfile.

Se você usou o projeto “Hello” que foi oferecido no módulo “ [Módulo 3]: Git e Github” , então você não precisa criar um novo Dockerfile, pois este repositório do projeto já contém Dockerfile.

 FROM eclipse-temurin:17-jre-jammy ENV HOME=/opt/app WORKDIR $HOME ADD hello-0.0.1-SNAPSHOT.jar $HOME ENTRYPOINT ["java", "-jar", "/opt/app/hello-0.0.1-SNAPSHOT.jar" ]

Se você usou seu próprio repositório de projeto e ele não continha um Dockerfile, você precisará criar um novo Dockerfile.

Para criar um novo Dockerfile, execute o seguinte comando, que criará o novo arquivo.

 sudo touch Dockerfile

Em seguida, você pode preencher esse arquivo com uma sequência de comandos que descrevem como construir um ambiente de aplicativo em contêiner. Esses comandos incluem ações como copiar arquivos na imagem, instalar software, definir variáveis de ambiente e configurar o contêiner.

Para preencher o Dockerfile com esses comandos, execute o seguinte comando.

 vim Dockerfile

O Dockerfile está pronto para uso.

Etapa 7: faça login no Docker

Agora que seu Dockerfile está preparado para uso, copie o artefato JAR do seu projeto da instância **"JenkinsServer"**EC2 e cole-o na instância EC2 "AnsibleServer" . É importante observar que essa transferência será ainda mais automatizada através do pipeline.

Ao concluir esta etapa, você estará pronto para testar seu Dockerfile junto com o ambiente Docker que configurou.

Antes de começar a testar, certifique-se de se autenticar no Dockerhub. Execute o seguinte comando.

 docker login

Este comando solicitará que você forneça suas credenciais de login do Dockerhub, incluindo seu nome de usuário e senha.

Com isso, você concluiu o processo de login no Docker e agora está pronto para prosseguir com os testes.

Etapa 8: Testando o ambiente Docker e Dockerfile

Com seu login bem-sucedido no Dockerhub concluído, você está pronto para começar a testar o Dockerfile que preparou.

Execute este comando para criar uma imagem docker.

 docker build -t hello:latest .

A seguir, execute o comando subsequente para estabelecer uma tag que facilitará o upload da imagem para o Dockerhub:

 docker tag hello:latest zufarexplainedit/hello:latest

Por fim, prossiga para enviar a imagem do Docker para o Dockerhub por meio da execução deste comando.

 docker push zufarexplainedit/hello:latest

Seguindo estas etapas, navegue até sua conta Dockerhub para verificar se você consegue ver uma nova imagem ou não.

Agora você deve observar que a imagem foi efetivamente adicionada. Este resultado confirma a instalação bem-sucedida do ambiente Docker e que seu Dockerfile está correto.

[Módulo 6]: Ansible

Agora vamos configurar o Ansible Server na instância do EC2 Virtual Server.

Etapa 1: criar uma instância do servidor virtual AWS EC2

Você precisa de um servidor virtual para executar o Ansible.

Siga as instruções do [Módulo 1]: seção Servidor virtual AWS EC2 deste tutorial para concluir esta etapa e criar uma instância de servidor virtual EC2 para Ansible.

Etapa 2: conectar-se a uma instância do servidor virtual AWS EC2

Acesse a página inicial do Console AWS → Painel do Console de Gerenciamento EC2 → Instâncias → AnsibleServer.

Em seguida, clique no botão “Conectar” .

Então você verá esta página da web. Você deve clicar novamente no botão “Conectar” .

Agora você pode ver o terminal online da instância do servidor virtual EC2.

Agora vamos configurar o Ansible Server na instância do servidor virtual EC2.

Etapa 3: Altere o nome do host da instância do servidor virtual AWS EC2 “AnsibleServer”

A primeira coisa que você precisa fazer quando deseja configurar o AnsibleServer na instância do servidor virtual EC2 é alterar seu nome de host.

Vamos fazê-lo. Execute este comando para abrir o arquivo hostname:

 sudo vi /etc/hostname

Você deverá ver algo assim:

Substitua este nome de host por “ansible-server”. Em seguida, reinicie-o.

 sudo init 6 

Etapa 4: Adicionar e configurar um novo usuário na instância do servidor virtual AWS EC2 “AnsibleServer”

Agora vamos adicionar um novo usuário ansible-admin à instância do servidor virtual AWS EC2.

Para fazer isso use este comando:

 sudo useradd ansible-admin

Em seguida, defina a senha para o usuário ansible-admin .

 sudo passwd ansible-admin

Além disso, você precisa configurar os privilégios do usuário editando o arquivo sudoers .

 sudo visudo

Adicione “ansible-admin ALL=(ALL) ALL” a este arquivo sudoers .

Além disso, você precisa editar o arquivo /etc/ssh/sshd_config para ativar o PasswordAuthentication.

 sudo vi /etc/ssh/sshd_config 

Então você precisa recarregar o serviço para confirmar essas alterações.

 sudo service sshd reload

Como resultado da execução deste comando, você verá:

 sudo su - ansible-admin

Etapa 5: gerar chave em uma instância do servidor virtual AWS EC2

Você está planejando gerenciar servidores remotos, como instâncias de servidor virtual K8s EC2, mais adiante neste artigo. É por isso que você precisa configurar chaves SSH.

 ssh-keygen

Como resultado da execução deste comando, você verá:

Agora as chaves SSH estão geradas e prontas para uso.

Etapa 6: instalar o Ansible

Agora você pode instalar o Ansible em sua instância de servidor virtual EC2 “AnsibleServer” .

Vamos fazê-lo.

Execute este comando para instalar o Ansible.

 sudo amazon-linux-extras install ansible2

Para verificar o Ansible, use este comando:

 ansible --version

Como resultado da execução deste comando, você verá:

Etapa 7: Instale o plugin Jenkins “Publish over SSH” na instância JenkinsServer EC2

Como o Ansible está instalado em sua instância de servidor virtual EC2 “AnsibleServer” , você pode configurar o Jenkins para integrá-lo ao Ansible. Você precisa instalar o plugin “Publish over SSH” para integrar o Jenkins com a instância do EC2 Virtual Server onde o Ansible está instalado e com outras instâncias do EC2 Virtual Server onde o Kubernetes está instalado.

Vá para “Painel” → “ Gerenciar Jenkins” → “Configurar Sistema” → “Plugins disponíveis” .

Em seguida, digite “Publicar por SSH“ na caixa de pesquisa.

Clique no botão “Instalar sem reiniciar” . Aguarde o final do processo de download.

Agora o plugin “Publish over SSH” está instalado na instância do Jenkins EC2 Virtual Server.

Etapa 8: configurar o plugin “Publicar sobre SSH” do Jenkins

Com a instalação bem-sucedida do plugin Apache Maven Jenkins, agora você pode utilizar este plugin dentro do pipeline que criou e atualizou nos módulos 2 e 3.

Para fazer isso, siga estas etapas:

Vá para “Painel“ → “Gerenciar Jenkins” → “Configurar Sistema” → “Publicar via SSH” .

Insira todos os dados necessários como estão na captura de tela, incluindo nome do host, nome de usuário e chave privada (ou senha, se aplicável).

Em seguida, clique nos botões “Aplicar” e “Salvar” .

Aqui você concluiu a configuração do plugin Jenkins “Publicar sobre SSH” .

Em seguida, clique em “Test Configuration” para validar se o plugin está funcionando corretamente.

No lado esquerdo você pode ver que o status de configuração do plugin de teste é “Sucesso”. Isso significa que a configuração do plugin está correta.

Etapa 9: Crie um novo diretório Docker no AnsibleServer

Você precisa criar uma nova pasta na instância do AnsibleServer EC2 onde o JAR do projeto será armazenado. Este jar será usado para criar uma imagem Docker posteriormente.

Vamos começar.

Vá para a pasta “/opt” na instância do AnsibleServer EC2.

 cd /opt

Crie uma nova pasta “docker” lá.

 sudo mkdir docker

Dê privilégios a esta pasta “docker” .

 sudo chown ansible-admin:ansible-admin docker

Agora, verifique os privilégios da pasta “docker” executando este comando.

 ll

Você pode ver que a pasta “docker” pode ser acessada pelo usuário “ansible-admin” .

Etapa 10: Integrar o plugin “Publicar sobre SSH” do Github ao pipeline

Agora que o plugin Github “Publish over SSH” está instalado e configurado, você pode integrá-lo ao pipeline que criou no “[módulo 2]: Jenkins Server” para transferir um artefato jar do projeto de “ JenkinsServer” para “AnsibleServidor” .

Bem, para integrar o plugin “Publish over SSH” do Github ao pipeline, você precisa seguir estas etapas:

1. Navegue até “Dashboard“ → “CI_CD_Pipeline“ → “Configurar“ → “Ações pós-construção”.
2. Clique no botão “Adicionar ação pós-construção” .
3. Escolha a opção “Enviar artefatos de construção por SSH” .
4. Adicione “AnsibleServer” na entrada “Nome” na seção “Servidor SSH” **.**
5. Adicione “target/*.jar” na entrada “Arquivos de origem” na seção “Conjunto de transferência” **.**
6. Adicione “target/” na entrada “Remove prefix” na seção “Transfer Set” **.**
7. Adicione “//opt/docker/” na entrada “Diretório remoto” na seção “Conjunto de transferência” **.**
8. Por enquanto, basta colocar uma string vazia na entrada 'Exec command' na seção 'Transfer Set'.

Por fim, você deve clicar nos botões “Aplicar” e “Salvar” para finalizar a integração do plugin “Publicar sobre SSH” com o pipeline.

Etapa 11: Teste o plugin Github “Publish over SSH” integrado ao pipeline

Agora você pode usar seu pipeline atualizado para transferir um artefato jar do projeto de “ JenkinsServer” para “AnsibleServer” . Para fazer isso você precisa clicar no botão “Construir agora” . Como resultado, você verá um resultado de trabalho bem-sucedido no histórico de construção.

Se você abrir seu terminal AWS EC2 “AnsibleServer” . Você pode verificar se o pipeline funciona bem.

Basta usar este comando.

 cd /opt/docker

Dessa forma, você pode ver o artefato JAR, indicando a construção bem-sucedida do seu projeto no GitHub.

Etapa 12: configurar hosts Ansible

Ao executar um manual do Ansible, você especifica os hosts nos quais ele deve ser executado. Você pode fazer isso de duas maneiras:

1. Especifique hosts diretamente no playbook: em seu playbook, você pode definir o parâmetro hosts para uma lista de endereços IP ou nomes de host.
2. Use um arquivo de inventário: Ansible permite que você defina uma lista de hosts em um arquivo de inventário e faça referência a esse arquivo ao executar seu playbook. O arquivo de inventário padrão é /etc/ansible/hosts .

Ao editar /etc/ansible/hosts , você pode gerenciar facilmente grupos de hosts sem precisar escrever seus endereços IP sempre que executar um playbook.

Vamos descobrir o host da instância AnsibleServer EC2 executando o seguinte comando.

 sudo ifconfig 

Depois de descobrir o host da instância AnsibleServer EC2, você pode adicioná-lo ao arquivo hosts Ansible executando o seguinte comando.

 sudo vi /etc/ansible/hosts

Você também pode adicionar “[ansible]” como referência

Etapa 13: configurar a autenticação SSH sem senha para localhost para Ansible

Ansible foi projetado para automatizar tarefas em servidores remotos. A autenticação SSH sem senha permite que o Ansible se conecte a esses servidores sem a necessidade de inserção manual de senha.

Execute este comando para criar uma conexão segura do seu computador para outro computador (como aquele no endereço IP 172.31.34.41), usando a chave SSH do usuário ansible-admin.

 sudo ssh-copy-id -i /home/{your user name}/.ssh/id_rsa.pub {your user name}@{your host address}

No meu caso, é assim.

 sudo ssh-copy-id -i /home/ansible-admin/.ssh/id_rsa.pub [email protected] 

Agora você pode ver “Número de chaves adicionadas: 1” . Isso significa que a instalação da autenticação SSH sem senha foi concluída com êxito.

Etapa 14: crie um novo manual do Ansible para tarefas do Docker

Agora que o Ansible está configurado e pronto para uso, você pode criar um novo manual do Ansible para o seu pipeline. Este manual permitirá que o Ansible crie e envie uma nova imagem Docker para o Dockerhub.

Veja como você pode fazer isso:

1. Comece criando um novo arquivo de manual do Ansible. Basta usar este comando.

 touch hello-app.yml

2. Em seguida, edite o arquivo hello-app.yml recém-criado. Abra-o para edição com este comando.

 vi hello-app.yml

3. Dentro do arquivo, digite o seguinte.

 --- - hosts: ansible user: root tasks: - name: create docker image command: docker build -t hello:latest . args: chdir: /opt/docker - name: create tag to push image onto dockerhub command: docker tag hello:latest zufarexplainedit/hello:latest - name: push docker image onto dockerhub command: docker push zufarexplainedit/hello:latest

O manual do Ansible para tarefas do Docker está pronto para uso.

Etapa 13: teste o manual do Ansible com tarefas do Docker

Com Ansible, Ansible playbook, AnsibleServer e JenkinsServer todos configurados corretamente, é hora de testar o playbook Ansible.

Navegue até o local do seu manual do Ansible.

 cd /opt/docker

Em seguida, execute o seguinte comando.

 sudo -u ansible-admin ansible-playbook /opt/docker/hello-app.yml

Após a conclusão, você verá o resultado da execução bem-sucedida de seu manual do Ansible.

Além disso, reserve um momento para visitar sua conta Dockerhub e verifique se uma nova imagem está visível.

Você deverá ver a imagem recém-adicionada. Este resultado confirma que seu manual do Ansible está correto.

Etapa 14: Integrar tarefas do Ansible Docker ao pipeline

Agora que o plugin “Publish over SSH” do Github, Ansible e Docker estão instalados e configurados, você pode integrá-los todos no pipeline que você criou no “[módulo 2]: Jenkins Server” para transferir um artefato jar do projeto de “ JenkinsServer” para “AnsibleServer” e, em seguida, construa uma nova imagem Docker a partir do seu projeto e, em seguida, envie esta imagem Docker para o Dockerhub.

Para alcançá-lo, você precisa seguir estas etapas:

1. Navegue até “Dashboard“ → “CI_CD_Pipeline“ → “Configurar“ → “Ações pós-compilação” → “Enviar artefatos de compilação por SSH” .
2. Adicione o comando “sudo -u ansible-admin ansible-playbook /opt/docker/hello-app.yml” na entrada “Exec command” .

Por fim, clique nos botões “Aplicar” e “Salvar” para finalizar as tarefas de integração do Ansible Docker com o pipeline.

Etapa 15: Teste o “manual Ansible com tarefas Docker ” integrado ao pipeline

Agora você pode testar seu pipeline atualizado para transferir perfeitamente um artefato jar do projeto de “ JenkinsServer” para “AnsibleServer”, em seguida, construir uma nova imagem Docker de seu projeto e, em seguida, enviar essa imagem Docker para Dockerhub. Para fazer isso você precisa clicar no botão “Construir agora” . Como resultado, você verá um resultado de trabalho bem-sucedido no histórico de construção.

Além disso, reserve um momento para visitar sua conta Dockerhub e verifique se uma nova imagem está visível.

Você deverá ver a imagem recém-adicionada. Este resultado confirma que seu manual do Ansible com tarefas do Docker foi integrado com êxito ao pipeline.

[Módulo 7]: Kubernetes

Agora vamos configurar K8s na instância EC2. Você criará uma nova instância EC2 e instalará sua ferramenta de linha de comando kubectl para interagir ainda mais com um cluster Kubernetes .

Etapa 1: iniciar uma instância do servidor virtual AWS EC2

Use as instruções da seção “ Iniciar uma instância do servidor virtual AWS EC2” deste tutorial para concluir esta etapa.

Etapa 2: conectar-se a uma instância do servidor virtual AWS EC2

Clique no botão “Conectar”.

Agora você pode ver o terminal online da instância do EC2 Virtual Server.

Etapa 3: Altere o nome do host da instância do servidor virtual AWS EC2 “KubernetesServer”

A primeira coisa que você precisa fazer quando deseja configurar o KuberenetesServer na instância do servidor virtual EC2 é alterar seu nome de host.

Vamos fazê-lo. Execute este comando para abrir o arquivo hostname:

 sudo vi /etc/hostname

Você deveria ver algo assim.

Substitua este nome de host por “kubernetes-server” e reinicie-o.

 sudo init 6

Seu nome de host foi alterado.

Etapa 4: verifique a versão do AWS CLI

Use este comando para verificar a versão da AWS .

 aws --version

Dessa forma, você pode ver sua versão atual do aws-cli.

Se você puder ver a versão aws-cli/1.18 , deverá baixar a versão mais recente.

Etapa 5: atualizar AWS CLI

Agora que você descobriu que tem uma versão antiga do aws-cli em sua instância EC2, você precisa atualizá-la. Para isso, vá para AWS → Documentação → AWS Command Line Interface → Guia do usuário para versão 2.

Copie e cole o comando curl .

Primeiro, execute este comando para baixar o awscli versão 2.

 curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"

Aguarde o início do processo de download.

Você deveria ver algo assim.

Em segundo lugar, você precisa executar este comando para descompactar o arquivo awscli versão 2.

 unzip awscliv2.zip

Terceiro, você deve executar este comando para instalar o awscli versão 2.

 sudo ./aws/install

Em seguida, recarregue o terminal online da instância do Kubernetes EC2 Virtual Server.

A seguir, use este comando para verificar a versão AWS

 aws --version

Você pode ver que o aws cli tem aws-cli/2.

Etapa 6: instalar o kubectl

Agora você precisa instalar a ferramenta de linha de comando kubectl para interagir ainda mais com um cluster Kubernetes. Para isso você precisa ir para AWS → Documentação → Amazon EKS → Guia do usuário → Instalando ou atualizando kubectl → Linux .

Ou apenas clique no link https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html .

Primeiro, execute este comando para baixar o kubectl.

 curl -O https://s3.us-west-2.amazonaws.com/amazon-eks/1.27.1/2023-04-19/bin/linux/amd64/kubectl

Aguarde o processo de download.

Você verá algo assim.

Dê permissão ao kubectl.

 chmod +x kubectl

Mova o kubectl para a pasta /usr/local/bin.

 sudo mv kubectl /usr/local/bin

Verifique a versão do kubectl.

 kubectl version --output=yaml

Etapa 7: instalar o eksctl

Execute o comando para baixar o kubectl.

 curl --silent --location "https://github.com/weaveworks/eksctl/releases/latest/download/eksctl_$(uname -s)_amd64.tar.gz" | tar xz -C /tmp

Mova eksctl para a pasta /usr/local/bin.

 sudo mv /tmp/eksctl /usr/local/bin

Verifique a versão do eksctl.

 eksctl version

Você deve ver a versão

Etapa 8: Criar função IAM para eksctl

Você precisa criar uma função IAM e anexá-la à sua instância EC2 “KubernetesServer” .

Para fazer isso você precisa encontrar o EC2 na caixa de pesquisa.

Escolha EC2 Virtual Server clicando no link https://us-east-1.console.aws.amazon.com/ec2/ .

Vá para Painel IAM → Funções .

Clique no botão “Criar função” na página da web de funções do IAM .

Em seguida, escolha “serviço AWS”, “EC2”. E clique no botão “Avançar” .

Em seguida, encontre “AmazonEC2FullAccess” , “AmazonEC2FullAccess“ , “IAMFullAccess“ , “AWSCloudFormationFullAccess“ na caixa de pesquisa e clique no botão “Adicionar permissões” .

E então clique no botão “Avançar” .

Em seguida, digite “Eksctl_Role” na entrada “Nome da função” .

E clique no botão “Criar função” .

A função é criada finalmente.

Etapa 9: conectar a função IAM com eksctl

Acesse a página da web da instância AWS EC2. Escolha “KuberbetesServer”. Em seguida, clique em “Ações” → “Segurança” → “Modificar função IAM”.

Escolha “Eksctl_Role” e clique no botão “Atualizar função IAM” .

Agora sua função IAM está conectada ao seu “EKS_Server” e à ferramenta eksctl.

Etapa 10: Criar cluster eksctl

Agora é hora de configurar seu cluster EKS.

Para conseguir isso, siga estas etapas:

1. Modifique o seguinte comando com suas informações específicas.

 eksctl create cluster --name cluster-name \ --region region-name \ --node-type instance-type \ --nodes-min 2 \ --nodes-max 2 \ --zones <AZ-1>,<AZ-2>

Por exemplo, no meu caso, é assim.

 eksctl create cluster --name zufarexplainedit \ --region eu-north-1 \ --node-type t3.micro

2. Execute o comando modificado e aguarde pacientemente a conclusão do processo de criação do cluster. Você notará que o status do cluster EKS é indicado como "criando" na página da web do AWS CloudFormation.

   
   

O procedimento de criação do cluster normalmente leva cerca de 20 minutos. Depois de concluído, o terminal exibirá o resultado do processo.

Além disso, você pode verificar o status de criação bem-sucedida do cluster EKS na página da web do AWS CloudFormation.

Etapa 11: Criar arquivo yaml de implantação do Kubernetes

Agora, conforme o cluster Kubernetes, eksctl e kubectl estão instalados e configurados, você pode criar um arquivo yaml de implantação do Kubernetes.

Você pode fazer isso executando o seguinte comando.

 touch hello-app-deployment.yaml

Em seguida, edite este arquivo executando o seguinte comando.

 vi hello-app-deployment.yaml

Adicione este conteúdo ao hello-app-deployment.yaml.

 apiVersion: apps/v1 kind: Deployment metadata: name: zufarexplainedit-hello-app labels: app: hello-app spec: replicas: 2 selector: matchLabels: app: hello-app template: metadata: labels: app: hello-app spec: containers: - name: hello-app image: zufarexplainedit/hello imagePullPolicy: Always ports: - containerPort: 8080 strategy: type: RollingUpdate rollingUpdate: maxSurge: 1 maxUnavailable: 1

Agora hello-app-deployment.yaml está criado e pronto para uso.

Etapa 12: Criar arquivo yaml do serviço Kubernetes

À medida que o cluster Kubernetes, eksctl e kubectl são instalados e configurados, você pode criar o arquivo yaml do serviço Kubernetes.

Para fazer isso, você precisa criar um arquivo yaml do serviço Kubernetes executando o seguinte comando.

 touch hello-app-service.yaml

Em seguida, edite este arquivo executando o seguinte comando.

 vi hello-app-service.yaml

Adicione este conteúdo ao hello-app-deployment.yaml.

 apiVersion: v1 kind: Service metadata: name: zufarexplainedit-hello-app-service labels: app: hello-app spec: selector: app: hello-app ports: - port: 8080 targetPort: 8080 type: LoadBalancer

Agora hello-app-service.yaml está criado e pronto para uso.

Etapa 13: testar o cluster Kubernetes usando kubectl

Com seu cluster Kubernetes EKS instalado e configurado com sucesso, e seu serviço Kubernetes e arquivos de implantação prontos, é hora de colocar as coisas à prova usando comandos kubectl.

1. Aplicar implantação.

   Use o comando a seguir para aplicar a configuração de implantação.

 kubectl apply -f hello-app-deployment.yaml

Isso criará uma implantação com o número especificado de réplicas e uma estratégia de atualização contínua, garantindo a disponibilidade e a capacidade de gerenciamento do seu aplicativo.

2. Aplicar serviço.

Em seguida, aplique a configuração do serviço.

 kubectl apply -f hello-app-service.yaml

Isso configurará um serviço do tipo LoadBalancer, expondo sua aplicação à internet.

Observe que pode demorar um pouco para que o LoadBalancer seja provisionado e adquira um endereço IP externo.

3. Verifique o status do LoadBalancer.

   Monitore o status do seu serviço usando.

 kubectl get service zufarexplainedit-hello-app-service

Quando um IP externo é atribuído, você está quase pronto para acessar seu aplicativo.

4. Acesse seu aplicativo.

   Usando um navegador da web, insira o endereço IP externo atribuído seguido de :8080. Após um breve momento, a página será carregada, exibindo a mensagem “HelloWorld”. Lembre-se de que o carregamento inicial pode demorar alguns segundos.

   
   

   

   
   

 kubectl delete deployments --all

 kubectl delete pods --all

 kubectl delete services --all

 eksctl delete cluster --name {your cluster name} --region {your region name}

 eksctl delete cluster --name zufarexplainedit --region eu-north-1

Etapa 14: Adicionar e configurar um novo usuário na instância do servidor virtual AWS EC2 “KubernetesServer”

Agora vamos adicionar um novo usuário ansible-admin à instância do servidor virtual AWS EC2 “KubernetesServer” .

Para fazer isso use este comando.

 sudo useradd ansible-admin

Em seguida, defina a senha para o usuário ansible-admin .

 sudo passwd ansible-admin

Além disso, você precisa configurar os privilégios do usuário editando o arquivo sudoers .

 sudo visudo

Adicione “ansible-admin ALL=(ALL) ALL” a este arquivo sudoers .

Além disso, você precisa editar o arquivo /etc/ssh/sshd_config para ativar o PasswordAuthentication.

 sudo vi /etc/ssh/sshd_config 

Então você precisa recarregar o serviço para fazer essas alterações.

 sudo service sshd reload

Como resultado da execução deste comando, você verá:

 sudo su - ansible-admin

Etapa 15: gerar chave em uma instância do servidor virtual AWS EC2

Você está planejando gerenciar servidores remotos, como a instância de servidor virtual K8s EC2, mais adiante neste artigo. É por isso que você precisa configurar chaves SSH.

 ssh-keygen

Como resultado da execução deste comando, você verá:

Agora as chaves SSH estão geradas e prontas para uso.

Etapa 16: configurar a autenticação SSH sem senha para localhost para Ansible

Ansible foi projetado para automatizar tarefas em servidores remotos. A autenticação SSH sem senha permite que o Ansible se conecte a esses servidores sem a necessidade de inserção manual de senha.

Execute este comando para criar uma conexão segura do seu computador para outro computador (como aquele no endereço IP 172.31.34.41), usando a chave SSH do usuário ansible-admin.

 sudo ssh-copy-id -i /home/{your user name}/.ssh/id_rsa.pub {your user name}@{your host address}

No meu caso, é assim.

 sudo ssh-copy-id -i /home/ansible-admin/.ssh/id_rsa.pub [email protected] 

Agora você pode ver “Número de chaves adicionadas: 1” . Isso significa que a instalação da autenticação SSH sem senha foi concluída com êxito.

Etapa 17: Configurar hosts Ansible na instância AnsibleServer EC2

Ao executar um manual do Ansible, você especifica os hosts nos quais ele deve ser executado. Nesta etapa, você precisa especificar o host da instância KubernetesServer EC2. Para fazer isso você precisa repetir os mesmos passos que você passou em “ [Módulo 6]: Ansible”.

Vamos descobrir o host da instância KubernetesServer EC2 executando o seguinte comando.

 sudo ifconfig 

Depois de encontrar o host da instância KubernetesServer EC2, você pode adicioná-lo ao arquivo de hosts Ansible executando o comando a seguir.

 sudo vi /etc/ansible/hosts 

Você também pode adicionar “[kubernetes]” como referência

Etapa 18: crie um novo manual do Ansible para tarefas do Kubernetes

Agora que o Kubernetes está configurado e pronto para uso, você pode criar um novo manual do Ansible com tarefas do Kubernetes para seu pipeline. Este manual permitirá que o Ansible execute seu aplicativo no cluster Kubernetes com comandos kubectl.

Veja como você pode fazer isso:

1. Comece criando um novo arquivo de manual do Ansible. Basta usar este comando.

 touch kubernetes-hello-app.yml

2. Em seguida, edite o arquivo hello-app.yml recém-criado. Abra-o para edição com este comando.

 vi kubernetes-hello-app.yml

3. Dentro do arquivo, digite o seguinte:

 --- - hosts: kubernetes tasks: - name: deploy regapp on kubernetes command: kubectl apply -f hello-app-deployment.yaml - name: create service for regapp command: kubectl apply -f hello-app-service.yaml - name: update deployment with new pods if image updated in docker hub command: kubectl rollout restart deployment.apps/zufarexplainedit-hello-app

O manual do Ansible para tarefas do Kubernetes está pronto para uso.

Etapa 19: integre um novo manual do Ansible para tarefas do Kubernetes com Jenkins

Agora que o Kubernetes, o Ansible e o manual do Ansible para tarefas do Kubernetes estão configurados e prontos para uso, você pode integrá-lo ao Jenkins.

1. Vá para JenkinsServer → Painel do Jenkins → Novo item.

2. Crie um novo projeto Jenkins Freestyle com o nome “CD-Job”.

   
   

   

   
   

3. Clique no botão “OK”.

4. Vá para a seção “Ações pós-construção”.

5. Clique no botão “Adicionar ação pós-construção”.

6. Escolha a opção “Enviar artefatos de construção por SSH”.

7. Escolha “AnsibleServer” como servidor SSH.

8. Adicione este comando à entrada “exec command”.

   
   

 sudo -u ansible-admin ansible-playbook /opt/docker/kubernetes-hello-app.yml

9. Clique nos botões “Aplicar” e “Salvar”.

10. Vá para o painel do Jenkins → “CI_CD_Pipeline” → Configurar → seção “Ações pós-compilação”.

11. Clique no botão “Adicionar ação pós-construção”.

12. Escolha a opção “Construir outros projetos”.

13. Vá para a seção “Construir outros projetos”.

14. Escolha a opção “Acionar somente se a compilação for estável”.

15. Adicione “CD-Job” à entrada “Projeto para construção”.

    
    

    
    

    

    
    

16. Clique nos botões “Aplicar” e “Salvar”.

    
    

Agora você pode considerar que o pipeline está totalmente finalizado e pronto para uso.

Etapa 20: Testando a versão final do pipeline

Agora é a hora de testar a versão final do pipeline.

Navegue até Jenkins → painel do Jenkins → "CI_CD_Pipeline".

Clique no botão "Construir agora".

Para ver os resultados, revise os logs do console de build.

Você notará que o "CD-Job" foi acionado nos logs do console de construção e o status final está marcado como SUCESSO.

4

Além disso, você pode acessar o Dockerhub para confirmar a adição da nova imagem do Docker.

E, finalmente, você pode acessar seu aplicativo usando um navegador da web. Insira o endereço IP externo atribuído seguido de ":8080". Após um breve momento, a página será carregada, mostrando a mensagem “HelloWorld”.

Conclusão

Parabéns pela configuração deste pipeline de CI/CD moderno!

Você fez um trabalho incrível e é um verdadeiro herói!

Obrigado por todo o seu esforço!

Sobre o autor

Zufar Sunagatov é um experiente engenheiro de software sênior apaixonado por projetar sistemas de software modernos.

• Desenvolvi sistemas distribuídos de alto desempenho usando Java, Kotlin, AWS, Docker e Kubernetes para empresas como Citi (Londres), MTS (Moscou) e outras ( você pode seguir o perfil de Zufar no LinkedIn para mais informações ).
• Fundou o Ice Latte, um mercado online de código aberto do zero (você pode se juntar à equipe de Zufar e contribuir com seu projeto no GitHub: https://github.com/Sunagatov/Online-Store ).
• Estabeleceu a comunidade ZufarExplainedIT para compartilhar seu conhecimento e experiência com outras pessoas (você pode seguir a comunidade IT Telegram de Zufar: https://t.me/zufarexplained ).
• Foi mentor por mais de 3.000 minutos e conduziu 60 sessões no ADPlist, nutrindo aspirantes a talentos ( você pode ser orientado por Zufar no ADPlist ).
• Envolveu o público como palestrante em conferências e canais de TI no YouTube, compartilhando insights valiosos (exemplos de seus vídeos no YouTube incluem: “Тестовое собеседование Java разработчика #27 - Зуфар Сунагатов” , “Aspiring Speakers Lunchtime Lightning Talks 28 de maio” ).
• É autor de artigos de TI altamente populares com mais de 7.000 visualizações cada (exemplos de seus artigos são: “Microservice Architecture Patterns Part 1: Decomposition Patterns” , “Что значит «вариативный»? Объясняем простыми словами” ).