Tutorial: Implantação padrão do Amazon ECS com o CodePipeline - AWS CodePipeline
Pré-requisitosEtapa 1: Adicionar um arquivo de especificação de compilação ao repositório de origemEtapa 2: Criar uma pipeline de implantação contínuaEtapa 3: Adicionar permissões do Amazon ECR ao perfil do CodeBuildEtapa 4: Testar o pipeline

Tutorial: Implantação padrão do Amazon ECS com o CodePipeline

Este tutorial ajuda você a criar um pipeline de implantação contínua (CD) completo e abrangente com o Amazon ECS, por meio do CodePipeline.

Importante

Como parte da criação de um pipeline no console, um bucket de artefatos do S3 será usado pelo CodePipeline para artefatos. (Este bucket não é o mesmo utilizado para uma ação de origem do S3.) Se o bucket de artefatos do S3 estiver em uma conta diferente da conta do pipeline, garanta que o bucket de artefatos do S3 seja de propriedade de Contas da AWS seguras e confiáveis.

nota

Este tutorial destina-se à ação de implantação padrão do Amazon ECS para o CodePipeline. Para assistir a um tutorial que usa a ação de implantação azul/verde do Amazon ECS para o CodeDeploy no CodePipeline, consulte Tutorial: Criar um pipeline com a origem do Amazon ECR e a implantação do ECS para CodeDeploy.

nota

Este tutorial se destina à ação de implantação padrão do Amazon ECS para o CodePipeline com uma ação de origem. Para ver um tutorial que use a ação de implantação padrão do Amazon ECS com a ação de compilação ECRBuildAndPublish no CodePipeline para enviar a imagem por push, consulte Tutorial: Compilar e enviar por push uma imagem do Docker para o Amazon ECR com o CodePipeline (tipo V2).

Pré-requisitos

Para você usar este tutorial para criar seu pipeline de CD, alguns recursos precisam estar em operação. Veja aqui estão os itens que você precisa para começar:

nota

Todos esses recursos devem ser criados na mesma região da AWS.

  • Um repositório de controle de origem (este tutorial usa o CodeCommit) com seu Dockerfile e a origem da aplicação. Para obter mais informações, consulte Criar um repositório do CodeCommit no Guia do usuário do AWS CodeCommit.

  • Um repositório de imagens de Docker (este tutorial usa o Amazon ECR) que contém uma imagem criada com o Dockerfile e a origem da aplicação. Para obter mais informações, consulte Criação de um repositório e Envio de uma imagem por push no Guia do usuário do Amazon Elastic Container Registry.

  • Uma definição de tarefa do Amazon ECS que faz referência à imagem do Docker hospedada em seu repositório de imagens. Para obter mais informações, consulte Como criar uma definição de tarefa no Guia do desenvolvedor do Amazon Elastic Container Service.

    Importante

    A ação de implantação padrão do Amazon ECS para o CodePipeline cria sua própria revisão da definição de tarefa com base na revisão usada pelo serviço Amazon ECS. Se você criar novas revisões para a definição de tarefa sem atualizar o serviço Amazon ECS, a ação de implantação ignorará essas revisões.

    Veja a seguir um exemplo de definição de tarefa usado neste tutorial. O valor que você usa em name e family será usado na próxima etapa do seu arquivo de especificação de compilação.

    {
  "ipcMode": null,
  "executionRoleArn": "role_ARN",
  "containerDefinitions": [
    {
      "dnsSearchDomains": null,
      "environmentFiles": null,
      "logConfiguration": {
        "logDriver": "awslogs",
        "secretOptions": null,
        "options": {
          "awslogs-group": "/ecs/hello-world",
          "awslogs-region": "us-west-2",
          "awslogs-stream-prefix": "ecs"
        }
      },
      "entryPoint": null,
      "portMappings": [
        {
          "hostPort": 80,
          "protocol": "tcp",
          "containerPort": 80
        }
      ],
      "command": null,
      "linuxParameters": null,
      "cpu": 0,
      "environment": [],
      "resourceRequirements": null,
      "ulimits": null,
      "dnsServers": null,
      "mountPoints": [],
      "workingDirectory": null,
      "secrets": null,
      "dockerSecurityOptions": null,
      "memory": null,
      "memoryReservation": 128,
      "volumesFrom": [],
      "stopTimeout": null,
      "image": "image_name",
      "startTimeout": null,
      "firelensConfiguration": null,
      "dependsOn": null,
      "disableNetworking": null,
      "interactive": null,
      "healthCheck": null,
      "essential": true,
      "links": null,
      "hostname": null,
      "extraHosts": null,
      "pseudoTerminal": null,
      "user": null,
      "readonlyRootFilesystem": null,
      "dockerLabels": null,
      "systemControls": null,
      "privileged": null,
      "name": "hello-world"
    }
  ],
  "placementConstraints": [],
  "memory": "2048",
  "taskRoleArn": null,
  "compatibilities": [
    "EC2",
    "FARGATE"
  ],
  "taskDefinitionArn": "ARN",
  "family": "hello-world",
  "requiresAttributes": [],
  "pidMode": null,
  "requiresCompatibilities": [
    "FARGATE"
  ],
  "networkMode": "awsvpc",
  "cpu": "1024",
  "revision": 1,
  "status": "ACTIVE",
  "inferenceAccelerators": null,
  "proxyConfiguration": null,
  "volumes": []
}

  • Um cluster do Amazon ECS que executa um serviço que usa a definição de tarefa mencionada anteriormente. Para obter mais informações, consulte Criação de um cluster e Criação de um serviço no Guia do desenvolvedor do Amazon Elastic Container Service.

