Tutorial: Implantar um aplicativo na Amazon ECS

Para criar um usuário do IAM Identity Center

1. Faça login no AWS Management Console e abra o AWS IAM Identity Center console em 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 de AWScontas. Para ter mais informações, consulte Criando 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, escolha 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 aos grupos, escolha Avançar.

10. Na página Revisar e adicionar usuário, revise as informações e escolha Adicionar usuário.

    Uma caixa de diálogo de senha de uso único é exibida.

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

12. Escolha Fechar.

Para criar um conjunto de permissões

Você atribuirá esse conjunto de permissões para CodeCatalystECSUser mais tarde.

1. No painel de navegação, escolha Conjuntos de permissões e, em seguida, escolha Criar conjunto de permissões.

2. Escolha Conjunto de permissões predefinido e, em seguida, selecione AdministratorAccess. Essa política fornece permissões completas para todos 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 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.

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ê 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 o portal de AWS acesso, o nome de usuário URL e a senha de uso único paraCodeCatalystECSUser. Você deveria ter copiado essas informações para um editor de texto anteriormente.

   nota

   Se você não tiver essas informações, vá para a página de CodeCatalystECSUser detalhes no IAM Identity Center, escolha Redefinir senha, Gerar uma senha de uso único [...] e redefina a senha novamente para exibir as informações na tela.

2. Sair de AWS.

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

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

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

   Uma caixa de Conta da AWS aparece na tela.

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

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

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

Para iniciar uma AWS CloudShell instância

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

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

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

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

2. Verifique se uma versão aparece.

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

Para criar a função de execução da tarefa

