Tutorial: Implantar uma aplicação no Amazon ECS

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

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

   nota

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

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

3. Em Nome de usuário, digite:

   CodeCatalystECSUser

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

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

6. Em Nome e Sobrenome, digite:

   CodeCatalystECSUser

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

   CodeCatalystECSUser CodeCatalystECSUser

8. Escolha Próximo.

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

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

11. Selecione Copiar e cole as informações de login, incluindo o URL do portal de acesso da AWS e a senha de uso único.

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

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

3. Escolha Próximo.

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

   CodeCatalystECSPermissionSet

5. Escolha Próximo.

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

Para atribuir o conjunto de permissões a CodeCatalystECSUser

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

2. Escolha Atribuir usuários ou grupos.

3. Escolha a guia Users.

4. Marque a caixa de seleção ao lado dos logs do CodeCatalystECSUser.

5. Escolha Próximo.

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

7. Escolha Próximo.

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

   Agora você atribuiu CodeCatalystECSUser e CodeCatalystECSPermissionSet à sua Conta da AWS, vinculando-os.

Para sair e entrar novamente como CodeCatalystECSUser

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

2. Saia da AWS.

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

4. Faça login com o nome de usuário e a senha de uso único para CodeCatalystECSUser.

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

   Uma caixa de Conta da AWS aparece na tela.

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

7. Ao lado de CodeCatalystECSPermissionSet, selecione Console de gerenciamento.

   O AWS Management Console aparece. Agora você está conectado como CodeCatalystECSUser com as permissões apropriadas.

Para iniciar uma instância do AWS CloudShell

1. Como CodeCatalystECSUser, na barra de navegação superior, escolha o ícone AWS ( ).

   A página principal do AWS Management Console é exibida.

2. Na barra de navegação superior, escolha o ícone AWS CloudShell ( ).

   O CloudShell é aberto. Aguarde enquanto o ambiente do CloudShell é criado.

   nota

   Se você não vê o ícone do CloudShell, verifique se está em uma região compatível com o CloudShell. Este tutorial pressupõe que você esteja na região do Oeste dos EUA (Oregon).

Para verificar se a AWS CLI está instalada

1. No terminal do CloudShell, insira:

   aws --version

2. Confira se uma versão é exibida.

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

Como criar o perfil de execução de tarefas

Esse perfil concede ao Amazon ECS e AWS Fargate permissão para fazer chamadas de API em seu nome.

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

   1. No AWS CloudShell, insira o seguinte comando:

      cat > codecatalyst-ecs-trust-policy.json

      Um prompt piscando aparece no terminal do CloudShell.

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

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

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

   4. Pressione Enter e, depois, Ctrl+d para salvar o arquivo e sair do cat.

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

3. Anexe a política AmazonECSTaskExecutionRolePolicy gerenciada pela AWS ao perfil:

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

4. Exiba os detalhes do perfil:

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

5. 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, no AWS CloudShell, crie um cluster vazio:

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

2. (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 do Docker (httpd:2.4) do servidor Web Apache 2.4, que é extraída do DockerHub.

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

   cat > taskdef.json

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

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

4. Pressione Enter e, depois, Ctrl+d para salvar o arquivo e sair do cat.

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

1. Como CodeCatalystECSUser, no AWS CloudShell, registre a definição de tarefa:

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

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

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

3. Na guia Serviços, selecione Criar.

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

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

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

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

      codecatalyst-ecs-task-def

   4. Em Nome do serviço, digite:

      codecatalyst-ecs-service

   5. Em Tarefas desejadas, digite:

      3

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

   6. Expanda a seção Rede.

   7. Em VPC, escolha qualquer VPC.

   8. 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 e Criar uma sub-rede na VPC no Guia do usuário da Amazon VPC.

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

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

         CodeCatalyst ECS security group

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

   10. Selecione Criar na parte inferior.

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

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

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

Para criar um repositório de imagens no Amazon ECR

1. Como CodeCatalystECSUser, no AWS CloudShell, crie um repositório vazio no Amazon ECR:

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

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

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

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

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

1. Navegue até o seu espaço no CodeCatalyst.

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

3. Escolha a conexão de conta que representa a conta da AWS em que você criou os perfis de criação e implantação.

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

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

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

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

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

8. Copie o valor do Nome de exibição do Amazon CodeCatalyst. Esse valor será necessário posteriormente, ao criar seu fluxo de trabalho.

Como criar um repositório de origem

1. Abra o console do CodeCatalyst em https://codecatalyst.aws/.

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

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

4. Escolha Adicionar repositório e selecione Criar repositório.

5. Em Nome do repositório, insira:

   codecatalyst-ecs-source-repository

6. Escolha Criar.

Como adicionar o arquivo index.html

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

2. Em Arquivos, selecione Criar arquivo.

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

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

5. Selecione Confirmar e, depois, escolha Confirmar novamente.

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

Para adicionar o Dockerfile

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

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

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

4. Selecione Confirmar e, depois, escolha Confirmar novamente.

   O Dockerfile é adicionado ao repositório.

Como adicionar o arquivo taskdef.json

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

2. Em Nome do arquivo, insira:

   taskdef.json

3. 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_ID: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.

4. Selecione Confirmar e, depois, escolha Confirmar novamente.

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

Como criar um fluxo de trabalho

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

2. Selecione Criar fluxo de trabalho.

3. Em Repositório de origem, selecione codecatalyst-ecs-source-repository.

4. Em Ramificação, selecione main.

5. Escolha Criar.

6. Exclua o código de amostra YAML.

7. 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 perfis da AWS ao CodeCatalyst. Para ter mais informações sobre como configurar um ambiente com um perfil do IAM padrão, consulte Criar um ambiente.

   Name: codecatalyst-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:

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

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

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

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

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

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

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

   nota

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

   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 ter mais informações, consulte Modificação de uma definição de tarefa do Amazon ECS.

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

9. Escolha Commit (Confirmar).

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

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

       Add first workflow

    2. Em Repositório, selecione codecatalyst-ecs-source-repository.

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

    4. Escolha Commit (Confirmar).

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

Para visualizar o andamento da execução do fluxo de trabalho

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

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

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

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

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

Como verificar a implantação

1. Abra o console clássico do Amazon ECS em https://console.aws.amazon.com/ecs/.

2. Escolha seu cluster, codecatalyst-ecs-cluster.

3. Escolha a guia Tasks (Tarefas).

4. Escolha qualquer uma das três tarefas.

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

Para alterar o index.html

1. No console do CodeCatalyst, no painel de navegação, selecione Código e, depois, selecione Repositórios de origem e, depois, escolha seu repositório, codecatalyst-ecs-source-repository.

2. Escolha public-html e, depois, escolha index.html.

   O conteúdo de index.html aparece.

3. Selecione a opção Editar.

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

5. Selecione Confirmar e, depois, escolha Confirmar novamente.

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

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

7. Assista ao andamento da implantação:

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

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

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

8. 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/.

   2. Escolha seu cluster, codecatalyst-ecs-cluster.

   3. Escolha a guia Tasks (Tarefas).

   4. Escolha qualquer uma das três tarefas.

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

      Uma página Tutorial complete! é exibida.

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