View a markdown version of this page

Tutorial: Implantação padrão do Amazon ECS com 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 à função CodeBuildEtapa 4: Testar o pipeline

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: Implantação padrão do Amazon ECS com CodePipeline

Este tutorial ajuda você a criar um pipeline completo de implantação contínua (CD) de ponta a ponta com o Amazon ECS with. CodePipeline

Importante

Como parte da criação de um pipeline no console, um bucket de artefatos do S3 será usado pelo CodePipeline for 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 seu pipeline, certifique-se de que o bucket de artefatos do S3 seja de propriedade de Contas da AWS pessoas seguras e confiáveis.

nota

Este tutorial é sobre a ação de implantação padrão do Amazon ECS para CodePipeline. Para ver um tutorial que usa o Amazon ECS para CodeDeploy blue/green implementar ações em CodePipeline, consulteTutorial: Crie um pipeline com uma fonte e ECS-to-CodeDeploy implantação do Amazon ECR.

nota

Este tutorial é para a ação de implantação padrão do Amazon ECS CodePipeline com uma ação de origem. Para ver um tutorial que usa a ação de implantação padrão do Amazon ECS junto com a ação de ECRBuildAndPublish criação CodePipeline para enviar sua imagem, consulteTutorial: crie e envie uma imagem do Docker para o Amazon ECR com 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 AWS região.

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

  • 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 CodePipeline cria sua própria revisão da definição da 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 é usado CodeBuild para criar sua imagem do Docker e enviá-la para o 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:

  • Pre-build estágio:

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

  • Post-build estágio:

    • 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 buildspec.yml arquivo para seu 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 CodePipeline assistente para criar seus estágios de pipeline e conectar seu repositório de origem ao seu serviço ECS.

Para criar o pipeline

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

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

    Se esta for a primeira vez que você usa CodePipeline, uma página introdutória será exibida em vez de 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 Repository name (Nome do repositório), escolha o nome do repositório do CodeCommit para usar 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 construção, em Provedor de compilação AWS CodeBuild, escolha e, em seguida, escolha 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 os registros CloudWatch . Talvez seja necessário expandir Avançado.

    9. Escolha Continuar para CodePipeline.

    10. Escolha Próximo.

      nota

      O assistente cria uma função CodeBuild de serviço para seu projeto de construção, chamada 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, para 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, a CodeBuild função padrão criada pelo assistente não tem permissões para executar todos os comandos contidos no buildspec.yml arquivo, portanto, o estágio de criaçã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 à função CodeBuild

O CodePipeline assistente criou uma função do IAM para o projeto de construção, chamada CodeBuild 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 à função CodeBuild

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

  2. No painel de navegação à esquerda, selecione Perfis.

  3. Na caixa de pesquisa, digite codebuild- e escolha a função que foi criada pelo CodePipeline assistente. 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 AmazonEC2ContainerRegistryPowerUser política e escolha Anexar política.

Etapa 4: Testar o pipeline

Seu pipeline deve ter tudo para executar uma implantação AWS contínua nativa de ponta a ponta. 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 CodePipeline console em https://console.aws.amazon.com/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.