Tutorial: Implantar uma aplicação no Amazon EKS - Amazon CodeCatalyst

Tutorial: Implantar uma aplicação no Amazon EKS

Neste tutorial, você aprende a implantar uma aplicação em contêineres no Amazon Elastic Kubernetes Service usando um fluxo de trabalho do Amazon CodeCatalyst, o Amazon EKS e alguns outros serviços da AWS. A aplicação implantada é um site simples “Hello, World!” criado em uma imagem do Docker do servidor da Web Apache. O tutorial mostra o trabalho de preparação necessário, como configurar uma máquina de desenvolvimento e um cluster do Amazon EKS, e depois descreve como criar um fluxo de trabalho para criar a aplicação e implantá-la no cluster.

Após a conclusão da implantação inicial, o tutorial instrui você a fazer uma alteração na origem da aplicação. Essa alteração faz com que uma nova imagem do Docker seja criada e enviada ao seu repositório de imagens do Docker com novas informações de revisão. A nova revisão da imagem do Docker é implantada no Amazon EKS.

dica

Em vez de seguir este tutorial, você pode usar um esquema que faz uma configuração completa do Amazon EKS para você. Você precisará usar o esquema Implantação de aplicações EKS. Para ter mais informações, consulte Criar um projeto com um esquema.

Pré-requisitos

Antes de começar este tutorial:

  • Você precisa de um espaço do Amazon CodeCatalyst com uma conta da AWS conectada. Para ter mais informações, consulte Criar um espaço.

  • Em seu espaço, você precisa de um projeto vazio chamado:

    codecatalyst-eks-project

    Use a opção Começar do zero para criar esse projeto.

    Para ter mais informações, consulte Criação de um projeto vazio no Amazon CodeCatalyst.

  • Em seu projeto, você precisa de um repositório de origem vazio do CodeCatalyst chamado:

    codecatalyst-eks-source-repository

    Para ter mais informações, consulte Armazenamento e colaboração no código com repositórios de origem no CodeCatalyst.

  • Em seu projeto, você precisa de um ambiente de CI/CD do CodeCatalyst (não de um Ambiente de Desenvolvimento) chamado:

    codecatalyst-eks-environment

    Configure esse ambiente da seguinte forma:

    • Escolha qualquer tipo, como Não produção.

    • Conecte sua conta da AWS a ele.

    • Para o Perfil do IAM padrão, escolha qualquer perfil. Você especificará um perfil diferente posteriormente.

    Para ter mais informações, consulte Implantação em Contas da AWS e VPCs.

Etapa 1: configurar sua máquina de desenvolvimento

A primeira etapa deste tutorial é configurar uma máquina de desenvolvimento com algumas ferramentas que você usará ao longo deste tutorial. Essas ferramentas são:

  • o utilitário eksctl — para criação de clusters

  • o utilitário kubectl — um pré-requisito para eksctl

  • a AWS CLI — também um pré-requisito para eksctl

Você pode instalar essas ferramentas em sua máquina de desenvolvimento existente, se tiver uma, ou pode usar um Ambiente de Desenvolvimento do CodeCatalyst, que é baseado em nuvem. A vantagem de um Ambiente de Desenvolvimento do CodeCatalyst é que ele é fácil de ativar e desativar e está integrado a outros serviços do CodeCatalyst, permitindo que você conclua este tutorial em menos etapas.

Este tutorial pressupõe que você usará um Ambiente de Desenvolvimento do CodeCatalyst.

As instruções a seguir descrevem uma maneira rápida de iniciar um Ambiente de Desenvolvimento do CodeCatalyst e configurá-lo com as ferramentas necessárias. Se você quiser instruções detalhadas, consulte:

Como iniciar um novo ambiente de desenvolvimento
  1. Abra o console do CodeCatalyst em https://codecatalyst.aws/.

  2. Navegue até o projeto, codecatalyst-eks-project.

  3. No painel de navegação, selecione Código e, depois, selecione Repositórios de origem.

  4. Escolha o nome para o seu repositório de origem, codecatalyst-eks-source-repository.

  5. Na parte superior, escolha Criar ambiente de desenvolvimento e AWS Cloud9 (no navegador).

  6. Verifique se Trabalhar na ramificação existente e principal estão selecionados e, depois, selecione Criar.

    O Ambiente de Desenvolvimento é iniciado em uma nova guia do navegador e seu repositório (codecatalyst-eks-source-repository) é clonado nela.

Para instalar e configurar o kubectl
  1. No terminal do Ambiente de Desenvolvimento, insira:

    curl -o kubectl https://amazon-eks.s3.us-west-2.amazonaws.com/1.18.9/2020-11-02/bin/linux/amd64/kubectl
  2. Insira:

    chmod +x ./kubectl
  3. Insira:

    mkdir -p $HOME/bin && cp ./kubectl $HOME/bin/kubectl && export PATH=$PATH:$HOME/bin
  4. Insira:

    echo 'export PATH=$PATH:$HOME/bin' >> ~/.bashrc
  5. Insira:

    kubectl version --short --client
  6. Confira se uma versão é exibida.

    Você agora tem o kubectl instalado.

Para instalar e configurar o eksctl
nota

eksctl não é estritamente necessário porque você pode usar o kubectl em vez disso. No entanto, o eksctl tem a vantagem de automatizar grande parte da configuração do cluster e, portanto, é a ferramenta recomendada para este tutorial.

  1. No terminal do Ambiente de Desenvolvimento, insira:

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

    sudo cp /tmp/eksctl /usr/bin
  3. Insira:

    eksctl version
  4. Confira se uma versão é exibida.

    Você agora tem o eksctl instalado.