Assim que você atender a esses pré-requisitos, poderá continuar com o tutorial e criar seu pipeline de CD.

Etapa 1: Adicionar um arquivo de especificação de compilação ao repositório de origem

Este tutorial usa o CodeBuild para criar sua imagem do Docker e enviá-la por push ao Amazon ECR. Adicione um arquivo buildspec.yml ao repositório de código-fonte para informar ao CodeBuild como fazer isso. O exemplo de especificação de compilação abaixo faz o seguinte:

  • Estágio pré-compilação:

    • Faça login no Amazon ECR.

    • Defina a URI de repositório de sua imagem ECR e adicione uma tag de imagem com os primeiros sete caracteres do ID de confirmação do Git da origem.

  • Estágio de compilação:

    • Crie a imagem de docker e marque-a como latest e com o ID de confirmação do Git.

  • Estágio pós-compilação:

    • Envie por push a imagem para o repositório do ECR com ambas as tags.

    • Grave um arquivo denominado imagedefinitions.json na raiz da compilação que contém o nome de contêiner, a imagem e tag do serviço do Amazon ECS. O estágio de implantação do pipeline de CD usa essas informações para criar uma nova revisão da definição de tarefa do serviço e, em seguida, atualiza o serviço para usar a nova definição de tarefa. O arquivo imagedefinitions.json é necessário para o operador de trabalho do ECS.

Cole este texto de exemplo para criar seu arquivo buildspec.yml e substitua os valores para definição da imagem e da tarefa. Este texto usa o exemplo de ID de conta 111122223333.

version: 0.2

phases:
  pre_build:
    commands:
      - echo Logging in to Amazon ECR...
      - aws --version
      - aws ecr get-login-password --region $AWS_DEFAULT_REGION | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-west-2.amazonaws.com
      - REPOSITORY_URI=012345678910.dkr.ecr.us-west-2.amazonaws.com/hello-world
      - COMMIT_HASH=$(echo $CODEBUILD_RESOLVED_SOURCE_VERSION | cut -c 1-7)
      - IMAGE_TAG=${COMMIT_HASH:=latest}
  build:
    commands:
      - echo Build started on `date`
      - echo Building the Docker image...
      - docker build -t $REPOSITORY_URI:latest .
      - docker tag $REPOSITORY_URI:latest $REPOSITORY_URI:$IMAGE_TAG
  post_build:
    commands:
      - echo Build completed on `date`
      - echo Pushing the Docker images...
      - docker push $REPOSITORY_URI:latest
      - docker push $REPOSITORY_URI:$IMAGE_TAG
      - echo Writing image definitions file...
      - printf '[{"name":"hello-world","imageUri":"%s"}]' $REPOSITORY_URI:$IMAGE_TAG > imagedefinitions.json
artifacts:
    files: imagedefinitions.json

A especificação de compilação foi escrita para o exemplo de definição de tarefa fornecido em Pré-requisitos, usado pelo serviço do Amazon ECS para este tutorial. O valor REPOSITORY_URI corresponde ao repositório image (sem nenhuma tag de imagem) e o valor hello-world próximo do final do arquivo corresponde ao nome do contêiner na definição de tarefa do serviço.

Para adicionar um arquivo buildspec.yml ao repositório de origem

  1. Abra um editor de texto e, em seguida, copie e cole a especificação de compilação acima em um novo arquivo.

  2. Substitua o valor REPOSITORY_URI (012345678910.dkr.ecr.us-west-2.amazonaws.com/hello-world) pelo URI do repositório do Amazon ECR (sem nenhuma tag de imagem) da imagem do Docker. Substitua hello-world pelo nome do contêiner na definição de tarefa do serviço que se refere à imagem de docker.

  3. Confirme e envie o arquivo buildspec.yml para o repositório de origem.

    1. Adicione o arquivo.

      git add .

    2. Confirme a alteração.

      git commit -m "Adding build specification."

    3. Envie a confirmação.

      git push

Etapa 2: Criar uma pipeline de implantação contínua

Use o assistente do CodePipeline para criar os estágios do pipeline e conectar o repositório de origem ao serviço do ECS.

