Tutorial: Implantar um aplicativo na Amazon ECS - Amazon CodeCatalyst
Pré-requisitosEtapa 1: configurar um AWS usuário e AWS CloudShellEtapa 2: implantar um aplicativo de espaço reservado na Amazon ECSEtapa 3: criar um repositório de ECR imagens da AmazonEtapa 4: criar funções de criação e implantaçãoEtapa 5: adicionar AWS funções a CodeCatalystEtapa 6: criar um repositório de origemEtapa 7: Adicionar arquivos de origemEtapa 8: criar e executar um fluxo de trabalhoEtapa 9: faça uma alteração nos arquivos de origemLimpeza

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

Tutorial: Implantar um aplicativo na Amazon ECS

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

dica

Em vez de seguir este tutorial, você pode usar um plano que faz uma ECS configuração completa da Amazon para você. Você precisará usar o Node.js API com AWS Fargate ou o Java API com AWS Fargate blueprint. Para ter mais informações, consulte Criando um projeto com um blueprint.

Pré-requisitos

Antes de começar

  • Você precisa de um CodeCatalyst espaço com uma AWS conta conectada. Para ter mais informações, consulte Criando um espaço.

  • 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 ter mais informações, consulte Criando um projeto vazio na Amazon CodeCatalyst.

  • 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 a IAMfunção padrão, escolha qualquer função. Você especificará uma função diferente posteriormente.

    Para ter mais informações, consulte Implantação em e Contas da AWS VPCs.

Etapa 1: configurar um AWS usuário e AWS CloudShell

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

nota

Não use seu usuário root para este tutorial. Você deve criar um usuário separado, caso contrário poderá ter problemas ao executar ações no AWS Command Line Interface (CLI) posteriormente.

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

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 ( AWS icon ).

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

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

    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.

Etapa 2: implantar um aplicativo de espaço reservado na Amazon ECS

Nesta seção, você implanta manualmente um aplicativo de espaço reservado na AmazonECS. Esse aplicativo de espaço reservado será substituído pelo aplicativo Hello World implantado pelo seu fluxo de trabalho. O aplicativo de espaço reservado é o Apache Web Server.

Para obter mais informações sobre a AmazonECS, consulte o Amazon Elastic Container Service Developer Guide.

Conclua a série de procedimentos a seguir para implantar o aplicativo de espaço reservado.

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.

Etapa 3: criar um repositório de ECR imagens da Amazon

Nesta seção, você cria um repositório privado de imagens no Amazon Elastic Container Registry (AmazonECR). Esse repositório armazena a imagem Docker do tutorial que substituirá a imagem de espaço reservado do Apache que você implantou anteriormente.

Para obter mais informações sobre a AmazonECR, consulte o Guia do usuário do Amazon Elastic Container Registry.

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.

Etapa 4: criar AWS funções

Nesta seção, você cria AWS IAM funções que seu CodeCatalyst fluxo de trabalho precisará para funcionar. Essas funções são:

  • Criar função — Concede permissão à ação de CodeCatalyst criação (no fluxo de trabalho) para acessar sua AWS conta e gravar na Amazon ECR e na AmazonEC2.

  • Função CodeCatalyst Deploy — concede à ECS ação Deploy to (no fluxo de trabalho) permissão para acessar sua AWS contaECS, a Amazon e alguns outros AWS serviços.

Para obter mais informações sobre IAM funções, consulte IAMfunções no Guia AWS Identity and Access Management do usuário.

nota

Para economizar tempo, você pode criar uma única função, chamada de CodeCatalystWorkflowDevelopmentRole-spaceName função, em vez das duas funções listadas anteriormente. Para ter mais informações, consulte Criando a CodeCatalystWorkflowDevelopmentRole-spaceNamefunção para sua conta e espaço. Entenda que a CodeCatalystWorkflowDevelopmentRole-spaceName função tem permissões muito amplas que podem representar um risco de segurança. Recomendamos que você use essa função somente em tutoriais e cenários em que a segurança seja menos preocupante. Este tutorial pressupõe que você esteja criando as duas funções listadas anteriormente.

Para criar as funções de criação e implantação, você pode usar AWS Management Console o. ou AWS CLI o.

AWS Management Console

Para criar as funções de criação e implantação, conclua a série de procedimentos a seguir.