Para verificar se a AWS CLI está instalada
  1. No terminal do Ambiente de Desenvolvimento, insira:

    aws --version
  2. Confira se uma versão aparece para verificar se a AWS CLI está instalada.

    Conclua os procedimentos restantes para configurar a AWS CLI com as permissões necessárias para acessar a AWS.

Para configurar a AWS CLI

Você deve configurar a AWS CLI com chaves de acesso e um token de sessão para dar acesso aos serviços da AWS. As instruções a seguir fornecem uma maneira rápida de configurar as chaves e o token, mas se você quiser instruções detalhadas, consulte Configuração da AWS CLI no Guia do usuário do AWS Command Line Interface.

  1. Crie um usuário do IAM Identity Center, da seguinte forma:

    1. Faça login no AWS Management Console e abra o console do AWS IAM Identity Center em https://console.aws.amazon.com/singlesignon/.

      (Talvez seja necessário selecionar Ativar se você nunca tiver feito login no IAM Identity Center antes.)

      nota

      Faça login usando a Conta da AWS que está conectada ao seu espaço do CodeCatalyst. Você pode verificar qual conta está conectada navegando até seu espaço e escolhendo a guia Contas da AWS. Para ter mais informações, consulte Criar um espaço.

    2. No painel de navegação, escolha Usuários e depois Adicionar usuário.

    3. Em Nome de usuário, digite:

      codecatalyst-eks-user
    4. Em Senha, selecione Gerar uma senha de uso único que você possa compartilhar com esse usuário.

    5. Em Endereço de e-mail e Confirmar endereço de e-mail, insira um endereço de e-mail que ainda não exista no IAM Identity Center.

    6. Em Nome, insira:

      codecatalyst-eks-user
    7. Em Sobrenome, insira:

      codecatalyst-eks-user
    8. Em Nome de exibição, mantenha:

      codecatalyst-eks-user codecatalyst-eks-user
    9. Escolha Próximo.

    10. Na página Adicionar usuário a grupos, selecione Avançar.

    11. Na página Revisar e adicionar usuário, revise as informações e selecione Adicionar usuário.

      Uma caixa de diálogo Senha de uso único é exibida.

    12. Selecione Copiar e cole as informações de login em um arquivo de texto. As informações de login consistem no URL do portal de acesso da AWS, um nome de usuário e uma senha de uso único.

    13. Escolha Fechar.

  2. Crie um conjunto de permissões, da seguinte forma:

    1. No painel de navegação, escolha Conjuntos de permissões e, depois, escolha Criar conjunto de permissões.

    2. Selecione Conjunto de permissões predefinido e AdministratorAccess. Esta política fornece permissões totais para todos os Serviços da AWS.

    3. Escolha Próximo.

    4. Em Nome do conjunto de permissões, remova AdministratorAccess e digite:

      codecatalyst-eks-permission-set
    5. Escolha Próximo.

    6. Na página Revisar e criar, revise as informações e selecione Criar.

  3. Atribua o conjunto de permissões para codecatalyst-eks-user, da seguinte forma:

    1. No painel de navegação, selecione Contas da AWS e marque a caixa de seleção ao lado da Conta da AWS a que você está conectado no momento.

    2. Escolha Atribuir usuários ou grupos.

    3. Escolha a guia Users.

    4. Marque a caixa de seleção ao lado dos logs do codecatalyst-eks-user.

    5. Escolha Próximo.

    6. Marque a caixa de seleção ao lado dos logs do codecatalyst-eks-permission-set.

    7. Escolha Próximo.

    8. Revise suas informações e selecione Enviar.

      Agora você atribuiu codecatalyst-eks-user e codecatalyst-eks-permission-set à sua Conta da AWS, vinculando-os.

  4. Obtenha as chaves de acesso de codecatalyst-eks-user e o token de sessão, da seguinte forma:

    1. Verifique se você tem o URL do portal de acesso da AWS, o nome de usuário e a senha de uso único do codecatalyst-eks-user. Você deveria ter copiado essas informações para um editor de texto anteriormente.

      nota

      Se você não tiver essas informações, acesse a página de detalhes do codecatalyst-eks-user no IAM Identity Center, selecione Redefinir senha, Gerar uma senha de uso único [...] e Redefinir senha novamente para exibir as informações na tela.

    2. Saia da AWS.

    3. Cole a URL do portal de acesso da AWS na barra de endereço do seu navegador.

    4. Faça login com:

      • Nome de usuário:

        codecatalyst-eks-user
      • Senha:

        Senhas de uso único

    5. Em Definir nova senha, insira uma nova senha e selecione Definir nova senha.

      Uma caixa de Conta da AWS aparece na tela.

    6. Selecione Conta da AWS e, depois, escolha o nome da Conta da AWS a que você atribuiu o usuário codecatalyst-eks-user e o conjunto de permissões.

    7. Ao lado de codecatalyst-eks-permission-set, selecione Linha de comando ou acesso programático.

    8. Copie os comandos no meio da página. Eles são semelhantes a:

      export AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE" export AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY" export AWS_SESSION_TOKEN="session-token"

      ... onde o token de sessão é uma longa string aleatória.

  5. Adicione as chaves de acesso e o token de sessão à AWS CLI, da seguinte forma:

    1. Retorne ao seu Ambiente de Desenvolvimento do CodeCatalyst.

    2. No prompt do terminal, cole os comandos que você copiou. Pressione Enter.

      Agora você configurou a AWS CLI com chaves de acesso e um token de sessão. Agora você pode usar a AWS CLI para concluir as tarefas exigidas por este tutorial.

      Importante

      Se, em algum momento durante este tutorial, você vir mensagens semelhantes a:

      Unable to locate credentials. You can configure credentials by running "aws configure".

      Ou:

      ExpiredToken: The security token included in the request is expired

      ... é porque a sessão da AWS CLI expirou. Nesse caso, não execute o comando aws configure. Em vez disso, use as instruções na etapa 4 desse procedimento, que começa com Obtain codecatalyst-eks-user's access key and session token, para atualizar sua sessão.

