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

Este tutorial ajuda você a criar um pipeline de implantação (CD) completo e end-to-end contínuo com a Amazon ECS com CodePipeline.

Importante

Como parte da criação de um pipeline no console, um bucket de artefatos S3 será usado CodePipeline por for artefacts. (Isso é diferente do bucket usado 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 Contas da AWS seja de propriedade de quem é seguro e confiável.

nota

Este tutorial é para a ação de implantação ECS padrão da Amazon para CodePipeline. Para obter um tutorial que usa a ação de implantação Amazon ECS to CodeDeploy blue/green em CodePipeline, consulte. Tutorial: Crie um pipeline com uma ECR fonte da Amazon e ECS para implantação CodeDeploy

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 do Docker (este tutorial usa a AmazonECR) que contém uma imagem que você criou a partir do Dockerfile e da fonte do aplicativo. 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 ECS tarefa da Amazon 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 ECS padrão da Amazon para CodePipeline cria sua própria revisão da definição da tarefa com base na revisão usada pelo ECS serviço da Amazon. Se você criar novas revisões para a definição da tarefa sem atualizar o ECS serviço da Amazon, 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 ECS cluster da Amazon que está executando um serviço que usa sua 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 enviar a imagem para a AmazonECR. Adicione um buildspec.yml arquivo ao seu repositório de código-fonte para saber CodeBuild como fazer isso. O exemplo de especificação de compilação abaixo faz o seguinte:

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

  • Faça login na AmazonECR.

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

• 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 a imagem para o seu ECR repositório com as duas tags.

  • Escreva um arquivo chamado imagedefinitions.json na raiz de compilação que tenha o nome do contêiner do seu ECS serviço Amazon, a imagem e a tag. 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 imagedefinitions.json arquivo é obrigatório para ECS o funcionário.

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 a definição de tarefa de amostra fornecida emPré-requisitos, usada pelo ECS serviço da Amazon 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 REPOSITORY_URI valor (012345678910.dkr.ecr.us-west-2.amazonaws.com/hello-world) pelo seu ECR repositório Amazon URI (sem nenhuma tag de imagem) para sua 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 funil e conectar seu repositório de origem ao seu ECS serviço.

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 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: Nome, em Nome do funil, digite o nome do seu funil. Para este tutorial, o nome do pipeline é hello-world.

4. Em Tipo de pipeline, escolha V2. Para obter mais informações, consulte Tipos de pipeline. Escolha Próximo.

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

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

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

6. Na página Etapa 3: 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 Environment image (Imagem do ambiente), escolha Managed image (Imagem gerenciada).

   3. Em Operating system (Sistema operacional), escolha Amazon Linux 2.

   4. Em Runtime(s) (Tempos de execução), selecione Standard (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 CloudWatch registros. 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 compilação, chamada codebuild-build-project-name-função de serviço. Anote o nome dessa função à medida que você adiciona ECR permissões da Amazon a ela posteriormente.

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

   1. Em Nome do cluster, escolha o ECS cluster da Amazon no qual seu serviço está sendo executado. 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.

8. Na página Step 5: Review (Etapa 5: revisar), revise a configuração do pipeline e escolha Create pipeline (Criar 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 ECR permissões da Amazon à CodeBuild função

O CodePipeline assistente criou uma IAM função para o projeto de CodeBuild construção, chamada codebuild-build-project-name-função de serviço. Para este tutorial, o nome é codebuild-hello-world-service-role. Como o buildspec.yml arquivo faz chamadas para ECR API as operações da Amazon, a função deve ter uma política que permita permissões para fazer essas ECR chamadas da Amazon. O procedimento a seguir ajuda você a anexar as permissões adequadas à função.

Para adicionar ECR permissões da Amazon à CodeBuild função

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

2. No painel de navegação à esquerda, escolha Roles.

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

Etapa 4: Testar o pipeline

Seu pipeline deve ter tudo para executar uma implantação AWS contínua end-to-end nativa. 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. Seu pipeline deve ser concluído e seu ECS serviço da Amazon executa a imagem do Docker que foi criada a partir da alteração do código.