Para criar o pipeline

  1. Abra o console do CodePipeline em https://console.aws.amazon.com/codesuite/codepipeline/.

  2. Na página Bem-vindo, escolha Criar pipeline.

    Se esta for a primeira vez que você usa o CodePipeline, uma página de introdução será exibida, em vez da página Bem-vindo. Escolha Get Started Now (Começar agora).

  3. Na página Etapa 1: Escolher opção de criação, em Opções de criação, selecione a opção Criar pipeline personalizado. Escolha Próximo.

  4. Em Etapa 2: Escolher configurações de pipeline, em Nome do pipeline, digite o nome do pipeline. Para este tutorial, o nome do pipeline é hello-world.

  5. Em Tipo de pipeline, mantenha a seleção padrão em V2. Os tipos de pipeline diferem em características e preços. Para obter mais informações, consulte Tipos de pipeline. Escolha Próximo.

  6. Na página Etapa 3: Adicionar estágio de origem, em Provedor de origem, escolha AWS CodeCommit.

    1. Em Nome do repositório, escolha o nome do repositório do CodeCommit a ser usado como o local de origem do pipeline.

    2. Em Branch name (Nome da ramificação), escolha a ramificação a ser usada e selecione Next (Próximo).

  7. Na página Etapa 4: Adicionar estágio de compilação em Provedor de compilação, escolha AWS CodeBuild e selecione Criar projeto.

    1. Em Project name, escolha um nome exclusivo para seu projeto de compilação. Para este tutorial, o nome do projeto é hello-world.

    2. Em Imagem do ambiente, escolha Imagem gerenciada.

    3. Em Sistema operacional, escolha Amazon Linux 2.

    4. Em Runtime(s), selecione Padrão.

    5. Em Imagem, escolha aws/codebuild/amazonlinux2-x86_64-standard:3.0.

    6. Em Image version (Versão da imagem) e Environment type (Tipo de ambiente), use os valores padrão.

    7. Selecione Enable this flag if you want to build Docker images or want your builds to get elevated privileges (Ativar este sinalizador se quiser criar imagens do Docker ou desejar que suas compilações obtenham privilégios elevados).

    8. Desmarque CloudWatch logs (Logs do Cloudwatch). Talvez seja necessário expandir Avançado.

    9. Escolha Continue to CodePipeline (Continuar para CodePipeline).

    10. Escolha Próximo.

      nota

      O assistente cria um perfil de serviço do CodeBuild para o projeto de compilação, chamado codebuild-build-project-name-service-role. Observe esse nome de perfil ao adicionar as permissões do Amazon ECR a ele posteriormente.

  8. Na página Etapa 5: Adicionar estágio de implantação, em Provedor de implantação, escolha Amazon ECS.

    1. Em Nome do cluster, escolha o cluster do Amazon ECS no qual o serviço está em execução. Para este tutorial, o cluster é default.

    2. Em Service name (Nome do serviço), escolha o serviço a ser atualizado e selecione Next (Próximo). Para este tutorial, o nome do serviço é hello-world.

  9. Na página Step 6: Review, revise a configuração do pipeline e escolha Create pipeline para criá-lo.

    nota

    Agora que o pipeline foi criado, ele tentará passar pelos diferentes estágios de pipeline. No entanto, o perfil padrão do CodeBuild criado pelo assistente não tem permissões para executar todos os comandos contidos no arquivo buildspec.yml. Por esse motivo, o estágio de compilação falha. A próxima seção adiciona as permissões para o estágio de compilação.

Etapa 3: Adicionar permissões do Amazon ECR ao perfil do CodeBuild

O assistente do CodePipeline criou um perfil do IAM para o projeto de compilação do CodeBuild, chamado codebuild-build-project-name-service-role. Para este tutorial, o nome será codebuild-hello-world-service-role. Como o arquivo buildspec.yml faz chamadas para operações de API do Amazon ECR, o perfil deve ter uma política que conceda permissões para a realização dessas chamadas ao Amazon ECR. O procedimento a seguir ajuda você a anexar as permissões adequadas à função.

Para adicionar permissões do Amazon ECR ao perfil do CodeBuild

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

  2. No painel de navegação à esquerda, escolha Funções.

  3. Na caixa de pesquisa, digite codebuild- e escolha o perfil criado pelo assistente do CodePipeline. Para este tutorial, o nome da função é codebuild-hello-world-service-role.

  4. Na página Summary (Resumo), escolha Attach policies (Associar políticas).

  5. Selecione a caixa à esquerda da política AmazonEC2ContainerRegistryPowerUser e escolha Attach policy.

Etapa 4: Testar o pipeline

O pipeline deve ter tudo para realizar uma implantação contínua de ponta a ponta nativa da AWS. Agora, teste a funcionalidade enviando uma alteração de código ao repositório de origem.

Para testar o pipeline

  1. Faça uma alteração no código no repositório de origem configurado, confirme e envie a alteração.

  2. Abra o console do CodePipeline em https://console.aws.amazon.com/codesuite/codepipeline/.

  3. Escolha o pipeline na lista.

  4. Observe a evolução do pipeline pelos respectivos estágios. O pipeline será concluído e o serviço do Amazon ECS executará a imagem do Docker criada a partir da alteração do código.