Etapa 2: criar um cluster do Amazon EKS

Nesta seção, você cria um cluster no Amazon EKS. As instruções abaixo descrevem uma maneira rápida de criar o cluster usando o eksctl, mas se você quiser instruções detalhadas, consulte:

nota

Os clusters privados não são compatíveis com a integração do CodeCatalyst com o Amazon EKS.

Antes de começar

Verifique se você concluiu as seguintes tarefas na sua máquina de desenvolvimento:

  • Instalou o utilitário eksctl.

  • Instalou o utilitário kubectl.

  • Instalou a AWS CLI e a configurou com chaves de acesso e um token de sessão.

Para ter informações sobre como concluir essas tarefas, consulte Etapa 1: configurar sua máquina de desenvolvimento.

Para criar um cluster
Importante

Não use a interface de usuário do serviço Amazon EKS para criar o cluster porque o cluster não será configurado corretamente. Use o utilitário eksctl, conforme descrito nas etapas a seguir.

  1. Acesse o Ambiente de Desenvolvimento.

  2. Crie um cluster e nós:

    eksctl create cluster --name codecatalyst-eks-cluster --region us-west-2

    Em que:

    • codecatalyst-eks-cluster é substituído pelo nome que você deseja dar ao cluster.

    • us-west-2 é substituído pela sua região.

    Depois de 10 a 20 minutos, uma mensagem semelhante à seguinte é exibida:

    EKS cluster "codecatalyst-eks-cluster" in "us-west-2" region is ready

    nota

    Você verá várias mensagens waiting for CloudFormation stack enquanto a AWS cria seu cluster. Isso é esperado.

  3. Verifique se o cluster foi criado:

    kubectl cluster-info

    Você verá uma mensagem semelhante à seguinte, indicando uma criação de cluster bem-sucedida:

    Kubernetes master is running at https://long-string.gr7.us-west-2.eks.amazonaws.com CoreDNS is running at https://long-string.gr7.us-west-2.eks.amazonaws.com/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy

Etapa 3: criar uma imagem de repositório do Amazon ECR

Nesta seção, você cria um repositório de imagens privadas no Amazon Elastic Container Registry (Amazon ECR). Esse repositório armazena a imagem do Docker do tutorial.

Para obter mais informações sobre o Amazon ECR, consulte o Guia do usuário do Amazon Elastic Container Registry.

Para criar um repositório de imagens no Amazon ECR
  1. Acesse o Ambiente de Desenvolvimento.

  2. Crie um repositório vazio no Amazon ECR:

    aws ecr create-repository --repository-name codecatalyst-eks-image-repo

    Substitua codecatalyst-eks-image-repo pelo nome que você deseja dar ao repositório do Amazon ECR.

    Este tutorial pressupõe que você tem um repositório chamado codecatalyst-eks-image-repo.

  3. Exiba os detalhes do repositório do Amazon ECR:

    aws ecr describe-repositories \ --repository-names codecatalyst-eks-image-repo
  4. Observe o valor “repositoryUri”:, por exemplo, 111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-eks-image-repo.

    Você precisará dele mais tarde ao adicionar o repositório ao seu fluxo de trabalho.

Etapa 4: adicionar arquivos de origem

Nesta seção, você adiciona arquivos de origem da aplicação ao seu repositório de origem (codecatalyst-eks-source-repository). Eles consistem em:

  • Um arquivo index.html: exibe uma mensagem “Hello, World!” no navegador.

  • Um Dockerfile: descreve a imagem básica a ser usada para sua imagem do Docker e os comandos do Docker a serem aplicados a ela.

  • Um arquivo deployment.yaml: o manifesto do Kubernetes que define o serviço e a implantação do Kubernetes.

A estrutura de pastas é esta:

|— codecatalyst-eks-source-repository |— Kubernetes |— deployment.yaml |— public-html | |— index.html |— Dockerfile

index.html

O arquivo index.html exibe uma mensagem “Hello, World!” no navegador.

Como adicionar o arquivo index.html
  1. Acesse o Ambiente de Desenvolvimento.

  2. Em codecatalyst-eks-source-repository, crie uma pasta chamada public-html.

  3. Em /public-html, crie um arquivo chamado index.html com o conteúdo a seguir:

    <html> <head> <title>Hello World</title> <style> body { background-color: black; text-align: center; color: white; font-family: Arial, Helvetica, sans-serif; } </style> </head> <body> <h1>Hello, World!</h1> </body> </html>
  4. No prompt do terminal, insira:

    cd /projects/codecatalyst-eks-source-repository
  5. Adicione, confirme e envie:

    git add . git commit -m "add public-html/index.html" git push

    O index.html é adicionado ao seu repositório em uma pasta public-html.

Dockerfile

O Dockerfile descreve a imagem base do Docker a ser usada e os comandos do Docker a serem aplicados a ela. Para ter mais informações sobre o Dockerfile, consulte a Referência de Dockerfile.

O Dockerfile especificado aqui indica o uso da imagem base do Apache 2.4 (httpd). Também inclui instruções para copiar um arquivo fonte chamado index.html para uma pasta no servidor Apache que serve páginas da Web. A instrução EXPOSE no Dockerfile diz ao Docker que o contêiner está escutando na porta 80.