Para criar uma função de criação

  1. Crie uma política para a função, da seguinte forma:

    1. Faça login em AWS.

    2. Abra o console do IAM em https://console.aws.amazon.com/iam/.

    3. No painel de navegação, escolha Policies.

    4. Escolha Create policy.

    5. Escolha a guia JSON.

    6. Exclua o código existente.

    7. Cole o seguinte código:

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

      Na primeira vez em que a função for usada para executar ações de fluxo de trabalho, use o caractere curinga na declaração de política de recursos e, em seguida, defina o escopo da política com o nome do recurso depois que ele estiver disponível.

      "Resource": "*"

    8. Escolha Próximo: etiquetas.

    9. Selecione Next: Review (Próximo: revisar).

    10. Em Nome, insira:

      codecatalyst-ecs-build-policy

    11. Escolha Criar política.

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

  2. Crie a função de criação, da seguinte forma:

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

    2. Escolha a política de confiança personalizada.

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

    4. Adicione a seguinte política de confiança personalizada:

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

    5. Escolha Próximo.

    6. Em Políticas de permissões, pesquise codecatalyst-ecs-build-policy e marque sua caixa de seleção.

    7. Escolha Próximo.

    8. Em Nome da função, digite:

      codecatalyst-ecs-build-role

    9. Em Descrição da função, insira:

      CodeCatalyst ECS build role

    10. Selecione Criar função.

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

  3. Obtenha a função de construçãoARN, da seguinte forma:

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

    2. Na caixa de pesquisa, insira o nome da função que você acabou de criar (codecatalyst-ecs-build-role).

    3. Escolha a função na lista.

      A página de resumo da função é exibida.

    4. Na parte superior, copie o ARNvalor. Você precisará disso mais tarde.

