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 com fluxos de trabalho
<a name="deploy"></a>



Usando [CodeCatalyst fluxos de trabalho](workflow.md), você pode implantar aplicativos e outros recursos em vários destinos, como Amazon ECS e muito mais. AWS Lambda

## Como faço para implantar uma aplicação?
<a name="deploy-concepts"></a>

Para implantar um aplicativo ou recurso CodeCatalyst, primeiro você cria um fluxo de trabalho e, em seguida, especifica uma ação de implantação dentro dele. Uma *ação de implantação* é um componente básico do fluxo de trabalho *que define o* que você deseja implantar, *onde* e *como* deseja implantá-lo (por exemplo, usando um blue/green esquema). Você adiciona uma ação de implantação ao seu fluxo de trabalho usando o editor visual do CodeCatalyst console ou o editor YAML.

As etapas detalhadas para implantar uma aplicação ou um recurso são as seguintes.

**Como implantar uma aplicação (tarefas detalhadas)**

1. No seu CodeCatalyst projeto, você **adiciona o código-fonte** de um aplicativo que deseja implantar. Para obter mais informações, consulte [Armazenando o código-fonte em repositórios para um projeto no CodeCatalyst](source-repositories.md).

1. Em seu CodeCatalyst projeto, você **adiciona um ambiente** que define a Amazon Virtual Private Cloud (VPC) de destino Conta da AWS e opcional na qual você deseja implantar. Para obter mais informações, consulte [Implantação em e Contas da AWS VPCs](deploy-environments.md).

1. No seu CodeCatalyst projeto, você **cria um fluxo de trabalho**. No fluxo de trabalho, você define como criar, testar e implantar a aplicação. Para obter mais informações, consulte [Conceitos básicos de fluxos de trabalho](workflows-getting-started.md).

1. No fluxo de trabalho, você **adiciona um gatilho**, uma **ação de criação** e, se desejar, uma **ação de teste**. Para obter mais informações, consulte [Início da execução automática de um fluxo de trabalho usando gatilhos](workflows-add-trigger.md), [Adição da ação de criação](build-add-action.md) e [Adição da ação de teste](test-add-action.md).