Para adicionar o Dockerfile
  1. Em codecatalyst-eks-source-repository, crie um arquivo chamado Dockerfile com o conteúdo a seguir:

    FROM httpd:2.4 COPY ./public-html/index.html /usr/local/apache2/htdocs/index.html EXPOSE 80

    Não inclua uma extensão de arquivo.

    Importante

    O Dockerfile deve residir na pasta raiz do repositório. O comando Docker build do fluxo de trabalho espera que ele esteja lá.

  2. Adicione, confirme e envie:

    git add . git commit -m "add Dockerfile" git push

    O Dockerfile é adicionado ao repositório.

deployment.yaml

Nesta seção, você adiciona um arquivo deployment.yaml ao seu repositório. O arquivo deployment.yaml é um manifesto do Kubernetes que define dois tipos de recursos do Kubernetes a serem executados: um “serviço” e uma “implantação”.

  • O “serviço” implanta um balanceador de carga no Amazon EC2. O balanceador de carga fornece um URL público voltado para a Internet e uma porta padrão (porta 80) que você pode usar para navegar até a aplicação “Hello, World!” .

  • A “implantação” implanta três pods, e cada pod terá um contêiner do Docker com a aplicação “Hello, World!” . Os três pods são implantados nos nós que foram criados quando você criou o cluster.

O manifesto neste tutorial é curto. No entanto, um manifesto pode incluir vários tipos de recursos do Kubernetes, como pods, trabalhos, entradas e políticas de rede. Além disso, você pode usar vários arquivos de manifesto se sua implantação for complexa.

Para adicionar um arquivo deployment.yaml
  1. Em codecatalyst-eks-source-repository, crie uma pasta chamada Kubernetes.

  2. Em /Kubernetes, crie um arquivo chamado deployment.yaml com o conteúdo a seguir:

    apiVersion: v1 kind: Service metadata: name: my-service labels: app: my-app spec: type: LoadBalancer selector: app: my-app ports: - protocol: TCP port: 80 targetPort: 80 --- apiVersion: apps/v1 kind: Deployment metadata: name: my-deployment labels: app: my-app spec: replicas: 3 selector: matchLabels: app: my-app template: metadata: labels: app: my-app spec: containers: - name: codecatalyst-eks-container # The $REPOSITORY_URI and $IMAGE_TAG placeholders will be replaced by actual values supplied by the build action in your workflow image: $REPOSITORY_URI:$IMAGE_TAG ports: - containerPort: 80
  3. Adicione, confirme e envie:

    git add . git commit -m "add Kubernetes/deployment.yaml" git push

    O arquivo deployment.yaml é adicionado ao seu repositório em uma pasta chamada Kubernetes.

Agora você adicionou todos os seus arquivos de origem.

Reserve um momento para verificar seu trabalho e garantir que colocou todos os arquivos nas pastas corretas. A estrutura de pastas é esta:

|— codecatalyst-eks-source-repository |— Kubernetes |— deployment.yaml |— public-html | |— index.html |— Dockerfile

Etapa 5: criar perfis da AWS

Nesta seção, você cria perfis do AWS IAM de que seu fluxo de trabalho do CodeCatalyst precisará para funcionar. Esses perfis são:

  • Perfil de criação — Concede à ação de criação do CodeCatalyst (no fluxo de trabalho) permissão para acessar sua conta da AWS e gravar no Amazon ECR e no Amazon EC2.

  • Perfil de implantação — Concede à ação Implantar no cluster do Kubernetes do CodeCatalyst (no fluxo de trabalho) permissão para acessar sua conta da AWS e o Amazon EKS.

Para ter informações sobre perfis do IAM, consulte Perfis do IAM no Guia do usuário do AWS Identity and Access Management.

nota

Para economizar tempo, você pode criar um único perfil, chamado CodeCatalystWorkflowDevelopmentRole-spaceName, em vez dos dois perfis listados anteriormente. Para ter mais informações, consulte Criar o perfil CodeCatalystWorkflowDevelopmentRole-spaceName para a conta e o espaço. Entenda que o perfil CodeCatalystWorkflowDevelopmentRole-spaceName tem permissões bem amplas, o que pode representar um risco de segurança. Recomendamos que você use esse perfil apenas em tutoriais e em cenários em que a segurança seja menos preocupante. Este tutorial pressupõe que você esteja criando os dois perfis listados anteriormente.

Para criar os perfis de criação e implantação, conclua a série de procedimentos a seguir.

1. Para criar uma política de confiança para os dois perfis
  1. Acesse o Ambiente de Desenvolvimento.

  2. No diretório Cloud9-long-string, crie um arquivo chamado codecatalyst-eks-trust-policy.json com o seguinte conteúdo:

    { "Version": "2012-10-17", "Statement": [ { "Sid": "", "Effect": "Allow", "Principal": { "Service": [ "codecatalyst-runner.amazonaws.com", "codecatalyst.amazonaws.com" ] }, "Action": "sts:AssumeRole" } ] }
2. Para criar a política de criação do perfil de criação
  • No diretório Cloud9-long-string, crie um arquivo chamado codecatalyst-eks-build-policy.json com o seguinte conteúdo:

    { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "ecr:*", "ec2:*" ], "Resource": "*" } ] }
    nota

    Na primeira vez em que o perfil for usado para executar ações de fluxo de trabalho, use o caractere curinga na declaração de política de recursos e defina o escopo da política com o nome do recurso depois que ele estiver disponível.

    "Resource": "*"