Essa função concede à Amazon ECS AWS Fargate permissão para fazer API chamadas 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.

   2. Insira o código a seguir no prompt:

      {
        "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 uma função 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 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

4. Exiba os detalhes da função:

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

5. Observe o "Arn": valor da função, por exemplo,arn:aws:iam::111122223333:role/codecatalyst-ecs-task-execution-role. Você precisará desse nome de recurso da Amazon (ARN) mais tarde.

Para criar um ECS cluster da Amazon

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

1. ComoCodeCatalystECSUser, em AWS CloudShell, crie um cluster vazio:

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

2. (Opcional) Verifique se o cluster foi criado com êxito:

   aws ecs list-clusters

   O ARN do codecatalyst-ecs-cluster 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, da qual foi extraída. DockerHub

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

   cat > taskdef.json

2. Cole o código a seguir no prompt:

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

   com a função ARN de execução da tarefa em que você anotouPara criar a função de execução da tarefa.

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 de definição de tarefas na Amazon ECS

1. ComoCodeCatalystECSUser, em AWS CloudShell, registre a definição da 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 codecatalyst-ecs-task-def tarefa deve aparecer na lista.

Para criar o ECS serviço Amazon

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

1. AssimCodeCatalystECSUser, mude para o console do Amazon Elastic Container Service, caso ainda não tenha feito isso.

2. Escolha o cluster que você criou anteriormente,codecatalyst-ecs-cluster.

3. Na guia Serviços, escolha Criar.

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

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

   2. Em Tipo de lançamento, 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, insira:

      3

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

   6. Expanda a seção Rede.

   7. Para VPC, escolha qualquer umVPC.

   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 sub-rede VPC and, crie-a. Consulte Criar uma VPC e Criar uma sub-rede VPC em seu Guia do VPC usuário da Amazon.

   9. Em Grupo de segurança, escolha Criar um novo grupo de segurança e, em seguida, faça o seguinte:

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

         codecatalyst-ecs-security-group

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

         CodeCatalyst ECS security group

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

   10. Na parte inferior, escolha Criar.

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

5. Escolha a guia Tarefas e, em seguida, escolha o botão Atualizar. Verifique se todas as três tarefas têm a coluna Último status definida como Em execução.

(Opcional) Para verificar se seu aplicativo 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 It Works! página é exibida. Isso indica que o ECS serviço da Amazon iniciou com sucesso uma tarefa que lançou um contêiner Docker com a imagem do Apache.

   Neste ponto do tutorial, você implantou manualmente uma definição de ECS cluster, serviço e tarefa da Amazon, bem como um aplicativo de espaço reservado do Apache. Com todos esses itens prontos, agora você está pronto para criar um fluxo de trabalho que substituirá o aplicativo de espaço reservado Apache pelo aplicativo Hello World do tutorial.

Para criar um repositório de imagens na Amazon ECR

1. Por CodeCatalystECSUser exemplo AWS CloudShell, crie um repositório vazio na AmazonECR:

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

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

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

3. Observe o “repositoryUri”: valor, 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 funções de criação e implantação à conexão da sua conta

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

2. Escolha AWS contas. Uma lista de conexões de conta é exibida.

3. Escolha a conexão de conta que representa a AWS conta em que você criou suas funções de criação e implantação.

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

   A página Adicionar IAM função ao CodeCatalyst espaço da Amazon é exibida. Talvez seja necessário fazer login para acessar a página.

5. Selecione Adicionar uma função existente na qual você criou IAM.

   Uma lista suspensa é exibida. A lista exibe todas as IAM funções com uma política de confiança que inclui os diretores codecatalyst-runner.amazonaws.com e codecatalyst.amazonaws.com de serviço.

6. Na lista suspensacodecatalyst-ecs-build-role, escolha e escolha Adicionar função.

   nota

   Se você verThe 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

7. Escolha Adicionar IAM função, escolha Adicionar uma função existente na qual você criou eIAM, na lista suspensa, escolha. codecatalyst-ecs-deploy-role Escolha Add role (adicionar função).

   Agora você adicionou as funções de criação e implantação ao seu espaço.

8. Copie o valor do nome de CodeCatalyst exibição da Amazon. Você precisará desse valor posteriormente, ao criar seu fluxo de trabalho.

Como criar um repositório de origem

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

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

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

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

5. Em Nome do repositório, digite:

   codecatalyst-ecs-source-repository

6. Escolha Criar.

Para adicionar o arquivo index.html

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

2. Em Arquivos, escolha Criar arquivo.

3. Em Nome do arquivo, digite:

   public-html/index.html

   Importante

   Certifique-se de incluir o public-html/ prefixo para criar uma pasta com o mesmo nome. index.htmlEspera-se que o esteja nessa pasta.

4. Na caixa de texto, insira o seguinte código:

   <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. Escolha Confirmar e, em seguida, escolha Confirmar novamente.

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

Para adicionar o Dockerfile

1. No seu repositório de origem, escolha Criar arquivo.

2. Em Nome do arquivo, digite:

   Dockerfile

   Não inclua uma extensão de arquivo.

   Importante

   O Dockerfile deve residir na pasta raiz do seu repositório. O Docker build comando do fluxo de trabalho espera que ele esteja lá.

3. Na caixa de texto, insira o seguinte código:

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

4. Escolha Confirmar e, em seguida, escolha Confirmar novamente.

   O Dockerfile é adicionado ao seu repositório.

Para adicionar o arquivo taskdef.json

1. No seu repositório de origem, escolha Criar arquivo.

2. Em Nome do arquivo, digite:

   taskdef.json

3. Na caixa de texto, insira o seguinte código:

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

   com a função ARN de execução da tarefa em que você anotouPara criar a função de execução da tarefa.

4. Escolha Confirmar e, em seguida, escolha Confirmar novamente.

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

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.

2. Escolha Criar fluxo de trabalho.

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

4. Para Branch, escolhamain.

5. Escolha Criar.

6. Exclua o código de YAML amostra.

7. Adicione o YAML código a seguir:

   nota

   No YAML código a seguir, você pode omitir as Connections: seções, se quiser. Se você omitir essas seções, deverá garantir que a função especificada no campo Função padrão IAM em seu ambiente inclua as permissões e as políticas de confiança de ambas as funções descritas emEtapa 5: adicionar AWS funções a CodeCatalyst. Para obter mais informações sobre como configurar um ambiente com uma IAM função padrão, consulteCriar 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:

   • Ambas as instâncias de codecatalyst-ecs-environment com o nome do ambiente em que você criouPré-requisitos.

   • Ambas as instâncias de 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 ter mais informações, consulte Etapa 5: adicionar AWS funções a CodeCatalyst.

   • codecatalyst-ecs-build-role com o nome da função de construção em que você criouEtapa 4: criar AWS funções.

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

   • 111122223333.dkr.ecr.us-west-2.amazonaws.com (no Run: aws ecr comando) com o do ECR repositório URI da Amazon 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ê criouEtapa 4: criar AWS funções.

   • Ambas as instâncias de us-west-2 com seu código de AWS região. Para obter uma lista de códigos de região, consulte Endpoints regionais no Referência geral da AWS.

   nota

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

   dica

   Em vez de usar os sed comandos find e 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 ECS tarefas Render Amazon para essa finalidade. Para ter mais informações, consulte Modificando uma definição de ECS tarefa da Amazon.

8. (Opcional) Escolha Validar para garantir que o YAML código 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 Confirmar mensagem, remova o texto e digite:

       Add first workflow

    2. Para Repositório, escolhacodecatalyst-ecs-source-repository.

    3. Em Nome da filial, escolha 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 workflow.yaml arquivo ao seu repositório de origem, o gatilho iniciou a execução do fluxo de trabalho.

Para ver o progresso 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.

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

3. Escolha BuildBackendver o progresso da compilação.

4. Escolha DeployToECSver o progresso da implantação.

   Para obter mais informações sobre a visualização dos detalhes da execução, consulteVisualizando o status e os detalhes da execução do fluxo de trabalho.

Para verificar a implantação

1. Abra o console ECS clássico da Amazon 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 ECS serviço da Amazon implantou seu aplicativo com sucesso.

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

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 Hello World texto paraTutorial complete!.

5. Escolha Confirmar e, em seguida, 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, escolha Exibir confirmações e anote a ID da confirmação da index.html alteração.

7. Assista ao progresso da implantação:

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

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

   3. Escolha BuildBackende veja DeployToECSo progresso da execução do fluxo de trabalho.

8. Verifique se seu aplicativo foi atualizado, da seguinte forma:

   1. Abra o console ECS clássico da Amazon 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 Tutorial complete! página é exibida.

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