Para criar uma função de implantação

  1. Crie uma política para a função, da seguinte forma:

    1. Faça login em AWS.

    2. Abra o console do IAM em https://console.aws.amazon.com/iam/.

    3. No painel de navegação, escolha Policies.

    4. Escolha Create Policy.

    5. Escolha a guia JSON.

    6. Exclua o código existente.

    7. Cole o seguinte código:

      {
    "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 a função for usada 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": "*"

    8. Escolha Próximo: etiquetas.

    9. Selecione Next: Review (Próximo: revisar).

    10. Em Nome, insira:

      codecatalyst-ecs-deploy-policy

    11. Escolha Criar política.

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

  2. Crie a função de implantação, da seguinte forma:

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

    2. Escolha a política de confiança personalizada.

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

    4. Adicione a seguinte política de confiança personalizada:

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

    5. Escolha Próximo.

    6. Em Políticas de permissões, pesquise codecatalyst-ecs-deploy-policy e marque sua caixa de seleção.

    7. Escolha Próximo.

    8. Em Nome da função, digite:

      codecatalyst-ecs-deploy-role

    9. Em Descrição da função, insira:

      CodeCatalyst ECS deploy role

    10. Selecione Criar função.

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

  3. Obtenha a função de implantaçãoARN, da seguinte forma:

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

    2. Na caixa de pesquisa, insira o nome da função que você acabou de criar (codecatalyst-ecs-deploy-role).

    3. Escolha a função na lista.

      A página de resumo da função é exibida.

    4. Na parte superior, copie o ARNvalor. Você precisará disso mais tarde.

AWS CLI

Para criar as funções de criação e implantação, conclua a série de procedimentos a seguir.

Para criar uma política de confiança para ambas as funções

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

  1. Crie o arquivo:

    cat > codecatalyst-ecs-trust-policy.json

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

    {
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "",
            "Effect": "Allow",
            "Principal": {
                "Service":  [
                   "codecatalyst-runner.amazonaws.com",
                   "codecatalyst.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.

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

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

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

      cat > codecatalyst-ecs-build-policy.json

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

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

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

  3. Na saída do comando, observe o "arn": valor, por exemplo,arn:aws:iam::111122223333:policy/codecatalyst-ecs-build-policy. Você precisa disso ARN mais tarde.

  4. Crie a função de criação e anexe a política de confiança a ela:

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

  5. Anexe a política de compilaçã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

    Em que arn:aws:iam::111122223333:policy/codecatalyst-ecs-build-policy é substituída pela política ARN de compilação que você anotou anteriormente.

  6. Exiba os detalhes da função de criação:

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

  7. Observe o "Arn": valor da função, por exemplo,arn:aws:iam::111122223333:role/codecatalyst-ecs-build-role. Você precisa disso ARN mais tarde.

Para criar a política de implantação e a função 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

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

      {
    "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 a função for usada para executar ações de fluxo de trabalho, use o caractere curinga na declaração de política de recursos e, em seguida, defina o escopo da política com o nome do recurso depois que ele estiver disponível.

      "Resource": "*"

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

  3. Na saída do comando, observe o "arn": valor da política de implantação, por exemplo,arn:aws:iam::111122223333:policy/codecatalyst-ecs-deploy-policy. Você precisa disso ARN mais tarde.

  4. Crie a função de implantação e anexe a política de confiança a ela:

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

  5. Anexe a política de implantação à função de implantação, onde arn:aws:iam::111122223333:policy/codecatalyst-ecs-deploy-policy é substituída pela política ARN 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

  6. Exiba os detalhes da função de implantação:

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

  7. Observe o "Arn": valor da função, por exemplo,arn:aws:iam::111122223333:role/codecatalyst-ecs-deploy-role. Você precisa disso ARN mais tarde.

Etapa 5: adicionar AWS funções a CodeCatalyst

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

Etapa 6: criar um repositório de origem

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 obter mais informações sobre repositórios de origem, consulteCriação de um repositório de origem.

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.

Etapa 7: Adicionar arquivos de origem

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 index.html arquivo — Exibe uma mensagem Hello World no navegador.

  • Um Dockerfile — descreve a imagem base a ser usada para sua imagem do Docker e os comandos do Docker a serem aplicados a ela.

  • Um taskdef.json arquivo — Define a imagem do Docker a ser usada ao iniciar tarefas em seu cluster.

A estrutura de pastas é a seguinte:

.
|— 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 Clonando um repositório de origem.

index.html

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

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.

Dockerfile

O Dockerfile descreve a imagem base do Docker a ser usada e os comandos do Docker a serem aplicados a ela. Para obter mais informações sobre o Dockerfile, consulte a Referência do Dockerfile.

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 EXPOSE instrução no Dockerfile diz ao Docker que o contêiner está escutando na porta 80.

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.

taskdef.json

O taskdef.json arquivo que você adiciona nesta etapa é o mesmo que você já especificou, Etapa 2: implantar um aplicativo de espaço reservado na Amazon ECS com a seguinte diferença:

Em vez de especificar um nome de imagem do Docker codificado no image: campo (httpd:2.4), a definição da tarefa aqui usa algumas variáveis para denotar a imagem: e. $REPOSITORY_URI $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 obter detalhes sobre os parâmetros de definição de tarefas, consulte Parâmetros de definição de tarefas no Amazon Elastic Container Service Developer Guide.

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.

Etapa 8: criar e executar um fluxo de trabalho

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

O fluxo de trabalho consiste nos seguintes blocos de construçã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 obter mais informações sobre gatilhos, consulte Iniciando um fluxo de trabalho executado automaticamente usando gatilhos.

  • Uma ação de construção (BuildBackend) — No gatilho, a ação cria a imagem do Docker usando o Dockerfile e envia a imagem para a Amazon. ECR A ação de criação também atualiza o taskdef.json com o valor de image campo correto e, em seguida, 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 obter mais informações sobre a ação de criação, consulteConstruindo com fluxos de trabalho.

  • 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 construção (TaskDefArtifact), encontra o taskdef.json interior dele e o registra no seu serviço da AmazonECS. Em seguida, o serviço segue as instruções no taskdef.json arquivo para executar três ECS tarefas da Amazon — e os contêineres Hello World Docker associados — dentro do seu cluster da 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.

  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.

Etapa 9: faça uma alteração nos arquivos de origem

Nesta seção, você faz uma alteração no index.html arquivo no seu repositório de origem. Essa alteração faz com que o fluxo de trabalho crie uma nova imagem do Docker, marque-a com um ID de confirmação, envie-a para a Amazon ECR e a implemente na AmazonECS.

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.

Limpeza

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

No AWS Management Console, limpe nesta ordem:

  1. Na AmazonECS, faça o seguinte:

    1. Excluircodecatalyst-ecs-service.

    2. Excluircodecatalyst-ecs-cluster.

    3. Cancelar registro de codecatalyst-ecs-task-definition.

  2. Na AmazonECR, excluacodecatalyst-ecs-image-repo.

  3. Na AmazonEC2, excluacodecatalyst-ecs-security-group.

  4. No IAM Identity Center, exclua:

    1. CodeCatalystECSUser

    2. CodeCatalystECSPermissionSet

No CodeCatalyst console, limpe da seguinte forma:

  1. Excluircodecatalyst-ecs-workflow.

  2. Excluircodecatalyst-ecs-environment.

  3. Excluircodecatalyst-ecs-source-repository.

  4. Excluircodecatalyst-ecs-project.

Neste tutorial, você aprendeu como implantar um aplicativo em um ECS serviço da Amazon usando um CodeCatalyst fluxo de trabalho e uma ECS ação Implantar na Amazon.