3. Para criar a política do perfil de implantação
  • No diretório Cloud9-long-string, crie um arquivo chamado codecatalyst-eks-deploy-policy.json com o seguinte conteúdo:

    { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "eks:DescribeCluster", "eks:ListClusters" ], "Resource": "*" } ] }
    nota

    Na primeira vez em que o perfil for usado para executar ações de fluxo de trabalho, use o caractere curinga na declaração de política de recursos e defina o escopo da política com o nome do recurso depois que ele estiver disponível.

    "Resource": "*"

Agora você adicionou três documentos de política ao seu Ambiente de Desenvolvimento. A estrutura do seu diretório agora deve ficar assim:

|— Cloud9-long-string |— .c9 |— codecatalyst-eks-source-repository |— Kubernetes |— public-html |— Dockerfile codecatalyst-eks-build-policy.json codecatalyst-eks-deploy-policy.json codecatalyst-eks-trust-policy.json
4. Para adicionar a política de criação à AWS
  1. No terminal do Ambiente de Desenvolvimento, insira:

    cd /projects
  2. Insira:

    aws iam create-policy \ --policy-name codecatalyst-eks-build-policy \ --policy-document file://codecatalyst-eks-build-policy.json
  3. Pressione Enter.

  4. Na saída do comando, observe o valor "arn":, por exemplo, arn:aws:iam::111122223333:policy/codecatalyst-eks-build-policy. Esse ARN será necessário posteriormente.

5. Para adicionar a política de implantação à AWS
  1. Insira:

    aws iam create-policy \ --policy-name codecatalyst-eks-deploy-policy \ --policy-document file://codecatalyst-eks-deploy-policy.json
  2. Pressione Enter.

  3. Na saída do comando, observe o valor "arn": da política de implantação, por exemplo, arn:aws:iam::111122223333:policy/codecatalyst-eks-deploy-policy. Esse ARN será necessário posteriormente.

6. Para criar o perfil de criação
  1. Insira:

    aws iam create-role \ --role-name codecatalyst-eks-build-role \ --assume-role-policy-document file://codecatalyst-eks-trust-policy.json
  2. Pressione Enter.

  3. Insira:

    aws iam attach-role-policy \ --role-name codecatalyst-eks-build-role \ --policy-arn arn:aws:iam::111122223333:policy/codecatalyst-eks-build-policy

    Onde arn:aws:iam::111122223333:policy/codecatalyst-eks-build-policy é substituído pelo ARN da política de criação que você observou anteriormente.

  4. Pressione Enter.

  5. No prompt do terminal, insira:

    aws iam get-role \ --role-name codecatalyst-eks-build-role
  6. Pressione Enter.

  7. Observe o valor "Arn": do perfil, por exemplo, arn:aws:iam::111122223333:role/codecatalyst-eks-build-role. Esse ARN será necessário posteriormente.

7. Para criar o perfil de implantação
  1. Insira:

    aws iam create-role \ --role-name codecatalyst-eks-deploy-role \ --assume-role-policy-document file://codecatalyst-eks-trust-policy.json
  2. Pressione Enter.

  3. Insira:

    aws iam attach-role-policy \ --role-name codecatalyst-eks-deploy-role \ --policy-arn arn:aws:iam::111122223333:policy/codecatalyst-eks-deploy-policy

    Onde arn:aws:iam::111122223333:policy/codecatalyst-eks-deploy-policy é substituído pelo ARN da política de implantação que você observou anteriormente.

  4. Pressione Enter.

  5. Insira:

    aws iam get-role \ --role-name codecatalyst-eks-deploy-role
  6. Pressione Enter.

  7. Observe o valor "Arn": do perfil, por exemplo, arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role. Esse ARN será necessário posteriormente.

Agora você criou perfis de criação e implantação e anotou os ARNs.

Etapa 6: adicionar perfis da AWS ao CodeCatalyst

Nesta etapa, você adiciona o perfil de criação (codecatalyst-eks-build-role) e o perfil de implantação (codecatalyst-eks-deploy-role) à Conta da AWS conectada ao seu espaço. Isso torna os perfis disponíveis para uso em seu fluxo de trabalho.

Para adicionar perfis de criação e implantação à sua Conta da AWS
  1. No console do CodeCatalyst, navegue até o seu espaço.

  2. Na parte superior, selecione Configurações.

  3. No painel de navegação, selecione Contas da AWS. Uma lista de contas é exibida.

  4. Na coluna Nome de exibição do Amazon CodeCatalyst, copie o nome de exibição da Conta da AWS em que você criou os perfis de criação e implantação. (Pode ser um número.) Esse valor será necessário posteriormente, ao criar seu fluxo de trabalho.

  5. Escolha o nome de exibição.

  6. Selecione Gerenciar perfis no console de gerenciamento da AWS.

    A página Adicionar perfil do IAM ao espaço do Amazon CodeCatalyst é exibida. Talvez seja necessário fazer login para acessá-la.

  7. Selecione Adicionar um perfil existente que você criou no IAM.

    Uma lista suspensa aparece. A lista exibe os perfis de criação e implantação e outros perfis do IAM com uma política de confiança que inclui as entidades principais de serviço codecatalyst-runner.amazonaws.com e codecatalyst.amazonaws.com.

  8. Na lista suspensa, adicione:

    • codecatalyst-eks-build-role

    • codecatalyst-eks-deploy-role

    nota

    Se você vir The security token included in the request is invalid, pode ser porque você não tem as permissões corretas. Para corrigir esse problema, saia e faça login novamente na AWS com a conta da AWS que você usou ao criar seu espaço no CodeCatalyst.

  9. Volte ao console do CodeCatalyst e atualize a página.

    Os perfis de criação e implantação agora devem aparecer em Perfis do IAM.

    Esses perfis agora estão disponíveis para uso em fluxos de trabalho do CodeCatalyst.

