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

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