A Amazon não CodeCatalyst está mais aberta a novos clientes. Os clientes atuais podem continuar usando o serviço normalmente. Para obter mais informações, consulte [Como migrar do CodeCatalyst](migration.md).

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Tutorial: Implantar uma aplicação no Amazon EKS
<a name="deploy-tut-eks"></a>

Neste tutorial, você aprende a implantar um aplicativo em contêineres no Amazon Elastic Kubernetes Service usando CodeCatalyst um fluxo de trabalho da Amazon, o Amazon EKS e alguns outros serviços. AWS A aplicação implantada é um site simples “Hello, World\$1” 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 obter mais informações, consulte [Criar um projeto com um esquema](projects-create.md#projects-create-console-template).

**Topics**
+ [Pré-requisitos](#deploy-tut-eks-prereqs)
+ [Etapa 1: configurar sua máquina de desenvolvimento](#deploy-tut-eks-dev-env-create)
+ [Etapa 2: criar um cluster do Amazon EKS](#deploy-tut-eks-cluster)
+ [Etapa 3: criar uma imagem de repositório do Amazon ECR](#deploy-tut-eks-ecr)
+ [Etapa 4: adicionar arquivos de origem](#deploy-tut-eks-source-files)
+ [Etapa 5: criar AWS funções](#deploy-tut-eks-roles)
+ [Etapa 6: Adicionar AWS funções a CodeCatalyst](#deploy-tut-eks-import-roles)
+ [Etapa 7: atualizar o ConfigMap](#deploy-tut-eks-configmap)
+ [Etapa 8: criar e executar um fluxo de trabalho](#deploy-tut-eks-workflow)
+ [Etapa 9: realizar uma alteração nos arquivos de origem](#deploy-tut-eks-change)
+ [Limpeza](#deploy-tut-eks-cleanup)

## Pré-requisitos
<a name="deploy-tut-eks-prereqs"></a>

Antes de começar este tutorial:
+ Você precisa de um CodeCatalyst **espaço** na Amazon com uma AWS conta conectada. Para obter mais informações, consulte [Criar um espaço](spaces-create.md).
+ 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 obter mais informações, consulte [Criando um projeto vazio na Amazon CodeCatalyst](projects-create.md#projects-create-empty).
+ Em seu projeto, você precisa de um **repositório CodeCatalyst de origem** vazio chamado:

  ```
  codecatalyst-eks-source-repository
  ```

  Para obter mais informações, consulte [Armazene e colabore no código com repositórios de origem no CodeCatalystArmazenamento e colaboração no código com repositórios de origem](source.md).
+ Em seu projeto, você precisa de um ambiente de CodeCatalyst CI/CD (não um **ambiente** de desenvolvimento) chamado:

  ```
  codecatalyst-eks-environment
  ```

  Configure esse ambiente da seguinte forma:
  + Escolha qualquer tipo, como **Não produção**.
  + Conecte sua AWS conta a ela. 
  + Para o **Perfil do IAM padrão**, escolha qualquer perfil. Você especificará um perfil diferente posteriormente.

  Para obter mais informações, consulte [Implantação em e Contas da AWS VPCs](deploy-environments.md).

## Etapa 1: configurar sua máquina de desenvolvimento
<a name="deploy-tut-eks-dev-env-create"></a>

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`
+ o 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 CodeCatalyst desenvolvimento baseado em nuvem. A vantagem de um ambiente de CodeCatalyst desenvolvimento é que ele é fácil de ativar e desativar e está integrado a outros CodeCatalyst serviços, permitindo que você conclua este tutorial em menos etapas.

Este tutorial pressupõe que você usará um ambiente de CodeCatalyst desenvolvimento.

As instruções a seguir descrevem uma maneira rápida de iniciar um ambiente de CodeCatalyst desenvolvimento e configurá-lo com as ferramentas necessárias, mas se você quiser instruções detalhadas, consulte:
+ [Criar um Ambiente de Desenvolvimento](devenvironment-create.md) neste guia.
+ [Instalação do kubectl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) no **Guia do usuário do Amazon EKS**.
+ [Instalação ou atualização do eksctl](https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html) no **Guia do usuário do Amazon EKS**.
+ [Instalação ou atualização da versão mais recente da AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) no *Guia do usuário do AWS Command Line Interface *.

**Como iniciar um novo ambiente de desenvolvimento**

1. Abra o CodeCatalyst console em [https://codecatalyst.aws/](https://codecatalyst.aws/).

1. Navegue até o projeto, `codecatalyst-eks-project`.

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

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

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

1. 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
   ```

1. Insira:

   ```
   chmod +x ./kubectl
   ```

1. Insira:

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

1. Insira:

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

1. Insira:

   ```
   kubectl version --short --client
   ```

1. 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
   ```

1. Insira:

   ```
   sudo cp /tmp/eksctl /usr/bin
   ```

1. Insira:

   ```
   eksctl version
   ```

1. Confira se uma versão é exibida.

   Você agora tem o `eksctl` instalado.

**Para verificar se o AWS CLI está instalado**

1. No terminal do Ambiente de Desenvolvimento, insira:

   ```
   aws --version
   ```

1. Verifique se uma versão aparece para verificar se o AWS CLI está instalado.

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

**Para configurar o AWS CLI**

Você deve configurar o AWS CLI com chaves de acesso e um token de sessão para dar acesso aos AWS serviços. 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](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) 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 Console de gerenciamento da AWS e abra o Centro de Identidade do AWS IAM console em [https://console.aws.amazon.com/singlesignon/](https://console.aws.amazon.com/singlesignon/).

      (Talvez seja necessário selecionar **Ativar** se você nunca tiver feito login no IAM Identity Center antes.)
**nota**  
Certifique-se de fazer login usando o Conta da AWS que está conectado ao seu CodeCatalyst espaço. Você pode verificar qual conta está conectada navegando até seu espaço e escolhendo a guia **Contas da AWS**. Para obter mais informações, consulte [Criar um espaço](spaces-create.md).

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

   1. Em **Nome de usuário**, digite:

      ```
      codecatalyst-eks-user
      ```

   1. Em **Senha**, selecione **Gerar uma senha de uso único que você possa compartilhar com esse usuário**.

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

   1. Em **Nome**, insira:

      ```
      codecatalyst-eks-user
      ```

   1. Em **Sobrenome**, insira:

      ```
      codecatalyst-eks-user
      ```

   1. Em **Nome de exibição**, mantenha:

      ```
      codecatalyst-eks-user codecatalyst-eks-user
      ```

   1. Escolha **Próximo**.

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

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

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

   1. Escolha **Fechar**.

1. 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**.

   1. Escolha Conjunto de **permissões predefinido** e, em seguida, selecione **AdministratorAccess**. Esta política fornece permissões totais para todos os Serviços da AWS. 

   1. Escolha **Próximo**.

   1. Em **Nome do conjunto de permissões**, remova `AdministratorAccess` e digite:

      ```
      codecatalyst-eks-permission-set
      ```

   1. Escolha **Próximo**.

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

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

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

   1. Escolha **Atribuir usuários ou grupos**.

   1. Escolha a guia **Users**.

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

   1. Escolha **Próximo**.

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

   1. Escolha **Próximo**.

   1. Revise suas informações e selecione **Enviar**.

      Agora você designou `codecatalyst-eks-user` e `codecatalyst-eks-permission-set` para o seu Conta da AWS, unindo-os.

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

   1. Verifique se você tem a URL do portal de AWS acesso, o nome de usuário e a senha de uso único para`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.

   1. Sair de AWS.

   1. Cole o URL do portal de AWS acesso na barra de endereço do seu navegador.

   1. Faça login com:
      + **Nome de usuário**:

        ```
        codecatalyst-eks-user
        ```
      + **Senha**:

        *one-time-password*

   1. Em **Definir nova senha**, insira uma nova senha e selecione **Definir nova senha**.

      Uma caixa de **Conta da AWS** aparece na tela.

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

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

   1. 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 *session-token* está uma longa sequência aleatória.

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

   1. Retorne ao seu ambiente de CodeCatalyst desenvolvimento.

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

      Agora você configurou o AWS CLI com chaves de acesso e um token de sessão. Agora você pode usar 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 sua AWS CLI sessão 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
<a name="deploy-tut-eks-cluster"></a>

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:
+ [Conceitos básicos do eksctl](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html) no ** Guia do usuário do Amazon EKS**

  or
+ [Introdução ao console e à AWS CLI](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-console.html) no **Guia do usuário do Amazon EKS** (este tópico fornece instruções do `kubectl` para criar o cluster) 

**nota**  
Os [clusters privados](https://docs.aws.amazon.com/eks/latest/userguide/private-clusters.html) não são compatíveis com a CodeCatalyst integração 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`.
+ Instalei AWS CLI e configurei 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](#deploy-tut-eks-dev-env-create).

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

1. 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 seu 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.

1. 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
<a name="deploy-tut-eks-ecr"></a>

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.

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

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

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

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

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

   ```
   aws ecr describe-repositories \
         --repository-names codecatalyst-eks-image-repo
   ```

1. 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
<a name="deploy-tut-eks-source-files"></a>

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\$1” 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
```

**Topics**
+ [index.html](#deploy-tut-eks-source-files-index)
+ [Dockerfile](#deploy-tut-eks-source-files-dockerfile)
+ [deployment.yaml](#deploy-tut-eks-source-files-deployment-yml)

### index.html
<a name="deploy-tut-eks-source-files-index"></a>

O arquivo `index.html` exibe uma mensagem “Hello, World\$1” no navegador. 

**Como adicionar o arquivo index.html**

1. Acesse o Ambiente de Desenvolvimento.

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

1. 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>
   ```

1. No prompt do terminal, insira:

   ```
   cd /projects/codecatalyst-eks-source-repository
   ```

1. 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
<a name="deploy-tut-eks-source-files-dockerfile"></a>

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](https://docs.docker.com/engine/reference/builder/).

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

1. Adicione, confirme e envie:

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

   O Dockerfile é adicionado ao repositório.

### deployment.yaml
<a name="deploy-tut-eks-source-files-deployment-yml"></a>

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\$1” aplicativo. 
+ A “implantação” implanta três pods, e cada pod terá um contêiner do Docker com a aplicação “Hello, World\$1” aplicativo. 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`.

1. 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
   ```

1. 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 AWS funções
<a name="deploy-tut-eks-roles"></a>

Nesta seção, você cria funções AWS do IAM que seu CodeCatalyst fluxo de trabalho precisará para funcionar. Esses perfis são:
+ **Função de criação** — concede permissão à ação de CodeCatalyst criação (no fluxo de trabalho) para acessar sua AWS conta e gravar no Amazon ECR e no Amazon EC2.
+ **Função de implantação** — concede à ação de **cluster CodeCatalyst Deploy to Kubernetes** (no fluxo de trabalho) permissão para acessar sua conta AWS e o Amazon EKS.

Para ter informações sobre perfis do IAM, consulte [Perfis do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) 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 obter mais informações, consulte [Criar o perfil **CodeCatalystWorkflowDevelopmentRole-*spaceName*** para a conta e o espaço](ipa-iam-roles.md#ipa-iam-roles-service-create). 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.

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

**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:

------
#### [ JSON ]

****  

  ```
  {
      "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:

------
#### [ JSON ]

****  

  ```
  {
      "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 compilação ao AWS**

1. No terminal do Ambiente de Desenvolvimento, insira:

   ```
   cd /projects
   ```

1. Insira:

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

1. Pressione **Enter**.

1. 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 ao AWS**

1. Insira:

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

1. Pressione **Enter**.

1. 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
   ```

1. Pressione **Enter**.

1. 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 construção que você observou anteriormente.

1. Pressione **Enter**.

1. No prompt do terminal, insira:

   ```
   aws iam get-role \
         --role-name codecatalyst-eks-build-role
   ```

1. Pressione **Enter**.

1. 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
   ```

1. Pressione **Enter**.

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

1. Pressione **Enter**.

1. Insira:

   ```
   aws iam get-role \
         --role-name codecatalyst-eks-deploy-role
   ```

1. Pressione **Enter**.

1. 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 funções de criação e implantação e anotou suas ARNs.

## Etapa 6: Adicionar AWS funções a CodeCatalyst
<a name="deploy-tut-eks-import-roles"></a>

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

**Para adicionar funções de criação e implantação ao seu Conta da AWS**

1. No CodeCatalyst console, navegue até seu espaço.

1. Na parte superior, selecione **Configurações**.

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

1. Na coluna **Nome de CodeCatalyst exibição da Amazon**, copie o nome de exibição de Conta da AWS onde você criou suas funções de criação e implantação. (Pode ser um número.) Esse valor será necessário posteriormente, ao criar seu fluxo de trabalho.

1. Escolha o nome de exibição.

1. Escolha **Gerenciar funções no console de AWS gerenciamento**.

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

1. 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`.

1. 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 com a AWS conta que você usou ao criar seu CodeCatalyst espaço. AWS 

1. Volte ao CodeCatalyst console e atualize a página.

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

   Essas funções agora estão disponíveis para uso em CodeCatalyst fluxos de trabalho.

## Etapa 7: atualizar o ConfigMap
<a name="deploy-tut-eks-configmap"></a>

Você deve adicionar o perfil de implantação que você criou em [Etapa 5: criar AWS funções](#deploy-tut-eks-roles) 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 Kubernetes ConfigMap 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 Amazon EKS.
  +  *arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role*é substituído pelo ARN da função de implantação que você criou em. [Etapa 5: criar AWS funções](#deploy-tut-eks-roles)
  +  *codecatalyst-eks-deploy-role*(ao lado de`--username`) é substituído pelo nome da função de implantação que você criou em[Etapa 5: criar AWS funções](#deploy-tut-eks-roles).
**nota**  
Se você decidiu não criar uma função de implantação, *codecatalyst-eks-deploy-role* substitua pelo nome da `CodeCatalystWorkflowDevelopmentRole-spaceName` função. Para obter mais informações sobre esse perfil, consulte [Etapa 5: criar AWS funções](#deploy-tut-eks-roles).
  +  *us-west-2*é substituído pela sua região.

  Para saber detalhes sobre esse comando, consulte [Gerenciar usuários e perfis do IAM](https://eksctl.io/usage/iam-identity-mappings/).

  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
  ```

**Para configurar o arquivo Kubernetes ConfigMap usando kubectl**

1. No terminal do Ambiente de Desenvolvimento, insira:

   ```
   kubectl edit configmap -n kube-system aws-auth
   ```

   O ConfigMap arquivo aparece na tela.

1. 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 da função de implantação que você criou em. [Etapa 5: criar AWS funções](#deploy-tut-eks-roles) 
   +  *codecatalyst-eks-deploy-role*(ao lado de`username:`) é substituído pelo nome da função de implantação que você criou em[Etapa 5: criar AWS funções](#deploy-tut-eks-roles).
**nota**  
Se você decidiu não criar uma função de implantação, *codecatalyst-eks-deploy-role* substitua pelo nome da `CodeCatalystWorkflowDevelopmentRole-spaceName` função. Para obter mais informações sobre esse perfil, consulte [Etapa 5: criar AWS funções](#deploy-tut-eks-roles).

   Para saber detalhes, consulte [Habilitar o acesso da entidade principal do IAM ao seu cluster](https://docs.aws.amazon.com/eks/latest/userguide/add-user-role.html) 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
<a name="deploy-tut-eks-workflow"></a>

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](workflows-add-trigger.md).
+ 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](build-workflow-actions.md).
+ 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\$1” Contêiner do Docker, dentro do cluster do Amazon EKS. 

**Para criar um fluxo de trabalho**

1. Vá para o CodeCatalyst console.

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

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

1. Selecione **Criar fluxo de trabalho**.

1. Em **Repositório de origem**, selecione `codecatalyst-eks-source-repository`.

1. Em **Ramificação**, selecione `main`.

1. Escolha **Criar**.

1. Exclua o código de amostra YAML.

1. 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](workflow-reference.md).
**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 AWS funções a CodeCatalyst](#deploy-tut-eks-import-roles). Para ter mais informações sobre como configurar um ambiente com um perfil do IAM padrão, consulte [Criar um ambiente](deploy-environments-creating-environment.md).

   ```
   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:
   + Ambas as instâncias de *codecatalyst-eks-environment* com o nome do ambiente em que você criou[Pré-requisitos](#deploy-tut-eks-prereqs).
   + Ambas as instâncias *codecatalyst-account-connection* com o nome de exibição da conexão da sua conta. O nome de exibição pode ser um número. Para obter mais informações, consulte [Etapa 6: Adicionar AWS funções a CodeCatalyst](#deploy-tut-eks-import-roles).
   + *codecatalyst-eks-build-role*com o nome da função de construção em que você criou[Etapa 5: criar AWS funções](#deploy-tut-eks-roles).
   + *111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-eks-image-repo*(na `Value:` propriedade) com o URI do repositório Amazon ECR em que você criou. [Etapa 3: criar uma imagem de repositório do Amazon ECR](#deploy-tut-eks-ecr)
   + *111122223333.dkr.ecr.us-west-2.amazonaws.com*(no `Run: aws ecr` comando) com o URI do repositório Amazon ECR sem o sufixo da imagem (). `/codecatalyst-eks-image-repo`
   + *codecatalyst-eks-deploy-role*com o nome da função de implantação na qual você criou[Etapa 5: criar AWS funções](#deploy-tut-eks-roles).
   + Ambas as instâncias *us-west-2* com seu código de AWS região. Para ver uma lista de códigos de região, consulte [Endpoints regionais](https://docs.aws.amazon.com/general/latest/gr/rande.html) na *Referência geral da AWS*.
**nota**  
Se você decidiu não criar e implantar funções, *codecatalyst-eks-deploy-role* substitua *codecatalyst-eks-build-role* e pelo nome da `CodeCatalystWorkflowDevelopmentRole-spaceName` função. Para obter mais informações sobre esse perfil, consulte [Etapa 5: criar AWS funções](#deploy-tut-eks-roles).

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

1. Selecione **Confirmar**.

1. 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
      ```

   1. Em **Repositório**, selecione `codecatalyst-eks-source-repository`.

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

   1. Selecione **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 CodeCatalyst console, escolha **CI/CD** e, em seguida, escolha Fluxos de trabalho.**

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

1. Escolha **BuildBackend**ver o progresso da construção.

1. Escolha **DeployToEKS** para ver o progresso 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](workflows-view-run.md).

**Como verificar a implantação**

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

1. À esquerda, na parte inferior, escolha **Balanceadores de carga**.

1. 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`

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

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

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

## Etapa 9: realizar uma alteração nos arquivos de origem
<a name="deploy-tut-eks-change"></a>

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.

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

   ```
   cd /projects/codecatalyst-eks-source-repository
   ```

1.  Obtenha as alterações mais recentes do fluxo de trabalho:

   ```
   git pull
   ```

1. Abra o `codecatalyst-eks-source-repository/public-html/index.html`.

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

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

1. (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.

1. Assista ao andamento da implantação:

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

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

   1. Escolha **BuildBackend**e **DeployToEKS** para ver o progresso da execução do fluxo de trabalho.

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

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

   1. À esquerda, na parte inferior, escolha **Balanceadores de carga**.

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

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

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

1. (Opcional) Em AWS, alterne 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
<a name="deploy-tut-eks-cleanup"></a>

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.

     Após 5 a 10 minutos, o cluster e os recursos associados são excluídos, incluindo, mas não se limitando a, CloudFormation pilhas, grupos de nós (no Amazon EC2) e balanceadores de carga.
**Importante**  
Se o `eksctl delete cluster` comando não funcionar, talvez seja necessário atualizar suas AWS credenciais ou suas `kubectl` credenciais. Se você não tiver certeza de quais credenciais atualizar, atualize as AWS credenciais primeiro. Para atualizar suas credenciais da AWS , consulte [Como faço para corrigir os erros “Não é possível localizar credenciais” e ExpiredToken "”?](troubleshooting-workflows.md#troubleshooting-workflows-auth-errors-eks). Para atualizar suas credenciais do `kubectl`, consulte [Como faço para corrigir os erros “Não foi possível conectar-se ao servidor”?](troubleshooting-workflows.md#troubleshooting-workflows-unable-connect-eks).

1. No AWS console, limpe da seguinte forma:

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

   1. No IAM Identity Center, exclua:

      1. `codecatalyst-eks-user`

      1. `codecatalyst-eks-permission-set`

   1. No IAM, exclua:
      + `codecatalyst-eks-build-role`
      + `codecatalyst-eks-deploy-role`
      + `codecatalyst-eks-build-policy`
      + `codecatalyst-eks-deploy-policy`

1. No CodeCatalyst console, limpe da seguinte forma:

   1. Exclua `codecatalyst-eks-workflow`.

   1. Exclua `codecatalyst-eks-environment`.

   1. Exclua `codecatalyst-eks-source-repository`.

   1. Exclua o Ambiente de Desenvolvimento.

   1. Exclua `codecatalyst-eks-project`.

Neste tutorial, você aprendeu a implantar um aplicativo em um serviço Amazon EKS usando um CodeCatalyst fluxo de trabalho e uma ação de cluster **Deploy to Kubernetes.**