Etapa 7: atualizar o ConfigMap

Você deve adicionar o perfil de implantação que você criou em Etapa 5: criar perfis da AWS ao arquivo ConfigMap do Kubernetes para dar à ação Implantar no cluster do Kubernetes (no fluxo de trabalho) a capacidade de acessar e interagir com seu cluster. Você pode usar o eksctl ou kubectl para executar essa tarefa.

Para configurar o arquivo ConfigMap do Kubernetes usando eksctl
  • No terminal do Ambiente de Desenvolvimento, insira:

    eksctl create iamidentitymapping --cluster codecatalyst-eks-cluster --arn arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role --group system:masters --username codecatalyst-eks-deploy-role --region us-west-2

    Em que:

    • codecatalyst-eks-cluster é substituído pelo nome do cluster do Amazon EKS.

    • arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role é substituído pelo ARN do perfil de implantação que você criou em Etapa 5: criar perfis da AWS.

    • codecatalyst-eks-deploy-role (ao lado de --username) é substituído pelo nome do perfil de implantação que você criou em Etapa 5: criar perfis da AWS.

      nota

      Se você decidiu não criar um perfil de implantação, substitua codecatalyst-eks-deploy-role pelo nome do perfil CodeCatalystWorkflowDevelopmentRole-spaceName. Para obter mais informações sobre essa função, consulte Etapa 5: criar perfis da AWS.

    • us-west-2 é substituído pela sua região.

    Para saber detalhes sobre esse comando, consulte Gerenciar usuários e perfis do IAM.

    Uma mensagem semelhante à seguinte é exibida:

    2023-06-09 00:58:29 [ℹ]  checking arn arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role against entries in the auth ConfigMap
    2023-06-09 00:58:29 [ℹ]  adding identity "arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role" to auth ConfigMap
Como configurar o arquivo ConfigMap do Kubernetes usando kubectl
  1. No terminal do Ambiente de Desenvolvimento, insira:

    kubectl edit configmap -n kube-system aws-auth

    O arquivo ConfigMap é exibido na tela.

  2. Adicione o texto em itálico vermelho:

    # Please edit the object below. Lines beginning with a '#' will be ignored,
    # and an empty file will abort the edit. If an error occurs while saving this file will be
    # reopened with the relevant failures.
    #
    apiVersion: v1
    data:
      mapRoles: |
        - groups:
          - system:bootstrappers
          - system:nodes
          rolearn: arn:aws:iam::111122223333:role/eksctl-codecatalyst-eks-cluster-n-NodeInstanceRole-16BC456ME6YR5
          username: system:node:{{EC2PrivateDNSName}}
        - groups:
          - system:masters
          rolearn: arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role
          username: codecatalyst-eks-deploy-role
      mapUsers: |
        []
    kind: ConfigMap
    metadata:
      creationTimestamp: "2023-06-08T19:04:39Z"
      managedFields:
      ...

    Em que:

    • arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role é substituído pelo ARN do perfil de implantação que você criou em Etapa 5: criar perfis da AWS.

    • codecatalyst-eks-deploy-role (ao lado de username:) é substituído pelo nome do perfil de implantação que você criou em Etapa 5: criar perfis da AWS.

      nota

      Se você decidiu não criar um perfil de implantação, substitua codecatalyst-eks-deploy-role pelo nome do perfil CodeCatalystWorkflowDevelopmentRole-spaceName. Para obter mais informações sobre essa função, consulte Etapa 5: criar perfis da AWS.

    Para saber detalhes, consulte Habilitar o acesso da entidade principal do IAM ao seu cluster no Guia do usuário do Amazon EKS.

Agora você concedeu ao perfil de implantação e, por extensão, à ação Implantar no Amazon EKS, permissões system:masters para seu cluster do Kubernetes.

Etapa 8: criar e executar um fluxo de trabalho

Nesta etapa, você cria um fluxo de trabalho que cria os arquivos de origem em uma imagem do Docker e, depois, implanta a imagem em três pods no cluster do Amazon EKS.

O fluxo de trabalho consiste nos seguintes blocos de compilação que são executados sequencialmente:

  • Um gatilho – Esse gatilho inicia a execução automática do fluxo de trabalho quando você envia uma alteração ao seu repositório de origem. Para ter mais informações sobre gatilhos, consulte Início da execução automática de um fluxo de trabalho usando gatilhos.

  • Uma ação de criação (BuildBackend) – No gatilho, a ação cria a imagem do Docker usando o Dockerfile e envia a imagem para o Amazon ECR. A ação de criação também atualiza as variáveis $REPOSITORY_URI e $IMAGE_TAG no arquivo deployment.yaml com os valores corretos e, depois, cria um artefato de saída desse arquivo e de qualquer outro na pasta Kubernetes. Neste tutorial, o único arquivo na pasta Kubernetes é deployment.yaml, mas você pode incluir mais arquivos. O artefato é usado como entrada para a ação de implantação, que será a seguir.

    Para ter mais informações sobre a ação de criação, consulte Criação com fluxos de trabalho.

  • Uma ação de implantação (DeployToEKS) – Ao concluir a ação de criação, a ação de implantação procura o artefato de saída gerado pela ação de criação (Manifests), encontra o deployment.yaml dentro dele. Em seguida, a ação segue as instruções no arquivo deployment.yaml para executar três pods, cada um contendo um único “Hello, World!” Contêiner do Docker, dentro do cluster do Amazon EKS.