1. No fluxo de trabalho, você **adiciona uma ação de implantação**. Você pode escolher entre várias ações de implantação CodeCatalyst fornecidas para seu aplicativo em diferentes destinos, como o Amazon ECS. (Você também pode usar uma ação de compilação ou uma GitHub ação para implantar seu aplicativo. Para obter mais informações sobre a ação de criação e GitHub as ações, consulte[Alternativas para ações de implantação](#deploy-concepts-alternatives).)

1. Você **inicia o fluxo de trabalho** manual ou automaticamente por meio de um gatilho. O fluxo de trabalho executa as ações de criação, teste e implantação em sequência para implantar a aplicação e os recursos no destino. Para obter mais informações, consulte [Iniciar um fluxo de trabalho executado manualmente](workflows-manually-start.md).

## Lista de ações de implantação
<a name="deploy-concepts-action-supported"></a>

As seguintes ações de implantação estão disponíveis:
+ Implantar CloudFormation pilha — Essa ação cria uma CloudFormation pilha AWS com base em um [CloudFormation modelo ou [AWS Serverless Application Model modelo](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-guide.html)](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-specification.html) fornecido por você. Para obter mais informações, consulte [Implantação de uma pilha CloudFormation](deploy-action-cfn.md).
+ Implantar no Amazon ECS - Essa ação registra um arquivo de [definição de tarefa](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html#welcome-task-definitions) que você fornece. Para obter mais informações, consulte [Implantação no Amazon ECS com um fluxo de trabalho](deploy-action-ecs.md).
+ Implantar no cluster do Kubernetes - Essa ação implanta uma aplicação em um cluster do Amazon Elastic Kubernetes Service. Para obter mais informações, consulte [Implantar no Amazon EKS com um fluxo de trabalho](deploy-action-eks.md).
+ AWS CDK implantar — Essa ação implanta um [AWS CDK aplicativo](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_concepts) em AWS. Para obter mais informações, consulte [Implantando um AWS CDK aplicativo com um fluxo de trabalho](cdk-dep-action.md).

**nota**  
*Há outras CodeCatalyst ações que podem implantar recursos; no entanto, elas não são consideradas ações de implantação porque suas informações de implantação não aparecem na página **Ambientes**.* Para saber mais sobre a página **Ambientes** e ver as implantações, consulte [Implantação em e Contas da AWS VPCs](deploy-environments.md) e [Visualizar informações de implantação](deploy-view-deployment-info.md).

## Benefícios das ações de implantação
<a name="deploy-concepts-why-use"></a>

O uso de ações de implantação em um fluxo de trabalho fornece os seguintes benefícios:
+ **Histórico de implantação**: visualize um histórico de suas implantações para ajudar a gerenciar e comunicar as alterações no software implantado. 
+ **Rastreabilidade** — Acompanhe o status de suas implantações por meio do CodeCatalyst console e veja quando e onde cada revisão do aplicativo foi implantada.
+ **Reversões**: reverta as implantações automaticamente se houver erros. Também é possível configurar alarmes para ativar reversões de implantação.
+ **Monitoramento** — Observe sua implantação conforme ela progride nos vários estágios do fluxo de trabalho.
+ **Integração com outros CodeCatalyst recursos** — armazene o código-fonte e, em seguida, crie, teste e implante, tudo em um único aplicativo.

## Alternativas para ações de implantação
<a name="deploy-concepts-alternatives"></a>

Você não precisa usar ações de implantação, embora elas sejam recomendadas porque oferecem os benefícios descritos na seção anterior. Em vez disso, você pode usar as seguintes [CodeCatalyst ações](workflows-actions.md#workflows-actions-types-cc):
+ Uma ação de **criação**.

  Normalmente, você usa ações de criação quando quer implantar em um destino para o qual não existe uma ação de implantação correspondente ou quando quer ter mais controle sobre o procedimento de implantação. Para ter mais informações sobre como usar ações de criação para implantar recursos, consulte [Criação com fluxos de trabalho](build-workflow-actions.md).
+ Uma **GitHub ação**.

  Você pode usar uma [GitHub ação](workflows-actions.md#workflows-actions-types-github) dentro de um CodeCatalyst fluxo de trabalho para implantar aplicativos e recursos (em vez de uma CodeCatalyst ação). Para obter informações sobre como usar GitHub ações em um CodeCatalyst fluxo de trabalho, consulte [Integração com GitHub ações](integrations-github-actions.md)

Você também pode usar os seguintes AWS serviços para implantar seu aplicativo, se não quiser usar um CodeCatalyst fluxo de trabalho para fazer isso:
+ AWS CodeDeploy — veja [O que é CodeDeploy?](https://docs.aws.amazon.com/codedeploy/latest/userguide/welcome.html)
+ AWS CodeBuild e AWS CodePipeline — veja [O que é AWS CodeBuild?](https://docs.aws.amazon.com/codebuild/latest/userguide/welcome.html) e [o que é AWS CodePipeline?](https://docs.aws.amazon.com/codepipeline/latest/userguide/welcome.html)
+ CloudFormation — veja [O que é CloudFormation?](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html)

Use CodeDeploy, CodeBuild CodePipeline, e CloudFormation serviços para implantações corporativas complexas.

**Topics**
+ [Como faço para implantar uma aplicação?](#deploy-concepts)
+ [Lista de ações de implantação](#deploy-concepts-action-supported)
+ [Benefícios das ações de implantação](#deploy-concepts-why-use)
+ [Alternativas para ações de implantação](#deploy-concepts-alternatives)
+ [Implantação no Amazon ECS com um fluxo de trabalho](deploy-action-ecs.md)
+ [Implantar no Amazon EKS com um fluxo de trabalho](deploy-action-eks.md)
+ [Implantação de uma pilha CloudFormation](deploy-action-cfn.md)
+ [Implantando um AWS CDK aplicativo com um fluxo de trabalho](cdk-dep-action.md)
+ [Inicializando um AWS CDK aplicativo com um fluxo de trabalho](cdk-boot-action.md)
+ [Publicação de arquivos no Amazon S3 com um fluxo de trabalho](s3-pub-action.md)
+ [Implantação em e Contas da AWS VPCs](deploy-environments.md)
+ [Exibir o URL da aplicação no diagrama do fluxo de trabalho](deploy-app-url.md)
+ [Remoção de um destino de implantação](deploy-remove-target.md)
+ [Rastreamento do status de implantação por confirmação](track-changes.md)
+ [Visualização dos logs de implantação](deploy-deployment-logs.md)
+ [Visualizar informações de implantação](deploy-view-deployment-info.md)

# Implantação no Amazon ECS com um fluxo de trabalho
<a name="deploy-action-ecs"></a>

Esta seção descreve como implantar um aplicativo em contêiner em um cluster do Amazon Elastic Container Service usando um CodeCatalyst fluxo de trabalho. Para fazer isso, você deve adicionar a ação **Implantar no Amazon ECS** ao seu fluxo de trabalho. Essa ação registra um arquivo de [definição de tarefa](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html#welcome-task-definitions) que você fornece. Após o registro, a definição da tarefa é instanciada pelo [serviço do Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html) em execução no [cluster do Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html#welcome-clusters). “Instanciar uma definição de tarefa” é equivalente a implantar uma aplicação no Amazon ECS.

Para usar essa ação, você deve ter um cluster, serviço e arquivo de definição de tarefas do Amazon ECS pronto.

Para ter mais informações sobre o Amazon ECS, consulte o *Guia do desenvolvedor do Amazon Elastic Container Service*.

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

**dica**  
Para ter um exemplo prático da ação **Implantar no Amazon ECS**, crie um projeto com o esquema **API Node.js com AWS Fargate** ou a **API Java com AWS Fargate**. Para obter mais informações, consulte [Criar um projeto com um esquema](projects-create.md#projects-create-console-template).

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

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

A ação **Implantar no Amazon ECS** é 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 ECS
<a name="deploy-tut-ecs"></a>

Neste tutorial, você aprende a implantar um aplicativo sem servidor no Amazon Elastic Container Service (Amazon ECS) usando um fluxo de trabalho, o Amazon ECS e alguns outros serviços. AWS A aplicação implantada é um site simples do Hello World construído em uma imagem do Docker do servidor da Web Apache. O tutorial explica o trabalho de preparação necessário, como a configuração de um cluster, e descreve como criar um fluxo de trabalho para criar e implantar a aplicação.

**dica**  
Em vez de seguir este tutorial, você pode usar um esquema que faz uma configuração completa do Amazon ECS para você. Você precisará usar o esquema **API Node.js com AWS Fargate** ou **API Java com AWS Fargate**. Para obter mais informações, consulte [Criar um projeto com um esquema](projects-create.md#projects-create-console-template).

**Topics**
+ [Pré-requisitos](#deploy-tut-ecs-prereqs)
+ [Etapa 1: configurar um AWS usuário e AWS CloudShell](#deploy-tut-ecs-user-cloudshell)
+ [Etapa 2: implantar uma aplicação de espaço reservado no Amazon ECS](#deploy-tut-ecs-placeholder)
+ [Etapa 3: criar uma imagem de repositório do Amazon ECR](#deploy-tut-ecs-ecr)
+ [Etapa 4: criar AWS funções](#deploy-tut-ecs-build-deploy-roles)
+ [Etapa 5: adicionar AWS funções a CodeCatalyst](#deploy-tut-ecs-import-roles)
+ [Etapa 6: criar um repositório de origem](#deploy-tut-ecs-source-repo)
+ [Etapa 7: adicionar arquivos de origem](#deploy-tut-ecs-source-files)
+ [Etapa 8: criar e executar um fluxo de trabalho](#deploy-tut-ecs-workflow)
+ [Etapa 9: realizar uma alteração nos arquivos de origem](#deploy-tut-ecs-change)
+ [Limpeza](#deploy-tut-ecs-cleanup)

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

Antes de começar
+ Você precisa de um CodeCatalyst **espaço** 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-ecs-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 CodeCatalyst **ambiente** chamado:

  ```
  codecatalyst-ecs-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 um AWS usuário e AWS CloudShell
<a name="deploy-tut-ecs-user-cloudshell"></a>

A primeira etapa deste tutorial é criar um usuário e executar uma AWS CloudShell instância como esse usuário. Centro de Identidade do AWS IAM Durante este tutorial, CloudShell é o seu computador de desenvolvimento e é onde você configura AWS recursos e serviços. Exclua esse usuário depois de concluir o tutorial.

**nota**  
Não use seu usuário-raiz neste tutorial. Você deve criar um usuário separado, caso contrário poderá ter problemas ao executar ações na AWS Command Line Interface (CLI) posteriormente.

Para obter mais informações sobre os usuários do IAM Identity Center e CloudShell consulte o *Guia Centro de Identidade do AWS IAM do usuário* e o *Guia AWS CloudShell do usuário*. 

**Como criar um usuário do Centro de Identidade do IAM**

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/).
**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:

   ```
   CodeCatalystECSUser
   ```

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** e **Sobrenome**, digite:

   ```
   CodeCatalystECSUser
   ```

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

   ```
   CodeCatalystECSUser CodeCatalystECSUser
   ```

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, incluindo o URL do portal de acesso da AWS e a senha de uso único.

1. Escolha **Fechar**.

**Para criar um conjunto de permissões**

Você atribuirá esse conjunto de permissões a `CodeCatalystECSUser` posteriormente.

1. No painel de navegação, escolha **Conjuntos de permissões** e selecione **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**, digite:

   ```
   CodeCatalystECSPermissionSet
   ```

1. Escolha **Próximo**.

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

**Para atribuir o conjunto de permissões a CodeCatalyst ECSUser**

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

1. Escolha **Próximo**.

1. Marque a caixa de seleção ao lado dos logs do `CodeCatalystECSPermissionSet`.

1. Escolha **Próximo**.

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

   Agora você designou `CodeCatalystECSUser` e `CodeCatalystECSPermissionSet` para o seu Conta da AWS, unindo-os.

**Para sair e entrar novamente como CodeCatalyst ECSUser**

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

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

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

1. Escolha e **Conta da AWS**, em seguida, escolha o nome do Conta da AWS ao qual você atribuiu o `CodeCatalystECSUser` usuário e o conjunto de permissões.

1. Ao lado de `CodeCatalystECSPermissionSet`, selecione **Console de gerenciamento**.

   O Console de gerenciamento da AWS aparece. Agora você está conectado como `CodeCatalystECSUser` com as permissões apropriadas.

**Para iniciar uma AWS CloudShell instância**

1. Como`CodeCatalystECSUser`, na barra de navegação superior, escolha o AWS ícone (![\[AWS icon\]](http://docs.aws.amazon.com/pt_br/codecatalyst/latest/userguide/images/deploy/aws-logo.png)).

   A página principal do Console de gerenciamento da AWS aparece.

1. Na barra de navegação superior, escolha o AWS CloudShell ícone (![\[CloudShell icon\]](http://docs.aws.amazon.com/pt_br/codecatalyst/latest/userguide/images/deploy/CloudShell.png)).

   CloudShell abre. Aguarde enquanto o CloudShell ambiente é criado.
**nota**  
Se você não vê o CloudShell ícone, verifique se você está em uma [região suportada pelo CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/faq-list.html#regions-available). Este tutorial pressupõe que você esteja na região do Oeste dos EUA (Oregon).

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

1. No CloudShell terminal, digite:

   ```
   aws --version
   ```

1. Confira se uma versão é exibida.

   O já AWS CLI está configurado para o usuário atual`CodeCatalystECSUser`, portanto, não há necessidade de configurar AWS CLI chaves e credenciais, como é normalmente o caso.

## Etapa 2: implantar uma aplicação de espaço reservado no Amazon ECS
<a name="deploy-tut-ecs-placeholder"></a>

Nesta seção, você implanta manualmente uma aplicação de espaço reservado no Amazon ECS. Essa aplicação de espaço reservado será substituída pela aplicação Hello World implantada pelo fluxo de trabalho. A aplicação de espaço reservado é o Apache Web Server.

Para ter mais informações sobre o Amazon ECS, consulte o *Guia do desenvolvedor do Amazon Elastic Container Service*.

Conclua a série de procedimentos a seguir para implantar a aplicação de espaço reservado.<a name="deploy-tut-ecs-create-task-execution-role"></a>

**Como criar o perfil de execução de tarefas**

Essa função concede ao Amazon ECS AWS Fargate permissão para fazer chamadas de API em seu nome. 

1. Crie uma política de confiança:

   1. Em AWS CloudShell, digite o seguinte comando:

      ```
      cat > codecatalyst-ecs-trust-policy.json
      ```

      Um aviso piscando aparece no CloudShell terminal.

   1. No prompt, insira o seguinte código:

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

****  

      ```
      {
        "Version":"2012-10-17",		 	 	 
        "Statement": [
          {
            "Sid": "",
            "Effect": "Allow",
            "Principal": {
              "Service": "ecs-tasks.amazonaws.com"
            },
            "Action": "sts:AssumeRole"
          }
        ]
      }
      ```

------

   1. Coloque o cursor após o último colchete (`}`).

   1. Pressione **Enter** e, depois, **Ctrl\$1d** para salvar o arquivo e sair do cat.

1. Crie um perfil de execução de tarefas:

   ```
   aws iam create-role \
         --role-name codecatalyst-ecs-task-execution-role \
         --assume-role-policy-document file://codecatalyst-ecs-trust-policy.json
   ```

1. Anexe a `AmazonECSTaskExecutionRolePolicy` política AWS gerenciada à função:

   ```
   aws iam attach-role-policy \
         --role-name codecatalyst-ecs-task-execution-role \
         --policy-arn arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy
   ```

1. Exiba os detalhes do perfil:

   ```
   aws iam get-role \
         --role-name codecatalyst-ecs-task-execution-role
   ```

1. Observe o valor `"Arn":` do perfil, por exemplo, `arn:aws:iam::111122223333:role/codecatalyst-ecs-task-execution-role`. Você precisará desse nome do recurso da Amazon (ARN) posteriormente.

**Para criar um cluster do Amazon ECS**

Esse cluster conterá a aplicação de espaço reservado Apache e, posteriormente, a aplicação Hello World. 

1. Como`CodeCatalystECSUser`, em AWS CloudShell, crie um cluster vazio:

   ```
   aws ecs create-cluster --cluster-name codecatalyst-ecs-cluster
   ```

1. (Opcional) Verifique se o cluster foi criado:

   ```
   aws ecs list-clusters
   ```

   O ARN do cluster `codecatalyst-ecs-cluster` deve aparecer na lista, indicando uma criação bem-sucedida.

**Para criar um arquivo de definição de tarefa**

O arquivo de definição da tarefa indica a execução da imagem Docker (`httpd:2.4`) [do servidor Web Apache 2.4](https://hub.docker.com/_/httpd), da qual foi extraída. DockerHub

1. Como`CodeCatalystECSUser`, em AWS CloudShell, crie um arquivo de definição de tarefa:

   ```
   cat > taskdef.json
   ```

1. No prompt, cole o seguinte código:

   ```
   {
       "executionRoleArn": "arn:aws:iam::111122223333:role/codecatalyst-ecs-task-execution-role",
       "containerDefinitions": [
           {
               "name": "codecatalyst-ecs-container",
               "image": "httpd:2.4",
               "essential": true,
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ]
           }
       ],
       "requiresCompatibilities": [
           "FARGATE"
       ],
       "cpu": "256",
       "family": "codecatalyst-ecs-task-def",
       "memory": "512",
       "networkMode": "awsvpc"
   }
   ```

   No código anterior, substitua *arn:aws:iam::111122223333:role/codecatalyst-ecs-task-execution-role*

   pelo ARN do perfil de execução da tarefa que você anotou em [Como criar o perfil de execução de tarefas](#deploy-tut-ecs-create-task-execution-role).

1. Coloque o cursor após o último colchete (`}`).

1. Pressione **Enter** e, depois, **Ctrl\$1d** para salvar o arquivo e sair do cat.

**Para registrar o arquivo definição de tarefa com o Amazon ECS**

1. Como`CodeCatalystECSUser`, em AWS CloudShell, registre a definição da tarefa:

   ```
   aws ecs register-task-definition \
       --cli-input-json file://taskdef.json
   ```

1. (Opcional) Verifique se a definição da tarefa foi registrada:

   ```
   aws ecs list-task-definitions
   ```

   A definição da tarefa `codecatalyst-ecs-task-def` deve aparecer na lista.

**Para criar o serviço do Amazon ECS**

O serviço Amazon ECS executa as tarefas (e os contêineres do Docker associados) da aplicação de espaço reservado Apache e, posteriormente, da aplicação Hello World.

1. Como `CodeCatalystECSUser`, mude para o console do Amazon Elastic Container Service, se você ainda não tiver feito isso.

1. Selecione o cluster que você criou antes, `codecatalyst-ecs-cluster`.

1. Na guia **Serviços**, selecione **Criar**.

1. Na página **Criar**, faça o seguinte:

   1. Mantenha todas as configurações padrão, exceto as listadas a seguir.

   1. Para **Launch type (Tipo de inicialização)**, escolha **FARGATE**.

   1. Em **Definição de tarefa**, na lista suspensa **Família**, escolha:

      `codecatalyst-ecs-task-def`

   1. Em **Nome do serviço**, digite:

      ```
      codecatalyst-ecs-service
      ```

   1. Em **Tarefas desejadas**, digite:

      ```
      3
      ```

      Neste tutorial, cada tarefa inicia um único contêiner do Docker.

   1. Expanda a seção **Rede**.

   1. Em **VPC**, escolha qualquer VPC.

   1. Em **Sub-redes**, escolha qualquer sub-rede.
**nota**  
Especifique somente uma sub-rede. Isso é tudo o que é necessário para este tutorial.
**nota**  
Se você não tiver uma VPC e uma sub-rede, crie-as. Consulte [Criar uma VPC](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html#Create-VPC) e [Criar uma sub-rede na VPC](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html#AddaSubnet) no *Guia do usuário da Amazon VPC*.

   1. Em **Grupo de segurança**, selecione **Criar um grupo de segurança** e faça o seguinte:

      1. Em **Nome do grupo de segurança**, digite:

         ```
         codecatalyst-ecs-security-group
         ```

      1. Em **Descrição do grupo de segurança**, digite:

         ```
         CodeCatalyst ECS security group
         ```

      1. Escolha **Adicionar regra**. Em **Tipo**, selecione **HTTP** e, em **Origem**, selecione **Qualquer lugar**.

   1. Selecione **Criar** na parte inferior.

   1. Aguarde enquanto o serviço é criado. Isso pode levar alguns minutos.

1. Escolha a guia **Tarefas** e escolha o botão de atualização. Verifique se as três tarefas têm a coluna **Último status** definida como **Em execução**.

**(Opcional) Para verificar se a aplicação de espaço reservado Apache está em execução**

1. Na guia **Tarefas**, escolha qualquer uma das três tarefas.

1. No campo **IP público**, escolha **endereço aberto**.

   Uma página `It Works!` é exibida. Isso indica que o serviço Amazon ECS iniciou uma tarefa que executou um contêiner do Docker com a imagem do Apache.

   Neste ponto do tutorial, você implantou manualmente uma definição de cluster, serviço e tarefa do Amazon ECS, bem como uma aplicação de espaço reservado do Apache. Com todos esses itens prontos, agora você já pode criar um fluxo de trabalho que substituirá a aplicação de espaço reservado Apache pela aplicação Hello World do tutorial.

## Etapa 3: criar uma imagem de repositório do Amazon ECR
<a name="deploy-tut-ecs-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 que substituirá a imagem de espaço reservado do Apache que você implantou anteriormente. 

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. Por `CodeCatalystECSUser` exemplo AWS CloudShell, crie um repositório vazio no Amazon ECR:

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

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

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

1. Observe o valor `“repositoryUri”:`, por exemplo, `111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-ecs-image-repo`.

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

## Etapa 4: criar AWS funções
<a name="deploy-tut-ecs-build-deploy-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 CodeCatalyst Deploy to ECS** (no fluxo de trabalho) permissão para acessar sua AWS conta, o Amazon ECS e alguns outros AWS serviços.

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 as funções de criação e implantação, você pode usar Console de gerenciamento da AWS o. ou AWS CLI o.

------
#### [ Console de gerenciamento da AWS ]

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

**Como criar um perfil de criação**

1. Crie uma política para o perfil da seguinte maneira:

   1. Faça login em AWS.

   1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

   1. No painel de navegação, selecione **Políticas**.

   1. Escolha **Criar política**.

   1. Escolha a guia **JSON**.

   1. Exclua o código existente.

   1. Cole o seguinte código:

------
#### [ 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": "*"
      ```

   1. Escolha **Próximo: tags**.

   1. Selecione **Próximo: revisar**.

   1. Em **Nome**, insira:

      ```
      codecatalyst-ecs-build-policy
      ```

   1. Selecione **Criar política**.

      Agora você criou uma política de permissões.

1. Crie o perfil de criação, da seguinte forma:

   1. No painel de navegação, escolha **Perfis** e **Criar perfil**.

   1. Selecione **Política de confiança personalizada**.

   1. Exclua a política de confiança personalizada existente.

   1. Adicione a política de confiança personalizada a seguir:

   1. Escolha **Próximo**.

   1. Em **Políticas de permissões**, procure `codecatalyst-ecs-build-policy` e marque a caixa de seleção.

   1. Escolha **Próximo**.

   1. Em **Nome do perfil**, insira:

      ```
      codecatalyst-ecs-build-role
      ```

   1. Em **Descrição do perfil**, insira:

      ```
      CodeCatalyst ECS build role
      ```

   1. Selecione **Criar perfil**.

   Agora você criou um perfil de criação com uma política de permissões e uma política de confiança.

1. Obtenha o ARN do perfil de criação, da seguinte forma:

   1. No painel de navegação, escolha **Perfis**.

   1. Na caixa de pesquisa, insira o nome do perfil que você acabou de criar (`codecatalyst-ecs-build-role`).

   1. Escolha o perfil na lista.

      A página **Resumo** do perfil é exibida.

   1. Na parte superior, copie o valor do **ARN**. Você precisará disso mais tarde.

**Para criar um perfil de implantação**

1. Crie uma política para o perfil da seguinte maneira:

   1. Faça login em AWS.

   1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

   1. No painel de navegação, selecione **Políticas**.

   1. Escolha **Create Policy**.

   1. Escolha a guia **JSON**.

   1. Exclua o código existente.

   1. Cole o seguinte código:

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

****  

      ```
      {
          "Version":"2012-10-17",		 	 	 
          "Statement": [{
          "Action":[
            "ecs:DescribeServices",
            "ecs:CreateTaskSet",
            "ecs:DeleteTaskSet",
            "ecs:ListClusters",
            "ecs:RegisterTaskDefinition",
            "ecs:UpdateServicePrimaryTaskSet",
            "ecs:UpdateService",
            "elasticloadbalancing:DescribeTargetGroups",
            "elasticloadbalancing:DescribeListeners",
            "elasticloadbalancing:ModifyListener",
            "elasticloadbalancing:DescribeRules",
            "elasticloadbalancing:ModifyRule",
            "lambda:InvokeFunction",
            "lambda:ListFunctions",
            "cloudwatch:DescribeAlarms",
            "sns:Publish",
            "sns:ListTopics", 
            "s3:GetObject",
            "s3:GetObjectVersion",
            "codedeploy:CreateApplication", 
            "codedeploy:CreateDeployment", 
            "codedeploy:CreateDeploymentGroup", 
            "codedeploy:GetApplication", 
            "codedeploy:GetDeployment", 
            "codedeploy:GetDeploymentGroup", 
            "codedeploy:ListApplications", 
            "codedeploy:ListDeploymentGroups", 
            "codedeploy:ListDeployments", 
            "codedeploy:StopDeployment", 
            "codedeploy:GetDeploymentTarget", 
            "codedeploy:ListDeploymentTargets", 
            "codedeploy:GetDeploymentConfig", 
            "codedeploy:GetApplicationRevision", 
            "codedeploy:RegisterApplicationRevision", 
            "codedeploy:BatchGetApplicationRevisions", 
            "codedeploy:BatchGetDeploymentGroups", 
            "codedeploy:BatchGetDeployments", 
            "codedeploy:BatchGetApplications", 
            "codedeploy:ListApplicationRevisions", 
            "codedeploy:ListDeploymentConfigs", 
            "codedeploy:ContinueDeployment"           
         ],
         "Resource":"*",
         "Effect":"Allow"
      },{"Action":[
            "iam:PassRole"
         ],
         "Effect":"Allow",
         "Resource":"*",
         "Condition":{"StringLike":{"iam:PassedToService":[
                  "ecs-tasks.amazonaws.com",
                  "codedeploy.amazonaws.com"
               ]
            }
         }
      }]
      }
      ```

------
**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. Em seguida, você pode definir o escopo da política com o nome do recurso depois que ele estiver disponível.  

      ```
      "Resource": "*"
      ```

   1. Escolha **Próximo: tags**.

   1. Selecione **Próximo: revisar**.

   1. Em **Nome**, insira:

      ```
      codecatalyst-ecs-deploy-policy
      ```

   1. Selecione **Criar política**.

      Agora você criou uma política de permissões.

1. Crie o perfil de implantação, da seguinte forma:

   1. No painel de navegação, escolha **Perfis** e **Criar perfil**.

   1. Selecione **Política de confiança personalizada**.

   1. Exclua a política de confiança personalizada existente.

   1. Adicione a política de confiança personalizada a seguir:

   1. Escolha **Próximo**.

   1. Em **Políticas de permissões**, procure `codecatalyst-ecs-deploy-policy` e marque a caixa de seleção.

   1. Escolha **Próximo**.

   1. Em **Nome do perfil**, insira:

      ```
      codecatalyst-ecs-deploy-role
      ```

   1. Em **Descrição do perfil**, insira:

      ```
      CodeCatalyst ECS deploy role
      ```

   1. Selecione **Criar perfil**.

   Agora você criou um perfil de implantação com uma política de confiança.

1. Obtenha o ARN do perfil de implantação, da seguinte forma:

   1. No painel de navegação, escolha **Perfis**.

   1. Na caixa de pesquisa, insira o nome do perfil que você acabou de criar (`codecatalyst-ecs-deploy-role`).

   1. Escolha o perfil na lista.

      A página **Resumo** do perfil é exibida.

   1. Na parte superior, copie o valor do **ARN**. Você precisará disso mais tarde.

------
#### [ AWS CLI ]

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

**Para criar uma política de confiança para os dois perfis**

Por `CodeCatalystECSUser` exemplo AWS CloudShell, crie um arquivo de política de confiança:

1. Crie o arquivo:

   ```
   cat > codecatalyst-ecs-trust-policy.json
   ```

1. No prompt do terminal, cole o seguinte código:

1. Coloque o cursor após o último colchete (`}`).

1. Pressione **Enter** e, depois, **Ctrl\$1d** para salvar o arquivo e sair do cat.

**Para criar a política de criação e o perfil de criação**

1. Crie a política de criação:

   1. Por `CodeCatalystECSUser` exemplo AWS CloudShell, crie um arquivo de política de compilação:

      ```
      cat > codecatalyst-ecs-build-policy.json
      ```

   1. No prompt, insira o seguinte código:

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

****  

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

------

   1. Coloque o cursor após o último colchete (`}`).

   1. Pressione **Enter** e, depois, **Ctrl\$1d** para salvar o arquivo e sair do cat.

1. Adicione a política de compilação a AWS:

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

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

1. Crie o perfil de criação e anexe a política de confiança a ele:

   ```
   aws iam create-role \
         --role-name codecatalyst-ecs-build-role \
         --assume-role-policy-document file://codecatalyst-ecs-trust-policy.json
   ```

1. Anexe a política de criação à função de criação:

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

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

1. Exiba os detalhes do perfil de criação:

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

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

**Para criar a política e o perfil de implantação**

1. Crie uma política de implantação:

   1. Em AWS CloudShell, crie um arquivo de política de implantação:

      ```
      cat > codecatalyst-ecs-deploy-policy.json
      ```

   1. No prompt, insira o seguinte código:

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

****  

      ```
      {
          "Version":"2012-10-17",		 	 	 
          "Statement": [{
          "Action":[
            "ecs:DescribeServices",
            "ecs:CreateTaskSet",
            "ecs:DeleteTaskSet",
            "ecs:ListClusters",
            "ecs:RegisterTaskDefinition",
            "ecs:UpdateServicePrimaryTaskSet",
            "ecs:UpdateService",
            "elasticloadbalancing:DescribeTargetGroups",
            "elasticloadbalancing:DescribeListeners",
            "elasticloadbalancing:ModifyListener",
            "elasticloadbalancing:DescribeRules",
            "elasticloadbalancing:ModifyRule",
            "lambda:InvokeFunction",
            "lambda:ListFunctions",
            "cloudwatch:DescribeAlarms",
            "sns:Publish",
            "sns:ListTopics", 
            "s3:GetObject",
            "s3:GetObjectVersion",
            "codedeploy:CreateApplication", 
            "codedeploy:CreateDeployment", 
            "codedeploy:CreateDeploymentGroup", 
            "codedeploy:GetApplication", 
            "codedeploy:GetDeployment", 
            "codedeploy:GetDeploymentGroup", 
            "codedeploy:ListApplications", 
            "codedeploy:ListDeploymentGroups", 
            "codedeploy:ListDeployments", 
            "codedeploy:StopDeployment", 
            "codedeploy:GetDeploymentTarget", 
            "codedeploy:ListDeploymentTargets", 
            "codedeploy:GetDeploymentConfig", 
            "codedeploy:GetApplicationRevision", 
            "codedeploy:RegisterApplicationRevision", 
            "codedeploy:BatchGetApplicationRevisions", 
            "codedeploy:BatchGetDeploymentGroups", 
            "codedeploy:BatchGetDeployments", 
            "codedeploy:BatchGetApplications", 
            "codedeploy:ListApplicationRevisions", 
            "codedeploy:ListDeploymentConfigs", 
            "codedeploy:ContinueDeployment"           
         ],
         "Resource":"*",
         "Effect":"Allow"
      },{"Action":[
            "iam:PassRole"
         ],
         "Effect":"Allow",
         "Resource":"*",
         "Condition":{"StringLike":{"iam:PassedToService":[
                  "ecs-tasks.amazonaws.com",
                  "codedeploy.amazonaws.com"
               ]
            }
         }
      }]
      }
      ```

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

   1. Coloque o cursor após o último colchete (`}`).

   1. Pressione **Enter** e, depois, **Ctrl\$1d** para salvar o arquivo e sair do cat.

1. Adicione a política de implantação a AWS:

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

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

1. Crie o perfil de implantação e anexe a política de confiança a ele:

   ```
   aws iam create-role \
         --role-name codecatalyst-ecs-deploy-role \
         --assume-role-policy-document file://codecatalyst-ecs-trust-policy.json
   ```

1. Anexe a política de implantação à função de implantação, que *arn:aws:iam::111122223333:policy/codecatalyst-ecs-deploy-policy* é substituída pelo ARN da política de implantação que você anotou anteriormente.

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

1. Exiba os detalhes do perfil de implantação:

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

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

------

## Etapa 5: adicionar AWS funções a CodeCatalyst
<a name="deploy-tut-ecs-import-roles"></a>

Nesta etapa, você adiciona a função de criação (`codecatalyst-ecs-build-role`) e a função de implantação (`codecatalyst-ecs-deploy-role`) à conexão da CodeCatalyst conta em seu espaço.

**Para adicionar perfis de criação e implantação à conexão da sua conta**

1. Dentro CodeCatalyst, navegue até seu espaço.

1. Selecione **Contas da AWS **. Uma lista de conexões de conta é exibida.

1. Escolha a conexão de conta que representa a AWS conta em que você criou suas funções de criação e implantaçã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 todos os 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, selecione `codecatalyst-ecs-build-role` e **Adicionar perfil**.
**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. Escolha **Adicionar perfil do IAM**, selecione **Adicionar um perfil existente que você criou no IAM** e, na lista suspensa, escolha `codecatalyst-ecs-deploy-role`. Escolha **Add role (adicionar função)**.

   Agora você adicionou os perfis de criação e implantação ao seu espaço.

1. Copie o valor do **nome de CodeCatalyst exibição da Amazon**. Esse valor será necessário posteriormente, ao criar seu fluxo de trabalho.

## Etapa 6: criar um repositório de origem
<a name="deploy-tut-ecs-source-repo"></a>

Nesta etapa, você cria um repositório de origem no CodeCatalyst. Esse repositório armazena os arquivos de origem do tutorial, como o arquivo de definição da tarefa.

Para ter mais informações sobre repositórios de origem, consulte [Criar um repositório de origem](source-repositories-create.md).

**Como criar um repositório de origem**

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

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

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

1. Escolha **Adicionar repositório** e selecione **Criar repositório**.

1. Em **Nome do repositório**, insira:

   ```
   codecatalyst-ecs-source-repository
   ```

1. Escolha **Criar**.

## Etapa 7: adicionar arquivos de origem
<a name="deploy-tut-ecs-source-files"></a>

Nesta seção, você adiciona os arquivos de origem do Hello World ao seu CodeCatalyst repositório,`codecatalyst-ecs-source-repository`. Eles consistem em:
+ Um arquivo `index.html` - Exibe uma mensagem do Hello World no navegador. 
+ Um Dockerfile: descreve a imagem básica a ser usada para sua imagem do Docker e os comandos do Docker a serem aplicados a ela. 
+ Um arquivo `taskdef.json` - Define a imagem do Docker a ser usada ao iniciar tarefas em seu cluster.

A estrutura de pastas é esta:

```
.
|— public-html
|  |— index.html
|— Dockerfile
|— taskdef.json
```

**nota**  
As instruções a seguir mostram como adicionar os arquivos usando o CodeCatalyst console, mas você pode usar o Git se preferir. Para obter detalhes, consulte [Clonar um repositório de origem](source-repositories-clone.md). 

**Topics**
+ [index.html](#deploy-tut-ecs-source-files-index)
+ [Dockerfile](#deploy-tut-ecs-source-files-dockerfile)
+ [taskdef.json](#deploy-tut-ecs-source-files-taskdef)

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

O arquivo `index.html` exibe uma mensagem do Hello World no navegador. 

**Como adicionar o arquivo index.html**

1. No CodeCatalyst console, acesse seu repositório de origem,`codecatalyst-ecs-source-repository`.

1. Em **Arquivos**, selecione **Criar arquivo**.

1. Em **Nome do arquivo**, insira:

   ```
   public-html/index.html
   ```
**Importante**  
Inclua o prefixo `public-html/` para criar uma pasta com o mesmo nome. Espera-se que `index.html` esteja nessa pasta.

1. Na caixa de texto, insira o código 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. Selecione **Confirmar** e, depois, escolha **Confirmar** novamente.

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

### Dockerfile
<a name="deploy-tut-ecs-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. No repositório de origem, selecione **Criar arquivo**.

1. Em **Nome do arquivo**, insira:

   ```
   Dockerfile
   ```

   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. Na caixa de texto, insira o código a seguir:

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

1. Selecione **Confirmar** e, depois, escolha **Confirmar** novamente.

   O Dockerfile é adicionado ao repositório. 

### taskdef.json
<a name="deploy-tut-ecs-source-files-taskdef"></a>

O arquivo `taskdef.json` que você adiciona nessa etapa é o mesmo que você já especificou em [Etapa 2: implantar uma aplicação de espaço reservado no Amazon ECS](#deploy-tut-ecs-placeholder) com a seguinte diferença:

Em vez de especificar um nome de imagem do Docker codificado no campo `image:` (`httpd:2.4`), a definição da tarefa aqui usa algumas variáveis para indicar a imagem: `$REPOSITORY_URI` e `$IMAGE_TAG`. Essas variáveis serão substituídas por valores reais gerados pela ação de criação do fluxo de trabalho quando você executar o fluxo de trabalho em uma etapa posterior.

Para saber detalhes sobre os parâmetros de definição de tarefa, consulte [Parâmetros de definição de tarefa](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html) no *Guia do desenvolvedor do Amazon Elastic Container Service*.

**Como adicionar o arquivo taskdef.json**

1. No repositório de origem, selecione **Criar arquivo**.

1. Em **Nome do arquivo**, insira:

   ```
   taskdef.json
   ```

1. Na caixa de texto, insira o código a seguir:

   ```
   {
       "executionRoleArn": "arn:aws:iam::account_ID:role/codecatalyst-ecs-task-execution-role",
       "containerDefinitions": [
           {
               "name": "codecatalyst-ecs-container",
               # The $REPOSITORY_URI and $IMAGE_TAG variables will be replaced 
               # by the workflow at build time (see the build action in the 
               # workflow)
               "image": $REPOSITORY_URI:$IMAGE_TAG,
               "essential": true,
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ]
           }
       ],
       "requiresCompatibilities": [
           "FARGATE"
       ],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512",
       "family": "codecatalyst-ecs-task-def"
   }
   ```

   No código anterior, substitua

   *arn:aws:iam::account\$1ID:role/codecatalyst-ecs-task-execution-role*

   pelo ARN do perfil de execução da tarefa que você anotou em [Como criar o perfil de execução de tarefas](#deploy-tut-ecs-create-task-execution-role).

1. Selecione **Confirmar** e, depois, escolha **Confirmar** novamente.

   O arquivo `taskdef.json` é adicionado ao repositório. 

## Etapa 8: criar e executar um fluxo de trabalho
<a name="deploy-tut-ecs-workflow"></a>

Nesta etapa, você cria um fluxo de trabalho que pega seus arquivos de origem, os cria em uma imagem do Docker e, depois, implanta a imagem no seu cluster do Amazon ECS. Essa implantação substitui a aplicação de espaço reservado Apache existente.

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 o `taskdef.json` com o valor de campo `image` correto e, depois, cria um artefato de saída desse arquivo. Esse 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 (`DeployToECS`): 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 (`TaskDefArtifact`), encontra o `taskdef.json` dentro dele e o registra no seu serviço do Amazon ECS. Em seguida, o serviço segue as instruções no arquivo `taskdef.json` para executar três tarefas do Amazon ECS – e os contêineres do Docker do Hello World associados – dentro do seu cluster do Amazon ECS. 

**Para criar um fluxo de trabalho**

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

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

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

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

1. Escolha **Criar**.

1. Exclua o código de amostra YAML.

1. Adicione o seguinte código YAML:
**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 5: adicionar AWS funções a CodeCatalyst](#deploy-tut-ecs-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-ecs-workflow
   SchemaVersion: 1.0
   
   Triggers:
     - Type: PUSH
       Branches:
         - main
   Actions:
     BuildBackend:
       Identifier: aws/build@v1
       Environment:
         Name: codecatalyst-ecs-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-ecs-build-role
       Inputs:
         Sources:
           - WorkflowSource
         Variables:
           - Name: REPOSITORY_URI
             Value: 111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-ecs-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 taskdef.json
           - Run: find taskdef.json -type f | xargs sed -i "s|\$REPOSITORY_URI|$REPOSITORY_URI|g"
           - Run: find taskdef.json -type f | xargs sed -i "s|\$IMAGE_TAG|$IMAGE_TAG|g"
           - Run: cat taskdef.json
           # The output artifact will be a zip file that contains a task definition file.
       Outputs:
         Artifacts:
           - Name: TaskDefArtifact
             Files: 
               - taskdef.json
     DeployToECS:
       DependsOn: 
         - BuildBackend
       Identifier: aws/ecs-deploy@v1
       Environment:
         Name: codecatalyst-ecs-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-ecs-deploy-role
       Inputs:
         Sources: []
         Artifacts:
           - TaskDefArtifact
       Configuration:
         region: us-west-2
         cluster: codecatalyst-ecs-cluster
         service: codecatalyst-ecs-service
         task-definition: taskdef.json
   ```

   No código anterior, substitua:
   + Ambas as instâncias de *codecatalyst-ecs-environment* com o nome do ambiente em que você criou[Pré-requisitos](#deploy-tut-ecs-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 5: adicionar AWS funções a CodeCatalyst](#deploy-tut-ecs-import-roles).
   + *codecatalyst-ecs-build-role*com o nome da função de construção em que você criou[Etapa 4: criar AWS funções](#deploy-tut-ecs-build-deploy-roles).
   + *111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-ecs-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-ecs-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-ecs-image-repo`
   + *codecatalyst-ecs-deploy-role*com o nome da função de implantação na qual você criou[Etapa 4: criar AWS funções](#deploy-tut-ecs-build-deploy-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#regional-endpoints) na *Referência geral da AWS*.
**nota**  
Se você decidiu não criar e implantar funções, *codecatalyst-ecs-deploy-role* substitua *codecatalyst-ecs-build-role* e pelo nome da `CodeCatalystWorkflowDevelopmentRole-spaceName` função. Para obter mais informações sobre esse perfil, consulte [Etapa 4: criar AWS funções](#deploy-tut-ecs-build-deploy-roles).
**dica**  
Em vez de usar os comandos `find` e `sed` mostrados no código do fluxo de trabalho anterior para atualizar o nome do repositório e da imagem, você pode usar a ação de definição de tarefas **Renderizar Amazon ECS** para essa finalidade. Para obter mais informações, consulte [Modificação de uma definição de tarefa do Amazon ECS](render-ecs-action.md).

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-ecs-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-ecs-workflow`.

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

1. Escolha o **DeployToECS** 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 clássico do Amazon ECS em [https://console.aws.amazon.com/ecs/](https://console.aws.amazon.com/ecs/).

1. Escolha seu cluster, `codecatalyst-ecs-cluster`.

1. Escolha a guia **Tasks (Tarefas)**. 

1. Escolha qualquer uma das três tarefas.

1. No campo **IP público**, escolha **endereço aberto**.

   Uma página “Hello World” aparece no navegador, indicando que o serviço Amazon ECS implantou a aplicação.

## Etapa 9: realizar uma alteração nos arquivos de origem
<a name="deploy-tut-ecs-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. No CodeCatalyst console, no painel de navegação, escolha **Código**, escolha **Repositórios de origem** e, em seguida, escolha seu repositório. `codecatalyst-ecs-source-repository`

1. Escolha `public-html` e, depois, escolha `index.html`.

   O conteúdo de `index.html` aparece.

1. Escolha **Editar**. 

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

1. Selecione **Confirmar** e, depois, escolha **Confirmar** novamente.

   A confirmação faz com que uma nova execução do fluxo de trabalho seja iniciada. 

1. (Opcional) Acesse a página principal do repositório de origem, selecione **Exibir confirmações** e anote o ID da confirmação da alteração em `index.html`.

1. Assista ao andamento da implantação:

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

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

   1. Escolha **BuildBackend**e **DeployToECS** 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 clássico do Amazon ECS em [https://console.aws.amazon.com/ecs/](https://console.aws.amazon.com/ecs/).

   1. Escolha seu cluster, `codecatalyst-ecs-cluster`.

   1. Escolha a guia **Tasks (Tarefas)**. 

   1. Escolha qualquer uma das três tarefas.

   1. No campo **IP público**, escolha **endereço aberto**.

      Uma página `Tutorial complete!` é exibida.

1. (Opcional) Em AWS, mude para o console do Amazon ECR e verifique se a nova imagem do Docker foi marcada com o ID de confirmação da etapa 6.

## Limpeza
<a name="deploy-tut-ecs-cleanup"></a>

Limpe os arquivos e serviços usados neste tutorial para evitar cobranças por eles.

No Console de gerenciamento da AWS, limpe nesta ordem:

1. No Amazon ECS, faça o seguinte:

   1. Exclua `codecatalyst-ecs-service`.

   1. Exclua `codecatalyst-ecs-cluster`.

   1. Cancelar registro de `codecatalyst-ecs-task-definition`.

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

1. No Amazon EC2, exclua `codecatalyst-ecs-security-group`.

1. No IAM Identity Center, exclua:

   1. `CodeCatalystECSUser`

   1. `CodeCatalystECSPermissionSet`

No CodeCatalyst console, limpe da seguinte forma:

1. Exclua `codecatalyst-ecs-workflow`.

1. Exclua `codecatalyst-ecs-environment`.

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

1. Exclua `codecatalyst-ecs-project`.

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

# Adição da ação “Implantar no Amazon ECS”
<a name="deploy-action-ecs-adding"></a>

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

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

**Para adicionar a ação “Implantar no Amazon ECS” 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 Amazon ECS** 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 Amazon ECS**. 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 de ação “Implantar no Amazon ECS”](deploy-action-ref-ecs.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 Amazon ECS” 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 Amazon ECS** 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 Amazon ECS**. 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 de ação “Implantar no Amazon ECS”](deploy-action-ref-ecs.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 Amazon ECS”
<a name="deploy-action-ecs-variables"></a>

A ação **Implantar no Amazon ECS** 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 cluster do Amazon ECS no qual foi implantado durante a execução do fluxo de trabalho. Exemplo: `codecatalyst-ecs-cluster`  | 
|  deployment-platform  |  O nome da plataforma de implantação. Codificado para `AWS:ECS`.  | 
|  service  |  O nome do serviço do Amazon ECS no qual foi implantado durante a execução do fluxo de trabalho. Exemplo: `codecatalyst-ecs-service`  | 
|  task-definition-arn  |  O nome do recurso da Amazon (ARN) da definição de tarefa que foi registrada durante a execução do fluxo de trabalho. Exemplo: `arn:aws:ecs:us-west-2:111122223333:task-definition/codecatalyst-task-def:8`O `:8` no exemplo anterior indica a revisão que foi registrada.  | 
|  deployment-url  |  Um link para a guia **Eventos** do console do Amazon ECS, onde você pode ver detalhes da implantação do Amazon ECS associada à execução do fluxo de trabalho. Exemplo: `https://console.aws.amazon.com/ecs/home?region=us-west-2#/clusters/codecatalyst-ecs-cluster/services/codecatalyst-ecs-service/events`  | 
|  region  |  O código da região em Região da AWS que foi implantado durante a execução do fluxo de trabalho. Exemplo: `us-west-2`  | 

# YAML de ação “Implantar no Amazon ECS”
<a name="deploy-action-ref-ecs"></a>

Confira a seguir a definição de YAML da ação **Implantar no Amazon ECS**. Para saber como usar essa ação, consulte [Implantação no Amazon ECS com um fluxo de trabalho](deploy-action-ecs.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.   
  ECSDeployAction\$1nn: 
    Identifier: aws/ecs-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: iam-role-name
    Inputs:
      # Specify a source or an artifact, but not both.
      Sources:
        - source-name-1
      Artifacts:
        - task-definition-artifact
    Configuration: 
      region: us-east-1 
      cluster: ecs-cluster
      service: ecs-service
      task-definition: task-definition-path
      force-new-deployment: false|true
      codedeploy-appspec: app-spec-file-path
      codedeploy-application: application-name
      codedeploy-deployment-group: deployment-group-name
      codedeploy-deployment-description: deployment-description
```

## ECSDeployAction
<a name="deploy.action.ecs.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: `ECSDeployAction_nn`.

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

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

(*ECSDeployAction*/**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/ecs-deploy@v1`.

**UI correspondente: diagrama de fluxo de ECSDeploy trabalho/Action\$1NN/aws/ecs-deploy @v1 label**

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

(*ECSDeployAction*/**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.ecs.computename"></a>

(*ECSDeployAction*/**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.ecs.computetype"></a>

(*ECSDeployAction*/Compute/**Type**)

(Obrigatório se [Compute](#deploy.action.ecs.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.ecs.computefleet"></a>

(*ECSDeployAction*/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.ecs.timeout"></a>

(*ECSDeployAction*/**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.ecs.environment"></a>

(*ECSDeployAction*/**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.ecs.environment.name"></a>

(*ECSDeployAction*/Environment/**Name**)

(Obrigatório se [Environment](#deploy.action.ecs.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.ecs.environment.connections"></a>

(*ECSDeployAction*/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.ecs.environment.connections.name"></a>

(*ECSDeployAction*/Environment/Connections/**Name**)

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

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.ecs.environment.connections.role"></a>

(*ECSDeployAction*/Environment/Connections/**Role**)

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

Especifique o nome do perfil do IAM que a ação **Implantar no Amazon ECS** 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": [{
      "Action":[
        "ecs:DescribeServices",
        "ecs:CreateTaskSet",
        "ecs:DeleteTaskSet",
        "ecs:ListClusters",
        "ecs:RegisterTaskDefinition",
        "ecs:UpdateServicePrimaryTaskSet",
        "ecs:UpdateService",
        "elasticloadbalancing:DescribeTargetGroups",
        "elasticloadbalancing:DescribeListeners",
        "elasticloadbalancing:ModifyListener",
        "elasticloadbalancing:DescribeRules",
        "elasticloadbalancing:ModifyRule",
        "lambda:InvokeFunction",
        "lambda:ListFunctions",
        "cloudwatch:DescribeAlarms",
        "sns:Publish",
        "sns:ListTopics", 
        "s3:GetObject",
        "s3:GetObjectVersion",
        "codedeploy:CreateApplication", 
        "codedeploy:CreateDeployment", 
        "codedeploy:CreateDeploymentGroup", 
        "codedeploy:GetApplication", 
        "codedeploy:GetDeployment", 
        "codedeploy:GetDeploymentGroup", 
        "codedeploy:ListApplications", 
        "codedeploy:ListDeploymentGroups", 
        "codedeploy:ListDeployments", 
        "codedeploy:StopDeployment", 
        "codedeploy:GetDeploymentTarget", 
        "codedeploy:ListDeploymentTargets", 
        "codedeploy:GetDeploymentConfig", 
        "codedeploy:GetApplicationRevision", 
        "codedeploy:RegisterApplicationRevision", 
        "codedeploy:BatchGetApplicationRevisions", 
        "codedeploy:BatchGetDeploymentGroups", 
        "codedeploy:BatchGetDeployments", 
        "codedeploy:BatchGetApplications", 
        "codedeploy:ListApplicationRevisions", 
        "codedeploy:ListDeploymentConfigs", 
        "codedeploy:ContinueDeployment"           
     ],
     "Resource":"*",
     "Effect":"Allow"
  },{"Action":[
        "iam:PassRole"
     ],
     "Effect":"Allow",
     "Resource":"*",
     "Condition":{"StringLike":{"iam:PassedToService":[
              "ecs-tasks.amazonaws.com",
              "codedeploy.amazonaws.com"
           ]
        }
     }
  }]
  }
  ```

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

**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.ecs.inputs"></a>

(*ECSDeployAction*/**Inputs**)

(Optional)

A seção `Inputs` define os dados que `ECSDeployAction` 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 ECS**.

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

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

(*ECSDeployAction*/Inputs/**Sources**)

(Obrigatório se o arquivo de definição de tarefas estiver armazenado em um repositório de origem)

Se seu arquivo de definição de tarefa estiver armazenado em um repositório de origem, especifique o rótulo do repositório de origem. Atualmente, o único rótulo compatível é `WorkflowSource`.

Se seu arquivo de definição de tarefa não estiver em um repositório de origem, ele deverá 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.ecs.inputs.artifacts"></a>

(*ECSDeployAction*/Inputs/**Artifacts**)

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

Se o arquivo de definição de tarefa que você deseja implantar estiver em um artefato gerado por uma ação anterior, especifique esse artefato aqui. Se seu arquivo de definição de tarefa não estiver em um artefato, ele deverá 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.ecs.configuration"></a>

(*ECSDeployAction*/**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**

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

(Configuration/**region**)

(Obrigatório)

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

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

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

(*ECSDeployAction*/Configuration/**cluster**)

(Obrigatório)

Especifique o nome de um cluster existente do Amazon ECS. A ação **Implantar no Amazon ECS** implantará a aplicação em contêineres como uma tarefa nesse cluster. Para ter mais informações sobre clusters do Amazon ECS, consulte [Clusters](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html#welcome-clusters) no *Guia do desenvolvedor do Amazon Elastic Container Service*.

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

## service
<a name="deploy.action.ecs.service"></a>

(*ECSDeployAction*/Configuration/**service**)

(Obrigatório)

Especifique o nome de um serviço do Amazon ECS existente que instanciará o arquivo de definição de tarefas. Esse serviço deve residir no cluster especificado no campo `cluster`. Para ter mais informações sobre serviços do Amazon ECS, consulte [Serviços do Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html) no *Guia do desenvolvedor do Amazon Elastic Container Service*.

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

## task-definition
<a name="deploy.action.ecs.task.definition"></a>

(*ECSDeployAction*/Configuration/**task-definition**)

(Obrigatório)

Especifique o caminho para um arquivo de definição de tarefa existente. Se o arquivo residir em seu repositório de origem, o caminho é relativo à pasta raiz do repositório de origem. Se o arquivo residir em um artefato de uma ação anterior do fluxo de trabalho, o caminho é relativo à pasta raiz do artefato. Para ter mais informações sobre os arquivos de definição de tarefa, consulte [Definições de tarefa](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html#welcome-task-definitions) no *Guia do desenvolvedor do Amazon Elastic Container Service*.

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

## force-new-deployment
<a name="deploy.action.ecs.forcenewdeployment"></a>

(*ECSDeployAction*/Configuration/**force-new-deployment**)

(Obrigatório)

Se habilitado, o serviço do Amazon ECS poderá iniciar novas implantações sem alterações na definição do serviço. Forçar uma implantação faz com que o serviço interrompa todas as tarefas atualmente em execução e inicie novas tarefas. Para ter mais informações sobre como forçar novas implantações, consulte [Atualização de um serviço](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/update-service.html), no *Guia do desenvolvedor do Amazon Elastic Container Service*.

Padrão: `false`

Interface de usuário correspondente: guia Configuração/**Forçar uma nova implantação do serviço**

## codedeploy-appspec
<a name="deploy.action.ecs.codedeploy.appspec"></a>

(*ECSDeployAction*/Configuration/**codedeploy-appspec**)

(Obrigatório se você configurou seu serviço Amazon ECS para usar blue/green implantações; caso contrário, omita)

Especifique o nome e o caminho para um arquivo de especificação de CodeDeploy aplicativo existente (AppSpec). Esse arquivo deve residir na raiz do seu repositório de CodeCatalyst origem. Para obter mais informações sobre AppSpec arquivos, consulte os [arquivos de especificação do CodeDeploy aplicativo (AppSpec)](https://docs.aws.amazon.com/codedeploy/latest/userguide/application-specification-files.html) no *Guia AWS CodeDeploy do usuário*.

**nota**  
Forneça CodeDeploy informações somente se você tiver configurado seu serviço Amazon ECS para realizar blue/green implantações. Para implantações de atualizações contínuas (o padrão), CodeDeploy omita as informações. Para ter mais informações sobre implantações do Amazon ECS, consulte [Tipos de implantação do Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html), no *Guia do Desenvolvedor do Amazon Elastic Container Service*.

**nota**  
Os **CodeDeploy**campos podem estar ocultos no editor visual. Para fazer com que apareçam, consulte [Por que os CodeDeploy campos estão ausentes no editor visual?](troubleshooting-workflows.md#troubleshooting-workflows-codedeploy).

UI correspondente: guia Configuração/ **CodeDeploy AppSpec**

## codedeploy-application
<a name="deploy.action.ecs.codedeploy.application"></a>

(*ECSDeployAction*/Configuration/**codedeploy-application**)

(Obrigatório se `codedeploy-appspec` for incluído)

Especifique o nome de um CodeDeploy aplicativo existente. Para obter mais informações sobre CodeDeploy aplicativos, consulte Como [trabalhar com aplicativos CodeDeploy no](https://docs.aws.amazon.com/codedeploy/latest/userguide/applications.html) *Guia do AWS CodeDeploy usuário*.

**UI correspondente: guia de configuração/aplicativo CodeDeploy **

## codedeploy-deployment-group
<a name="deploy.action.ecs.codedeploy.deploymentgroup"></a>

(*ECSDeployAction*/Configuration/**codedeploy-deployment-group**)

(Obrigatório se `codedeploy-appspec` for incluído)

Especifique o nome de um grupo CodeDeploy de implantação existente. Para obter mais informações sobre grupos de CodeDeploy implantação, consulte [Trabalhando com grupos de implantação CodeDeploy no](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-groups.html) *Guia AWS CodeDeploy do Usuário*.

UI correspondente: guia de configuração/grupo **CodeDeploy de implantação**

## codedeploy-deployment-description
<a name="deploy.action.ecs.codedeploy.deploymentdescription"></a>

(*ECSDeployAction*/Configuration/**codedeploy-deployment-description**)

(Optional)

Especifique uma descrição da implantação que essa ação criará. Para obter mais informações, consulte Como [trabalhar com implantações CodeDeploy no](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployments.html) *Guia do AWS CodeDeploy usuário*.

UI correspondente: guia de configuração/descrição **CodeDeploy da implantação**

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

# Implantação de uma pilha CloudFormation
<a name="deploy-action-cfn"></a>

Esta seção descreve como implantar uma AWS CloudFormation pilha usando um CodeCatalyst fluxo de trabalho. Para fazer isso, você deve adicionar a ação **Deploy CloudFormation stack** ao seu fluxo de trabalho. A ação implanta uma CloudFormation pilha de recursos AWS com base em um modelo fornecido por você. O modelo pode ser um:
+ CloudFormation modelo — Para obter mais informações, consulte Como [trabalhar com CloudFormation modelos](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-guide.html).
+ AWS SAM modelo — Para obter mais informações, consulte a [especificação AWS Serverless Application Model (AWS SAM)](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-specification.html).
**nota**  
Para usar um AWS SAM modelo, primeiro você deve empacotar seu AWS SAM aplicativo usando a `[sam package](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-package.html)` operação. Para ver um tutorial que mostra como fazer esse empacotamento automaticamente como parte de um CodeCatalyst fluxo de trabalho da Amazon, consulte[Tutorial: Implantar uma aplicação sem servidor](deploy-tut-lambda.md).

Se a pilha já existir, a ação executará a CloudFormation `[CreateChangeSet](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateChangeSet.html)` operação e, em seguida, a `[ExecuteChangeSet](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_ExecuteChangeSet.html)` operação. A ação espera que as alterações sejam implantadas e se marca como bem-sucedida ou com falha, dependendo dos resultados.

Use a ação **Deploy CloudFormation stack** se você já tiver um AWS SAM modelo CloudFormation ou que contenha recursos que gostaria de implantar, ou se planeja gerar um automaticamente como parte de uma [ação de criação](build-add-action.md) de fluxo de trabalho usando ferramentas como AWS SAM e. [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/latest/guide/home.html)

Não há restrições sobre o modelo que você pode usar, seja o que for que você possa criar CloudFormation ou AWS SAM usar com a ação **Deploy CloudFormation stack**.

**dica**  
Para ver um tutorial que mostra como implantar um aplicativo sem servidor usando a ação **Deploy CloudFormation stack**, consulte. [Tutorial: Implantar uma aplicação sem servidor](deploy-tut-lambda.md)

**Topics**
+ [Imagem de tempo de execução usada pela ação 'Deploy CloudFormation stack'](#deploy-action-cfn-runtime)
+ [Tutorial: Implantar uma aplicação sem servidor](deploy-tut-lambda.md)
+ [Adicionando a ação “Deploy CloudFormation stack”](deploy-action-cfn-adding.md)
+ [Configurar reversões](deploy-consumption-enable-alarms.md)
+ [Variáveis de “ CloudFormation pilha de implantação”](deploy-action-cfn-variables.md)
+ [Ação “Implantar CloudFormation pilha” YAML](deploy-action-ref-cfn.md)

## Imagem de tempo de execução usada pela ação 'Deploy CloudFormation stack'
<a name="deploy-action-cfn-runtime"></a>

A ação **Deploy CloudFormation stack** é 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 sem servidor
<a name="deploy-tut-lambda"></a>

Neste tutorial, você aprende a criar, testar e implantar um aplicativo sem servidor como uma CloudFormation pilha usando um fluxo de trabalho.

A aplicação neste tutorial é uma aplicação web simples que gera uma mensagem “Hello World”. Ele consiste em uma AWS Lambda função e um Amazon API Gateway, e você o cria usando o [AWS Serverless Application Model (AWS SAM)](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html), que é uma extensão do [CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html).

**Topics**
+ [Pré-requisitos](#deploy-tut-lambda-cfn-prereqs)
+ [Etapa 1: criar um repositório de origem](#deploy-tut-lambda-cfn-source)
+ [Etapa 2: criar AWS funções](#deploy-tut-lambda-cfn-roles)
+ [Etapa 3: adicionar AWS funções a CodeCatalyst](#deploy-tut-lambda-cfn-roles-add)
+ [Etapa 4: criar um bucket do Amazon S3](#deploy-tut-lambda-cfn-s3)
+ [Etapa 5: adicionar arquivos de origem](#deploy-tut-lambda-cfn-files)
+ [Etapa 6: criar e executar um fluxo de trabalho](#deploy-tut-lambda-cfn-workflow)
+ [Etapa 7: fazer uma alteração](#deploy-tut-lambda-cfn-change)
+ [Limpeza](#deploy-tut-lambda-cfn-clean-up)

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

Antes de começar
+ Você precisa de um CodeCatalyst **espaço** 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-cfn-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 CodeCatalyst **ambiente** chamado:

  ```
  codecatalyst-cfn-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: criar um repositório de origem
<a name="deploy-tut-lambda-cfn-source"></a>

Nesta etapa, você cria um repositório de origem no CodeCatalyst. Esse repositório é usado para armazenar os arquivos de origem do tutorial, como o arquivo da função do Lambda. 

Para ter mais informações sobre repositórios de origem, consulte [Criar um repositório de origem](source-repositories-create.md).

**Como criar um repositório de origem**

1. Em CodeCatalyst, no painel de navegação, escolha **Código** e, em seguida, escolha **Repositórios de origem**. 

1. Escolha **Adicionar repositório** e selecione **Criar repositório**.

1. Em **Nome do repositório**, insira:

   ```
   codecatalyst-cfn-source-repository
   ```

1. Escolha **Criar**.

Agora você criou um repositório chamado `codecatalyst-cfn-source-repository`.

## Etapa 2: criar AWS funções
<a name="deploy-tut-lambda-cfn-roles"></a>

Nesta etapa, você cria as seguintes funções AWS do IAM:
+ **Função de implantação** — concede permissão à ação CodeCatalyst **Deploy CloudFormation stack** para acessar sua AWS conta e CloudFormation serviço onde você implantará seu aplicativo sem servidor. A ação **Deploy CloudFormation stack** faz parte do seu fluxo de trabalho.
+ **Função de criação** — concede à ação de CodeCatalyst criação permissão para acessar sua AWS conta e gravar no Amazon S3, onde seu pacote de aplicativos sem servidor será armazenado. A ação de criação faz parte do seu fluxo de trabalho.
+ **Função do Stack** — concede CloudFormation permissão para ler e modificar os recursos especificados no AWS SAM modelo que você fornecerá posteriormente. Também concede permissão para CloudWatch.

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 três 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 que podem 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 três perfis listados anteriormente.

**nota**  
Um [perfil de execução do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) também é necessário, mas você não precisa criá-lo agora porque o arquivo `sam-template.yml` o cria quando você executa o fluxo de trabalho na etapa 5.



**Para criar um perfil de implantação**

1. Crie uma política para o perfil da seguinte maneira:

   1. Faça login em AWS.

   1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

   1. No painel de navegação, selecione **Políticas**.

   1. Escolha **Criar política**.

   1. Escolha a guia **JSON**.

   1. Exclua o código existente.

   1. Cole o seguinte código:
**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": "*"
      ```

   1. Escolha **Próximo: tags**.

   1. Selecione **Próximo: revisar**.

   1. Em **Nome**, insira:

      ```
      codecatalyst-deploy-policy
      ```

   1. Selecione **Criar política**.

      Agora você criou uma política de permissões.

1. Crie o perfil de implantação, da seguinte forma:

   1. No painel de navegação, escolha **Perfis** e **Criar perfil**.

   1. Selecione **Política de confiança personalizada**.

   1. Exclua a política de confiança personalizada existente.

   1. Adicione a política de confiança personalizada a seguir:

   1. Escolha **Próximo**.

   1. Em **Políticas de permissões**, procure `codecatalyst-deploy-policy` e marque a caixa de seleção.

   1. Escolha **Próximo**.

   1. Em **Nome do perfil**, insira:

      ```
      codecatalyst-deploy-role
      ```

   1. Em **Descrição do perfil**, insira:

      ```
      CodeCatalyst deploy role
      ```

   1. Selecione **Criar perfil**.

   Agora você criou um perfil de implantação com uma política de confiança e uma política de permissões.

1. Obtenha o ARN do perfil de implantação, da seguinte forma:

   1. No painel de navegação, selecione **Perfis**.

   1. Na caixa de pesquisa, insira o nome do perfil que você acabou de criar (`codecatalyst-deploy-role`).

   1. Escolha o perfil na lista.

      A página **Resumo** do perfil é exibida.

   1. Na parte superior, copie o valor do **ARN**.

   Agora você criou o perfil de implantação com as permissões apropriadas e obteve o ARN.

**Como criar um perfil de criação**

1. Crie uma política para o perfil da seguinte maneira:

   1. Faça login em AWS.

   1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

   1. No painel de navegação, selecione **Políticas**.

   1. Escolha **Criar política**.

   1. Escolha a guia **JSON**.

   1. Exclua o código existente.

   1. Cole o seguinte código:
**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": "*"
      ```

   1. Escolha **Próximo: tags**.

   1. Selecione **Próximo: revisar**.

   1. Em **Nome**, insira:

      ```
      codecatalyst-build-policy
      ```

   1. Selecione **Criar política**.

      Agora você criou uma política de permissões.

1. Crie o perfil de criação, da seguinte forma:

   1. No painel de navegação, escolha **Perfis** e **Criar perfil**.

   1. Selecione **Política de confiança personalizada**.

   1. Exclua a política de confiança personalizada existente.

   1. Adicione a política de confiança personalizada a seguir:

   1. Escolha **Próximo**.

   1. Em **Políticas de permissões**, procure `codecatalyst-build-policy` e marque a caixa de seleção.

   1. Escolha **Próximo**.

   1. Em **Nome do perfil**, insira:

      ```
      codecatalyst-build-role
      ```

   1. Em **Descrição do perfil**, insira:

      ```
      CodeCatalyst build role
      ```

   1. Selecione **Criar perfil**.

   Agora você criou um perfil de criação com uma política de confiança e uma política de permissões.

1. Obtenha o ARN do perfil de criação, da seguinte forma:

   1. No painel de navegação, selecione **Perfis**.

   1. Na caixa de pesquisa, insira o nome do perfil que você acabou de criar (`codecatalyst-build-role`).

   1. Escolha o perfil na lista.

      A página **Resumo** do perfil é exibida.

   1. Na parte superior, copie o valor do **ARN**.

   Agora você criou o perfil de criação com as permissões apropriadas e obteve o ARN.<a name="deploy-tut-lambda-cfn-roles-stack"></a>

**Para criar um perfil de pilha**

1. Faça login AWS usando a conta na qual você deseja implantar sua pilha.

1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Crie o perfil de pilha, da seguinte forma:

   1. No painel de navegação, selecione **Perfis**.

   1. Escolha **Criar Perfil**.

   1. Selecione **Serviço da AWS **.

   1. Na seção **Caso de uso**, escolha na **CloudFormation**lista suspensa.

   1. Selecione o botão **CloudFormation**de rádio.

   1. Selecione **Avançar** na parte inferior.

   1. Usando a caixa de pesquisa, encontre as políticas de permissões a seguir e marque as respectivas caixas de seleção.
**nota**  
Se você procurar uma política e ela não aparecer, selecione **Limpar filtros** e tente novamente.
      + **CloudWatchFullAccess**
      + **AWS CloudFormationFullAccess**
      + **IAMFullAcesso**
      + **AWS Lambda\$1 FullAccess**
      + **APIGatewayAdministrador da Amazon**
      + **Amazon S3 FullAccess**
      + **AmazonEC2ContainerRegistryFullAccess**

      A primeira política permite o acesso para CloudWatch habilitar reversões de pilha quando ocorre um alarme.

      As políticas restantes permitem AWS SAM acessar os serviços e recursos na pilha que serão implantados neste tutorial. Para ter mais informações, consulte [Permissões](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-permissions.html) no *Guia do desenvolvedor do AWS Serverless Application Model *.

   1. Escolha **Próximo**.

   1. Em **Nome do perfil**, insira:

      ```
      codecatalyst-stack-role
      ```

   1. Selecione **Criar perfil**.

1. Obtenha o ARN do perfil de pilha, da seguinte forma:

   1. No painel de navegação, selecione **Perfis**.

   1. Na caixa de pesquisa, insira o nome do perfil que você acabou de criar (`codecatalyst-stack-role`).

   1. Escolha o perfil na lista.

   1. Na seção **Resumo**, copie o valor de **ARN**. Você precisará disso mais tarde.

   Agora você criou o perfil de pilha com as permissões apropriadas e obteve o ARN.

## Etapa 3: adicionar AWS funções a CodeCatalyst
<a name="deploy-tut-lambda-cfn-roles-add"></a>

Nesta etapa, você adiciona a função de criação (`codecatalyst-build-role`) e a função de implantação (`codecatalyst-deploy-role`) à conexão da CodeCatalyst conta em seu espaço.

**nota**  
Não é necessário adicionar o perfil de pilha (`codecatalyst-stack-role`) à conexão. Isso ocorre porque a função de pilha é usada por *CloudFormation*(não CodeCatalyst), *depois* que uma conexão já foi estabelecida entre CodeCatalyst e AWS usando a função de implantação. Como a função de pilha não é usada por CodeCatalyst para obter acesso AWS, ela não precisa ser associada a uma conexão de conta.

**Para adicionar perfis de criação e implantação à conexão da sua conta**

1. Dentro CodeCatalyst, navegue até seu espaço.

1. Selecione **Contas da AWS **. Uma lista de conexões de conta é exibida.

1. Escolha a conexão de conta que representa a AWS conta em que você criou suas funções de criação e implantaçã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 todos os 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, selecione `codecatalyst-build-role` e **Adicionar perfil**.

1. Escolha **Adicionar perfil do IAM**, selecione **Adicionar um perfil existente que você criou no IAM** e, na lista suspensa, escolha `codecatalyst-deploy-role`. Escolha **Add role (adicionar função)**.

   Agora você adicionou os perfis de criação e implantação ao seu espaço.

1. Copie o valor do **nome de CodeCatalyst exibição da Amazon**. Esse valor será necessário posteriormente, ao criar seu fluxo de trabalho.

## Etapa 4: criar um bucket do Amazon S3
<a name="deploy-tut-lambda-cfn-s3"></a>

Nesta etapa, você cria um bucket do Amazon S3 no qual armazena o arquivo .zip do pacote de implantação da aplicação sem servidor.

**Como criar um bucket do Amazon S3**

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

1. No painel principal, selecione **Criar bucket**.

1. Em **Nome do bucket**, insira:

   ```
   codecatalyst-cfn-s3-bucket
   ```

1. Na **região da AWS **, escolha uma região. Este tutorial pressupõe que você tenha escolhido o **Oeste dos EUA (Oregon) us-west-2**. Para ter informações sobre regiões com suporte do Amazon S3, consulte [Endpoints e cotas do Amazon Simple Storage Service](https://docs.aws.amazon.com/general/latest/gr/s3.html) na *Referência geral da AWS*.

1. Selecione **Criar bucket** na parte inferior da página.

Agora você criou um bucket chamado **codecatalyst-cfn-s3-bucket** na região Oeste dos EUA (Oregon), us-west-2.

## Etapa 5: adicionar arquivos de origem
<a name="deploy-tut-lambda-cfn-files"></a>

Nesta etapa, você adiciona vários arquivos de origem do aplicativo ao seu repositório CodeCatalyst de origem. A pasta `hello-world` contém os arquivos da aplicação que você implantará. A pasta `tests` contém testes de unidade. A estrutura de pastas é esta:

```
.
|— hello-world
|  |— tests
|     |— unit
|        |— test-handler.js
|  |— app.js
|— .npmignore
|— package.json
|— sam-template.yml
|— setup-sam.sh
```

### Arquivo .npmignore
<a name="deploy-tut-lambda-cfn-files-npmignore"></a>

O arquivo `.npmignore` indica quais arquivos e pastas o npm deve excluir do pacote da aplicação. Neste tutorial, o npm exclui a pasta `tests` porque ela não faz parte da aplicação.

**Como adicionar o arquivo .npmignore**

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

1. Selecione o projeto, `codecatalyst-cfn-project`

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

1. Na lista de repositórios de origem, escolha o seu repositório, `codecatalyst-cfn-source-repository`. 

1. Em **Arquivos**, selecione **Criar arquivo**.

1. Em **Nome do arquivo**, insira:

   ```
   .npmignore
   ```

1. Na caixa de texto, insira o código a seguir:

   ```
   tests/*
   ```

1. Selecione **Confirmar** e, depois, escolha **Confirmar** novamente.

   Agora você criou um arquivo chamado `.npmignore` na raiz do repositório.

### Arquivo package.json
<a name="deploy-tut-lambda-cfn-files-package-json"></a>

O arquivo `package.json` contém metadados importantes sobre seu projeto Node, como nome do projeto, número da versão, descrição, dependências e outros detalhes que descrevem como interagir e executar a aplicação.

O `package.json` neste tutorial inclui uma lista de dependências e um script `test`. O script de teste faz o seguinte:
+ Usando [mocha](https://mochajs.org/), o script de teste executa os testes de unidade especificados em `hello-world/tests/unit/` e grava os resultados em um arquivo `junit.xml` usando o repórter [xunit]().
+ Usando [Istambul (nyc)](https://istanbul.js.org/), o script de teste gera um relatório de cobertura de código (`clover.xml`) usando o repórter [clover](https://openclover.org/doc/manual/4.2.0/general--about-openclover.html). Para ter mais informações, consulte [Uso de repórteres alternativos](https://istanbul.js.org/docs/advanced/alternative-reporters/#clover) na documentação do Istambul.

**Como adicionar o arquivo package.json**

1. No repositório, em **Arquivos**, selecione **Criar arquivo**.

1. Em **Nome do arquivo**, insira:

   ```
   package.json
   ```

1. Na caixa de texto, insira o código a seguir:

   ```
   {
     "name": "hello_world",
     "version": "1.0.0",
     "description": "hello world sample for NodeJS",
     "main": "app.js",
     "repository": "https://github.com/awslabs/aws-sam-cli/tree/develop/samcli/local/init/templates/cookiecutter-aws-sam-hello-nodejs",
     "author": "SAM CLI",
     "license": "MIT",
     "dependencies": {
       "axios": "^0.21.1",
       "nyc": "^15.1.0"
     },
     "scripts": {
       "test": "nyc --reporter=clover mocha hello-world/tests/unit/ --reporter xunit --reporter-option output=junit.xml"
     },
     "devDependencies": {
       "aws-sdk": "^2.815.0",
       "chai": "^4.2.0",
       "mocha": "^8.2.1"
     }
   }
   ```

1. Selecione **Confirmar** e, depois, escolha **Confirmar** novamente.

   Agora você adicionou um arquivo chamado `package.json` à raiz do repositório.

### Arquivo sam-template.yml
<a name="deploy-tut-lambda-cfn-files-sam-template-yml"></a>

O arquivo `sam-template.yml` contém as instruções para implantar a função do Lambda e o gateway de API e configurá-los juntos. Ele segue a [especificação do AWS Serverless Application Model modelo](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-specification.html), que estende a especificação do CloudFormation modelo.

Você usa um AWS SAM modelo neste tutorial em vez de um CloudFormation modelo normal porque AWS SAM oferece um tipo de recurso útil [AWS: :Serverless: :Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html). Esse tipo executa muitas behind-the-scenes configurações que você normalmente precisa escrever para usar a CloudFormation sintaxe básica. Por exemplo, o `AWS::Serverless::Function` cria uma função do Lambda, uma função de execução do Lambda e mapeamentos da origem do evento que iniciam a função. Você precisa codificar tudo isso se quiser escrevê-lo usando o básico CloudFormation.

Embora este tutorial use um modelo pré-escrito, você pode gerar um como parte do seu fluxo de trabalho usando uma ação de criação. Para obter mais informações, consulte [Implantação de uma pilha CloudFormation](deploy-action-cfn.md).

**Para adicionar o arquivo sam-template.yml**

1. No repositório, em **Arquivos**, selecione **Criar arquivo**.

1. Em **Nome do arquivo**, insira:

   ```
   sam-template.yml
   ```

1. Na caixa de texto, insira o código a seguir:

   ```
   AWSTemplateFormatVersion: '2010-09-09'
   Transform: AWS::Serverless-2016-10-31
   Description: >
     serverless-api
   
     Sample SAM Template for serverless-api
     
   # More info about Globals: https://github.com/awslabs/serverless-application-model/blob/master/docs/globals.rst
   Globals:
     Function:
       Timeout: 3
   
   Resources:
     HelloWorldFunction:
       Type: AWS::Serverless::Function # For details on this resource type, see https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#awsserverlessfunction
       Properties:
         CodeUri: hello-world/
         Handler: app.lambdaHandler
         Runtime: nodejs12.x
         Events:
           HelloWorld:
             Type: Api # For details on this event source type, see https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#api
             Properties:
               Path: /hello
               Method: get
   
   Outputs:
     # ServerlessRestApi is an implicit API created out of the events key under Serverless::Function
     # Find out about other implicit resources you can reference within AWS SAM at
     # https://github.com/awslabs/serverless-application-model/blob/master/docs/internals/generated_resources.rst#api
     HelloWorldApi:
       Description: "API Gateway endpoint URL for the Hello World function"
       Value: !Sub "https://${ServerlessRestApi}.execute-api.${AWS::Region}.amazonaws.com/Prod/hello/"
     HelloWorldFunction:
       Description: "Hello World Lambda function ARN"
       Value: !GetAtt HelloWorldFunction.Arn
     HelloWorldFunctionIamRole:
       Description: "Implicit Lambda execution role created for the Hello World function"
       Value: !GetAtt HelloWorldFunctionRole.Arn
   ```

1. Selecione **Confirmar** e, depois, escolha **Confirmar** novamente.

   Agora você adicionou um arquivo chamado `sam-template.yml` à pasta raiz do repositório.

### Arquivo setup-sam.sh
<a name="deploy-tut-lambda-cfn-files-setup-sam"></a>

O `setup-sam.sh` arquivo contém as instruções para baixar e instalar o utilitário AWS SAM CLI. O fluxo de trabalho usa esse utilitário para empacotar a origem de `hello-world`.

**Para adicionar o arquivo setup-sam.sh**

1. No repositório, em **Arquivos**, selecione **Criar arquivo**.

1. Em **Nome do arquivo**, insira:

   ```
   setup-sam.sh
   ```

1. Na caixa de texto, insira o código a seguir:

   ```
   #!/usr/bin/env bash
   echo "Setting up sam"
   
   yum install unzip -y
   
   curl -LO https://github.com/aws/aws-sam-cli/releases/latest/download/aws-sam-cli-linux-x86_64.zip
   unzip -qq aws-sam-cli-linux-x86_64.zip -d sam-installation-directory
   
   ./sam-installation-directory/install; export AWS_DEFAULT_REGION=us-west-2
   ```

   No código anterior, *us-west-2* substitua por sua AWS região.

1. Selecione **Confirmar** e, depois, escolha **Confirmar** novamente.

   Agora você adicionou um arquivo chamado `setup-sam.sh` à raiz do repositório.

### Arquivo app.js
<a name="deploy-tut-lambda-cfn-files-app-js"></a>

O `app.js` contém o código da função do Lambda. Neste tutorial, o código retorna o texto `hello world`.

**Para adicionar o arquivo app.js**

1. No repositório, em **Arquivos**, selecione **Criar arquivo**.

1. Em **Nome do arquivo**, insira:

   ```
   hello-world/app.js
   ```

1. Na caixa de texto, insira o código a seguir:

   ```
   // const axios = require('axios')
   // const url = 'http://checkip.amazonaws.com/';
   let response;
   
   /**
    *
    * Event doc: https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html#api-gateway-simple-proxy-for-lambda-input-format
    * @param {Object} event - API Gateway Lambda Proxy Input Format
    *
    * Context doc: https://docs.aws.amazon.com/lambda/latest/dg/nodejs-prog-model-context.html 
    * @param {Object} context
    *
    * Return doc: https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html
    * @returns {Object} object - API Gateway Lambda Proxy Output Format
    * 
    */
   exports.lambdaHandler = async (event, context) => {
       try {
           // const ret = await axios(url);
           response = {
               'statusCode': 200,
               'body': JSON.stringify({
                   message: 'hello world',
                   // location: ret.data.trim()
               })
           }
       } catch (err) {
           console.log(err);
           return err;
       }
   
       return response
   };
   ```

1. Selecione **Confirmar** e, depois, escolha **Confirmar** novamente.

   Agora você criou uma pasta chamada `hello-world` e um arquivo chamado `app.js`.

### Arquivo test-handler.js
<a name="deploy-tut-lambda-cfn-files-test-handler-js"></a>

O arquivo `test-handler.js` contém testes de unidade para a função do Lambda.

**Para adicionar o arquivo test-handler.js**

1. No repositório, em **Arquivos**, selecione **Criar arquivo**.

1. Em **Nome do arquivo**, insira:

   ```
   hello-world/tests/unit/test-handler.js
   ```

1. Na caixa de texto, insira o código a seguir:

   ```
   'use strict';
   
   const app = require('../../app.js');
   const chai = require('chai');
   const expect = chai.expect;
   var event, context;
   
   describe('Tests index', function () {
       it('verifies successful response', async () => {
           const result = await app.lambdaHandler(event, context)
   
           expect(result).to.be.an('object');
           expect(result.statusCode).to.equal(200);
           expect(result.body).to.be.an('string');
   
           let response = JSON.parse(result.body);
   
           expect(response).to.be.an('object');
           expect(response.message).to.be.equal("hello world");
           // expect(response.location).to.be.an("string");
       });
   });
   ```

1. Selecione **Confirmar** e, depois, escolha **Confirmar** novamente.

   Agora você adicionou um arquivo chamado `test-handler.js` abaixo da pasta `hello-world/tests/unit`.

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:

```
.
|— hello-world
|  |— tests
|     |— unit
|        |— test-handler.js
|  |— app.js
|— .npmignore
|— README.md
|— package.json
|— sam-template.yml
|— setup-sam.sh
```

## Etapa 6: criar e executar um fluxo de trabalho
<a name="deploy-tut-lambda-cfn-workflow"></a>

Nesta etapa, você cria um fluxo de trabalho que empacota o código-fonte do Lambda e o implanta. 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 teste (`Test`) — No gatilho, essa ação instala o [gerenciador de pacotes Node (npm)](https://www.npmjs.com/) e, depois, executa o comando `npm run test`. Esse comando diz ao npm para executar o script `test` definido no arquivo `package.json`. O script `test`, por sua vez, executa os testes de unidade e gera dois relatórios: um relatório de teste (`junit.xml`) e um relatório de cobertura de código (`clover.xml`). Para obter mais informações, consulte [Arquivo package.json](#deploy-tut-lambda-cfn-files-package-json).

  Em seguida, a ação de teste transforma os relatórios XML em CodeCatalyst relatórios e os exibe no CodeCatalyst console, na guia **Relatórios** da ação de teste.

  Para ter mais informações sobre a ação de teste, consulte [Teste com fluxos de trabalhoTeste com fluxos de trabalho](test-workflow-actions.md).
+ Uma ação de construção (`BuildBackend`) — Ao concluir a ação de teste, a ação de compilação baixa e instala a AWS SAM CLI, empacota `hello-world` a fonte e copia o pacote em seu bucket do Amazon S3, onde o serviço Lambda espera que esteja. A ação também gera um novo arquivo de AWS SAM modelo chamado `sam-template-packaged.yml` e o coloca em um artefato de saída chamado. `buildArtifact`

  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 (`DeployCloudFormationStack`) — 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 construção (`buildArtifact`), encontra o AWS SAM modelo dentro dela e, em seguida, executa o modelo. O AWS SAM modelo cria uma pilha que implanta o aplicativo sem servidor.

**Como criar um fluxo de trabalho**

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-cfn-source-repository`.

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

1. Escolha **Criar**.

1. Exclua o código de amostra YAML.

1. Adicione o seguinte código YAML:
**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 2: criar AWS funções](#deploy-tut-lambda-cfn-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-cfn-workflow
   SchemaVersion: 1.0
   
   Triggers:
     - Type: PUSH
       Branches:
         - main   
   Actions:
     Test:
       Identifier: aws/managed-test@v1
       Inputs:
         Sources:
           - WorkflowSource
       Outputs:
         Reports:
           CoverageReport:
             Format: CLOVERXML
             IncludePaths:
               - "coverage/*"
           TestReport:
             Format: JUNITXML
             IncludePaths:
               - junit.xml
       Configuration:
         Steps:
           - Run: npm install
           - Run: npm run test  
     BuildBackend:
       Identifier: aws/build@v1
       DependsOn:
         - Test
       Environment:
         Name: codecatalyst-cfn-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-build-role
       Inputs:
         Sources:
           - WorkflowSource
       Configuration: 
         Steps:
           - Run: . ./setup-sam.sh
           - Run: sam package --template-file sam-template.yml --s3-bucket codecatalyst-cfn-s3-bucket --output-template-file sam-template-packaged.yml --region us-west-2
       Outputs:
         Artifacts:
           - Name: buildArtifact
             Files:
               - "**/*"
     DeployCloudFormationStack:
       Identifier: aws/cfn-deploy@v1
       DependsOn: 
         - BuildBackend
       Environment:
         Name: codecatalyst-cfn-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-deploy-role
       Inputs:
         Artifacts:
           - buildArtifact
         Sources: []
       Configuration:
         name: codecatalyst-cfn-stack
         region: us-west-2
         role-arn: arn:aws:iam::111122223333:role/StackRole
         template: ./sam-template-packaged.yml
         capabilities: CAPABILITY_IAM,CAPABILITY_AUTO_EXPAND
   ```

   No código anterior, substitua:
   + Ambas as instâncias de *codecatalyst-cfn-environment* com o nome do seu ambiente.
   + 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 3: adicionar AWS funções a CodeCatalyst](#deploy-tut-lambda-cfn-roles-add).
   + *codecatalyst-build-role* pelo nome do perfil de criação criado em [Etapa 2: criar AWS funções](#deploy-tut-lambda-cfn-roles).
   + *codecatalyst-cfn-s3-bucket*com o nome do bucket do Amazon S3 em que você criou. [Etapa 4: criar um bucket do Amazon S3](#deploy-tut-lambda-cfn-s3)
   + Ambas as instâncias são *us-west-2* com a região em que seu bucket do Amazon S3 reside (primeira instância) e onde sua pilha será implantada (segunda instância). Essas regiões podem ser diferentes. Este tutorial pressupõe que as duas regiões estejam definidas como `us-west-2`. Para obter detalhes sobre regiões suportadas pelo Amazon S3 CloudFormation, consulte [Pontos de extremidade e cotas de serviço](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) no. *Referência geral da AWS*
   + *codecatalyst-deploy-role* pelo nome do perfil de implantação criado em [Etapa 2: criar AWS funções](#deploy-tut-lambda-cfn-roles).
   + *codecatalyst-cfn-environment*com o nome do ambiente em que você criou[Pré-requisitos](#deploy-tut-lambda-cfn-prereqs).
   + *arn:aws:iam::111122223333:role/StackRole*com o Amazon Resource Name (ARN) da função de pilha que você criou. [Etapa 2: criar AWS funções](#deploy-tut-lambda-cfn-roles)
**nota**  
Se você decidiu não criar, implantar e empilhar funções *codecatalyst-build-role**codecatalyst-deploy-role*, substitua e *arn:aws:iam::111122223333:role/StackRole* pelo nome ou ARN da `CodeCatalystWorkflowDevelopmentRole-spaceName` função. Para obter mais informações sobre essa função, consulte [Etapa 2: criar AWS funções](#deploy-tut-lambda-cfn-roles).

   Para ter informações sobre as propriedades no código mostrado anteriormente, consulte a [Ação “Implantar CloudFormation pilha” YAML](deploy-action-ref-cfn.md).

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 **Nome do arquivo do fluxo de trabalho**, mantenha o padrão, `codecatalyst-cfn-workflow`.

   1. Em **Confirmar mensagem**, insira:

      ```
      add initial workflow file
      ```

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

   1. Em **Nome da ramificação**, selecione **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 `codecatalyst-cfn-workflow.yaml` ao repositório de origem, o gatilho iniciou a execução do fluxo de trabalho.

**Para visualizar a execução do fluxo de trabalho em andamento**

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

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

1. Escolha a guia **Execuções**.

1. Na coluna **ID da execução**, escolha o ID da execução.

1. Selecione **Teste** para ver o andamento dos testes.

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

1. Escolha **DeployCloudFormationStack**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).

1. Quando a **DeployCloudFormationStack**ação terminar, faça o seguinte:
   + Se a execução do fluxo de trabalho for bem-sucedida, vá para o próximo procedimento.
   + Se a execução do fluxo de trabalho falhar no **teste** ou na **BuildBackend**ação, escolha **Logs** para solucionar o problema.
   + Se a execução do fluxo de trabalho falhar na **DeployCloudFormationStack**ação, escolha a ação de implantação e, em seguida, escolha a guia **Resumo**. Role até a seção de **CloudFormation eventos** para ver a mensagem de erro detalhada. Se ocorrer uma reversão, exclua a `codecatalyst-cfn-stack` pilha por meio do CloudFormation console AWS antes de executar novamente o fluxo de trabalho.

**Como verificar a implantação**

1. Depois de uma implantação bem-sucedida, selecione **Variáveis (7)** na barra de menu horizontal próxima à parte superior. (Não selecione **Variáveis** no painel à direita.)

1. Em seguida **HelloWorldApi**, cole o `https://` URL em um navegador.

   Uma mensagem JSON **hello world** da função do Lambda é exibida, indicando que o fluxo de trabalho implantou e configurou a função do Lambda e o gateway de API.
**dica**  
Você pode CodeCatalyst exibir esse URL no diagrama do fluxo de trabalho com algumas configurações pequenas. Para obter mais informações, consulte [Exibir o URL da aplicação no diagrama do fluxo de trabalho](deploy-app-url.md).

**Para verificar os resultados do teste de unidade e a cobertura do código**

1. No diagrama do fluxo de trabalho, selecione **Teste** e, depois, escolha **Relatórios**.

1. Escolha **TestReport**visualizar os resultados do teste de unidade ou opte por **CoverageReport**visualizar os detalhes da cobertura de código dos arquivos que estão sendo testados, neste caso `app.js` `test-handler.js` e.

**Para verificar os recursos implantados**

1. Faça login no Console de gerenciamento da AWS e abra o console do API Gateway em [https://console.aws.amazon.com/apigateway/](https://console.aws.amazon.com/apigateway/). 

1. Observe a **codecatalyst-cfn-stack**API que o AWS SAM modelo criou. O nome da API vem do valor `Configuration/name` no arquivo de definição do fluxo de trabalho (`codecatalyst-cfn-workflow.yaml`).

1. Abra o AWS Lambda console em [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).

1. Selecione **Funções** no painel de navegação.

1. Selecione a função do Lambda, `codecatalyst-cfn-stack-HelloWorldFunction-string`.

1. Você pode ver como o gateway de API é um gatilho para a função. Essa integração foi configurada automaticamente pelo tipo AWS SAM `AWS::Serverless::Function` de recurso.

## Etapa 7: fazer uma alteração
<a name="deploy-tut-lambda-cfn-change"></a>

Nesta etapa, você faz uma alteração no código-fonte do Lambda e o confirma. Essa confirmação inicia a execução de um novo fluxo de trabalho. Essa execução implanta a nova função do Lambda em um esquema azul esverdeado que usa a configuração padrão de mudança de tráfego especificada no console do Lambda.

**Para fazer uma alteração na origem do Lambda**

1. Em CodeCatalyst, navegue até seu projeto.

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

1. Escolha seu repositório de origem `codecatalyst-cfn-source-repository`.

1. Altere o arquivo da aplicação:

   1. Escolha a pasta `hello-world`.

   1. Escolha o arquivo `app.js`.

   1. Escolha **Editar**.

   1. Na linha 23, altere `hello world` para **Tutorial complete\$1**.

   1. Selecione **Confirmar** e, depois, escolha **Confirmar** novamente.

      A confirmação faz com que uma execução do fluxo de trabalho seja iniciada. Essa execução falhará porque você não atualizou os testes de unidade para refletir a alteração do nome.

1. Atualize os testes de unidade:

   1. Selecione `hello-world\tests\unit\test-handler.js`.

   1. Escolha **Editar**.

   1. Na linha 19, altere `hello world` para **Tutorial complete\$1**.

   1. Selecione **Confirmar** e, depois, escolha **Confirmar** novamente.

      A confirmação faz com que outra execução do fluxo de trabalho seja iniciada. Essa execução será bem-sucedida.

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

1. Selecione `codecatalyst-cfn-workflow` e **Execuções**.

1. Escolha o ID da última execução. O status ainda deve ser em andamento.

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

1. Quando o fluxo de trabalho terminar, selecione **Variáveis (7)** na parte superior.

1. Em seguida **HelloWorldApi**, cole o `https://` URL em um navegador.

   Uma mensagem `Tutorial complete!` aparece no navegador, indicando que a nova aplicação foi implantada.

## Limpeza
<a name="deploy-tut-lambda-cfn-clean-up"></a>

Limpe os arquivos e serviços usados neste tutorial para evitar cobranças por eles.

**Para limpar no CodeCatalyst console**

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

1. Exclua `codecatalyst-cfn-workflow`.

1. Exclua `codecatalyst-cfn-environment`.

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

1. Exclua `codecatalyst-cfn-project`.

**Para limpar no Console de gerenciamento da AWS**

1. Limpe da CloudFormation seguinte forma:

   1. Abra o CloudFormation console em [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).

   1. Exclua o `codecatalyst-cfn-stack`.

      A exclusão da pilha remove todos os recursos do tutorial dos serviços do gateway de API e Lambda.

1. Limpe no Amazon S3, da seguinte forma:

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

   1. Selecione a `codecatalyst-cfn-s3-bucket`.

   1. Exclua os conteúdos do bucket.

   1. Exclua o bucket.

1. Limpe no IAM, da seguinte forma:

   1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

   1. Exclua o `codecatalyst-deploy-policy`.

   1. Exclua o `codecatalyst-build-policy`.

   1. Exclua o `codecatalyst-stack-policy`.

   1. Exclua o `codecatalyst-deploy-role`.

   1. Exclua o `codecatalyst-build-role`.

   1. Exclua o `codecatalyst-stack-role`.

Neste tutorial, você aprendeu a implantar um aplicativo sem servidor como uma CloudFormation pilha usando um CodeCatalyst fluxo de trabalho e uma ação **Deploy CloudFormation ** stack.

# Adicionando a ação “Deploy CloudFormation stack”
<a name="deploy-action-cfn-adding"></a>

Use as instruções a seguir para adicionar a ação **Deploy CloudFormation stack** ao seu fluxo de trabalho. 

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

**Para adicionar a ação “Implantar CloudFormation pilha” 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. Pesquise a ação **Deploy CloudFormation stack** 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
   + Escolha **Deploy CloudFormation stack**. 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 [Ação “Implantar CloudFormation pilha” YAML](deploy-action-ref-cfn.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 CloudFormation pilha” 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. Pesquise a ação **Deploy CloudFormation stack** 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
   + Escolha **Deploy CloudFormation stack**. 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 [Ação “Implantar CloudFormation pilha” YAML](deploy-action-ref-cfn.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.

------

# Configurar reversões
<a name="deploy-consumption-enable-alarms"></a>

Por padrão, se a ação **Implantar CloudFormation pilha** falhar, ela fará CloudFormation com que a pilha volte para o último estado estável conhecido. Você pode alterar o comportamento para que as reversões ocorram não apenas quando a ação falhar, mas também quando ocorrer um CloudWatch alarme específico da Amazon. Para obter mais informações sobre CloudWatch alarmes, consulte [Usando CloudWatch alarmes da Amazon no Guia CloudWatch ](https://docs.aws.amazon.com/) *do usuário da Amazon*.

Você também pode alterar o comportamento padrão para que CloudFormation não reverta a pilha quando a ação falhar. 

Use as instruções a seguir para configurar reversões.

**nota**  
Você não pode iniciar uma reversão manualmente.

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

**Antes de começar**

1. Certifique-se de ter um [fluxo de trabalho](workflow.md) que inclua uma ação funcional do **Deploy CloudFormation stack**. Para obter mais informações, consulte [Implantação de uma pilha CloudFormation](deploy-action-cfn.md).

1. Na função especificada no campo **opcional Função da pilha -** da ação **Implantar CloudFormation pilha**, certifique-se de incluir a **CloudWatchFullAccess**permissão. Para ter informações sobre como criar esse perfil com as permissões apropriadas, consulte [Etapa 2: criar AWS funções](deploy-tut-lambda.md#deploy-tut-lambda-cfn-roles).

**Para configurar alarmes de reversão para a ação “Implantar pilha” CloudFormation**

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. Escolha sua ação **Deploy CloudFormation stack**.

1. No painel de detalhes, selecione **Configuração**.

1. Na parte inferior, expanda **Avançado**.

1. Em **Monitorar alarme ARNs**, escolha **Adicionar alarme**.

1. Insira informações nos seguintes campos.
   + **ARN do alarme**

     Especifique o Amazon Resource Name (ARN) de um CloudWatch alarme da Amazon para usar como gatilho de reversão. Por exemplo, .`arn:aws:cloudwatch::123456789012:alarm/MyAlarm` Você pode ter no máximo cinco gatilhos de reversão.
**nota**  
Se você especificar um ARN de CloudWatch alarme, também precisará configurar permissões adicionais para permitir o acesso à ação. CloudWatch Para obter mais informações, consulte [Configurar reversões](#deploy-consumption-enable-alarms).
   + **Tempo de monitoramento**

     Especifique um período de tempo, de 0 a 180 minutos, durante o qual CloudFormation monitora os alarmes especificados. O monitoramento começa *após* a implantação de todos os recursos da pilha. Se o alarme ocorrer dentro do tempo de monitoramento especificado, a implantação falhará e CloudFormation reverterá toda a operação da pilha.

     Padrão: 0. CloudFormation monitora apenas os alarmes enquanto os recursos da pilha estão sendo implantados, não depois.

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

**Para configurar acionadores de reversão para a ação “Implantar pilha” CloudFormation**

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. Escolha o nome de um fluxo de trabalho que inclua a ação **Implantar pilha do CloudFormation **. É 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. Adicione as propriedades `monitor-alarm-arns` e `monitor-timeout-in-minutes` no código YAML para adicionar gatilhos de reversão. Para ver uma explicação de cada propriedade, consulte [Ação “Implantar CloudFormation pilha” YAML](deploy-action-ref-cfn.md).

1. Na função especificada na `role-arn` propriedade da ação **Deploy CloudFormation stack**, certifique-se de incluir a **CloudWatchFullAccess**permissão. Para ter informações sobre como criar esse perfil com as permissões apropriadas, consulte [Etapa 2: criar AWS funções](deploy-tut-lambda.md#deploy-tut-lambda-cfn-roles).

------

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

**Para desativar as reversões da ação “Implantar pilha” CloudFormation**

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. Escolha o nome de um fluxo de trabalho que inclua a ação **Implantar pilha do CloudFormation **. É 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. Escolha sua ação **Deploy CloudFormation stack**.

1. No painel de detalhes, selecione **Configuração**.

1. Na parte inferior, expanda **Avançado**.

1. Ative a opção **Desabilitar reversão**.

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

**Para desativar as reversões da ação “Implantar pilha” CloudFormation**

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. Escolha o nome de um fluxo de trabalho que inclua a ação **Implantar pilha do CloudFormation **. É 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. Adicione a propriedade `disable-rollback: 1` no código YAML para interromper as reversões. Para ver uma explicação dessa propriedade, consulte [Ação “Implantar CloudFormation pilha” YAML](deploy-action-ref-cfn.md).

------

# Variáveis de “ CloudFormation pilha de implantação”
<a name="deploy-action-cfn-variables"></a>

A ação **Deploy CloudFormation stack** produz e define as seguintes variáveis em tempo de execução. 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 | 
| --- | --- | 
|  deployment-platform  |  O nome da plataforma de implantação. Codificado para `AWS:CloudFormation`.  | 
|  region  |  O código da região em Região da AWS que foi implantado durante a execução do fluxo de trabalho. Exemplo: `us-west-2`  | 
|  stack-id  |  O nome do recurso da Amazon (ARN) da pilha implantada. Exemplo: `arn:aws:cloudformation:us-west-2:111122223333:stack/codecatalyst-cfn-stack/6aad4380-100a-11ec-a10a-03b8a84d40df`  | 

# Ação “Implantar CloudFormation pilha” YAML
<a name="deploy-action-ref-cfn"></a>

A seguir está a definição YAML da ação **Deploy CloudFormation stack**. Para saber como usar essa ação, consulte [Implantação de uma pilha CloudFormation](deploy-action-cfn.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.    
  DeployCloudFormationStack:  
    Identifier: aws/cfn-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: DeployRole
    Inputs:
      Sources:
        - source-name-1
      Artifacts:
        - CloudFormation-artifact
    Configuration:
      name: stack-name
      region: us-west-2
      template: template-path
      role-arn: arn:aws:iam::123456789012:role/StackRole        
      capabilities: CAPABILITY_IAM,CAPABILITY_NAMED_IAM,CAPABILITY_AUTO_EXPAND
      parameter-overrides: KeyOne=ValueOne,KeyTwo=ValueTwo | path-to-JSON-file
      no-execute-changeset: 1|0
      fail-on-empty-changeset: 1|0
      disable-rollback: 1|0
      termination-protection: 1|0
      timeout-in-minutes: minutes
      notification-arns: arn:aws:sns:us-east-1:123456789012:MyTopic,arn:aws:sns:us-east-1:123456789012:MyOtherTopic
      monitor-alarm-arns: arn:aws:cloudwatch::123456789012:alarm/MyAlarm,arn:aws:cloudwatch::123456789012:alarm/MyOtherAlarm
      monitor-timeout-in-minutes: minutes       
      tags: '[{"Key":"MyKey1","Value":"MyValue1"},{"Key":"MyKey2","Value":"MyValue2"}]'
```

## DeployCloudFormationStack
<a name="deploy.action.cfn.deploycloudformationstack"></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: `DeployCloudFormationStack_nn`.

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

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

(*DeployCloudFormationStack*/**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/cfn-deploy@v1`.

Interface de usuário correspondente: rótulo do diagrama de fluxo de trabalho/DeployCloudFormationStack\$1nn/**aws/cfn-deploy@v1**

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

(*DeployCloudFormationStack*/**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.cfn.computename"></a>

(*DeployCloudFormationStack*/**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.cfn.computetype"></a>

(*DeployCloudFormationStack*/Compute/**Type**)

(Obrigatório se [Compute](#deploy.action.cfn.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.cfn.computefleet"></a>

(*DeployCloudFormationStack*/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.cfn.timeout"></a>

(*DeployCloudFormationStack*/**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 em minutos - opcional**

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

(*DeployCloudFormationStack*/**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.cfn.environment.name"></a>

(*DeployCloudFormationStack*/Environment/**Name**)

(Obrigatório se [Environment](#deploy.action.cfn.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.cfn.environment.connections"></a>

(*DeployCloudFormationStack*/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.cfn.environment.connections.name"></a>

(*DeployCloudFormationStack*/Environment/Connections/**Name**)

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

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.cfn.environment.connections.role"></a>

(*DeployCloudFormationStack*/Environment/Connections/**Role**)

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

Especifique o nome da função do IAM que a ação **Deploy CloudFormation stack** usa para acessar AWS e o CloudFormation serviço. 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.
**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:

**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.cfn.inputs"></a>

(*DeployCloudFormationStack*/**Inputs**)

(Optional)

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

**nota**  
São permitidas no máximo quatro entradas (uma fonte e três artefatos) por ação de **implantação da CloudFormation pilha**.

Se você precisar consultar arquivos que residem em entradas diferentes (digamos, uma origem e um artefato), a entrada de origem será a entrada primária e o artefato será a entrada secundária. As referências a arquivos em entradas secundárias usam um prefixo especial para diferirem das primárias. Para obter detalhes, consulte [Exemplo: referência de arquivos em vários artefatos](workflows-working-artifacts-ex.md#workflows-working-artifacts-ex-ref-file).

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

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

(*DeployCloudFormationStack*/Inputs/**Sources**)

(Obrigatório se o seu AWS SAM modelo CloudFormation ou modelo estiver armazenado em um repositório de origem)

Se seu AWS SAM modelo CloudFormation ou modelo estiver armazenado em um repositório de origem, especifique o rótulo desse repositório de origem. Atualmente, o único rótulo compatível é `WorkflowSource`.

Se o seu AWS SAM modelo CloudFormation ou modelo não estiver contido em um repositório de origem, ele deverá residir em um artefato gerado por outra ação ou em um bucket do Amazon S3.

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.cfn.inputs.artifacts"></a>

(*DeployCloudFormationStack*/Inputs/**Artifacts**)

(Obrigatório se seu AWS SAM modelo CloudFormation ou modelo estiver armazenado em um [artefato de saída](workflows-working-artifacts-output.md) de uma ação anterior)

Se o AWS SAM modelo CloudFormation ou que você deseja implantar estiver contido em um artefato gerado por uma ação anterior, especifique esse artefato aqui. Se seu CloudFormation modelo não estiver contido em um artefato, ele deverá residir no seu repositório de origem ou em um bucket do Amazon S3.

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.cfn.configuration"></a>

(*DeployCloudFormationStack*/**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**

## name
<a name="deploy.action.cfn.stackname"></a>

(*DeployCloudFormationStack*/Configuration/**name**)

(Obrigatório)

Especifique um nome para a CloudFormation pilha que a ação **Deploy CloudFormation stack** cria ou atualiza.

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

## region
<a name="deploy.action.cfn.stackregion"></a>

(*DeployCloudFormationStack*/Configuration/**region**)

(Obrigatório)

Especifique o Região da AWS local no qual a pilha será implantada. Para obter uma lista dos códigos das regiões, consulte [Endpoints regionais](https://docs.aws.amazon.com/general/latest/gr/rande.html#region-names-codes).

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

## template
<a name="deploy.action.cfn.templatepath"></a>

(*DeployCloudFormationStack*/Configuration/**template**)

(Obrigatório)

Especifique o nome e o caminho para seu arquivo CloudFormation ou arquivo AWS SAM de modelo. O modelo pode estar no formato JSON ou YAML e pode residir em um repositório de origem, em um artefato de uma ação anterior ou em um bucket do Amazon S3. Se o arquivo de modelo estiver em um repositório ou artefato de origem, o caminho será relativo à origem ou à raiz do artefato. Se o modelo estiver em um bucket do Amazon S3, o caminho será o valor do **URL do objeto** do modelo.

Exemplos:

`./MyFolder/MyTemplate.json`

`MyFolder/MyTemplate.yml`

`https://MyBucket.s3.us-west-2.amazonaws.com/MyTemplate.yml`

**nota**  
Talvez seja necessário adicionar um prefixo ao caminho do arquivo do modelo para indicar em qual artefato ou origem encontrá-lo. Para obter mais informações, consulte [Fazer referência a arquivos do repositório de origem](workflows-sources-reference-files.md) e [Referência de arquivos em um artefato](workflows-working-artifacts-refer-files.md).

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

## role-arn
<a name="deploy.action.cfn.stackrolearn"></a>

(*DeployCloudFormationStack*/Configuration/**role-arn**)

(Obrigatório)

Especifique o Amazon Resource Name (ARN) da função da pilha. CloudFormation usa essa função para acessar e modificar recursos em sua pilha. Por exemplo: `arn:aws:iam::123456789012:role/StackRole`.

O perfil da pilha deve incluir:
+ Uma ou mais políticas de permissões. As políticas dependem dos recursos que você tem na pilha. Por exemplo, se sua pilha inclui uma AWS Lambda função, você precisa adicionar permissões que concedam acesso ao Lambda. Se você seguiu o tutorial descrito em [Tutorial: Implantar uma aplicação sem servidor](deploy-tut-lambda.md), ele inclui um procedimento intitulado [Para criar um perfil de pilha](deploy-tut-lambda.md#deploy-tut-lambda-cfn-roles-stack) que lista as permissões que o perfil de pilha precisa se você estiver implantando uma pilha típica de aplicações sem servidor.
**Atenção**  
Limite as permissões às exigidas pelo CloudFormation serviço para acessar os recursos em sua pilha. Usar um perfil com permissões mais amplas pode representar um risco de segurança.
+ A seguinte política de confiança:

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

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [
          {
              "Sid": "",
              "Effect": "Allow",
              "Principal": {
                  "Service": "cloudformation.amazonaws.com"
              },
              "Action": "sts:AssumeRole"
          }
      ]
  }
  ```

------

Se desejar, associe esse perfil à conexão da sua conta. Para saber mais sobre como associar 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). Se você não associar o perfil da pilha à conexão da conta, ele não aparecerá na lista suspensa **Perfil da pilha** no editor visual. No entanto, o ARN do perfil ainda poderá ser especificado no campo `role-arn` usando o editor YAML.

**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: guia Configuração/**Perfil da pilha - opcional**

## capabilities
<a name="deploy.action.cfn.capabilities"></a>

(*DeployCloudFormationStack*/Configuration/**capabilities**)

(Obrigatório)

Especifique uma lista dos recursos do IAM necessários para permitir CloudFormation a criação de determinadas pilhas. Na maioria dos casos, você pode sair de `capabilities` com o valor padrão de `CAPABILITY_IAM,CAPABILITY_NAMED_IAM,CAPABILITY_AUTO_EXPAND`.

Se você vir `##[error] requires capabilities: [capability-name]` nos logs da ação **Implantar pilha do CloudFormation **, consulte [Como faço para corrigir erros de recursos do IAM?](troubleshooting-workflows.md#troubleshooting-workflows-capabilities) para ter informações sobre como corrigir o problema.

Para obter mais informações sobre os recursos do IAM, consulte Como [reconhecer recursos do IAM em CloudFormation modelos](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html#using-iam-capabilities) no *Guia do usuário do IAM*.

Interface de usuário correspondente: guia Configuração/Avançada/**Recursos**

## parameter-overrides
<a name="deploy.action.cfn.parameter.overrides"></a>

(*DeployCloudFormationStack*/Configuration/**parameter-overrides**)

(Optional)

Especifique parâmetros no seu CloudFormation ou no AWS SAM modelo que não tenham valores padrão ou para os quais você deseja especificar valores não padrão. Para obter mais informações sobre parâmetros, consulte [Parâmetros](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/parameters-section-structure.html) no *Guia AWS CloudFormation do usuário*.

A propriedade `parameter-overrides` aceita:
+ Um arquivo JSON contendo os parâmetros e valores.
+ Uma lista separada por vírgulas de parâmetros e valores.

**Para especificar um arquivo JSON**

1. Verifique se o arquivo JSON usa uma das seguintes sintaxes:

   ```
   {
     "Parameters": {
       "Param1": "Value1",
       "Param2": "Value2",
       ...
     }
   }
   ```

   Ou...

   ```
   [
     {
        "ParameterKey": "Param1",
        "ParameterValue": "Value1"
     },
     ...
   ]
   ```

   (Existem outras sintaxes, mas elas não são suportadas CodeCatalyst no momento em que este artigo foi escrito.) *Para obter mais informações sobre a especificação de CloudFormation parâmetros em um arquivo JSON, consulte [Sintaxe JSON compatível](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/cloudformation/deploy/index.html#supported-json-syntax) na Referência de Comandos.AWS CLI *

1. Especifique o caminho para o arquivo JSON usando um dos seguinte formatos:
   + Se o arquivo JSON residir em um artefato de saída de uma ação anterior, use:

     `file:///artifacts/current-action-name/output-artifact-name/path-to-json-file`

     Consulte o **Exemplo 1** para saber detalhes.
   + Se o arquivo JSON residir no seu repositório de origem, use:

     `file:///sources/WorkflowSource/path-to-json-file`

     Consulte o **Exemplo 2** para saber detalhes.

     **Exemplo 1**: o arquivo JSON reside em um artefato de saída

     ```
     ##My workflow YAML
     ...
     Actions:
       MyBuildAction:
         Identifier: aws/build@v1
         Outputs:
           Artifacts:
             - Name: ParamArtifact
               Files:
                 - params.json
         Configuration:
         ...
       MyDeployCFNStackAction:
         Identifier: aws/cfn-deploy@v1
         Configuration:
           parameter-overrides: file:///artifacts/MyDeployCFNStackAction/ParamArtifact/params.json
     ```

     **Exemplo 2**: o arquivo JSON reside no repositório de origem, em uma pasta chamada `my/folder`

     ```
     ##My workflow YAML
     ...
     Actions:
       MyDeployCloudFormationStack:
         Identifier: aws/cfn-deploy@v1
         Inputs:
           Sources:
             - WorkflowSource
         Configuration:
           parameter-overrides: file:///sources/WorkflowSource/my/folder/params.json
     ```

**Como usar uma lista de parâmetros separada por vírgula**
+ Adicione pares de nome-valor do parâmetro na propriedade `parameter-overrides` usando o seguinte formato:

  `param-1=value-1,param-2=value-2`

  Por exemplo, assumindo o seguinte CloudFormation modelo:

  ```
  ##My CloudFormation template
  
  Description: My CloudFormation template
  
  Parameters:
    InstanceType:
      Description: Defines the Amazon EC2 compute for the production server.
      Type: String
      Default: t2.micro
      AllowedValues:
        - t2.micro
        - t2.small
        - t3.medium
      
  Resources:
  ...
  ```

  ... você pode definir a propriedade `parameter-overrides` da seguinte forma:

  ```
  ##My workflow YAML
  ...
  Actions:
  ...
    DeployCloudFormationStack:
      Identifier: aws/cfn-deploy@v1
      Configuration:
        parameter-overrides: InstanceType=t3.medium,UseVPC=true
  ```
**nota**  
Você pode especificar um nome de parâmetro sem um valor correspondente usando `undefined` como valor. Por exemplo:  
`parameter-overrides: MyParameter=undefined`  
 O efeito é que, durante uma atualização da pilha, CloudFormation usa o valor do parâmetro existente para o nome do parâmetro fornecido.

Interface de usuário correspondente:
+ Guia Configuração/Avançado/**Substituições de parâmetros**
+ tab/Advanced/ParameterSubstituições de configuração/ **Especifique substituições usando** um arquivo
+ tab/Advanced/ParameterSubstituições de configuração/ **Especifique substituições usando um conjunto de valores**

## no-execute-changeset
<a name="deploy.action.cfn.noexecutechangeset"></a>

(*DeployCloudFormationStack*/Configuration/**no-execute-changeset**)

(Optional)

Especifique se você CodeCatalyst deseja criar o conjunto de CloudFormation alterações e depois parar antes de executá-lo. Isso lhe dá a oportunidade de revisar o conjunto de alterações no CloudFormation console. Se você determinar que o conjunto de alterações parece bom, desative essa opção e execute novamente o fluxo de trabalho para que ele CodeCatalyst possa criar e executar o conjunto de alterações sem parar. O padrão é criar e executar o conjunto de alterações sem parar. Para obter mais informações, consulte o parâmetro CloudFormation [deploy](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deploy/index.html) na *Referência de AWS CLI Comandos*. Para ter mais informações sobre a visualização de conjuntos de alterações, consulte [Visualização de um conjunto de alterações](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-changesets-view.html) no *Guia do usuário do AWS CloudFormation *.

Interface de usuário correspondente: guia Configuração/Avançado/**Sem executar o conjunto de alterações**

## fail-on-empty-changeset
<a name="deploy.action.cfn.failonemptychangeset"></a>

(*DeployCloudFormationStack*/Configuration/**fail-on-empty-changeset**)

(Optional)

Especifique se você deseja CodeCatalyst falhar na ação **Deploy CloudFormation stack** se o conjunto de CloudFormation alterações estiver vazio. (Se um conjunto de alterações estiver vazio, isso significa que não foram feitas alterações na pilha durante a implantação mais recente.) O padrão é permitir que a ação continue se o conjunto de alterações estiver vazio e retornar uma mensagem `UPDATE_COMPLETE` mesmo que a pilha não tenha sido atualizada.

Para obter mais informações sobre essa configuração, consulte o parâmetro CloudFormation [deploy](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deploy/index.html) na *Referência de AWS CLI Comandos*. Para ter mais informações sobre conjuntos de alterações, consulte [Atualizar pilhas usando conjuntos de alterações](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-changesets.html) no *Manual do usuário do AWS CloudFormation *.

Interface de usuário correspondente: guia Configuração/Avançado/**Falha no conjunto de alterações vazio**

## disable-rollback
<a name="deploy.action.cfn.disablerollback"></a>

(*DeployCloudFormationStack*/Configuration/**disable-rollback**)

(Optional)

Especifique se você CodeCatalyst deseja reverter a implantação da pilha se ela falhar. A reversão retorna a pilha ao último estado estável conhecido. O padrão é habilitar reversões. Para obter mais informações sobre essa configuração, consulte o parâmetro CloudFormation [deploy](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deploy/index.html) na *Referência de AWS CLI Comandos*.

Para obter mais informações sobre como a ação **Deploy CloudFormation stack** lida com reversões, consulte. [Configurar reversões](deploy-consumption-enable-alarms.md)

Para ter mais informações sobre como reverter uma pilha, consulte [Opções de falha de pilha](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stack-failure-options.html) no *Guia do usuário do AWS CloudFormation *.

Interface de usuário correspondente: guia Configuração/Avançado/**Desativar reversão**

## termination-protection
<a name="deploy.action.cfn.terminationprotection"></a>

(*DeployCloudFormationStack*/Configuration/**termination-protection**)

(Optional)

Especifique se você deseja que a ** CloudFormation pilha Deploy** adicione proteção de encerramento à pilha que está implantando. Se um usuário tentar excluir uma pilha com proteção contra encerramento ativada, a exclusão falhará e a pilha, incluindo o status dela, permanecerá inalterada. O padrão é desativar a proteção contra encerramento. Para ter mais informações, consulte [Proteção de uma pilha contra exclusão](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-protect-stacks.html) no *Guia do usuário do AWS CloudFormation *.

Interface de usuário correspondente: guia Configuração/Avançado/**Proteção contra encerramento**

## timeout-in-minutes
<a name="deploy.action.cfn.timeoutinminutes"></a>

(*DeployCloudFormationStack*/Configuration/**timeout-in-minutes**)

(Optional)

Especifique a quantidade de tempo, em minutos, que CloudFormation deve ser alocada antes de expirar as operações de criação da pilha e definir o status da pilha como. `CREATE_FAILED` Se o CloudFormation não puder criar a pilha inteira dentro do tempo alocado, além de não ser criada, a pilha será revertida.

Por padrão, não há tempo limite para criação da pilha. No entanto, recursos individuais podem ter seus próprios limites de tempo com base na natureza do serviço que implementam. Por exemplo, se um recurso individual em sua pilha expirar, a criação dela também expirará, ainda que o tempo limite especificado para a criação não tenha sido atingido.

**UI correspondente: guia de configuração/avançado/tempo limite CloudFormation**

## notification-arns
<a name="deploy.action.cfn.notificationarns"></a>

(*DeployCloudFormationStack*/Configuration/**notification-arns**)

(Optional)

Especifique o ARN de um tópico do Amazon SNS para o qual você CodeCatalyst deseja enviar mensagens de notificação. Por exemplo, .`arn:aws:sns:us-east-1:111222333:MyTopic` Quando a ação **Deploy CloudFormation stack** é executada, CodeCatalyst CloudFormation coordena-se para enviar uma notificação por CloudFormation evento que ocorre durante o processo de criação ou atualização da pilha. (Os eventos são visíveis na guia **Eventos** do CloudFormation console para a pilha.) Você pode definir até cinco tópicos. Para ter mais informações, consulte [O que é a Amazon SNS?](https://docs.aws.amazon.com/sns/latest/dg/welcome.html)

**UI correspondente: guia Configuração/Avançado/Notificação ARNs**

## monitor-alarm-arns
<a name="deploy.action.cfn.monitoralarmarns"></a>

(*DeployCloudFormationStack*/Configuration/**monitor-alarm-arns**)

(Optional)

Especifique o Amazon Resource Name (ARN) de um CloudWatch alarme da Amazon para usar como gatilho de reversão. Por exemplo, .`arn:aws:cloudwatch::123456789012:alarm/MyAlarm` Você pode ter no máximo cinco gatilhos de reversão.

**nota**  
Se você especificar um ARN de CloudWatch alarme, também precisará configurar permissões adicionais para permitir o acesso à ação. CloudWatch Para obter mais informações, consulte [Configurar reversões](deploy-consumption-enable-alarms.md).

**UI correspondente: guia de configuração/avançado/alarme de monitor ARNs**

## monitor-timeout-in-minutes
<a name="deploy.action.cfn.monitortimeinminutes"></a>

(*DeployCloudFormationStack*/Configuration/**monitor-timeout-in-minutes**)

(Optional)

Especifique um período de tempo, de 0 a 180 minutos, durante o qual CloudFormation monitora os alarmes especificados. O monitoramento começa *após* a implantação de todos os recursos da pilha. Se o alarme ocorrer dentro do tempo de monitoramento especificado, a implantação falhará e CloudFormation reverterá toda a operação da pilha.

Padrão: 0. CloudFormation monitora apenas os alarmes enquanto os recursos da pilha estão sendo implantados, não depois.

Interface de usuário correspondente: guia Configuração/Avançado/**Tempo de monitoramento**

## tags
<a name="deploy.action.cfn.tags"></a>

(*DeployCloudFormationStack*/Configuration/**tags**)

(Optional)

Especifique as tags para anexar à sua CloudFormation pilha. As tags são pares de chave/valor arbitrários que você pode usar para identificar sua pilha em relação à finalidade, como alocação de custos. Para obter mais informações sobre o que as tags são e como elas podem ser usadas, consulte [Marcar recursos](https://docs.aws.amazon.com/) no *Guia do usuário do Amazon EC2*. Para obter mais informações sobre como marcar CloudFormation, consulte [Configuração das opções de CloudFormation pilha](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-console-add-tags.html) no Guia do *AWS CloudFormation usuário*.

Uma chave pode ter caracteres alfanuméricos ou espaços e pode ter até 127 caracteres. Um valor pode ter caracteres alfanuméricos ou espaços e pode ter até 255 caracteres.

É possível adicionar até 50 tags exclusivas para cada pilha.

Interface de usuário correspondente: guia Configuração/Avançado/**Tags**

# Implantando um AWS CDK aplicativo com um fluxo de trabalho
<a name="cdk-dep-action"></a>

Esta seção descreve como implantar um AWS Cloud Development Kit (AWS CDK) aplicativo em sua AWS conta usando um fluxo de trabalho. Para fazer isso, você deve adicionar a ação **Implantação do AWS CDK ** ao seu fluxo de trabalho. A ação de **AWS CDK implantação** sintetiza e implanta seu AWS Cloud Development Kit (AWS CDK) aplicativo em. AWS Se seu aplicativo já existir em AWS, a ação o atualizará, se necessário. 

Para obter informações gerais sobre como criar aplicativos usando o AWS CDK, consulte [O que é o AWS CDK?](https://docs.aws.amazon.com/cdk/v2/guide/home.html) no *Guia do AWS Cloud Development Kit (AWS CDK) desenvolvedor*.

**Topics**
+ [Quando usar a ação 'AWS CDK implantar'](#cdk-dep-action-when-to-use)
+ [Como a ação 'AWS CDK implantar' funciona](#cdk-dep-action-how-it-works)
+ [Versões da CLI do CDK usadas pela ação 'implantar'AWS CDK](#cdk-dep-action-cdk-version)
+ [Imagem de tempo de execução usada pela ação 'AWS CDK implantar'](#cdk-dep-action-runtime)
+ [Quantas pilhas a ação pode implantar?](#cdk-dep-action-how-many-stacks)
+ [Exemplo: implantação de um aplicativo AWS CDK](cdk-dep-action-example-workflow.md)
+ [Adicionando a ação 'AWS CDK implantar'](cdk-dep-action-add.md)
+ [Variáveis de “Implantação do AWS CDK ”](cdk-dep-action-variables.md)
+ [YAML da ação “Implantação do AWS CDK ”](cdk-dep-action-ref.md)

## Quando usar a ação 'AWS CDK implantar'
<a name="cdk-dep-action-when-to-use"></a>

Use essa ação se você desenvolveu um aplicativo usando o AWS CDK e agora deseja implantá-lo automaticamente como parte do fluxo de trabalho de integração e entrega contínuas automatizadas (CI/CD). Por exemplo, talvez você queira implantar seu AWS CDK aplicativo automaticamente sempre que alguém mesclar uma pull request relacionada à fonte do seu AWS CDK aplicativo. 

## Como a ação 'AWS CDK implantar' funciona
<a name="cdk-dep-action-how-it-works"></a>

A **Implantação do AWS CDK ** funciona da seguinte maneira:

1. [Em tempo de execução, se você especificou a versão 1.0.12 ou anterior da ação, a ação baixará a CLI CDK mais recente (também chamada de Tookit) para a imagem AWS CDK do ambiente de tempo de execução. CodeCatalyst ](#cdk-dep-action-runtime)

   Se você especificou a versão 1.0.13 ou posterior, a ação vem junto com uma [versão específica](#cdk-dep-action-cdk-version) da CLI do CDK e, portanto, nenhum download ocorre.

1. A ação usa a CLI do CDK para executar o comando `cdk deploy`. Esse comando sintetiza e implanta seu AWS CDK aplicativo em. AWS Para ter mais informações sobre esse comando, consulte o tópico [Kit de ferramentas do AWS CDK (comando cdk)](https://docs.aws.amazon.com/cli/latest/reference/s3/sync.html) no *Guia do desenvolvedor do AWS Cloud Development Kit (AWS CDK) *.

## Versões da CLI do CDK usadas pela ação 'implantar'AWS CDK
<a name="cdk-dep-action-cdk-version"></a>

A tabela a seguir mostra qual versão da CLI do CDK é usada por padrão por diferentes versões da ação **Implantação do AWS CDK **.

**nota**  
Talvez você consiga substituir o padrão. Para ter mais informações, consulte [CdkCliVersion](cdk-dep-action-ref.md#cdk.dep.cdk.cli.version) no [YAML da ação “Implantação do AWS CDK ”](cdk-dep-action-ref.md).


| Versão da ação “Implantação do AWS CDK ” | AWS CDK Versão CLI | 
| --- | --- | 
|  1.0.0 – 1.0.12  |  mais recente  | 
|  1.0.13 ou posterior  |  2.99.1  | 

## Imagem de tempo de execução usada pela ação 'AWS CDK implantar'
<a name="cdk-dep-action-runtime"></a>

A tabela a seguir mostra as imagens do ambiente de execução CodeCatalyst usadas para executar diferentes versões da ação de **AWS CDK implantação**. As imagens incluem diferentes conjuntos de ferramentas pré-instaladas. Para obter mais informações, consulte [Imagens ativas](build-images.md#build-curated-images).

**nota**  
Recomendamos atualizar sua ação **Implantação do AWS CDK ** para a versão 2.x para aproveitar as ferramentas mais recentes disponíveis na imagem de março de 2024. Para atualizar a ação, defina a propriedade `Identifier` como `aws/cdk-deploy@v2` no arquivo de definição de fluxo de trabalho. Para obter mais informações, consulte [YAML da ação “Implantação do AWS CDK ”](cdk-dep-action-ref.md). 


| Versão da ação “Implantação do AWS CDK ” | Imagens de ambiente de runtime | 
| --- | --- | 
|  1.x  |  Imagens de novembro de 2022  | 
|  2.x  |  Imagens de março de 2024  | 

## Quantas pilhas a ação pode implantar?
<a name="cdk-dep-action-how-many-stacks"></a>

A **Implantação do AWS CDK ** pode implantar somente uma única pilha. Se seu AWS CDK aplicativo consistir em várias pilhas, você deverá criar uma pilha principal com pilhas aninhadas e implantar a principal usando essa ação.

# Exemplo: implantação de um aplicativo AWS CDK
<a name="cdk-dep-action-example-workflow"></a>

O exemplo de fluxo de trabalho a seguir inclui a ação **Implantação do AWS CDK **, junto com a ação **Inicialização do AWS CDK **. 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. Esse repositório contém seu AWS CDK aplicativo. 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 **AWS CDK bootstrap** (`CDKBootstrap`) — No gatilho, a ação implanta a pilha de `CDKToolkit` bootstrap em. AWS Se a pilha do `CDKToolkit` já existir no ambiente, ela será atualizada se necessário; caso contrário, nada acontecerá e a ação será marcada como bem-sucedida.
+ Uma ação de **AWS CDK implantação** (`AWS CDK Deploy`) — Ao concluir a ação de **AWS CDK bootstrap**, a ação de **AWS CDK implantação** sintetiza o código do seu AWS CDK aplicativo em um CloudFormation modelo e implanta a pilha definida no modelo em. AWS

**nota**  
O exemplo de fluxo de trabalho a seguir serve para fins ilustrativos e não funcionará sem configuração adicional.

**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 exigidas pelas ações **Inicialização do AWS CDK ** e **Implantação do AWS CDK **. 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). Para ter mais informações sobre as permissões e as políticas de confiança exigidas pelas ações **Inicialização do AWS CDK ** e **Implantação do AWS CDK **, consulte a descrição da propriedade `Role` na [YAML da ação “Inicialização do AWS CDK ”](cdk-boot-action-ref.md) e [YAML da ação “Implantação do AWS CDK ”](cdk-dep-action-ref.md).

```
Name: codecatalyst-cdk-deploy-workflow
SchemaVersion: 1.0

Triggers:
  - Type: PUSH
    Branches:
      - main
Actions:
  CDKBootstrap:
    Identifier: aws/cdk-bootstrap@v2
    Inputs:
      Sources:
        - WorkflowSource
    Environment:
      Name: codecatalyst-cdk-deploy-environment
      Connections:
        - Name: codecatalyst-account-connection
          Role: codecatalyst-cdk-bootstrap-role
    Configuration:
      Region: us-west-2
        
  CDKDeploy:
    Identifier: aws/cdk-deploy@v2
    DependsOn: 
      - CDKBootstrap
    Environment:
      Name: codecatalyst-cdk-deploy-environment
      Connections:
        - Name: codecatalyst-account-connection
          Role: codecatalyst-cdk-deploy-role
    Inputs:
      Sources:
        - WorkflowSource
    Configuration:
      StackName: my-app-stack
      Region: us-west-2
```

# Adicionando a ação 'AWS CDK implantar'
<a name="cdk-dep-action-add"></a>

 Use as instruções a seguir para adicionar a ação **Implantação do AWS CDK ** ao seu fluxo de trabalho. 

**Antes de começar**

Antes de adicionar a ação **Implantação do AWS CDK ** ao seu fluxo de trabalho, conclua as seguintes tarefas:

1. **Tenha um AWS CDK aplicativo pronto**. Você pode escrever seu AWS CDK aplicativo usando AWS CDK v1 ou v2, em qualquer linguagem de programação compatível com o. AWS CDK Verifique se os arquivos da aplicação AWS CDK estão disponíveis em:
   + Um [repositório de CodeCatalyst origem](source.md) ou 
   + Um [artefato CodeCatalyst de saída](workflows-working-artifacts.md) gerado por outra ação do fluxo de trabalho

1. **Inicialize seu AWS ambiente.** Para inicializar, você pode:
   + Usar um dos métodos descritos em [Como inicializar](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html#bootstrapping-howto) no *Guia do desenvolvedor do AWS Cloud Development Kit (AWS CDK) *.
   + Usar a ação **Inicialização do AWS CDK **. Você pode adicionar essa ação no mesmo fluxo de trabalho da **Implantação do AWS CDK ** ou em um diferente. Apenas garanta que a ação de inicialização seja executada pelo menos uma vez antes de executar a ação **Implantação do AWS CDK ** para que os recursos necessários estejam disponíveis. Para obter mais informações sobre a ação de **AWS CDK bootstrap**, consulte[Inicializando um AWS CDK aplicativo com um fluxo de trabalho](cdk-boot-action.md).

     Para ter mais informações sobre inicialização, consulte [Inicialização](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html) no *Guia do desenvolvedor do AWS Cloud Development Kit (AWS CDK) *.

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

**Para adicionar a ação 'AWS CDK implantar' 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 **Implantação do AWS CDK ** 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
   + Escolha **Implantação do AWS CDK **. 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 “Implantação do AWS CDK ”](cdk-dep-action-ref.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.
**nota**  
Se a ação **Implantação do AWS CDK ** falhar com um erro `npm install`, consulte [Como faço para corrigir erros de “instalação npm”?](troubleshooting-workflows.md#troubleshooting-workflows-npm) para ter informações sobre como corrigir o erro.

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

**Para adicionar a ação 'AWS CDK implantar' 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 **Implantação do AWS CDK ** 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
   + Escolha **Implantação do AWS CDK **. 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 “Implantação do AWS CDK ”](cdk-dep-action-ref.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.
**nota**  
Se a ação **Implantação do AWS CDK ** falhar com um erro `npm install`, consulte [Como faço para corrigir erros de “instalação npm”?](troubleshooting-workflows.md#troubleshooting-workflows-npm) para ter informações sobre como corrigir o erro.

------

# Variáveis de “Implantação do AWS CDK ”
<a name="cdk-dep-action-variables"></a>

A ação **Implantação do AWS CDK ** 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 | 
| --- | --- | 
|  stack-id  |  O Amazon Resource Name (ARN) da pilha de AWS CDK aplicativos que foi implantada durante a execução do fluxo de trabalho. Exemplo: `arn:aws:cloudformation:us-west-2:111122223333:stack/codecatalyst-cdk-app-stack/6aad4380-100a-11ec-a10a-03b8a84d40df`  | 
|  deployment-platform  |  O nome da plataforma de implantação. Codificado para `AWS:CloudFormation`.  | 
|  region  |  O código da região em Região da AWS que foi implantado durante a execução do fluxo de trabalho. Exemplo: `us-west-2`  | 
|  SKIP-DEPLOYMENT  |  Um valor de `true` indica que a implantação da pilha de AWS CDK aplicativos foi ignorada durante a execução do fluxo de trabalho. Uma implantação da pilha será ignorada se não houver nenhuma alteração na pilha desde a última implantação. Essa variável só será produzida se o valor for `true`. Codificado para `true`.  | 
|  *CloudFormation variables*  |  Além de gerar as variáveis listadas anteriormente, a ação de **AWS CDK implantação** também expõe as variáveis de *CloudFormation*saída como variáveis de *fluxo* de trabalho para uso em ações subsequentes do fluxo de trabalho. Por padrão, a ação expõe somente as primeiras quatro (ou menos) CloudFormation variáveis encontradas. Para determinar quais estão expostas, execute a ação **Implantação do AWS CDK ** uma vez e, depois, consulte a guia **Variáveis** da página de detalhes da execução. Se as variáveis listadas na guia **Variáveis** não forem as desejadas, você poderá configurar outras usando a propriedade YAML `CfnOutputVariables`. Para ter mais informações, consulte a descrição da propriedade [CfnOutputVariables](cdk-dep-action-ref.md#cdk.dep.cfn.out) na [YAML da ação “Implantação do AWS CDK ”](cdk-dep-action-ref.md).  | 

# YAML da ação “Implantação do AWS CDK ”
<a name="cdk-dep-action-ref"></a>

Confira a seguir a definição de YAML da ação **Implantação do AWS CDK **. Para saber como usar essa ação, consulte [Implantando um AWS CDK aplicativo com um fluxo de trabalho](cdk-dep-action.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.   
  CDKDeploy\$1nn: 
    Identifier: aws/cdk-deploy@v2
    DependsOn:
      - CDKBootstrap
    Compute:  
      Type: EC2 | Lambda
      Fleet: fleet-name
    Timeout: timeout-minutes
    Inputs:
      # Specify a source or an artifact, but not both.
      Sources:
        - source-name-1
      Artifacts:
        - artifact-name
    Outputs:
      Artifacts:
        - Name: cdk_artifact
          Files: 
            - "cdk.out/**/*"
    Environment:
      Name: environment-name
      Connections:
        - Name: account-connection-name
          Role: iam-role-name
    Configuration:
      StackName: my-cdk-stack
      Region: us-west-2
      Tags: '{"key1": "value1", "key2": "value2"}'
      Context: '{"key1": "value1", "key2": "value2"}'
      CdkCliVersion: version
      CdkRootPath: directory-containing-cdk.json-file
      CfnOutputVariables: '["CnfOutputKey1","CfnOutputKey2","CfnOutputKey3"]'
      CloudAssemblyRootPath: path-to-cdk.out
```

## CDKDeploy
<a name="cdk.dep.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: `CDKDeploy_nn`.

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

## Identifier
<a name="cdk.dep.identifier"></a>

(*CDKDeploy*/**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).

**nota**  
A especificação de `aws/cdk-deploy@v2` faz com que a ação seja executada na [imagem de março de 2024](build-images.md#build.default-image), que inclui ferramentas mais recentes, como Node.js 18. A especificação de `aws/cdk-deploy@v1` faz com que a ação seja executada na [imagem de novembro de 2022](build-images.md#build.previous-image), que inclui ferramentas mais antigas, como Node.js 16.

Padrão: `aws/cdk-deploy@v2`.

Interface de usuário correspondente: Diagrama de fluxo de trabalho/CDKDeploy\$1nn/rótulo **aws/cdk-deploy@v2**

## DependsOn
<a name="cdk.dep.dependson"></a>

(*CDKDeploy*/**DependsOn**)

(Optional)

Especifique uma ação ou um grupo de ação que deve ser executado para que a ação **Implantação do AWS CDK ** seja executada. Recomendamos especificar a ação **Inicialização do AWS CDK ** na propriedade `DependsOn`, da seguinte forma:

```
CDKDeploy:
  Identifier: aws/cdk-deploy@v2
  DependsOn:
    - CDKBootstrap
```

**nota**  
A [inicialização é um pré-requisito obrigatório para a implantação de um aplicativo](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html). AWS CDK Se você não incluir a ação **Inicialização do AWS CDK ** no fluxo de trabalho, deverá encontrar outra maneira de implantar a pilha de inicialização do AWS CDK antes de executar a ação **Implantação do AWS CDK **. Para obter mais informações, consulte [Adicionando a ação 'AWS CDK implantar'](cdk-dep-action-add.md) em [Implantando um AWS CDK aplicativo com um fluxo de trabalho](cdk-dep-action.md).

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="cdk.dep.computename"></a>

(*CDKDeploy*/**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="cdk.dep.computetype"></a>

(*CDKDeploy*/Compute/**Type**)

(Obrigatório se [Compute](#cdk.dep.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="cdk.dep.computefleet"></a>

(*CDKDeploy*/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="cdk.dep.timeout"></a>

(*CDKDeploy*/**Timeout**)

(Obrigatório)

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

## Inputs
<a name="cdk.dep.inputs"></a>

(*CDKDeploy*/**Inputs**)

(Optional)

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

**nota**  
Somente uma entrada (uma fonte ou um artefato) é permitida para cada ação **Implantação do AWS CDK **.

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

## Sources
<a name="cdk.dep.inputs.sources"></a>

(*CDKDeploy*/Inputs/**Sources**)

(Obrigatório se o AWS CDK aplicativo que você deseja implantar estiver armazenado em um repositório de origem)

Se seu AWS CDK aplicativo estiver armazenado em um repositório de origem, especifique o rótulo desse repositório de origem. A ação **Implantação do AWS CDK ** sintetiza a aplicação nesse repositório antes de iniciar o processo de implantação. Atualmente, o único rótulo compatível é `WorkflowSource`.

Se seu AWS CDK aplicativo não estiver contido em um repositório de origem, ele deverá 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="cdk.dep.inputs.artifacts"></a>

(*CDKDeploy*/Inputs/**Artifacts**)

(Obrigatório se o AWS CDK aplicativo que você deseja implantar estiver armazenado em um [artefato de saída](workflows-working-artifacts-output.md) de uma ação anterior)

Se seu AWS CDK aplicativo estiver contido em um artefato gerado por uma ação anterior, especifique esse artefato aqui. A ação de **AWS CDK implantação** sintetiza o aplicativo no artefato especificado em um CloudFormation modelo antes de iniciar o processo de implantação. Se seu AWS CDK aplicativo não estiver contido em um artefato, ele deverá residir no 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 Entradas/**Artefatos - opcional**

## Outputs
<a name="cdk.dep.outputs"></a>

(*CDKDeploy*/**Outputs**)

(Optional)

Define os dados que são gerados pela ação durante a execução de um fluxo de trabalho.

Interface de usuário correspondente: guia **Saídas**

## Artifacts - output
<a name="cdk.dep.outputs.artifacts"></a>

(*CDKDeploy*/Outputs/**Artifacts**

(Optional)

Especifique os artefatos gerados pela ação. Você pode referenciar esses artefatos como entrada em outras ações.

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 Saídas/**Artefatos**

## Name
<a name="cdk.dep.outputs.artifacts.name"></a>

(*CDKDeploy*/Outputs/Artifacts/**Name**)

(Obrigatório se [Artifacts - output](#cdk.dep.outputs.artifacts) for incluído)

Especifique o nome do artefato que conterá o CloudFormation modelo sintetizado pela ação de **AWS CDK implantação** em tempo de execução. O valor padrão é `cdk_artifact`. Se você não especificar um artefato, a ação sintetizará o modelo, mas não o salvará em um artefato. Pense em salvar o modelo sintetizado em um artefato para preservar um registro dele para fins de teste ou solução de problemas.

**UI correspondente: artefato de tab/Artifacts/Add saída/Nome do artefato de construção**

## Files
<a name="cdk.dep.outputs.artifacts.files"></a>

(*CDKDeploy*/Outputs/Artifacts/**Files**)

(Obrigatório se [Artifacts - output](#cdk.dep.outputs.artifacts) for incluído)

Especifique os arquivos a serem incluídos no artefato. Você deve especificar `"cdk.out/**/*"` para incluir o modelo sintetizado CloudFormation do seu AWS CDK aplicativo.

**nota**  
`cdk.out` é o diretório padrão no qual os arquivos sintetizados são salvos. Se você especificou um diretório de saída diferente de `cdk.out` no arquivo `cdk.json`, especifique esse diretório aqui em vez de `cdk.out`.

**UI correspondente: produz tab/Artifacts/Add artefatos/arquivos produzidos pela compilação**

## Environment
<a name="cdk.dep.environment"></a>

(*CDKDeploy*/**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="cdk.dep.environment.name"></a>

(*CDKDeploy*/Environment/**Name**)

(Obrigatório se [Environment](#cdk.dep.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="cdk.dep.environment.connections"></a>

(*CDKDeploy*/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="cdk.dep.environment.connections.name"></a>

(*CDKDeploy*/Environment/Connections/**Name**)

(Obrigatório se [Connections](#cdk.dep.environment.connections) for incluído)

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="cdk.dep.environment.connections.role"></a>

(*CDKDeploy*/Environment/Connections/**Role**)

(Obrigatório se [Connections](#cdk.dep.environment.connections) for incluído)

Especifique o nome da conexão da conta.

Especifique o nome da função do IAM que a ação de **AWS CDK implantação** usa para acessar AWS e implantar a pilha de AWS CDK aplicativos. 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": [
          {
              "Sid": "VisualEditor0",
              "Effect": "Allow",
              "Action": [
                  "cloudformation:DescribeStackEvents",
                  "cloudformation:DescribeChangeSet",
                  "cloudformation:DescribeStacks",
                  "cloudformation:ListStackResources"
              ],
              "Resource": "*"
          },
          {
              "Sid": "VisualEditor1",
              "Effect": "Allow",
              "Action": "sts:AssumeRole",
              "Resource": "arn:aws:iam::111122223333:role/cdk-*"
          }
      ]
  }
  ```

------
+ A política de confiança personalizada a seguir:

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

## Configuration
<a name="cdk.dep.configuration"></a>

(*CDKDeploy*/**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**

## StackName
<a name="cdk.dep.stack.name"></a>

(*CDKDeploy*/Configuration/**StackName**)

(Obrigatório)

O nome da sua pilha de AWS CDK aplicativos, conforme aparece no arquivo do ponto de entrada no diretório do seu AWS CDK aplicativo. `bin` O exemplo a seguir mostra o conteúdo de um arquivo de TypeScript ponto de entrada, com o nome da pilha destacado em. *red italics* Se o arquivo do ponto de entrada estiver em outra linguagem, ele terá uma aparência semelhante.

```
import * as cdk from 'aws-cdk-lib';
import { CdkWorksopTypescriptStack } from '../lib/cdk_workshop_typescript-stack';

const app = new cdk.App();
new CdkWorkshopTypescriptStack(app, 'CdkWorkshopTypescriptStack');
```

Você pode especificar apenas uma pilha.

**dica**  
Se você tiver várias pilhas, poderá criar uma pilha principal com pilhas aninhadas. Em seguida, você pode especificar a pilha principal nessa ação para implantar todas as pilhas.

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

## Region
<a name="cdk.dep.region"></a>

(*CDKDeploy*/Configuration/**Region**)

(Optional)

Especifique Região da AWS no qual a pilha de AWS CDK aplicativos será implantada. Para obter uma lista dos códigos das regiões, consulte [Endpoints regionais](https://docs.aws.amazon.com/general/latest/gr/rande.html#region-names-codes).

Se você não especificar uma região, a ação de implantação será **AWS CDK implantada** na região especificada em seu AWS CDK código. Para ter mais informações, consulte [Ambientes](https://docs.aws.amazon.com/cdk/v2/guide/environments.html) no *Guia do desenvolvedor do AWS Cloud Development Kit (AWS CDK) *.

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

## Tags
<a name="cdk.dep.tags"></a>

(*CDKDeploy*/Configuration/**Tags**)

(Optional)

Especifique as tags que você deseja aplicar aos AWS recursos na pilha de AWS CDK aplicativos. As tags são aplicadas à pilha em si, bem como aos recursos individuais na pilha. Para ter mais informações sobre marcação, consulte [Marcação](https://docs.aws.amazon.com/cdk/v2/guide/tagging.html), no *Guia do desenvolvedor do AWS Cloud Development Kit (AWS CDK) *.

**UI correspondente: Configuração tab/Advanced - opcional/Tags**

## Context
<a name="cdk.dep.context"></a>

(*CDKDeploy*/Configuration/**Context**)

(Optional)

Especifique contextos, na forma de pares de valores-chave, para associar à pilha de aplicativos. AWS CDK Para ter mais informações sobre contextos, consulte [Contextos de runtime](https://docs.aws.amazon.com/cdk/v2/guide/context.html) no *Guia do desenvolvedor do AWS Cloud Development Kit (AWS CDK) *.

**UI correspondente: Configuração tab/Advanced - opcional/Contexto**

## CdkCliVersion
<a name="cdk.dep.cdk.cli.version"></a>

(*CDKDeploy*/Configuration/**CdkCliVersion**)

(Optional)

Essa propriedade está disponível com a versão 1.0.13 ou posterior da ação **Implantação do AWS CDK ** e a versão 1.0.8 ou posterior da ação **Inicialização do AWS CDK **.

Especifique um dos seguintes:
+ A versão completa da interface de linha de AWS Cloud Development Kit (AWS CDK) comando (CLI) (também chamada de AWS CDK kit de ferramentas) que você deseja que essa ação use. Exemplo: `2.102.1`. Considere especificar uma versão completa para garantir consistência e estabilidade ao criar e implantar a aplicação.

  Ou
+ `latest`. Pense em especificar `latest` para aproveitar os recursos e correções mais recentes da CLI do CDK.

A ação baixará a versão especificada (ou a versão mais recente) da AWS CDK CLI para a [imagem de CodeCatalyst compilação](build-images.md) e, em seguida, usará essa versão para executar os comandos necessários para implantar seu aplicativo CDK ou inicializar seu ambiente. AWS 

Para ter uma lista das versões compatíveis da CLI do CDK que você pode usar, consulte [Versões do AWS CDK](https://docs.aws.amazon.com/cdk/api/versions.html).

Se você omitir essa propriedade, a ação usará uma versão padrão da AWS CDK CLI descrita em um dos tópicos a seguir:
+ [Versões da CLI do CDK usadas pela ação 'implantar'AWS CDK](cdk-dep-action.md#cdk-dep-action-cdk-version) 
+ [Versões do CDK CLI usadas pela ação AWS CDK "bootstrap”](cdk-boot-action.md#cdk-boot-action-cdk-version)

UI correspondente: guia de configuração/versão **AWS CDK CLI**

## CdkRootPath
<a name="cdk.dep.cdk.root.path"></a>

(*CDKDeploy*/Configuration/**CdkRootPath**)

(Optional)

O caminho para o diretório que contém o `cdk.json` arquivo do seu AWS CDK projeto. A ação **Implantação do AWS CDK ** é executada nessa pasta e todas as saídas criadas pela ação serão adicionadas a esse diretório. Se não for especificada, a ação de **AWS CDK implantação** pressupõe que o `cdk.json` arquivo esteja na raiz do seu AWS CDK projeto.

Interface de usuário correspondente: guia Configuração/**Diretório em que o cdk.json reside**

## CfnOutputVariables
<a name="cdk.dep.cfn.out"></a>

(*CDKDeploy*/Configuration/**CfnOutputVariables**)

(Optional)

Especifique quais `CfnOutput` construções no código do AWS CDK aplicativo você deseja expor como variáveis de saída do fluxo de trabalho. Depois, você pode referenciar as variáveis de saída do fluxo de trabalho em ações subsequentes no fluxo de trabalho. Para obter mais informações sobre variáveis em CodeCatalyst, consulte[Uso de variáveis em fluxos de trabalho](workflows-working-with-variables.md).

Por exemplo, se o código do seu AWS CDK aplicativo tiver a seguinte aparência:

```
import { Duration, Stack, StackProps, CfnOutput, RemovalPolicy} from 'aws-cdk-lib';
import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
import * as s3 from 'aws-cdk-lib/aws-s3';
import { Construct } from 'constructs';
import * as cdk from 'aws-cdk-lib';
export class HelloCdkStack extends Stack {
  constructor(scope: Construct, id: string, props?: StackProps) {
    super(scope, id, props);
    const bucket = new s3.Bucket(this, 'amzn-s3-demo-bucket', {
      removalPolicy: RemovalPolicy.DESTROY,
    });
    new CfnOutput(this, 'bucketName', {
      value: bucket.bucketName,
      description: 'The name of the s3 bucket',
      exportName: 'amzn-s3-demo-bucket',
    });
    const table = new dynamodb.Table(this, 'todos-table', {
      partitionKey: {name: 'todoId', type: dynamodb.AttributeType.NUMBER},
      billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
      removalPolicy: RemovalPolicy.DESTROY,
    })
    new CfnOutput(this, 'tableName', {
      value: table.tableName,
      description: 'The name of the dynamodb table',
      exportName: 'myDynamoDbTable',
    });
    ...
  }
}
```

... e a propriedade `CfnOutputVariables` for semelhante a:

```
Configuration:
  ...
  CfnOutputVariables: '["bucketName","tableName"]'
```

... a ação gera as seguintes variáveis de saída do fluxo de trabalho:


| Chave | Valor | 
| --- | --- | 
|  bucketName  |  `bucket.bucketName`  | 
|  tableName  |  `table.tableName`  | 

Depois, você pode referenciar as variáveis `bucketName` e `tableName` em ações subsequentes. Para saber como referenciar variáveis de saída do fluxo de trabalho em ações subsequentes, consulte [Referência a uma variável predefinida](workflows-working-with-variables-reference-output-vars.md).

Se você não especificar nenhuma `CfnOutput` construção na `CfnOutputVariables` propriedade, a ação expõe as primeiras quatro (ou menos) variáveis de saída encontradas como variáveis CloudFormation de saída do fluxo de trabalho. Para obter mais informações, consulte [Variáveis de “Implantação do AWS CDK ”](cdk-dep-action-variables.md).

**dica**  
Para obter uma lista de todas as variáveis de CloudFormation saída que a ação produz, execute o fluxo de trabalho que contém a ação de **AWS CDK implantação** uma vez e, em seguida, consulte a guia **Registros** da ação. Os registros contêm uma lista de todas as variáveis CloudFormation de saída associadas ao seu AWS CDK aplicativo. Depois de saber quais são todas as CloudFormation variáveis, você pode especificar quais deseja converter em variáveis de saída do fluxo de trabalho usando a `CfnOutputVariables` propriedade.

Para obter mais informações sobre variáveis de CloudFormation saída, consulte a documentação da `CfnOutput` construção, disponível em [class CfnOutput (construct)](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.CfnOutput.html) na *Referência da AWS Cloud Development Kit (AWS CDK) API*.

UI correspondente: guia de configuração/variáveis **CloudFormation de saída**

## CloudAssemblyRootPath
<a name="cdk.dep.cloud"></a>

(*CDKDeploy*/Configuration/**CloudAssemblyRootPath**)

(Optional)

Se você já sintetizou a pilha do seu AWS CDK aplicativo em uma montagem em nuvem (usando a `cdk synth` operação), especifique o caminho raiz do diretório de montagem em nuvem (). `cdk.out` O CloudFormation modelo localizado no diretório de montagem de nuvem especificado será implantado pela ação de **AWS CDK implantação** em você Conta da AWS usando o `cdk deploy --app` comando. Quando a opção `--app` está presente, a operação `cdk synth` não ocorre.

Se você não especificar um diretório de assembly de nuvem, a ação **Implantação do AWS CDK ** executará o comando `cdk deploy` sem a opção `--app`. Sem a `--app` opção, a `cdk deploy` operação sintetizará (`cdk synth`) e implantará seu AWS CDK aplicativo no seu. Conta da AWS

**Por que eu especificaria um conjunto de nuvem existente e sintetizado quando a ação “AWS CDK implantar” pode fazer a síntese em tempo de execução?**

Talvez você queira especificar um assembly de nuvem sintetizado existente para:
+ **Garanta que exatamente o mesmo conjunto de recursos seja implantado sempre que a ação “AWS CDK implantar” for executada**

  Se você não especificar um assembly de nuvem, é possível que a ação **Implantação do AWS CDK ** sintetize e implante arquivos diferentes, dependendo de quando ela for executada. Por exemplo, a ação **Implantação do AWS CDK ** pode sintetizar um assembly de nuvem com um conjunto de dependências durante um estágio de teste e outro conjunto de dependências durante um estágio de produção (se essas dependências mudarem entre os estágios). Para garantir a paridade exata entre o que foi testado e o que foi implantado, recomendamos sintetizar uma vez e depois usar o campo **Caminho para o diretório de assembly de nuvem** (editor visual) ou a propriedade `CloudAssemblyRootPath` (editor YAML) para especificar o assembly de nuvem já sintetizado.
+ **Usar gerenciadores de pacotes e ferramentas não padrão com a aplicação AWS CDK **

  Durante uma operação `synth`, a ação **Implantação do AWS CDK ** tenta executar a aplicação usando ferramentas padrão, como npm ou pip. Se a ação não conseguir executar a aplicação usando essas ferramentas, a síntese não ocorrerá e a ação falhará. Para contornar esse problema, você pode especificar os comandos exatos necessários para executar seu aplicativo com êxito no `cdk.json` arquivo do AWS CDK aplicativo e, em seguida, sintetizar seu aplicativo usando um método que não envolva a **AWS CDK ação de implantação**. Depois que o assembly de nuvem for gerado, você poderá especificá-lo no campo **Caminho para o diretório de assembly de nuvem** (editor visual) ou na propriedade `CloudAssemblyRootPath` (editor YAML) da ação **Implantação do AWS CDK **. 

Para obter informações sobre como configurar o `cdk.json` arquivo para incluir comandos para instalar e executar seu AWS CDK aplicativo, consulte [Especificação do comando do aplicativo](https://docs.aws.amazon.com/cdk/v2/guide/cli.html#cli-app-command).

Para ter informações sobre os comandos `cdk deploy` e `cdk synth`, bem como sobre a opção `--app`, consulte [Implantação de pilhas](https://docs.aws.amazon.com/cdk/v2/guide/cli.html#cli-deploy), [Sintetização de pilhas](https://docs.aws.amazon.com/cdk/v2/guide/cli.html#cli-synth) e [Como ignorar a síntese](https://docs.aws.amazon.com/cdk/v2/guide/cli.html#cli-deploy-nosynth) no *Guia do desenvolvedor do AWS Cloud Development Kit (AWS CDK) *.

Para ter informações sobre assemblies de nuvem, consulte [Assembly de nuvem](https://docs.aws.amazon.com/cdk/api/v2/docs/cloud-assembly-schema-readme.html) na *AWS Cloud Development Kit (AWS CDK) API Reference*.

Interface de usuário correspondente: guia Configuração/**Caminho para o diretório de assembly de nuvem**

# Inicializando um AWS CDK aplicativo com um fluxo de trabalho
<a name="cdk-boot-action"></a>

Esta seção descreve como inicializar um AWS CDK aplicativo usando um CodeCatalyst fluxo de trabalho. Para fazer isso, você deve adicionar a ação **Inicialização do AWS CDK ** ao seu fluxo de trabalho. A ação **Inicialização do AWS CDK ** provisiona uma pilha de inicialização no ambiente da AWS usando o [modelo moderno](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html#bootstrapping-template). Se já existir uma pilha de inicialização, a ação a atualizará, se necessário. Ter uma pilha de bootstrap presente AWS é um pré-requisito para implantar um aplicativo. AWS CDK 

Para ter mais informações sobre inicialização, consulte [Inicialização](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html) no *Guia do desenvolvedor do AWS Cloud Development Kit (AWS CDK) *.

**Topics**
+ [Quando usar a ação 'AWS CDK bootstrap'](#cdk-boot-action-when-to-use)
+ [Como funciona a ação 'AWS CDK bootstrap'](#cdk-boot-action-how-it-works)
+ [Versões do CDK CLI usadas pela ação AWS CDK "bootstrap”](#cdk-boot-action-cdk-version)
+ [Imagem de tempo de execução usada pela ação 'AWS CDK bootstrap'](#cdk-boot-action-runtime)
+ [Exemplo: inicialização de um aplicativo AWS CDK](cdk-boot-action-example-workflow.md)
+ [Adicionando a ação 'AWS CDK bootstrap'](cdk-boot-action-add.md)
+ [variáveis de “Inicialização do AWS CDK ”](cdk-boot-action-variables.md)
+ [YAML da ação “Inicialização do AWS CDK ”](cdk-boot-action-ref.md)

## Quando usar a ação 'AWS CDK bootstrap'
<a name="cdk-boot-action-when-to-use"></a>

Use essa ação se você tiver um fluxo de trabalho que implanta um AWS CDK aplicativo e quiser implantar (e atualizar, se necessário) a pilha de bootstrap ao mesmo tempo. Nesse caso, você adicionaria a ação de **AWS CDK bootstrap** ao mesmo fluxo de trabalho que implanta seu AWS CDK aplicativo.

**Não** use essa ação se uma das seguintes opções se aplicar:
+ Você já implantou uma pilha de inicialização usando outro mecanismo e deseja mantê-la intacta (sem atualizações).
+ Você quer usar um [modelo de inicialização personalizado](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html#bootstrapping-customizing), que não é compatível com a ação **Inicialização do AWS CDK **.

## Como funciona a ação 'AWS CDK bootstrap'
<a name="cdk-boot-action-how-it-works"></a>

A **Inicialização do AWS CDK ** funciona da seguinte maneira:

1. [Em tempo de execução, se você especificou a versão 1.0.7 ou anterior da ação, a ação baixará a CLI CDK mais recente (também chamada de AWS CDK Tookit) para a imagem de compilação. CodeCatalyst ](build-images.md)

   Se você especificou a versão 1.0.8 ou posterior, a ação vem junto com uma [versão específica](cdk-dep-action.md#cdk-dep-action-cdk-version) da CLI do CDK e, portanto, nenhum download ocorre.

1. A ação usa a CLI do CDK para executar o comando `cdk bootstrap`. Esse comando executa as tarefas de inicialização descritas no tópico [Inicialização](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html) no *Guia do desenvolvedor do AWS Cloud Development Kit (AWS CDK) *.

## Versões do CDK CLI usadas pela ação AWS CDK "bootstrap”
<a name="cdk-boot-action-cdk-version"></a>

A tabela a seguir mostra qual versão da CLI do CDK é usada por padrão por diferentes versões da ação **Inicialização do AWS CDK **.

**nota**  
Talvez você consiga substituir o padrão. Para ter mais informações, consulte [CdkCliVersion](cdk-boot-action-ref.md#cdk.boot.cdk.cli.version) no [YAML da ação “Inicialização do AWS CDK ”](cdk-boot-action-ref.md).


| versão de ação “Inicialização do AWS CDK ” | AWS CDK Versão CLI | 
| --- | --- | 
|  1.0.0 – 1.0.7  |  mais recente  | 
|  1.0.8 ou posterior  |  2.99.1  | 

## Imagem de tempo de execução usada pela ação 'AWS CDK bootstrap'
<a name="cdk-boot-action-runtime"></a>

A tabela a seguir mostra as imagens do ambiente de execução CodeCatalyst usadas para executar diferentes versões da ação de **AWS CDK bootstrap**. As imagens incluem diferentes conjuntos de ferramentas pré-instaladas. Para obter mais informações, consulte [Imagens ativas](build-images.md#build-curated-images).

**nota**  
Recomendamos atualizar sua ação **Inicialização do AWS CDK ** para a versão 2.x para aproveitar as ferramentas mais recentes disponíveis na imagem de março de 2024. Para atualizar a ação, defina a propriedade `Identifier` como `aws/cdk-bootstrap@v2` no arquivo de definição de fluxo de trabalho. Para obter mais informações, consulte [YAML da ação “Implantação do AWS CDK ”](cdk-dep-action-ref.md). 


| versão de ação “Inicialização do AWS CDK ” | Imagens de ambiente de runtime | 
| --- | --- | 
|  1.x  |  Imagens de novembro de 2022  | 
|  2.x  |  Imagens de março de 2024  | 

# Exemplo: inicialização de um aplicativo AWS CDK
<a name="cdk-boot-action-example-workflow"></a>

Consulte o [Exemplo: implantação de um aplicativo AWS CDK](cdk-dep-action-example-workflow.md) na [Implantando um AWS CDK aplicativo com um fluxo de trabalho](cdk-dep-action.md) para obter um fluxo de trabalho que inclui a ação **AWS CDK bootstrap**.

# Adicionando a ação 'AWS CDK bootstrap'
<a name="cdk-boot-action-add"></a>

 Use as instruções a seguir para adicionar a ação **Inicialização do AWS CDK ** ao seu fluxo de trabalho. 

**Antes de começar**

Antes de usar a ação **Inicialização do AWS CDK **, verifique se você tem uma aplicação AWS CDK pronta. A ação bootstrap sintetizará o AWS CDK aplicativo antes da inicialização. Você pode escrever a aplicação em qualquer linguagem de programação compatível com o AWS CDK.

Verifique se os arquivos AWS CDK do seu aplicativo estão disponíveis em:
+ Um [repositório de CodeCatalyst origem](source.md) ou 
+ Um [artefato CodeCatalyst de saída](workflows-working-artifacts.md) gerado por outra ação do fluxo de trabalho

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

**Para adicionar a ação 'AWS CDK bootstrap' 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 **Inicialização do AWS CDK ** 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 **Inicialização do AWS CDK **. A caixa de diálogo de detalhes da ação é exibida. Nessa caixa de diálogo:
     + (Opcional) Selecione **Visualizar origem** 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**, **Configuração** e **Saídas**, preencha os campos de acordo com suas necessidades. Para ver uma descrição de cada campo, consulte [YAML da ação “Inicialização do AWS CDK ”](cdk-boot-action-ref.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.
**nota**  
Se a ação **Inicialização do AWS CDK ** falhar com um erro `npm install`, consulte [Como faço para corrigir erros de “instalação npm”?](troubleshooting-workflows.md#troubleshooting-workflows-npm) para ter informações sobre como corrigir o erro.

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

**Para adicionar a ação 'AWS CDK bootstrap' 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 **Inicialização do AWS CDK ** e selecione **\$1** para adicioná-la ao diagrama do fluxo de trabalho e abrir o 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 “Inicialização do AWS CDK ”](cdk-boot-action-ref.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.
**nota**  
Se a ação **Inicialização do AWS CDK ** falhar com um erro `npm install`, consulte [Como faço para corrigir erros de “instalação npm”?](troubleshooting-workflows.md#troubleshooting-workflows-npm) para ter informações sobre como corrigir o erro.

------

# variáveis de “Inicialização do AWS CDK ”
<a name="cdk-boot-action-variables"></a>

A ação **Inicialização do AWS CDK ** 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 | 
| --- | --- | 
|  deployment-platform  |  O nome da plataforma de implantação. Codificado para `AWS:CloudFormation`.  | 
|  region  |  O código de região em Região da AWS que a pilha de AWS CDK bootstrap foi implantada durante a execução do fluxo de trabalho. Exemplo: `us-west-2`  | 
|  stack-id  |  O Amazon Resource Name (ARN) da pilha de bootstrap implantada. AWS CDK  Exemplo: `arn:aws:cloudformation:us-west-2:111122223333:stack/codecatalyst-cdk-bootstrap-stack/6aad4380-100a-11ec-a10a-03b8a84d40df`  | 
|  SKIP-DEPLOYMENT  |  Um valor de `true` indica que a implantação da sua pilha de AWS CDK bootstrap foi ignorada durante a execução do fluxo de trabalho. Uma implantação da pilha será ignorada se não houver nenhuma alteração na pilha desde a última implantação. Essa variável só será produzida se o valor for `true`. Codificado para `true`.  | 

# YAML da ação “Inicialização do AWS CDK ”
<a name="cdk-boot-action-ref"></a>

Confira a seguir a definição de YAML da ação **Inicialização do AWS CDK **. Para saber como usar essa ação, consulte [Inicializando um AWS CDK aplicativo com um fluxo de trabalho](cdk-boot-action.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.    
  CDKBootstrapAction\$1nn: 
    Identifier: aws/cdk-bootstrap@v2
    DependsOn:
      - action-name
    Compute:  
      Type: EC2 | Lambda
      Fleet: fleet-name
    Timeout: timeout-minutes
    Inputs:
      # Specify a source or an artifact, but not both.
      Sources:
        - source-name-1
      Artifacts:
        - artifact-name
    Outputs:
      Artifacts:
        - Name: cdk_bootstrap_artifacts
          Files: 
            - "cdk.out/**/*"
    Environment:
      Name: environment-name
      Connections:
        - Name: account-connection-name
          Role: iam-role-name
    Configuration:
      Region: us-west-2
      CdkCliVersion: version
```

## CDKBootstrapAction
<a name="cdk.boot.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: `CDKBootstrapAction_nn`.

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

## Identifier
<a name="cdk.boot.identifier"></a>

(*CDKBootstrapAction*/**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).

**nota**  
A especificação de `aws/cdk-bootstrap@v2` faz com que a ação seja executada na [imagem de março de 2024](build-images.md#build.default-image), que inclui ferramentas mais recentes, como Node.js 18. A especificação de `aws/cdk-bootstrap@v1` faz com que a ação seja executada na [imagem de novembro de 2022](build-images.md#build.previous-image), que inclui ferramentas mais antigas, como Node.js 16.

Padrão: `aws/cdk-bootstrap@v2`.

Interface de usuário correspondente: Diagrama de fluxo de trabalho/CDKBootstrapAction\$1nn/rótulo **aws/cdk-bootstrap@v2**

## DependsOn
<a name="cdk.boot.dependson"></a>

(*CDKBootstrapAction*/**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="cdk.boot.computename"></a>

(*CDKBootstrapAction*/**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="cdk.boot.computetype"></a>

(*CDKBootstrapAction*/Compute/**Type**)

(Obrigatório se [Compute](#cdk.boot.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="cdk.boot.computefleet"></a>

(*CDKBootstrapAction*/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="cdk.boot.timeout"></a>

(*CDKBootstrapAction*/**Timeout**)

(Obrigatório)

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

## Inputs
<a name="cdk.boot.inputs"></a>

(*CDKBootstrapAction*/**Inputs**)

(Optional)

A seção `Inputs` define os dados que a ação **Inicialização do AWS CDK ** precisa durante a execução de um fluxo de trabalho.

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

**nota**  
Somente uma entrada (uma fonte ou um artefato) é permitida para cada ação **Inicialização do AWS CDK **.

## Sources
<a name="cdk.boot.inputs.sources"></a>

(*CDKBootstrapAction*/Inputs/**Sources**)

(Obrigatório se seu AWS CDK aplicativo estiver armazenado em um repositório de origem)

Se seu AWS CDK aplicativo estiver armazenado em um repositório de origem, especifique o rótulo desse repositório de origem. A ação **Inicialização do AWS CDK ** sintetiza a aplicação nesse repositório antes de iniciar o processo de inicialização. Atualmente, o único rótulo do repositório compatível é `WorkflowSource`.

Se seu AWS CDK aplicativo não estiver contido em um repositório de origem, ele deverá 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="cdk.boot.inputs.artifacts"></a>

(*CDKBootstrapAction*/Inputs/**Artifacts**)

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

Se seu AWS CDK aplicativo estiver contido em um artefato gerado por uma ação anterior, especifique esse artefato aqui. A ação **AWS CDK bootstrap** sintetiza o aplicativo no artefato especificado em um CloudFormation modelo antes de iniciar o processo de inicialização. Se a aplicação AWS CDK não estiver em um artefato, ela deverá 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 Entradas/**Artefatos - opcional**

## Outputs
<a name="cdk.boot.outputs"></a>

(*CDKBootstrapAction*/**Outputs**)

(Optional)

Define os dados que são gerados pela ação durante a execução de um fluxo de trabalho.

Interface de usuário correspondente: guia **Saídas**

## Artifacts - output
<a name="cdk.boot.outputs.artifacts"></a>

(*CDKBootstrapAction*/Outputs/**Artifacts**)

(Optional)

Especifique os artefatos gerados pela ação. Você pode referenciar esses artefatos como entrada em outras ações.

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 Saídas/**Artefatos**

## Name
<a name="cdk.boot.outputs.artifacts.name"></a>

(*CDKBootstrapAction*/Outputs/Artifacts/**Name**)

(Obrigatório se [Artifacts - output](#cdk.boot.outputs.artifacts) for incluído)

Especifique o nome do artefato que conterá o CloudFormation modelo sintetizado pela ação de **AWS CDK bootstrap** em tempo de execução. O valor padrão é `cdk_bootstrap_artifacts`. Se você não especificar um artefato, a ação sintetizará o modelo, mas não o salvará em um artefato. Pense em salvar o modelo sintetizado em um artefato para preservar um registro dele para fins de teste ou solução de problemas.

**UI correspondente: artefato de tab/Artifacts/Add saída/Nome do artefato de construção**

## Files
<a name="cdk.boot.outputs.artifacts.files"></a>

(*CDKBootstrapAction*/Outputs/Artifacts/**Files**)

(Obrigatório se [Artifacts - output](#cdk.boot.outputs.artifacts) for incluído)

Especifique os arquivos a serem incluídos no artefato. Você deve especificar `"cdk.out/**/*"` para incluir o modelo sintetizado CloudFormation do seu AWS CDK aplicativo.

**nota**  
`cdk.out` é o diretório padrão no qual os arquivos sintetizados são salvos. Se você especificou um diretório de saída diferente de `cdk.out` no arquivo `cdk.json`, especifique esse diretório aqui em vez de `cdk.out`.

**UI correspondente: produz tab/Artifacts/Add artefatos/arquivos produzidos pela compilação**

## Environment
<a name="cdk.boot.environment"></a>

(*CDKBootstrapAction*/**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="cdk.boot.environment.name"></a>

(*CDKBootstrapAction*/Environment/**Name**)

(Obrigatório se [Environment](#cdk.boot.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="cdk.boot.environment.connections"></a>

(*CDKBootstrapAction*/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="cdk.boot.environment.connections.name"></a>

(*CDKBootstrapAction*/Environment/Connections/**Name**)

(Obrigatório se [Connections](#cdk.boot.environment.connections) for incluído)

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="cdk.boot.environment.connections.role"></a>

(*CDKBootstrapAction*/Environment/Connections/**Role**)

(Obrigatório se [Connections](#cdk.boot.environment.connections) for incluído)

Especifique o nome da função do IAM que a ação **AWS CDK bootstrap** usa para acessar AWS e adicionar a pilha de bootstrap. 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 apropriadas.

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

## Configuration
<a name="cdk.boot.configuration"></a>

(*CDKBootstrapAction*/**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**

## Region
<a name="cdk.boot.region"></a>

(*CDKBootstrapAction*/Configuration/**Region**)

(Obrigatório)

Especifique Região da AWS no qual a pilha de bootstrap será implantada. Essa região deve corresponder àquela na qual seu AWS CDK aplicativo está implantado. Para obter uma lista dos códigos das regiões, consulte [Endpoints regionais](https://docs.aws.amazon.com/general/latest/gr/rande.html#region-names-codes).

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

## CdkCliVersion
<a name="cdk.boot.cdk.cli.version"></a>

(*CDKBootstrapAction*/Configuration/**CdkCliVersion**)

(Optional)

Essa propriedade está disponível com a versão 1.0.13 ou posterior da ação **Implantação do AWS CDK ** e a versão 1.0.8 ou posterior da ação **Inicialização do AWS CDK **.

Especifique um dos seguintes:
+ A versão completa da interface de linha de AWS Cloud Development Kit (AWS CDK) comando (CLI) (também chamada de AWS CDK kit de ferramentas) que você deseja que essa ação use. Exemplo: `2.102.1`. Considere especificar uma versão completa para garantir consistência e estabilidade ao criar e implantar a aplicação.

  Ou
+ `latest`. Pense em especificar `latest` para aproveitar os recursos e correções mais recentes da CLI do CDK.

A ação baixará a versão especificada (ou a versão mais recente) da AWS CDK CLI para a [imagem de CodeCatalyst compilação](build-images.md) e, em seguida, usará essa versão para executar os comandos necessários para implantar seu aplicativo CDK ou inicializar seu ambiente. AWS 

Para ter uma lista das versões compatíveis da CLI do CDK que você pode usar, consulte [Versões do AWS CDK](https://docs.aws.amazon.com/cdk/api/versions.html).

Se você omitir essa propriedade, a ação usará uma versão padrão da AWS CDK CLI descrita em um dos tópicos a seguir:
+ [Versões da CLI do CDK usadas pela ação 'implantar'AWS CDK](cdk-dep-action.md#cdk-dep-action-cdk-version) 
+ [Versões do CDK CLI usadas pela ação AWS CDK "bootstrap”](cdk-boot-action.md#cdk-boot-action-cdk-version)

UI correspondente: guia de configuração/versão **AWS CDK CLI**

# Publicação de arquivos no Amazon S3 com um fluxo de trabalho
<a name="s3-pub-action"></a>

Esta seção descreve como publicar arquivos no Amazon S3 usando um CodeCatalyst fluxo de trabalho. Para fazer isso, você deve adicionar a ação **Publicação no Amazon S3** ao seu fluxo de trabalho. A ação **Publicar do Amazon S3** copia arquivos de um diretório de origem para um bucket do Amazon S3. O diretório de origem pode residir em:
+ Um [repositório de origem](source.md) ou 
+ Um [artefato de saída](workflows-working-artifacts.md) gerado por outra ação do fluxo de trabalho

**Topics**
+ [Quando usar a ação “Publicação no Amazon S3”](#s3-pub-action-when-to-use)
+ [Imagem de runtime usada pela ação “Publicação no Amazon S3”](#s3-pub-action-runtime)
+ [Exemplo: publicação de arquivos no Amazon S3](s3-pub-action-example-workflow.md)
+ [Adicionar a ação “Publicação no Amazon S3”](s3-pub-action-add.md)
+ [Ação YAML de “Publicação no Amazon S3”](s3-pub-action-ref.md)

## Quando usar a ação “Publicação no Amazon S3”
<a name="s3-pub-action-when-to-use"></a>

Use esta ação se:
+ Você tiver um fluxo de trabalho que gera arquivos que você deseja armazenar no Amazon S3.

  Por exemplo, você pode ter um fluxo de trabalho que cria um site estático que deseja hospedar no Amazon S3. Nesse caso, seu fluxo de trabalho incluiria uma [ação de criação](build-add-action.md) para compilar os arquivos HTML e de suporte do site e uma ação **Publicação no Amazon S3** para copiar os arquivos no Amazon S3.
+ Você tem um repositório de origem que contém arquivos que deseja armazenar no Amazon S3.

  Por exemplo, você pode ter um repositório de origem com arquivos de origem da aplicação que deseja arquivar todas as noites no Amazon S3.

## Imagem de runtime usada pela ação “Publicação no Amazon S3”
<a name="s3-pub-action-runtime"></a>

A ação **Publicação no Amazon S3** é 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).

# Exemplo: publicação de arquivos no Amazon S3
<a name="s3-pub-action-example-workflow"></a>

O exemplo de fluxo de trabalho a seguir inclui a ação **Publicação no Amazon S3**, junto com uma ação de criação. O fluxo de trabalho compila um site de documentação estática e depois o publica no Amazon S3, onde está hospedado. 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** (`BuildDocs`) – No gatilho, a ação compila um site de documentação estática (`mkdocs build`) e adiciona os arquivos HTML associados e os metadados de suporte a um artefato chamado `MyDocsSite`. 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 **Publicação no Amazon S3** (`PublishToS3`) – Ao concluir a ação de criação, essa ação copia o site no artefato `MyDocsSite` para o Amazon S3 para hospedagem.

**nota**  
O exemplo de fluxo de trabalho a seguir serve para fins ilustrativos e não funcionará sem configuração adicional.

**nota**  
No código YAML a seguir, você pode omitir a seção `Connections:` se quiser. Se você omitir esta seção, deverá garantir que o perfil especificado no campo **Perfil do IAM padrão** em seu ambiente inclua as permissões e políticas de confiança exigidas pela ação **Publicação no Amazon S3**. 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). Para ter mais informações sobre as permissões e as políticas de confiança exigidas pela ação **Publicação no Amazon S3**, consulte a descrição da propriedade [Role](s3-pub-action-ref.md#s3.pub.environment.connections.role) em [Ação YAML de “Publicação no Amazon S3”](s3-pub-action-ref.md).

```
Name: codecatalyst-s3-publish-workflow
SchemaVersion: 1.0

Triggers:
  - Type: PUSH
    Branches:
      - main
Actions:
  BuildDocs:
    Identifier: aws/build@v1
    Inputs:
      Sources:
        - WorkflowSource
    Configuration:
      Steps:
        - Run: echo BuildDocs started on `date`
        - Run: pip install --upgrade pip
        - Run: pip install mkdocs
        - Run: mkdocs build
        - Run: echo BuildDocs completed on `date`
    Outputs:
      Artifacts:
      - Name: MyDocsSite
        Files:
          - "site/**/*"
        
  PublishToS3:
    Identifier: aws/s3-publish@v1
    Environment:
      Name: codecatalyst-s3-publish-environment
      Connections:
        - Name: codecatalyst-account-connection
          Role: codecatalyst-s3-publish-build-role
    Inputs:
      Sources:
        - WorkflowSource
      Artifacts:
        - MyDocsSite
    Configuration:      
      DestinationBucketName: amzn-s3-demo-bucket
      SourcePath: /artifacts/PublishToS3/MyDocSite/site
      TargetPath: my/docs/site
```

# Adicionar a ação “Publicação no Amazon S3”
<a name="s3-pub-action-add"></a>

 Use as instruções a seguir para adicionar a ação **Publicação no Amazon S3** ao seu fluxo de trabalho. 

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

**Para adicionar a ação “Publicação no Amazon S3” 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 **Publicação no Amazon S3** 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 **Publicação no Amazon S3**. A caixa de diálogo de detalhes da ação é exibida. Nessa caixa de diálogo:
     + (Opcional) Selecione **Visualizar origem** 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**, **Configuração** e **Saídas**, preencha os campos de acordo com suas necessidades. Para ver uma descrição de cada campo, consulte [Ação YAML de “Publicação no Amazon S3”](s3-pub-action-ref.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 “Publicação no Amazon S3” 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 **Publicação no Amazon S3** 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 **Publicação no Amazon S3**. A caixa de diálogo de detalhes da ação é exibida. Nessa caixa de diálogo:
     + (Opcional) Selecione **Visualizar origem** 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 [Ação YAML de “Publicação no Amazon S3”](s3-pub-action-ref.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.

------

# Ação YAML de “Publicação no Amazon S3”
<a name="s3-pub-action-ref"></a>

Confira a seguir a definição de YAML da ação **Publicação no Amazon S3**. Para saber como usar essa ação, consulte [Publicação de arquivos no Amazon S3 com um fluxo de trabalho](s3-pub-action.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.    
  S3Publish\$1nn: 
    Identifier: aws/s3-publish@v1
    DependsOn:
      - build-action
    Compute:  
      Type: EC2 | Lambda
      Fleet: fleet-name
    Timeout: timeout-minutes
    Inputs:
      Sources:
        - source-name-1
      Artifacts:
        - artifact-name
      Variables:
        - Name: variable-name-1
          Value: variable-value-1
        - Name: variable-name-2
          Value: variable-value-2
    Environment:
      Name: environment-name
      Connections:
        - Name: account-connection-name
          Role: iam-role-name
    Configuration:
      SourcePath: my/source
      DestinationBucketName: amzn-s3-demo-bucket
      TargetPath: my/target
```

## S3Publish
<a name="s3.pub.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: `S3Publish_nn`.

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

## Identifier
<a name="s3.pub.identifier"></a>

(*S3Publish*/**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/s3-publish@v1`.

Interface de usuário correspondente: Diagrama de fluxo de trabalho/S3Publish\$1nn/rótulo **aws/s3-publish@v1**

## DependsOn
<a name="s3.pub.dependson"></a>

(*S3Publish*/**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="s3.pub.computename"></a>

(*S3Publish*/**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="s3.pub.computetype"></a>

(*S3Publish*/Compute/**Type**)

(Obrigatório se [Compute](#s3.pub.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).

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

## Fleet
<a name="s3.pub.computefleet"></a>

(*S3Publish*/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`.

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

## Timeout
<a name="s3.pub.timeout"></a>

(*S3Publish*/**Timeout**)

(Obrigatório)

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

## Inputs
<a name="s3.pub.inputs"></a>

(*S3Publish*/**Inputs**)

(Optional)

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

**nota**  
São permitidas no máximo quatro entradas (uma origem e três artefatos) para cada ação **Implantação do AWS CDK **. As variáveis não são contadas nesse total.

Se você precisar consultar arquivos que residem em entradas diferentes (digamos, uma origem e um artefato), a entrada de origem será a entrada primária e o artefato será a entrada secundária. As referências a arquivos em entradas secundárias usam um prefixo especial para diferirem das primárias. Para obter detalhes, consulte [Exemplo: referência de arquivos em vários artefatos](workflows-working-artifacts-ex.md#workflows-working-artifacts-ex-ref-file).

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

## Sources
<a name="s3.pub.inputs.sources"></a>

(*S3Publish*/Inputs/**Sources**)

(Obrigatório se os arquivos que você deseja publicar no Amazon S3 estiverem armazenados em um repositório de origem)

Se os arquivos que você deseja publicar no Amazon S3 estiverem armazenados em um repositório de origem, especifique o rótulo desse repositório de origem. Atualmente, o único rótulo compatível é `WorkflowSource`.

Se os arquivos que você deseja publicar no Amazon S3 não estiverem contidos em um repositório de origem, eles devem 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="s3.pub.inputs.artifacts"></a>

(*S3Publish*/Inputs/**Artifacts**)

(Obrigatório se os arquivos que você deseja publicar no Amazon S3 estiverem armazenados em um [artefato de saída](workflows-working-artifacts-output.md) de uma ação anterior)

Se os arquivos que você deseja publicar no Amazon S3 estiverem em um artefato gerado por uma ação anterior, especifique esse artefato aqui. Se as aplicações não estiverem em um artefato, elas deverão residir no 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**

## Variables - input
<a name="s3.pub.inputs.variables"></a>

(*S3Publish*/Inputs/**Variables**)

(Optional)

Especifique uma sequência de name/value pares que defina as variáveis de entrada que você deseja disponibilizar para a ação. Os nomes de variável 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 variável.

Para ter mais informações sobre variáveis, inclusive exemplos, consulte [Uso de variáveis em fluxos de trabalho](workflows-working-with-variables.md).

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

## Environment
<a name="s3.pub.environment"></a>

(*S3Publish*/**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="s3.pub.environment.name"></a>

(*S3Publish*/Environment/**Name**)

(Obrigatório se [Environment](#s3.pub.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="s3.pub.environment.connections"></a>

(*S3Publish*/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="s3.pub.environment.connections.name"></a>

(*S3Publish*/Environment/Connections/**Name**)

(Obrigatório se [Connections](#s3.pub.environment.connections) for incluído)

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="s3.pub.environment.connections.role"></a>

(*S3Publish*/Environment/Connections/**Role**)

(Obrigatório se [Connections](#s3.pub.environment.connections) for incluído)

Especifique o nome da função do IAM que a ação de **publicação do Amazon S3** usa para acessar AWS e copiar arquivos para o Amazon S3. 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": [
          {
              "Sid": "VisualEditor0",
              "Effect": "Allow",
              "Action": [
                  "s3:PutObject",
                  "s3:ListBucket",
                  "s3:DeleteObject"
              ],
              "Resource": [
                  "arn:aws:s3:::bucket-name",
                  "arn:aws:s3:::bucket-name/*"
              ]
          }
      ]
  }
  ```

------
+ A política de confiança personalizada a seguir:

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

## Configuration
<a name="s3.pub.configuration"></a>

(*S3Publish*/**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**

## SourcePath
<a name="s3.pub.source.directory"></a>

(*S3Publish*/Configuration/**SourcePath**)

(Obrigatório)

Especifique o nome e o caminho de um diretório ou arquivo que você deseja publicar no Amazon S3. O diretório ou arquivo pode residir em um repositório de origem ou em um artefato de uma ação anterior e é relativo ao repositório de origem ou à raiz do artefato.

Exemplos:

A especificação `./myFolder/` copia o conteúdo de `/myFolder` para o Amazon S3 e preserva a estrutura de diretórios subjacente.

A especificação `./myFolder/myfile.txt` copia *somente *`myfile.txt` para o Amazon S3. (A estrutura de diretórios foi removida.)

Não é possível usar curingas.

**nota**  
Talvez seja necessário adicionar um prefixo ao diretório ou caminho do arquivo para indicar em qual artefato ou origem encontrá-lo. Para obter mais informações, consulte [Fazer referência a arquivos do repositório de origem](workflows-sources-reference-files.md) e [Referência de arquivos em um artefato](workflows-working-artifacts-refer-files.md).

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

## DestinationBucketName
<a name="s3.pub.dest.bucket"></a>

(*S3Publish*/Configuration/**DestinationBucketName**)

(Obrigatório)

Especifique o nome do bucket do Amazon S3 em que você deseja publicar os arquivos.

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

## TargetPath
<a name="s3.pub.dest.directory"></a>

(*S3Publish*/Configuration/**TargetPath**)

(Optional)

Especifique o nome e o caminho do diretório no Amazon S3 em que você deseja publicar seus arquivos. Se o diretório não existir, ele será criada. O caminho do diretório não deve incluir o nome do bucket.

Exemplos:

`myS3Folder`

`./myS3Folder/myS3Subfolder`

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

# Implantação em e Contas da AWS VPCs
<a name="deploy-environments"></a>

Usando [CodeCatalyst fluxos de trabalho](workflow.md), você pode implantar aplicativos e outros recursos para atingir Conta da AWS s e Amazon VPCs na AWS nuvem. Para habilitar essas implantações, você deve configurar CodeCatalyst ambientes.

Um CodeCatalyst *ambiente*, que não deve ser confundido com um [ambiente de desenvolvimento](https://docs.aws.amazon.com/codecatalyst/latest/userguide/devenvironment.html), define o Amazon VPC de destino Conta da AWS e opcional ao qual um CodeCatalyst [fluxo de trabalho](workflow.md) se conecta. Um ambiente também define a [função do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) que um fluxo de trabalho precisa para acessar os AWS serviços e recursos na conta de destino.

É possível configurar vários ambientes e atribuir a eles nomes, como desenvolvimento, teste, preparação e produção. Quando você implanta nesses ambientes, as informações sobre as implantações aparecem nas CodeCatalyst guias **Atividade** de **implantação e Destinos** de implantação no ambiente.

## Como começo a usar ambientes?
<a name="deploy-environments-get-started"></a>

As etapas de alto nível para adicionar e usar um CodeCatalyst ambiente são as seguintes:

1. No seu CodeCatalyst espaço, **conecte uma ou mais AWS contas**. Durante esse processo, adicione os perfis do IAM que seu fluxo de trabalho exige para acessar recursos na sua Conta da AWS. Para obter mais informações, consulte [Permitindo acesso a AWS recursos com conexão Contas da AWS](ipa-connect-account.md).

1. Em seu CodeCatalyst projeto, **crie um ambiente** que inclua uma das funções Conta da AWS s e IAM da etapa 1. Para obter mais informações, consulte [Criar um ambiente](deploy-environments-creating-environment.md).

1. Em seu CodeCatalyst projeto, em um fluxo de trabalho, **adicione uma [ação](workflows-actions.md) que aponte para o ambiente** que você criou na etapa 2. Para obter mais informações, consulte [Adição de uma ação a um fluxo de trabalho](workflows-add-action.md).

   Agora você configurou um ambiente. A ação agora pode implantar recursos na Conta da AWS especificada no ambiente.

**nota**  
Você também pode adicionar uma Amazon VPC ao ambiente. Para obter mais informações, consulte [Adicionar conexões VPC a um espaço](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-vpcs.add.html) no *Guia de CodeCatalyst Administração e.* [Associação de uma VPC a um ambiente](deploy-environments-associate-vpc.md)

## Podem existir vários ambientes em um único fluxo de trabalho?
<a name="deploy-environments-multiple"></a>

Sim. Se um fluxo de trabalho incluir várias ações, cada uma dessas ações poderá ser atribuída a um ambiente. Por exemplo, você pode ter um fluxo de trabalho que inclua duas ações de implantação, em que uma é atribuída a um ambiente `my-staging-enviroment` e outra a um ambiente `my-production-environment`.

## Quais ações de fluxo de trabalho oferecem suporte aos ambientes?
<a name="deploy-environments-supported"></a>

Qualquer ação de fluxo de trabalho que implanta recursos na AWS nuvem ou se comunica com os AWS serviços por outros motivos (como monitoramento e geração de relatórios) oferece suporte aos ambientes.

## Quais ações permitem que suas informações de implantação sejam exibidas CodeCatalyst?
<a name="deploy-environments-supported-targets"></a>

Das ações de fluxo de trabalho que oferecem suporte a ambientes, apenas algumas oferecem suporte para que suas informações de implantação sejam exibidas nas páginas **Atividade** de **implantação e Destinos** de implantação do CodeCatalyst console.

As ações de fluxo de trabalho a seguir permitem que as informações de implantação sejam exibidas:
+ **Deploy CloudFormation stack** — Para obter mais informações, consulte [Implantação de uma pilha CloudFormation](deploy-action-cfn.md)
+ **Implantar no Amazon ECS**: para ter mais informações, consulte [Implantação no Amazon ECS com um fluxo de trabalho](deploy-action-ecs.md)
+ **Implantar no cluster do Kubernetes**: para ter mais informações, consulte [Implantar no Amazon EKS com um fluxo de trabalho](deploy-action-eks.md)
+ **AWS CDK implantar** — Para obter mais informações, consulte [Implantando um AWS CDK aplicativo com um fluxo de trabalho](cdk-dep-action.md)

## Regiões aceitas
<a name="deploy-environments-supported-regions"></a>

A página **Ambientes** pode exibir recursos em qualquer região da AWS .

## Um ambiente é obrigatório?
<a name="deploy-environments-optional-or-mandatory"></a>

Um ambiente é obrigatório se a ação do fluxo de trabalho à qual ele está atribuído implantar recursos na AWS nuvem ou se comunicar com os AWS serviços por outros motivos (como monitoramento e geração de relatórios).

Por exemplo, se você tem uma ação de criação que cria um aplicativo, mas não precisa se comunicar com sua VPC Conta da AWS ou com a Amazon VPC, não é necessário atribuir um ambiente à ação. Se, no entanto, a ação de criação enviar registros para o CloudWatch serviço da Amazon em seu Conta da AWS, a ação deverá ter um ambiente atribuído. 

**Topics**
+ [Como começo a usar ambientes?](#deploy-environments-get-started)
+ [Podem existir vários ambientes em um único fluxo de trabalho?](#deploy-environments-multiple)
+ [Quais ações de fluxo de trabalho oferecem suporte aos ambientes?](#deploy-environments-supported)
+ [Quais ações permitem que suas informações de implantação sejam exibidas CodeCatalyst?](#deploy-environments-supported-targets)
+ [Regiões aceitas](#deploy-environments-supported-regions)
+ [Um ambiente é obrigatório?](#deploy-environments-optional-or-mandatory)
+ [Criar um ambiente](deploy-environments-creating-environment.md)
+ [Associação de um ambiente a uma ação](deploy-environments-add-app-to-environment.md)
+ [Associação de uma VPC a um ambiente](deploy-environments-associate-vpc.md)
+ [Associando um Conta da AWS a um ambiente](deploy-environments-associate-account.md)
+ [Alteração do perfil do IAM de uma ação](deploy-environments-switch-role.md)

# Criar um ambiente
<a name="deploy-environments-creating-environment"></a>

Use as instruções a seguir para criar um ambiente que você possa associar posteriormente a uma ação de fluxo de trabalho.

**Antes de começar**

Você precisará do seguinte:
+ Um CodeCatalyst espaço. Para obter mais informações, consulte [Configuração e login no CodeCatalystConfiguração e login no CodeCatalyst](setting-up-topnode.md).
+ Um CodeCatalyst projeto. Para obter mais informações, consulte [Criar um projeto com um esquema](projects-create.md#projects-create-console-template).
+ Uma conexão de AWS conta que inclui as funções do IAM que sua ação de fluxo de trabalho precisará acessar AWS. Para ter informações sobre a criação de uma conexão de conta, consulte [Permitindo acesso a AWS recursos com conexão Contas da AWS](ipa-connect-account.md). Você pode usar no máximo uma conexão de conta por ambiente.
**nota**  
Você pode criar um ambiente sem uma conexão de conta. No entanto, você precisará voltar e adicionar a conexão posteriormente.
+ Uma das seguintes CodeCatalyst funções:
  + **Administrador do espaço**
  + **Administrador do projeto**
  + **Contributor (Colaborador)**
**nota**  
Se você tiver o **Perfil de colaborador**, poderá criar um ambiente, mas não poderá associá-lo a uma conexão de Conta da AWS . Você precisará pedir a alguém com a função de **administrador do Space** ou **administrador do projeto** que associe o ambiente a uma Conta da AWS conexão.

   Para ter mais informações sobre permissões e perfis, consulte [Concessão de permissões de projeto aos usuários](projects-members.md).

**Para criar um ambiente**

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

1. Selecione o projeto.

1. No painel de navegação, selecione **CI/CD** e **Ambientes**.

1. Em **Nome do ambiente**, insira um nome, como **Production** ou **Staging**.

1. Em **Tipo de ambiente**, selecione uma das seguintes opções:
   + **Não produção**: um ambiente em que você pode testar a aplicação para garantir que ela esteja funcionando conforme o esperado antes de colocá-la em produção.
   + **Produção**: um ambiente “ativo” que está disponível publicamente e hospeda a aplicação finalizada.

     Se você selecionar **Produção**, um selo **Produção** aparecerá na interface de usuário ao lado de todas as ações às quais o ambiente esteja associado. O selo ajuda você a ver rapidamente quais ações estão sendo implantadas na produção. Além da aparência do selo, não há diferenças entre ambientes de produção e não produção.

1. (Opcional) Em **Descrição**, insira uma descrição como **Production environment for the hello-world app**.

1. Em **Conta da AWS conexão - opcional**, escolha a conexão de AWS conta que você deseja associar a esse ambiente. As ações de fluxo de trabalho atribuídas a esse ambiente poderão se conectar à Conta da AWS associada. Para obter mais informações sobre a criação de Conta da AWS conexões em CodeCatalyst, consulte[Permitindo acesso a AWS recursos com conexão Contas da AWS](ipa-connect-account.md).

   Se a Conta da AWS conexão que você deseja usar não estiver listada, talvez seja porque ela não é permitida em seu projeto. Para obter mais informações, consulte [Configuração de conexões de contas restritas a projetos](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-accounts-restriction.html) no *Amazon CodeCatalyst * Administrator Guide.

1. Em **Perfil do IAM padrão**, escolha o perfil do IAM que você deseja associar a esse ambiente. As ações de fluxo de trabalho atribuídas a esse ambiente herdarão essa função do IAM e poderão usá-la para se conectar aos serviços e recursos em seu Conta da AWS.

   Se você precisar atribuir o ambiente a várias ações e essas ações precisarem de perfis do IAM diferentes do padrão especificado aqui, você poderá especificar os diferentes perfis na guia **Configuração** de cada ação, usando a opção **Alternar perfil**. Para obter mais informações, consulte [Alteração do perfil do IAM de uma ação](deploy-environments-switch-role.md).

   Se a função do IAM que você deseja usar como padrão não estiver listada, pode ser porque você ainda não a adicionou à sua Conta da AWS conexão. Para 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).

1. (Opcional) Em **Conexão VPC**, escolha uma conexão VPC que você deseja associar a esse ambiente. Para obter mais informações sobre a criação de conexões VPC, consulte Gerenciando [Amazon Virtual Private Clouds](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-vpcs.html) no *Amazon CodeCatalyst Administrator Guide*.

   Se a conexão VPC que você deseja usar não estiver listada, talvez seja porque ela inclui uma Conta da AWS conexão que não é permitida em seu projeto. Para obter mais informações, consulte [Configuração de conexões de contas restritas a projetos](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-accounts-restriction.html) no *Amazon CodeCatalyst * Administrator Guide.

1. Escolha **Criar ambiente**. CodeCatalyst cria um ambiente vazio.

**Próximas etapas**
+ Agora que criou um ambiente, você pode associá-lo a uma ação de fluxo de trabalho. Para obter mais informações, consulte [Associação de um ambiente a uma ação](deploy-environments-add-app-to-environment.md).

# Associação de um ambiente a uma ação
<a name="deploy-environments-add-app-to-environment"></a>

Quando você associa um ambiente a uma [ação de fluxo de trabalho compatível](deploy-environments.md#deploy-environments-supported), a função padrão do IAM do ambiente e a Amazon VPC opcional são atribuídas à ação. Conta da AWS A ação pode se conectar e implantar na Conta da AWS usando o perfil do IAM e também se conectar à Amazon VPC opcional.

Use as instruções a seguir para associar um ambiente a uma ação.

## Etapa 1: associar o ambiente a uma ação de fluxo de trabalho
<a name="deploy-environments-add-app-to-environment-assoc"></a>

Use o procedimento a seguir para associar um ambiente a uma ação de fluxo de trabalho.

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

**Para associar um ambiente a uma ação de fluxo de trabalho 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 diagrama do fluxo de trabalho, escolha uma ação compatível com ambientes. Para obter mais informações, consulte [Quais ações permitem que suas informações de implantação sejam exibidas CodeCatalyst?](deploy-environments.md#deploy-environments-supported-targets).

1. Escolha a guia **Configuração** e especifique as informações no campo **Ambiente**, da seguinte forma.

   **Ambiente**

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

1. (Opcional) Altere o perfil do IAM associado à ação. Você talvez queira alterar o perfil se ele contiver o conjunto errado de permissões para a ação.

    Para alterar o perfil:

   1. No **What's in*my-environment*?** caixa e escolha o ícone de elipse vertical (). ![\[Ellipsis.\]](http://docs.aws.amazon.com/pt_br/codecatalyst/latest/userguide/images/flows/elipsis.png)

   1. Escolha uma das seguintes opções:
      +  **Alternar perfil**. Escolha essa opção para alterar o perfil do IAM usado por essa ação, e somente essa ação. Outras ações continuam usando o perfil do IAM padrão especificado no ambiente associado. Para obter mais informações, consulte [Alteração do perfil do IAM de uma ação](deploy-environments-switch-role.md).
      +  **Editar ambiente**. Escolha essa opção para alterar o perfil do IAM padrão listado em seu ambiente. Quando você escolhe essa opção, sua ação — e qualquer outra ação associada ao mesmo ambiente — começa a usar o novo perfil do IAM padrão.
**Importante**  
Tenha cuidado ao atualizar o perfil do IAM padrão. Alterar o perfil pode levar a falhas de ação se as permissões no perfil não forem suficientes para todas as ações que compartilham o ambiente.

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 associar um ambiente a uma ação de fluxo de trabalho 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. Na ação do fluxo de trabalho que você deseja associar a um ambiente, adicione um código semelhante ao seguinte:

   ```
   action-name:
     Environment:
       Name: environment-name
   ```

   Para ter mais informações, consulte o tópico [Tipos de ação](workflows-actions.md#workflows-actions-types). Este tópico tem links para a documentação de cada ação, incluindo a referência YAML.

1. (Opcional) Se você quiser que a ação use um perfil diferente do perfil do IAM padrão listado no ambiente, adicione uma seção `Connections:` que inclua o perfil que você deseja usar. Para obter mais informações, consulte [Alteração do perfil do IAM de uma ação](deploy-environments-switch-role.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.

------

## Etapa 2: preencher a página de atividades de implantação
<a name="deploy-environments-add-app-to-environment-run"></a>

Depois de associar um ambiente a uma ação de fluxo de trabalho, você pode preencher as páginas **Atividade de implantação** **e Destino** de implantação na seção **Ambientes** do CodeCatalyst console com informações de implantação. Use as instruções a seguir para preencher essas páginas.

**nota**  
Apenas algumas ações permitem que suas informações de implantação sejam exibidas no CodeCatalyst console. Para obter mais informações, consulte [Quais ações permitem que suas informações de implantação sejam exibidas CodeCatalyst?](deploy-environments.md#deploy-environments-supported-targets).

**Para adicionar informações de implantação ao CodeCatalyst**

1. Se a execução de um fluxo de trabalho não foi iniciada automaticamente quando você confirmou as alterações em [Etapa 1: associar o ambiente a uma ação de fluxo de trabalho](#deploy-environments-add-app-to-environment-assoc), inicie manualmente a execução da seguinte forma:

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

   A execução do fluxo de trabalho inicia uma nova implantação, o que faz com que CodeCatalyst as informações de implantação sejam adicionadas CodeCatalyst a.

1. Verifique se a atividade de implantação foi adicionada ao CodeCatalyst console:

   1. No painel de navegação, selecione **CI/CD** e **Ambientes**.

   1. Escolha seu ambiente (por exemplo, `Production`).

   1. Escolha a guia **Atividade de implantação** e verifique se uma implantação aparece com o **Status** **BEM-SUCEDIDO**. Isso indica que a execução de um fluxo de trabalho implantou os recursos da aplicação.

   1. Escolha a guia **Destinos de implantação** e verifique se os recursos da aplicação aparecem.

# Associação de uma VPC a um ambiente
<a name="deploy-environments-associate-vpc"></a>

Quando uma ação é configurada com um ambiente que tem uma conexão VPC, a ação é executada conectada à VPC, aderindo às regras de rede e aos recursos de acesso especificados pela VPC associada. A mesma conexão VPC pode ser usada por um ou mais ambientes.

Use as instruções a seguir para associar uma conexão VPC a um ambiente.

**Para associar uma conexão VPC a um ambiente**

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

1. Selecione o projeto.

1. No painel de navegação, selecione **CI/CD** e **Ambientes**.

1. Escolha seu ambiente (por exemplo, `Production`).

1. Escolha a guia **Propriedades do ambiente**.

1. Selecione **Gerenciar conexão VPC**, escolha a conexão VPC desejada e selecione **Confirmar**. Isso associa a conexão VPC selecionada a esse ambiente.
**nota**  
Se a conexão VPC que você deseja usar não estiver listada, talvez seja porque ela inclui uma Conta da AWS conexão que não é permitida em seu projeto. Para obter mais informações, consulte [Configuração de conexões de contas restritas a projetos](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-accounts-restriction.html) no *Amazon CodeCatalyst* Administrator Guide.

Para obter mais informações, consulte [Gerenciando Amazon Virtual Private Clouds](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-vpcs.html) no *Guia CodeCatalyst do Administrador*.

# Associando um Conta da AWS a um ambiente
<a name="deploy-environments-associate-account"></a>

Use as instruções a seguir para associar um Conta da AWS a um ambiente. Quando você associa um Conta da AWS a um ambiente, as ações do fluxo de trabalho atribuídas ao ambiente poderão se conectar ao Conta da AWS.

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

**Antes de começar**

Você precisará do seguinte:
+ Uma conexão de AWS conta que inclui as funções do IAM que sua ação de fluxo de trabalho precisará acessar AWS. Para ter informações sobre a criação de uma conexão de conta, consulte [Permitindo acesso a AWS recursos com conexão Contas da AWS](ipa-connect-account.md). Você pode usar no máximo uma conexão de conta por ambiente.
+ Uma das seguintes CodeCatalyst funções: **administrador do espaço ou administrador** **do projeto**. Para obter mais informações, consulte [Concessão de permissões de projeto aos usuários](projects-members.md).

**Para associar um Conta da AWS a um ambiente**

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

1. Selecione o projeto.

1. No painel de navegação, selecione **CI/CD** e **Ambientes**.

1. Escolha seu ambiente (por exemplo, `Production`).

1. Selecione **Editar ambiente**.

1. Em **Propriedades do ambiente**, na lista suspensa **Conexão da Conta da AWS - opcional**, escolha a Conta da AWS desejada.

   Se a Conta da AWS conexão que você deseja usar não estiver listada, talvez seja porque ela não é permitida em seu projeto. Para obter mais informações, consulte [Configuração de conexões de contas restritas a projetos](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-accounts-restriction.html) no *Amazon CodeCatalyst * Administrator Guide.

1. Em **Perfil do IAM padrão**, escolha o perfil do IAM que você deseja associar a esse ambiente. As ações de fluxo de trabalho atribuídas a esse ambiente herdarão essa função do IAM e poderão usá-la para se conectar aos serviços e recursos em seu Conta da AWS.

   Se a função do IAM que você deseja usar como padrão não estiver listada, pode ser porque você ainda não a adicionou à sua Conta da AWS conexão. Para 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).

# Alteração do perfil do IAM de uma ação
<a name="deploy-environments-switch-role"></a>

Por padrão, quando você associa um [ambiente](deploy-environments.md) a uma [ação](workflows-actions.md) de fluxo de trabalho, a ação herda o perfil do IAM padrão especificado no ambiente. Você pode alterar esse comportamento para que a ação use um perfil diferente. Talvez você queira que uma ação use um perfil diferente se o perfil do IAM padrão não tiver as permissões de que a ação precisa para operar na nuvem da AWS .

Para atribuir um perfil do IAM diferente a uma ação, você pode usar a opção **Alternar perfil** no editor visual ou a propriedade `Connections:` no editor YAML. O novo perfil substitui o perfil do IAM padrão especificado no ambiente, permitindo que você mantenha o perfil do IAM padrão como está. Talvez você queira manter o perfil do IAM padrão como está se houver outras ações que o usem.

Use as instruções a seguir para configurar uma ação para usar um perfil do IAM diferente do especificado no ambiente.

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

**Para atribuir um perfil do IAM diferente a uma açã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. Escolha a caixa que representa a ação cujo perfil do IAM você deseja atualizar.

1. Escolha a guia **Configuração**.

1. No **What's in*my-environment*?** caixa, escolha o ícone de elipse vertical (). ![\[Ellipsis.\]](http://docs.aws.amazon.com/pt_br/codecatalyst/latest/userguide/images/flows/elipsis.png)

1. Selecione **Alternar perfil**.

1. Na caixa de diálogo **Alternar perfil**, na lista suspensa **Perfil do IAM**, escolha o perfil do IAM que você deseja que a ação use. Esse perfil substituirá o perfil do IAM padrão no ambiente. Se o perfil que você deseja usar não estiver na lista, adicione-o ao seu espaço. Para obter mais informações, consulte [Adicionar perfis do IAM às conexões da conta](ipa-connect-account-addroles.md).

   A função escolhida agora aparece na seção **What's in*my-environment*?** caixa junto com um selo **Definido no fluxo de trabalho**. O perfil também aparece no arquivo de definição do fluxo de trabalho, na seção `Connections:`.

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 atribuir um perfil do IAM diferente a uma açã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. Na ação do fluxo de trabalho em que você deseja usar um perfil do IAM diferente, adicione uma seção `Connections:` semelhante à seguinte:

   ```
   action-name:
     Environment:
       Name: environment-name
       Connections: 
         - Name: account-connection-name
           Role: iam-role-name
   ```

   No código anterior, *account-connection-name* substitua pelo nome da [conexão da conta](ipa-connect-account.md) que contém a função do IAM e *iam-role-name* substitua pelo nome da função do IAM que você deseja que a ação use. Esse perfil substituirá o perfil do IAM padrão no ambiente. Verifique se adicionou o perfil ao seu espaço. Para obter mais informações, consulte [Adicionar perfis do IAM às conexões da conta](ipa-connect-account-addroles.md).

   Para ter mais informações, consulte o tópico [Tipos de ação](workflows-actions.md#workflows-actions-types). Este tópico tem links para a documentação de cada ação, incluindo a referência YAML.

------

# Exibir o URL da aplicação no diagrama do fluxo de trabalho
<a name="deploy-app-url"></a>

Se o seu fluxo de trabalho implantar um aplicativo, você poderá configurar CodeCatalyst a Amazon para exibir a URL do aplicativo como um link clicável. Esse link aparece no CodeCatalyst console, dentro da ação que o implantou. O diagrama de fluxo de trabalho a seguir mostra o URL de **Exibir aplicação** que aparece na parte inferior de uma ação.

![\[Exibir URL da aplicação\]](http://docs.aws.amazon.com/pt_br/codecatalyst/latest/userguide/images/deploy/view-app-url.png)


Ao tornar essa URL clicável no CodeCatalyst console, você pode verificar rapidamente a implantação do seu aplicativo.

**nota**  
O URL da aplicação não é compatível com a ação **Implantar no Amazon ECS**.

Para habilitar esse recurso, adicione uma variável de saída à sua ação com um nome que contenha `appurl` ou `endpointurl`. Você pode usar um nome com ou sem um traço (`-`), sublinhado (`_`) ou espaço (` `). A string diferencia maiúsculas e minúsculas. Defina o valor da variável como o URL `http` ou `https` da aplicação implantada.

**nota**  
Se você estiver atualizando uma variável de saída existente para incluir o `app url`, ou a string `endpoint url`, atualize todas as referências a essa variável para usar o novo nome da variável.

Para ver as etapas detalhadas, consulte um destes procedimentos:
+ [Para exibir o URL do aplicativo na ação “AWS CDK implantar”](#deploy-app-url-cdk)
+ [Para exibir o URL do aplicativo na ação “Implantar CloudFormation pilha”](#deploy-app-url-cfn)
+ [Para exibir o URL da aplicação em todas as outras ações](#deploy-app-url-other)

Quando terminar de configurar o URL, verifique se ele aparece conforme o esperado seguindo estas instruções:
+ [Como verificar se o URL da aplicação foi adicionado](#deploy-app-url-verify)<a name="deploy-app-url-cdk"></a>

**Para exibir o URL do aplicativo na ação “AWS CDK implantar”**

1. Se você estiver usando a ação de **AWS CDK implantação**, adicione uma `CfnOutput` construção (que é um par de valores-chave) no código do seu AWS CDK aplicativo:
   + O nome da chave deve conter `appurl`, ou`endpointurl`, com ou sem um traço (`-`), sublinhado (`_`) ou espaço (` `). A string diferencia maiúsculas e minúsculas.
   + O valor deve ser o URL `http` ou `https` da aplicação implantada.

   Por exemplo, seu AWS CDK código pode ter a seguinte aparência:

   ```
   import { Duration, Stack, StackProps, CfnOutput, RemovalPolicy} from 'aws-cdk-lib';
   import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
   import * as s3 from 'aws-cdk-lib/aws-s3';
   import { Construct } from 'constructs';
   import * as cdk from 'aws-cdk-lib';
   export class HelloCdkStack extends Stack {
     constructor(scope: Construct, id: string, props?: StackProps) {
       super(scope, id, props);
       const bucket = new s3.Bucket(this, 'amzn-s3-demo-bucket', {
         removalPolicy: RemovalPolicy.DESTROY,
       });
       new CfnOutput(this, 'APP-URL', {
         value: https://mycompany.myapp.com,
         description: 'The URL of the deployed application',
         exportName: 'myApp',
       });
       ...
     }
   }
   ```

   Para obter mais informações sobre a `CfnOutput` construção, consulte a [interface CfnOutputProps](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.CfnOutputProps.html) na *Referência AWS Cloud Development Kit (AWS CDK) da API*.

1. Salve e confirme seu código.

1. Vá para [Como verificar se o URL da aplicação foi adicionado](#deploy-app-url-verify).<a name="deploy-app-url-cfn"></a>

**Para exibir o URL do aplicativo na ação “Implantar CloudFormation pilha”**

1. Se você estiver usando a ação **Deploy CloudFormation stack**, adicione uma saída à `Outputs` seção em seu CloudFormation modelo ou AWS SAM modelo com estas características:
   + A chave (também chamada de ID lógico) deve conter `appurl`, ou`endpointurl`, com ou sem um traço (`-`), sublinhado (`_`) ou espaço (` `). A string diferencia maiúsculas e minúsculas.
   + O valor deve ser o URL `http` ou `https` da aplicação implantada.

   Por exemplo, seu CloudFormation modelo pode ter a seguinte aparência:

   ```
   "Outputs" : {
     "APP-URL" : {
       "Description" : "The URL of the deployed app",
       "Value" : "https://mycompany.myapp.com",
       "Export" : {
         "Name" : "My App"
       }
     }
   }
   ```

   Para obter mais informações sobre CloudFormation saídas, consulte [Saídas](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/outputs-section-structure.html) no Guia do *AWS CloudFormation usuário*.

1. Salve e confirme seu código.

1. Vá para [Como verificar se o URL da aplicação foi adicionado](#deploy-app-url-verify).<a name="deploy-app-url-other"></a>

**Para exibir o URL da aplicação em todas as outras ações**

Se você estiver usando outra ação para implantar seu aplicativo, como a ação de criação ou **GitHub Ações**, faça o seguinte para que a URL do aplicativo seja exibida.

1. Defina uma variável de ambiente na seção `Inputs` ou `Steps` da ação no arquivo de definição do fluxo de trabalho. A variável deve ter estas características:
   + O `name` deve conter `appurl`, ou `endpointurl`, com ou sem um traço (`-`), sublinhado (`_`) ou espaço (` `). A string diferencia maiúsculas e minúsculas.
   + O valor deve ser o URL `http` ou `https` da aplicação implantada.

   Por exemplo, uma ação de criação pode ser semelhante a esta:

   ```
   Build-action:
     Identifier: aws/build@v1
     Inputs:
       Variables:
         - Name: APP-URL
           Value: https://mycompany.myapp.com
   ```

   … Ou esta:

   ```
   Actions:
     Build:
       Identifier: aws/build@v1
       Configuration:    
         Steps:
           - Run: APP-URL=https://mycompany.myapp.com
   ```

   Para ter mais informações sobre definição de variáveis de ambiente, consulte [Definição de uma variável](workflows-working-with-variables-define-input.md).

1. Exporte a variável.

   Por exemplo, sua ação de criação pode ser semelhante a esta:

   ```
   Build-action:
     ...
     Outputs:
       Variables:
         - APP-URL
   ```

   Para ter informações sobre exportação de variáveis, consulte [Exportação de uma variável para que outras ações possam usá-la](workflows-working-with-variables-export-input.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.

1. Vá para [Como verificar se o URL da aplicação foi adicionado](#deploy-app-url-verify).<a name="deploy-app-url-verify"></a>

**Como verificar se o URL da aplicação foi adicionado**
+ Inicie a execução de um fluxo de trabalho, caso ele não tenha sido iniciado automaticamente. A nova execução deve ter o URL da aplicação exibido como um link clicável no diagrama de fluxo de trabalho. Para ter mais informações sobre como iniciar execuções, consulte [Iniciar um fluxo de trabalho executado manualmente](workflows-manually-start.md). 

# Remoção de um destino de implantação
<a name="deploy-remove-target"></a>

Você pode remover um destino de implantação, como um cluster ou CloudFormation pilha do Amazon ECS, da página de **destinos de implantação** no CodeCatalyst console.

**Importante**  
Quando você remove um destino de implantação, ele é removido do CodeCatalyst console, mas permanece disponível no AWS serviço que o hospeda (se ainda existir).

Considere remover um alvo de implantação se o alvo estiver obsoleto. CodeCatalyst Os destinos podem ficar obsoletos se:
+ Você excluir o fluxo de trabalho implantado no destino.
+ Você alterar a pilha ou o cluster no qual está implantando. 
+ Você excluiu a pilha ou o cluster do serviço Amazon ECS CloudFormation ou do Amazon ECS no AWS console.

**Para remover um destino de implantação**

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

1. Selecione o projeto.

1. No painel de navegação, selecione **CI/CD** e **Ambientes**.

1. Escolha o nome do ambiente que contém o destino de implantação que você deseja remover. Para ter informações sobre ambientes, consulte [Implantação em e Contas da AWS VPCs](deploy-environments.md).

1. Escolha a guia **Destinos de implantação**.

1. Marque a caixa de opção ao lado do destino de implantação que você deseja remover.

1. Escolha **Remover **.

   O destino é removido da página.

# Rastreamento do status de implantação por confirmação
<a name="track-changes"></a>

A qualquer momento do ciclo de vida do desenvolvimento, é importante conhecer o status de implantação de confirmações específicas, como correções de bugs, novos recursos ou outras mudanças impactantes. Pense nos seguintes cenários nos quais o recurso de rastreamento do status de implantação é útil para as equipes de desenvolvimento:
+ Como desenvolvedor, você fez uma correção para solucionar um bug e deseja relatar o status da sua implantação nos ambientes de implantação da sua equipe.
+ Como gerente de lançamento, você deseja visualizar uma lista de confirmações implantadas para rastrear e relatar o status de implantação.

CodeCatalyst fornece uma visualização que você pode usar para determinar rapidamente onde confirmações ou alterações individuais foram implantadas e em qual ambiente. Essa visualização inclui: 
+ Uma lista de confirmações.
+ O status das implantações que incluem as confirmações.
+ Os ambientes em que as confirmações são implantadas com sucesso.
+ O status de todos os testes executados em relação aos commits em seu CI/CD fluxo de trabalho.

O procedimento a seguir detalha como navegar até essa visualização e usá-la para rastrear alterações em seu projeto.

**nota**  
O rastreamento do status de implantação por confirmação só é compatível com [CodeCatalyst repositórios.](source.md) Você não pode usar esse recurso com um [GitHub repositório, repositório Bitbucket ou GitLab repositório de projetos](extensions.md).

**Para rastrear o status de implantação por confirmação**

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

1. Selecione o projeto.

1. No painel de navegação, selecione **CI/CD** e **Alterar rastreamento**.

1. Nas duas listas suspensas na parte superior do painel principal, escolha o repositório de origem e a ramificação que contêm os commits cujo status de lançamento você deseja visualizar.

1. Selecione **Visualizar alterações**.

   Uma lista de confirmações é exibida.

   Para cada confirmação, é possível visualizar o seguinte:
   + Confirme informações, como ID, autor, mensagem e quando foram confirmadas. 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).
   + O status das implantações em cada ambiente. Para obter mais informações, consulte [Implantação em e Contas da AWS VPCs](deploy-environments.md).
   + Resultados do teste e da cobertura do código. Para obter mais informações, consulte [Teste com fluxos de trabalhoTeste com fluxos de trabalho](test-workflow-actions.md).
**nota**  
Os resultados da Análise de composição de software (SCA) não são exibidos.

1. (Opcional) Para visualizar mais informações sobre as alterações relacionadas a uma confirmação específica, incluindo a implantação mais recente e informações detalhadas sobre a cobertura do código e o teste de unidade, selecione **Visualizar detalhes** para essa confirmação.

# Visualização dos logs de implantação
<a name="deploy-deployment-logs"></a>

Você pode visualizar registros relacionados a ações de implantação específicas para solucionar problemas na Amazon CodeCatalyst.

Você pode visualizar os logs em um [fluxo de trabalho](workflow.md) ou um [ambiente](deploy-environments.md).

**Para visualizar os logs de uma ação de implantação em um fluxo de trabalho**

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. Selecione **Execuções**.

1. Escolha a execução do fluxo de trabalho que implantou a aplicação.

1. No diagrama do fluxo de trabalho, escolha a ação cujos logs você deseja exibir.

1. Escolha a guia **Logs** e expanda as seções para revelar as mensagens de log.

1. Para ver mais registros, escolha a guia **Resumo** e, em seguida, escolha **Exibir em CloudFormation** (se estiver disponível) para ver mais registros lá. Talvez seja necessário fazer login na AWS.

**Para visualizar os logs de uma ação de implantação em um ambiente**

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

1. Selecione o projeto.

1. No painel de navegação, selecione **CI/CD** e **Ambientes**.

1. Escolha o ambiente no qual a aplicação foi implantada.

1. Em **Atividade de implantação**, encontre a coluna **ID de execução do fluxo de trabalho** e escolha a execução do fluxo de trabalho que implantou sua pilha.

1. No diagrama do fluxo de trabalho, escolha a ação cujos logs você deseja exibir.

1. Escolha a guia **Logs** e expanda as seções para revelar as mensagens de log.

1. Para ver mais registros, escolha a guia **Resumo** e, em seguida, escolha **Exibir em CloudFormation** (se estiver disponível) para ver mais registros lá. Talvez seja necessário fazer login na AWS.

# Visualizar informações de implantação
<a name="deploy-view-deployment-info"></a>

Você pode ver as seguintes informações sobre uma implantação na Amazon CodeCatalyst:
+ Atividade de implantação, incluindo o status da implantação, a hora de início, a hora de término, o histórico e a duração dos eventos.
+ Nome da pilha Região da AWS, horário da última atualização e fluxos de trabalho associados.
+ Confirmações e solicitações pull.
+ Informações específicas da ação, por exemplo, CloudFormation eventos e resultados.

Você pode visualizar as informações de implantação em um [fluxo de trabalho](workflow.md), um [ambiente](deploy-environments.md) ou uma [ação](workflows-concepts.md#workflows-concepts-actions) de fluxo de trabalho.

**Para visualizar as informações de implantação em um fluxo de trabalho**
+ Acesse a execução do fluxo de trabalho que implantou a aplicação. Para instruções, consulte [Visualização do status e detalhes de execução do fluxo de trabalho](workflows-view-run.md). 

**Para visualizar as informações de implantação em um ambiente**

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

1. Selecione o projeto.

1. No painel de navegação, selecione **CI/CD** e **Ambientes**.

1. Escolha o ambiente em que sua pilha foi implantada, por exemplo, `Production`.

1. Selecione **Atividade de implantação** para visualizar o histórico de implantação de suas pilhas, o status das implantações (por exemplo, **SUCCEEDED** ou **FAILED**) e outras informações relacionadas à implantação.

1. Selecione **Destino de implantação** para visualizar informações sobre as pilhas, clusters ou outros destinos implantados no ambiente. Você pode visualizar informações como nome da pilha, região, provedor e identificador.

**Para visualizar as informações de implantação em uma ação**

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. No diagrama do fluxo de trabalho, escolha a ação do fluxo de trabalho que implantou a aplicação. Por exemplo, você pode escolher **DeployCloudFormationStack**.

1. Revise o conteúdo no painel direito para ter informações de implantação específicas da ação.