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

# Implantar no Amazon EKS com um fluxo de trabalho
<a name="deploy-action-eks"></a>

**dica**  
Para ver um tutorial que mostra como usar a ação **Implantar no cluster do Kubernetes**, consulte [Tutorial: Implantar uma aplicação no Amazon EKS](deploy-tut-eks.md).

Esta seção descreve como implantar um aplicativo em contêiner em um cluster Kubernetes usando um fluxo de trabalho. CodeCatalyst Para fazer isso, você deve adicionar a ação **Implantar no cluster do Kubernetes** ao seu fluxo de trabalho. Essa ação implanta a aplicação em um cluster do Kubernetes que você configurou no Amazon Elastic Kubernetes Service (EKS) usando um ou mais arquivos de manifesto do Kubernetes. Para um exemplo de manifesto, consulte [deployment.yaml](deploy-tut-eks.md#deploy-tut-eks-source-files-deployment-yml) em [Tutorial: Implantar uma aplicação no Amazon EKS](deploy-tut-eks.md).

Para ter mais informações sobre o Kubernetes, consulte a [documentação do Kubernetes](https://kubernetes.io/docs/home/).

Para ter mais informações sobre o Amazon EKS, consulte [O que é o Amazon EKS?](https://docs.aws.amazon.com/eks/latest/userguide/what-is-eks.html) no *Guia do usuário do Amazon EKS*.

**Topics**
+ [Como funciona a ação “Implantar no cluster do Kubernetes”](#deploy-action-eks-howitworks)
+ [Imagem de runtime usada pela ação “Implantar no Amazon EKS”](#deploy-action-eks-runtime)
+ [Tutorial: Implantar uma aplicação no Amazon EKS](deploy-tut-eks.md)
+ [Adição da ação “Implantar no cluster do Kubernetes”](deploy-action-eks-adding.md)
+ [Variáveis de “Implantar no cluster do Kubernetes”](deploy-action-eks-variables.md)
+ [YAML da ação “Implantar no cluster do Kubernetes”](deploy-action-ref-eks.md)

## Como funciona a ação “Implantar no cluster do Kubernetes”
<a name="deploy-action-eks-howitworks"></a>

A ação **Implantar no cluster do Kubernetes** funciona da seguinte forma:

1. Em tempo de execução, a ação instala o `kubectl` utilitário Kubernetes na máquina CodeCatalyst computacional em que a ação está sendo executada. A ação configura `kubectl` para apontar para o cluster do Amazon EKS que você forneceu ao configurar a ação. O utilitário `kubectl` é necessário para executar o comando `kubectl apply` a seguir.

1. A ação executa o `kubectl apply -f my-manifest.yaml` comando, que executa as instruções *my-manifest.yaml* para implantar seu aplicativo como um conjunto de contêineres e pods no cluster configurado. Para ter mais informações sobre esse comando, consulte o tópico [kubectl apply](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#apply) na *documentação de referência do Kubernetes*.

## Imagem de runtime usada pela ação “Implantar no Amazon EKS”
<a name="deploy-action-eks-runtime"></a>

A ação **Implantar no Amazon EKS** é executada em uma [imagem de novembro de 2022](build-images.md#build.previous-image). Para obter mais informações, consulte [Imagens ativas](build-images.md#build-curated-images).

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

# Adição da ação “Implantar no cluster do Kubernetes”
<a name="deploy-action-eks-adding"></a>

Use as instruções a seguir para adicionar a ação **Implantar no cluster do Kubernetes** ao seu fluxo de trabalho. 

**Antes de começar**

Antes de adicionar a ação **Implantar no cluster do Kubernetes** ao seu fluxo de trabalho, você deve preparar o seguinte:

**dica**  
Para configurar esses pré-requisitos rapidamente, siga as instruções em [Tutorial: Implantar uma aplicação no Amazon EKS](deploy-tut-eks.md).
+ Um cluster do Kubernetes no Amazon EKS. Para ter informações sobre clusters, consulte o [Clusters do Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/clusters.html) no **Guia do usuário do Amazon EKS**.
+ Pelo menos um Dockerfile que descreva como montar a aplicação em uma imagem do Docker. Para ter mais informações sobre Dockerfiles, consulte a [Referência de Dockerfile](https://docs.docker.com/engine/reference/builder/).
+ Pelo menos um arquivo de manifesto do Kubernetes, chamado de *arquivo de configuração* ou *configuração* na documentação do Kubernetes. Para ter mais informações, consulte [Gerenciamento de recursos](https://kubernetes.io/docs/concepts/cluster-administration/manage-deployment/) na documentação do Kubernetes.
+ Um perfil do IAM que dá à ação **Implantar no cluster do Kubernetes** a capacidade de acessar e interagir com seu cluster do Amazon EKS. Para obter mais informações, consulte o tópico [Role](deploy-action-ref-eks.md#deploy.action.eks.environment.connections.role) no [YAML da ação “Implantar no cluster do Kubernetes”](deploy-action-ref-eks.md).

  Depois de criar esse perfil, você deve adicioná-lo a:
  + Seu arquivo Kubernetes ConfigMap . Para saber como adicionar uma função a um ConfigMap arquivo, consulte [Habilitar o acesso 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**.
  + CodeCatalyst. Para saber como adicionar uma função do IAM ao CodeCatalyst, consulte[Adicionar perfis do IAM às conexões da conta](ipa-connect-account-addroles.md).
+ Um CodeCatalyst espaço, projeto e ambiente. O espaço e o ambiente devem estar conectados à AWS conta na qual você implantará seu aplicativo. Para obter mais informações, consulte [Criar um espaço](spaces-create.md), [Criando um projeto vazio na Amazon CodeCatalyst](projects-create.md#projects-create-empty) e [Implantação em e Contas da AWS VPCs](deploy-environments.md).
+ Um repositório de origem suportado pelo CodeCatalyst. O repositório armazena os arquivos de origem da aplicação, Dockerfiles e manifestos do Kubernetes. 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).

------
#### [ Visual ]

**Para adicionar a ação “Implantar no cluster do Kubernetes” usando o editor visual**

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

1. Selecione o projeto.

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

1. Selecione o nome do fluxo de trabalho. É possível filtrar pelo nome do repositório ou da ramificação de origem em que o fluxo de trabalho está definido, ou filtrar pelo nome ou o status do fluxo de trabalho.

1. Escolha **Editar**.

1. Selecione **Visual**.

1. No canto superior esquerdo, selecione **\$1 Ações** para abrir o catálogo de ações.

1. **Na lista suspensa, escolha Amazon. CodeCatalyst**

1. Procure a ação **Implantar no cluster do Kubernetes** e faça o seguinte:
   + Selecione o sinal de adição (**\$1**) para adicionar a ação ao diagrama do fluxo de trabalho e abrir seu painel de configuração.

     Ou
   + Selecione **Implantar no cluster do Kubernetes**. A caixa de diálogo de detalhes da ação é exibida. Nessa caixa de diálogo:
     + (Opcional) Selecione **Download** para [visualizar o código-fonte da ação](workflows-view-source.md#workflows-view-source.title).
     + Selecione **Adicionar ao fluxo de trabalho** para adicionar a ação ao diagrama do fluxo de trabalho e abrir seu painel de configuração.

1. Nas guias **Entradas** e **Configuração**, preencha os campos de acordo com suas necessidades. Para ver uma descrição de cada campo, consulte [YAML da ação “Implantar no cluster do Kubernetes”](deploy-action-ref-eks.md). Essa referência fornece informações detalhadas sobre cada campo (e o valor da propriedade YAML correspondente) conforme elas aparecem nos editores YAML e visual.

1. (Opcional) Selecione **Validar** para validar o código YAML do fluxo de trabalho antes de confirmar.

1. Selecione **Confirmar**, insira uma mensagem de confirmação e escolha **Confirmar** novamente.

------
#### [ YAML ]

**Para adicionar a ação “Implantar no cluster do Kubernetes” usando o editor YAML**

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

1. Selecione o projeto.

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

1. Selecione o nome do fluxo de trabalho. É possível filtrar pelo nome do repositório ou da ramificação de origem em que o fluxo de trabalho está definido, ou filtrar pelo nome ou o status do fluxo de trabalho.

1. Escolha **Editar**.

1. Selecione **YAML**.

1. No canto superior esquerdo, selecione **\$1 Ações** para abrir o catálogo de ações.

1. **Na lista suspensa, escolha Amazon. CodeCatalyst**

1. Procure a ação **Implantar no cluster do Kubernetes** e faça o seguinte:
   + Selecione o sinal de adição (**\$1**) para adicionar a ação ao diagrama do fluxo de trabalho e abrir seu painel de configuração.

     Ou
   + Selecione **Implantar no cluster do Kubernetes**. A caixa de diálogo de detalhes da ação é exibida. Nessa caixa de diálogo:
     + (Opcional) Selecione **Download** para [visualizar o código-fonte da ação](workflows-view-source.md#workflows-view-source.title).
     + Selecione **Adicionar ao fluxo de trabalho** para adicionar a ação ao diagrama do fluxo de trabalho e abrir seu painel de configuração.

1. Modifique as propriedades no código YAML de acordo com as suas necessidades. Uma explicação de cada propriedade disponível é fornecida em [YAML da ação “Implantar no cluster do Kubernetes”](deploy-action-ref-eks.md).

1. (Opcional) Selecione **Validar** para validar o código YAML do fluxo de trabalho antes de confirmar.

1. Selecione **Confirmar**, insira uma mensagem de confirmação e escolha **Confirmar** novamente.

------

# Variáveis de “Implantar no cluster do Kubernetes”
<a name="deploy-action-eks-variables"></a>

A ação **Implantar no cluster do Kubernetes** produz e define as seguintes variáveis em runtime. Elas são conhecidas como *variáveis predefinidas*.

Para ter informações sobre como referenciar essas variáveis em um fluxo de trabalho, consulte [Usar variáveis predefinidas](workflows-using-predefined-variables.md).


| Chave | Valor | 
| --- | --- | 
|  cluster  |  O nome do recurso da Amazon.com (ARN) do cluster do Amazon EKS no qual foi implantado durante a execução do fluxo de trabalho. Exemplo: `arn:aws:eks:us-west-2:111122223333:cluster/codecatalyst-eks-cluster`  | 
|  deployment-platform  |  O nome da plataforma de implantação. Codificado para `AWS:EKS`.  | 
|  metadata  |  Reservado. Metadados com formatação JSON relacionados ao cluster implantado durante a execução do fluxo de trabalho.  | 
|  namespace  |  O namespace do Kubernetes no qual o cluster foi implantado. Exemplo: `default`  | 
|  recursos  |  Reservado. Metadados com formatação JSON relacionados aos recursos implantados durante a execução do fluxo de trabalho.  | 
|  servidor  |  O nome do endpoint do servidor de API que você pode usar para se comunicar com seu cluster usando ferramentas de gerenciamento, como `kubectl`. Para ter mais informações sobre o endpoint de serviço da API, consulte o [Controle de acesso ao endpoint do cluster do Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/cluster-endpoint.html) no **Guia do usuário do Amazon EKS**. Exemplo: `https://random-string.gr7.us-west-2.eks.amazonaws.com`  | 

# YAML da ação “Implantar no cluster do Kubernetes”
<a name="deploy-action-ref-eks"></a>

Confira a seguir a definição de YAML da ação **Implantar no cluster do Kubernetes**. Para saber como usar essa ação, consulte [Implantar no Amazon EKS com um fluxo de trabalho](deploy-action-eks.md).

Essa definição de ação existe como uma seção dentro de um arquivo de definição de fluxo de trabalho mais amplo. Para obter mais informações sobre esse arquivo, consulte [Definição do YAML do fluxo de trabalho](workflow-reference.md).

**nota**  
A maioria das propriedades YAML a seguir tem elementos de interface de usuário correspondentes no editor visual. Para pesquisar um elemento de interface, use **Ctrl\$1F**. O elemento será listado com a propriedade YAML associada.

```
# The workflow definition starts here.
# See Propriedades de nível superior for details.
        
Name: MyWorkflow
SchemaVersion: 1.0 
Actions:

# The action definition starts here.   
  DeployToKubernetesCluster\$1nn: 
    Identifier: aws/kubernetes-deploy@v1
    DependsOn:
      - build-action
    Compute:  
        - Type: EC2 | Lambda
        - Fleet: fleet-name
    Timeout: timeout-minutes
    Environment:
      Name: environment-name
      Connections:
        - Name: account-connection-name
          Role: DeployToEKS
    Inputs:
      # Specify a source or an artifact, but not both.
      Sources:
        - source-name-1
      Artifacts:
        - manifest-artifact
    Configuration:
      Namespace: namespace
      Region: us-east-1 
      Cluster: eks-cluster
      Manifests: manifest-path
```

## DeployToKubernetesCluster
<a name="deploy.action.eks.name"></a>

(Obrigatório)

Especifique o nome da ação. Todos os nomes de ação devem ser exclusivos no fluxo de trabalho. Os nomes de ação são limitados a caracteres alfanuméricos (a-z, A-Z, 0-9), hifens (-) e sublinhados (\$1). Não são permitidos espaços. Não é possível usar aspas para habilitar caracteres especiais e espaços nos nomes de ação.

Padrão: `DeployToKubernetesCluster_nn`.

Interface de usuário correspondente: guia Configuração/**Nome de exibição da ação**

## Identifier
<a name="deploy.action.eks.identifier"></a>

(*DeployToKubernetesCluster*/**Identifier**)

(Obrigatório)

Identifica a ação. Não altere essa propriedade, a menos que você queira alterar a versão. Para obter mais informações, consulte [Especificação da versão da ação a ser usada](workflows-action-versions.md).

Padrão: `aws/kubernetes-deploy@v1`.

Interface de usuário correspondente: Diagrama de fluxo de trabalho/DeployToKubernetesCluster\$1nn/rótulo **aws/kubernetes-deploy@v1**

## DependsOn
<a name="deploy.action.eks.dependson"></a>

(*DeployToKubernetesCluster*/**DependsOn**)

(Optional)

Especifique uma ação, um grupo de ação ou um portão que deve ser executado com êxito para que essa ação seja executada.

Para ter mais informações sobre a funcionalidade “Depende de”, consulte [Sequenciar ações](workflows-depends-on.md).

Interface de usuário correspondente: guia Entradas/**Depende de - opcional**

## Compute
<a name="deploy.action.eks.computename"></a>

(*DeployToKubernetesCluster*/**Compute**)

(Optional)

O mecanismo de computação usado para executar as ações de fluxo de trabalho. É possível especificar a computação em nível de fluxo de trabalho ou em nível de ação, mas não em ambos. Quando especificada em nível de fluxo de trabalho, a configuração de computação se aplica a todas as ações definidas no fluxo de trabalho. Em nível de fluxo de trabalho, também é possível realizar várias ações na mesma instância. Para obter mais informações, consulte [Compartilhamento de computação entre ações](compute-sharing.md).

Interface de usuário correspondente: *nenhuma*

## Type
<a name="deploy.action.eks.computetype"></a>

(*DeployToKubernetesCluster*/Compute/**Type**)

(Obrigatório se [Compute](#deploy.action.eks.computename) for incluído)

O tipo do mecanismo de computação. É possível usar um dos seguintes valores:
+ **EC2** (editor visual) ou `EC2` (editor YAML)

  Otimizado para flexibilidade durante as execuções de ação.
+ **Lambda** (editor visual) ou `Lambda` (editor YAML)

  Velocidades otimizadas de inicialização da ação.

Para obter informações sobre tipos de dados, consulte [Tipos de computação](workflows-working-compute.md#compute.types).

**UI correspondente: Configuração tab/Advanced - opcional/Tipo de computação**

## Fleet
<a name="deploy.action.eks.computefleet"></a>

(*DeployToKubernetesCluster*/Compute/**Fleet**)

(Optional)

Especifique a máquina ou a frota que executará o fluxo de trabalho ou as ações de fluxo de trabalho. Com frotas sob demanda, quando uma ação é iniciada, o fluxo de trabalho provisiona os recursos necessários e as máquinas são destruídas quando a ação termina. Exemplos de frota sob demanda: `Linux.x86-64.Large`, `Linux.x86-64.XLarge`. Para ter mais informações sobre frotas sob demanda, consulte [Propriedades da frota sob demanda](workflows-working-compute.md#compute.on-demand).

Com frotas provisionadas, você configura um conjunto de máquinas dedicadas para realizar as ações do fluxo de trabalho. Essas máquinas permanecem ociosas, prontas para processar ações imediatamente. Para ter mais informações sobre frotas provisionadas, consulte [Propriedades da frota provisionada](workflows-working-compute.md#compute.provisioned-fleets).

Se `Fleet` for omitido, o padrão será `Linux.x86-64.Large`.

**UI correspondente: configuração tab/Advanced - opcional/frota de computação**

## Timeout
<a name="deploy.action.eks.timeout"></a>

(*DeployToKubernetesCluster*/**Timeout**)

(Optional)

Especifique a quantidade de tempo em minutos (editor YAML) ou horas e minutos (editor visual) que a ação pode ser executada antes de CodeCatalyst finalizar a ação. O mínimo é de cinco minutos e o máximo está descrito em [Cotas para fluxos de trabalho em CodeCatalyst](workflows-quotas.md). O tempo limite padrão é igual ao tempo limite máximo.

Interface de usuário correspondente: guia Configuração/**Tempo limite - opcional**

## Environment
<a name="deploy.action.eks.environment"></a>

(*DeployToKubernetesCluster*/**Environment**)

(Obrigatório)

Especifique o CodeCatalyst ambiente a ser usado com a ação. A ação se conecta à Conta da AWS Amazon VPC opcional especificada no ambiente escolhido. A ação usa a função padrão do IAM especificada no ambiente para se conectar ao e usa a Conta da AWS função do IAM especificada na [conexão da Amazon VPC](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-vpcs.add.html) para se conectar à Amazon VPC.

**nota**  
Se o perfil do IAM padrão não tiver as permissões exigidas pela ação, você poderá configurar a ação para usar um perfil diferente. Para obter mais informações, consulte [Alteração do perfil do IAM de uma ação](deploy-environments-switch-role.md).

Para ter mais informações sobre ambientes, consulte [Implantação em e Contas da AWS VPCs](deploy-environments.md) e [Criar um ambiente](deploy-environments-creating-environment.md).

Interface de usuário correspondente: guia Configuração/**Ambiente**

## Name
<a name="deploy.action.eks.environment.name"></a>

(*DeployToKubernetesCluster*/Environment/**Name**)

(Obrigatório se [Environment](#deploy.action.eks.environment) for incluído)

Especifique o nome de um ambiente existente que deseja associar à ação.

Interface de usuário correspondente: guia Configuração/**Ambiente**

## Connections
<a name="deploy.action.eks.environment.connections"></a>

(*DeployToKubernetesCluster*/Environment/**Connections**)

(Opcional nas versões mais recentes da ação; obrigatório nas versões mais antigas)

Especifique a conexão da conta a ser associada à ação. É possível especificar no máximo uma conexão de conta em `Environment`.

Se você não especificar uma conexão de conta:
+ A ação usa a Conta da AWS conexão e a função padrão do IAM especificadas no ambiente no CodeCatalyst console. Para ter informações sobre como adicionar uma conexão de conta e um perfil do IAM padrão ao ambiente, consulte [Criar um ambiente](deploy-environments-creating-environment.md).
+ O perfil do IAM padrão deve incluir as políticas e as permissões exigidas pela ação. Para determinar quais são essas políticas e permissões, consulte a descrição da propriedade **Perfil** na documentação de definição de YAML da ação.

Para ter mais informações sobre conexões de conta, consulte [Permitindo acesso a AWS recursos com conexão Contas da AWS](ipa-connect-account.md). Para ter informações sobre como adicionar uma conexão de conta a um ambiente, consulte [Criar um ambiente](deploy-environments-creating-environment.md).

Interface de usuário correspondente: uma das seguintes, dependendo da versão da ação:
+ (Versões mais recentes) A configuração tab/Environment/What está pronta? *my-environment* **/menu de três pontos/ Mudar função**
+ **(Versões mais antigas) Guia de configuração/' Environment/account/role AWS '/ conexão de conta**

## Name
<a name="deploy.action.eks.environment.connections.name"></a>

(*DeployToKubernetesCluster*/Environment/Connections/**Name**)

(Optional)

Especifique o nome da conexão da conta.

Interface de usuário correspondente: uma das seguintes, dependendo da versão da ação:
+ (Versões mais recentes) A configuração tab/Environment/What está pronta? *my-environment* **/menu de três pontos/ Mudar função**
+ **(Versões mais antigas) Guia de configuração/' Environment/account/role AWS '/ conexão de conta**

## Role
<a name="deploy.action.eks.environment.connections.role"></a>

(*DeployToKubernetesCluster*/Environment/Connections/**Role**)

(Obrigatório se [Connections](#deploy.action.eks.environment.connections) for incluído)

Especifique o nome do perfil do IAM que a ação **Implantar no cluster do Kubernetes** usa para acessar a AWS. Certifique-se de ter [adicionado a função ao seu CodeCatalyst espaço](ipa-connect-account-addroles.md) e de que a função inclua as seguintes políticas.

Se você não especificar uma função do IAM, a ação usará a função padrão do IAM listada no [ambiente](deploy-environments.md) no CodeCatalyst console. Se você usar o perfil padrão no ambiente, verifique se ele tem as políticas a seguir.
+ A política de permissões a seguir:
**Atenção**  
Limite as permissões às exibidas na política a seguir. Usar um perfil com permissões mais amplas pode representar um risco de segurança.

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

****  

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

------
**nota**  
Na primeira vez em que o perfil for usado, use o caractere curinga a seguir 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": "*"
  ```
+ A política de confiança personalizada a seguir:

Esse perfil deve ser adicionado a:
+ Sua conexão de conta. Para saber mais sobre como adicionar um perfil do IAM a uma conexão de conta, consulte [Adicionar perfis do IAM às conexões da conta](ipa-connect-account-addroles.md).
+ Seu Kubernetes ConfigMap. Para saber mais sobre como adicionar uma função do IAM a uma ConfigMap, consulte [Gerenciar usuários e funções do IAM](https://eksctl.io/usage/iam-identity-mappings/) na `eksctl` documentação.

**dica**  
Consulte também [Tutorial: Implantar uma aplicação no Amazon EKS](deploy-tut-eks.md) para obter instruções sobre como adicionar uma função do IAM a uma conexão de conta ConfigMap e.

**nota**  
Você pode usar o perfil `CodeCatalystWorkflowDevelopmentRole-spaceName` com essa ação, se desejar. Para obter mais informações sobre esse perfil, 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 de acesso completas, 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. 

Interface de usuário correspondente: uma das seguintes, dependendo da versão da ação:
+ (Versões mais recentes) A configuração tab/Environment/What está pronta? *my-environment* **/menu de três pontos/ Mudar função**
+ **(Versões mais antigas) Guia de configuração/' '/ Função Environment/account/role**

## Inputs
<a name="deploy.action.eks.inputs"></a>

(*DeployToKubernetesCluster*/**Inputs**)

(Obrigatório se [Connections](#deploy.action.eks.environment.connections) for incluído)

A seção `Inputs` define os dados que `DeployToKubernetesCluster` precisa durante a execução de um fluxo de trabalho.

**nota**  
Somente uma entrada (uma origem ou um artefato) é permitida por ação **Implantar no Amazon EKS**.

Interface de usuário correspondente: guia **Entradas**

## Sources
<a name="deploy.action.eks.inputs.sources"></a>

(*DeployToKubernetesCluster*/Inputs/**Sources**)

(Obrigatório se o arquivo de manifesto estiver armazenado em um repositório de origem)

Se os arquivos de manifesto do Kubernetes estiverem armazenados em um repositório de origem, especifique o rótulo do repositório de origem. Atualmente, o único rótulo compatível é `WorkflowSource`.

Se os arquivos de manifesto não estiverem em um repositório de origem, eles deverão residir em um artefato gerado por outra ação.

Para obter mais informações sobre fontes, consulte [Conectar repositórios de origem aos fluxos de trabalho](workflows-sources.md).

Interface de usuário correspondente: guia Entradas/**Origens - opcional**

## Artifacts - input
<a name="deploy.action.eks.inputs.artifacts"></a>

(*DeployToKubernetesCluster*/Inputs/**Artifacts**)

(Obrigatório se o arquivo de manifesto estiver armazenado em um [artefato de saída](workflows-working-artifacts-output.md) de uma ação anterior)

Se os arquivos de manifesto do Kubernetes estiverem contidos em um artefato gerado por uma ação anterior, especifique esse artefato aqui. Se os arquivos de manifesto não estiverem em um artefato, eles deverão residir em seu repositório de origem.

Para ter mais informações sobre artefatos, inclusive exemplos, consulte [Compartilhar artefatos e arquivos entre ações](workflows-working-artifacts.md).

Interface de usuário correspondente: guia Configuração/**Artefatos - opcional**

## Configuration
<a name="deploy.action.eks.configuration"></a>

(*DeployToKubernetesCluster*/**Configuration**)

(Obrigatório)

Uma seção na qual você pode definir as propriedades de configuração da ação.

Interface de usuário correspondente: guia **Configuração**

## Namespace
<a name="deploy.action.eks.namespace"></a>

(*DeployToKubernetesCluster*/Configuration/**Namespace**)

(Optional)

Especifique o namespace do Kubernetes no qual a aplicação Kubernetes será implantada. Use `default` se você não estiver usando namespaces com seu cluster. Para ter mais informações sobre namespaces, consulte [Subdivisão do cluster usando namespaces do Kubernetes](https://kubernetes.io/docs/tasks/administer-cluster/namespaces/#subdividing-your-cluster-using-kubernetes-namespaces) na documentação do Kubernetes.

Se você omitir o namespace, um valor de `default` será usado.

Interface de usuário correspondente: guia Configuração/**Namespace**

## Region
<a name="deploy.action.eks.region"></a>

(*DeployToKubernetesCluster*/Configuration/**Region**)

(Obrigatório)

Especifique a AWS região em que seu cluster e serviço do Amazon EKS residem. Para ver uma lista de códigos de região, consulte [Endpoints regionais](https://docs.aws.amazon.com/general/latest/gr/rande.html#region-names-codes) na *Referência geral da AWS*.

Interface de usuário correspondente: guia Configuração/**Região**

## Cluster
<a name="deploy.action.eks.cluster"></a>

(*DeployToKubernetesCluster*/Configuration/**Cluster**)

(Obrigatório)

Especifique o nome de um cluster existente do Amazon EKS. A ação **Implantar no cluster do Kubernetes** implantará a aplicação em contêineres nesse cluster. Para ter informações sobre clusters do Amazon EKS, consulte [Clusters](https://docs.aws.amazon.com/eks/latest/userguide/clusters.html) no **Guia do usuário do Amazon EKS**.

Interface de usuário correspondente: guia Configuração/**Cluster**

## Manifests
<a name="deploy.action.eks.manifest"></a>

(*DeployToKubernetesCluster*/Configuration/**Manifests**)

(Obrigatório)

Especifique o caminho para seus arquivos de manifesto do Kubernetes formatados em YAML, que são chamados de *arquivos de configuração* ou, simplesmente, *configurações* na *documentação do Kubernetes*.

Se você estiver usando vários arquivos de manifesto, coloque-os em uma única pasta e faça referência a essa pasta. Os arquivos de manifesto são processados alfanumericamente pelo Kubernetes, portanto, prefixe os nomes dos arquivos com números ou letras crescentes para controlar a ordem de processamento. Por exemplo:

`00-namespace.yaml`

`01-deployment.yaml`

Se os arquivos de manifesto residirem em seu repositório de origem, o caminho é relativo à pasta raiz do repositório de origem. Se os arquivos residirem em um artefato de uma ação anterior do fluxo de trabalho, o caminho é relativo à pasta raiz do artefato. 

Exemplos:

`Manifests/`

`deployment.yaml`

`my-deployment.yml`

Não use curingas (`*`).

**nota**  
Os [charts do Helm](https://helm.sh/docs/topics/charts/) e os [arquivos de personalização](https://kubernetes.io/docs/tasks/manage-kubernetes-objects/kustomization/) não são aceitos.

Para ter mais informações sobre os arquivos de manifesto, consulte [Como organizar as configurações de recursos](https://kubernetes.io/docs/concepts/cluster-administration/manage-deployment/#organizing-resource-configurations) na documentação do Kubernetes.

Interface de usuário correspondente: guia Configuração/**Manifestos**