Como criar um fluxo de trabalho
  1. Acesse o console do CodeCatalyst.

  2. Navegue até o projeto (codecatalyst-eks-project).

  3. No painel de navegação, escolha CI/CD e Fluxos de trabalho.

  4. Selecione Criar fluxo de trabalho.

  5. Em Repositório de origem, selecione codecatalyst-eks-source-repository.

  6. Em Ramificação, selecione main.

  7. Escolha Criar.

  8. Exclua o código de amostra YAML.

  9. Adicione o código YAML a seguir para criar um arquivo de definição de fluxo de trabalho:

    nota

    Para ter mais informações sobre o arquivo de definição de fluxo de trabalho, consulte Definição do YAML do fluxo de trabalho.

    nota

    No código YAML a seguir, você pode omitir as seções Connections: se quiser. Se você omitir essas seções, deverá garantir que o perfil especificado no campo Perfil do IAM padrão em seu ambiente inclua as permissões e as políticas de confiança dos dois perfis descritas em Etapa 6: adicionar perfis da AWS ao CodeCatalyst. Para ter mais informações sobre como configurar um ambiente com um perfil do IAM padrão, consulte Criar um ambiente.

    Name: codecatalyst-eks-workflow SchemaVersion: 1.0 Triggers: - Type: PUSH Branches: - main Actions: BuildBackend: Identifier: aws/build@v1 Environment: Name: codecatalyst-eks-environment Connections: - Name: codecatalyst-account-connection Role: codecatalyst-eks-build-role Inputs: Sources: - WorkflowSource Variables: - Name: REPOSITORY_URI Value: 111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-eks-image-repo - Name: IMAGE_TAG Value: ${WorkflowSource.CommitId} Configuration: Steps: #pre_build: - Run: echo Logging in to Amazon ECR... - Run: aws --version - Run: aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-west-2.amazonaws.com #build: - Run: echo Build started on `date` - Run: echo Building the Docker image... - Run: docker build -t $REPOSITORY_URI:latest . - Run: docker tag $REPOSITORY_URI:latest $REPOSITORY_URI:$IMAGE_TAG #post_build: - Run: echo Build completed on `date` - Run: echo Pushing the Docker images... - Run: docker push $REPOSITORY_URI:latest - Run: docker push $REPOSITORY_URI:$IMAGE_TAG # Replace the variables in deployment.yaml - Run: find Kubernetes/ -type f | xargs sed -i "s|\$REPOSITORY_URI|$REPOSITORY_URI|g" - Run: find Kubernetes/ -type f | xargs sed -i "s|\$IMAGE_TAG|$IMAGE_TAG|g" - Run: cat Kubernetes/* # The output artifact will be a zip file that contains Kubernetes manifest files. Outputs: Artifacts: - Name: Manifests Files: - "Kubernetes/*" DeployToEKS: DependsOn: - BuildBackend Identifier: aws/kubernetes-deploy@v1 Environment: Name: codecatalyst-eks-environment Connections: - Name: codecatalyst-account-connection Role: codecatalyst-eks-deploy-role Inputs: Artifacts: - Manifests Configuration: Namespace: default Region: us-west-2 Cluster: codecatalyst-eks-cluster Manifests: Kubernetes/

    No código anterior, substitua:

    • As duas instâncias do codecatalyst-eks-environment pelo nome do ambiente em que você criou em Pré-requisitos.

    • As duas instâncias da codecatalyst-account-connection pelo nome de exibição da conexão da sua conta. O nome de exibição pode ser um número. Para ter mais informações, consulte Etapa 6: adicionar perfis da AWS ao CodeCatalyst.

    • codecatalyst-eks-build-role pelo nome do perfil de criação que você criou em Etapa 5: criar perfis da AWS.

    • 111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-eks-image-repo (na propriedade Value:) pelo URI do repositório do Amazon ECR em que você criou em Etapa 3: criar uma imagem de repositório do Amazon ECR.

    • 111122223333.dkr.ecr.us-west-2.amazonaws.com (no comando Run: aws ecr) pelo URI do repositório do Amazon ECR sem o sufixo da imagem (/codecatalyst-eks-image-repo).

    • codecatalyst-eks-deploy-role pelo nome do perfil de implantação na qual você criou em Etapa 5: criar perfis da AWS.

    • As duas instâncias de us-west-2 pelo código de região da AWS. Para ver uma lista de códigos de região, consulte Endpoints regionais na Referência geral da AWS.

    nota

    Se você decidiu não criar perfis de criação e implantação, substitua codecatalyst-eks-build-role e codecatalyst-eks-deploy-role pelo nome do perfil CodeCatalystWorkflowDevelopmentRole-spaceName. Para obter mais informações sobre essa função, consulte Etapa 5: criar perfis da AWS.

  10. (Opcional) Selecione Validar para garantir que o código YAML seja válido antes de confirmar.

  11. Escolha Commit (Confirmar).

  12. Na caixa de diálogo Confirmar fluxo de trabalho, insira o seguinte:

    1. Em Mensagem de confirmação, remova o texto e digite:

      Add first workflow
    2. Em Repositório, selecione codecatalyst-eks-source-repository.

    3. Em Nome da ramificação, selecione a principal.

    4. Escolha Commit (Confirmar).

    Agora você criou um fluxo de trabalho. A execução de um fluxo de trabalho é iniciada automaticamente devido ao gatilho definido na parte superior do fluxo de trabalho. Especificamente, quando você confirmou (e enviou) o arquivo workflow.yaml ao repositório de origem, o gatilho iniciou a execução do fluxo de trabalho.

