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.

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

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

Etapa 1: crie uma conta AWS

Clique no botão Crie uma conta AWS .

Etapa 2: faça login em sua conta AWS

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

Etapa 3: Encontre o servidor virtual EC2

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” .

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)” .

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” .

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

[Módulo 2]: Servidor Jenkins

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

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” .

Etapa 3: Baixe o repositório Jenkins

1. Vá para de download do Jenkins.
2. Você pode ver as opções de versões estáveis (LTS) e regulares (semanais). Escolha a opção LTS.

   
   

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 //pkg.jenkins.io/redhat-stable/jenkins.repo

Etapa 4: importar a chave Jenkins

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

 sudo rpm --import //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

Etapa 6: instale o fontconfig

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

 sudo yum install fontconfig java-11-openjdk -y

Etapa 7: Instale o Jenkins

 sudo yum install jenkins -y

Etapa 8: inicie o Jenkins

 sudo systemctl start jenkins

 sudo systemctl status jenkins

Etapa 9: acesse o Jenkins

 //<your-ec2-ip>:8080

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

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.

[Módulo 3]: Git e Github

Etapa 1: instalar o Git

 sudo yum install git -y

 git --version

Etapa 2: abra o 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” .

Etapa 6: configurar o plug-in Github Jenkins

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, clique nos botões “Aplicar” e “Salvar” **.**

Etapa 7: Integrar o Git ao pipeline

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

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

[Módulo 4]: Apache Maven

Etapa 1: Baixe o Apache Maven

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

 cd /opt

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

Etapa 2: Extraia o Apache Maven do arquivo

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

Etapa 3: adicionar JAVA_HOME e M2_HOME

 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 .

 sudo find / -name java 

 source .bash_profile

Para verificar $PATH , use este comando.

 echo $PATH

Para verificar o Apache Maven , use este comando.

 mvn -v

Etapa 4: instale o plug-in Apache Maven Jenkins

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” .

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

Etapa 5: configurar o plug-in Apache Maven Jenkins

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” .

Etapa 6: Integrar o Apache Maven ao pipeline

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

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

[Módulo 5]: Docker

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

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

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

 sudo mkdir /opt/docker

 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

 id ansible-admin

Etapa 5: iniciar o Docker

 sudo systemctl start docker

 sudo systemctl status docker

Etapa 6: criar 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" ]

 sudo touch Dockerfile

 vim Dockerfile

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.

 docker login

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

 docker build -t hello:latest .

 docker tag hello:latest zufarexplainedit/hello:latest

 docker push zufarexplainedit/hello:latest

[Módulo 6]: Ansible

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

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

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

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

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

 sudo vi /etc/hostname

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.

 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 

 sudo service sshd reload

 sudo su - ansible-admin

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

 ssh-keygen

Etapa 6: instalar o Ansible

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

 sudo amazon-linux-extras install ansible2

 ansible --version

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.

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

Para fazer isso, siga estas etapas:

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

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

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

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

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.

 cd /opt/docker

Etapa 12: configurar hosts Ansible

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.

 sudo ifconfig 

 sudo vi /etc/ansible/hosts

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

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

 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

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

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

 cd /opt/docker

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

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.

[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

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

 sudo vi /etc/hostname

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

 sudo init 6

Etapa 4: verifique a versão do AWS CLI

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

 aws --version

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

Etapa 5: atualizar AWS CLI

Copie e cole o comando curl .

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

 unzip awscliv2.zip

 sudo ./aws/install

 aws --version

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 .

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

 chmod +x kubectl

 sudo mv kubectl /usr/local/bin

 kubectl version --output=yaml

Etapa 7: instalar o eksctl

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

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

 eksctl version

Etapa 8: Criar função IAM para eksctl

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

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” .

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

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>

 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.

   
   

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

 touch hello-app-deployment.yaml

 vi 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

Etapa 12: Criar arquivo yaml do serviço Kubernetes

 touch hello-app-service.yaml

 vi hello-app-service.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

Etapa 13: testar o cluster Kubernetes usando 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

2. Aplicar serviço.

 kubectl apply -f hello-app-service.yaml

3. Verifique o status do LoadBalancer.

   Monitore o status do seu serviço usando.

 kubectl get service zufarexplainedit-hello-app-service

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” .

 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 

 sudo service sshd reload

 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

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

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

 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”.

 sudo ifconfig 

 sudo vi /etc/ansible/hosts 

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

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

Etapa 19: integre um novo manual do Ansible para tarefas do Kubernetes com 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”.

    
    

Etapa 20: Testando a versão final do pipeline

Conclusã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 ( ).
• 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: ).
• Estabeleceu a comunidade ZufarExplainedIT para compartilhar seu conhecimento e experiência com outras pessoas (você pode seguir a comunidade IT Telegram de Zufar: ).
• Foi mentor por mais de 3.000 minutos e conduziu 60 sessões no ADPlist, nutrindo aspirantes a talentos ( ).
• 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: , ).
• É 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” , ).