Para visualizar o andamento da execução do fluxo de trabalho
  1. No painel de navegação do console do CodeCatalyst, selecione CI/CD e Fluxos de trabalho.

  2. Escolha o fluxo de trabalho que você acabou de criar, codecatalyst-eks-workflow.

  3. Selecione BuildBackend para ver o andamento da criação.

  4. Selecione DeployToEKS para ver o andamento da implantação.

    Para ter mais informações sobre como visualizar os detalhes da execução, consulte o Visualização do status e detalhes de execução do fluxo de trabalho.

Como verificar a implantação
  1. Abra o console do Amazon EC2 em https://console.aws.amazon.com/ec2/.

  2. À esquerda, na parte inferior, escolha Balanceadores de carga.

  3. Selecione o balanceador de carga que foi criado como parte da sua implantação do Kubernetes. Se você não tiver certeza de qual balanceador de carga escolher, procure as seguintes tags na guia Tags:

    • kubernetes.io/service-name

    • kubernetes.io/cluster/ekstutorialcluster

  4. Com o balanceador de carga correto selecionado, escolha a guia Descrição.

  5. Copie e cole o valor do Nome do DNS na barra de endereço do navegador.

    A página da Web “Hello, World!” aparece no navegador, indicando que você implantou a aplicação com êxito.

Etapa 9: realizar uma alteração nos arquivos de origem

Nesta seção, você faz uma alteração no arquivo index.html no repositório de origem. Essa alteração faz com que o fluxo de trabalho crie uma nova imagem do Docker, a marque com um ID de confirmação, a envie por push ao Amazon ECR e a implante no Amazon ECS.

Para alterar o index.html
  1. Acesse o Ambiente de Desenvolvimento.

  2. No prompt do terminal, mude para seu repositório de origem:

    cd /projects/codecatalyst-eks-source-repository
  3. Obtenha as alterações mais recentes do fluxo de trabalho:

    git pull
  4. Abra o codecatalyst-eks-source-repository/public-html/index.html.

  5. Na linha 14, altere o texto Hello, World! para Tutorial complete!.

  6. Adicione, confirme e envie:

    git add . git commit -m "update index.html title" git push

    A execução de um fluxo de trabalho é iniciada automaticamente.

  7. (Opcional) Insira:

    git show HEAD

    Anote o ID de confirmação da alteração index.html. Esse ID de confirmação será marcado na imagem do Docker que será implantada pela execução do fluxo de trabalho que você acabou de iniciar.

  8. Assista ao andamento da implantação:

    1. No console do CodeCatalyst, no painel de navegação, escolha CI/CD e Fluxos de trabalho.

    2. Escolha codecatalyst-eks-workflow para ver a última execução.

    3. Escolha BuildBackend e DeployToEKS para ver o andamento da execução do fluxo de trabalho.

  9. Verifique se a aplicação foi atualizada, da seguinte forma:

    1. Abra o console do Amazon EC2 em https://console.aws.amazon.com/ec2/.

    2. À esquerda, na parte inferior, escolha Balanceadores de carga.

    3. Selecione o balanceador de carga que foi criado como parte da sua implantação do Kubernetes.

    4. Copie e cole o valor do Nome do DNS na barra de endereço do navegador.

      A página da Web “Tutorial concluído!” aparece no navegador, indicando que você implantou uma nova revisão da aplicação com êxito.

  10. (Opcional) Na AWS, mude para o console do Amazon ECR e verifique se a nova imagem do Docker foi marcada com o ID de confirmação da etapa 7 deste procedimento.

Limpeza

Você deve limpar seu ambiente para não receber cobranças desnecessárias pelos recursos de armazenamento e computação usados neste tutorial.

Para limpar
  1. Exclua seu cluster:

    1. No terminal do Ambiente de Desenvolvimento, insira:

      eksctl delete cluster --region=us-west-2 --name=codecatalyst-eks-cluster

      Em que:

      • us-west-2 é substituído pela sua região.

      • codecatalyst-eks-cluster é substituído pelo nome do cluster que você criou.

      Depois de 5 a 10 minutos, o cluster e os recursos associados são excluídos, incluindo, mas não se limitando a, pilhas do AWS CloudFormation, grupos de nós (no Amazon EC2) e balanceadores de carga.

    Importante

    Se o comando eksctl delete cluster não funcionar, talvez seja necessário atualizar suas credenciais da AWS ou do kubectl. Se você não tiver certeza de quais credenciais atualizar, atualize as credenciais da AWS primeiro. Para atualizar suas credenciais da AWS, consulte Como faço para corrigir os erros “Não é possível localizar credenciais” e “ExpiredToken”?. Para atualizar suas credenciais do kubectl, consulte Como faço para corrigir os erros “Não foi possível conectar-se ao servidor”?.

  2. No console do AWS, limpe da seguinte forma:

    1. No Amazon ECR, exclua codecatalyst-eks-image-repo.

    2. No IAM Identity Center, exclua:

      1. codecatalyst-eks-user

      2. codecatalyst-eks-permission-set

    3. No IAM, exclua:

      • codecatalyst-eks-build-role

      • codecatalyst-eks-deploy-role

      • codecatalyst-eks-build-policy

      • codecatalyst-eks-deploy-policy

  3. No console do CodeCatalyst, limpe da seguinte forma:

    1. Exclua codecatalyst-eks-workflow.

    2. Exclua codecatalyst-eks-environment.

    3. Exclua codecatalyst-eks-source-repository.

    4. Exclua o Ambiente de Desenvolvimento.

    5. Exclua codecatalyst-eks-project.

Neste tutorial, você aprendeu como implantar uma aplicação em um serviço do Amazon EKS usando um fluxo de trabalho do CodeCatalyst e uma ação Implantar no cluster do Kubernetes.