Pré-requisitos Etapa 1: criar um Application Load Balancer Etapa 2: criar um cluster do Amazon ECS Etapa 3: registrar uma definição de tarefa Etapa 4: criar um serviço do Amazon ECS Etapa 5: criar os recursos do AWS CodeDeploy Etapa 6: criar e monitorar uma implantação do CodeDeploy Etapa 7: limpar

Implantar um serviço Amazon ECS usando uma implantação azul/verde

Saiba como criar um serviço do Amazon ECS que contém uma tarefa do Fargate que usa o tipo de implantação azul/verde com a AWS CLI.

nota

Adicionado suporte para executar uma implantação azul/verde para AWS CloudFormation. Para obter mais informações, consulte Executar implantações azuis/verdes do Amazon ECS por meio do CodeDeploy usando o AWS CloudFormation no Guia do usuário do AWS CloudFormation.

Pré-requisitos

Este tutorial pressupõe que você concluiu os seguintes pré-requisitos:

A versão mais recente da AWS CLI está instalada e configurada. Para obter mais informações sobre como instalar ou fazer upgrade do AWS CLI, consulte Instalar o AWS Command Line Interface.
As etapas em Configuração para usar o Amazon ECS foram concluídas.
Seu usuário da AWS tem as permissões necessárias especificadas no exemplo de política AmazonECS_FullAccess do IAM.
Você tem uma VPC e um grupo de segurança criados para uso. Para ter mais informações, consulte Criar uma nuvem privada virtual.
A função do IAM do CodeDeploy do Amazon ECS é criada. Para ter mais informações, consulte Função do IAM para CodeDeploy do Amazon ECS.

Etapa 1: criar um Application Load Balancer

Os serviços do Amazon ECS que usam o tipo de implantação azul/verde exigem o uso de um Application Load Balancer ou de um Network Load Balancer. Este tutorial usa um Application Load Balancer.

Para criar um Application Load Balancer

Use o comando create-load-balancer para criar um Application Load Balancer. Especifique duas sub-redes que não estejam na mesma Zona de disponibilidade, bem como um grupo de segurança.
```
aws elbv2 create-load-balancer \
     --name bluegreen-alb \
     --subnets subnet-abcd1234 subnet-abcd5678 \
     --security-groups sg-abcd1234 \
     --region us-east-1
```
O resultado inclui o Nome de recurso da Amazon (ARN) do load balancer, com o seguinte formato:
```
arn:aws:elasticloadbalancing:region:aws_account_id:loadbalancer/app/bluegreen-alb/e5ba62739c16e642
```

Use o comando create-target-group para criar um grupo de destino. Esse grupo de destino roteará o tráfego para a tarefa original definida no seu serviço.


aws elbv2 create-target-group \
     --name bluegreentarget1 \
     --protocol HTTP \
     --port 80 \
     --target-type ip \
     --vpc-id vpc-abcd1234 \
     --region us-east-1

A saída inclui o ARN do grupo de destino, com o seguinte formato:

arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget1/209a844cd01825a4

Use o comando create-listener para criar um listener do load balancer com uma regra padrão que encaminha solicitações ao grupo de destino.


aws elbv2 create-listener \
     --load-balancer-arn arn:aws:elasticloadbalancing:region:aws_account_id:loadbalancer/app/bluegreen-alb/e5ba62739c16e642 \
     --protocol HTTP \
     --port 80 \
     --default-actions Type=forward,TargetGroupArn=arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget1/209a844cd01825a4 \
     --region us-east-1

A saída inclui o ARN do listener, com o seguinte formato:

arn:aws:elasticloadbalancing:region:aws_account_id:listener/app/bluegreen-alb/e5ba62739c16e642/665750bec1b03bd4

Etapa 2: criar um cluster do Amazon ECS

Use o comando create-cluster para criar um cluster chamado tutorial-bluegreen-cluster a ser usado.


aws ecs create-cluster \
     --cluster-name tutorial-bluegreen-cluster \
     --region us-east-1

A saída inclui o ARN do cluster, com o seguinte formato:

arn:aws:ecs:region:aws_account_id:cluster/tutorial-bluegreen-cluster

Etapa 3: registrar uma definição de tarefa

Use o comando register-task-definition para registrar uma definição de tarefa compatível com o Fargate. Ele exige o uso do modo de rede awsvpc. Veja a seguir o exemplo de definição de tarefa usado para este tutorial.

Primeiro, crie um arquivo chamado fargate-task.json com os conteúdos a seguir. Certifique-se de usar o ARN para a sua função de execução da tarefa. Para ter mais informações, consulte Função do IAM de execução de tarefas do Amazon ECS.


{
    "family": "tutorial-task-def",
        "networkMode": "awsvpc",
        "containerDefinitions": [
            {
                "name": "sample-app",
                "image": "httpd:2.4",
                "portMappings": [
                    {
                        "containerPort": 80,
                        "hostPort": 80,
                        "protocol": "tcp"
                    }
                ],
                "essential": true,
                "entryPoint": [
                    "sh",
                    "-c"
                ],
                "command": [
                    "/bin/sh -c \"echo '<html> <head> <title>Amazon ECS Sample App</title> <style>body {margin-top: 40px; background-color: #00FFFF;} </style> </head><body> <div style=color:white;text-align:center> <h1>Amazon ECS Sample App</h1> <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p> </div></body></html>' >  /usr/local/apache2/htdocs/index.html && httpd-foreground\""
                ]
            }
        ],
        "requiresCompatibilities": [
            "FARGATE"
        ],
        "cpu": "256",
        "memory": "512",
        "executionRoleArn": "arn:aws:iam::aws_account_id:role/ecsTaskExecutionRole"
}

Em seguida, registre a definição de tarefa usando o arquivo fargate-task.json criado.


aws ecs register-task-definition \
     --cli-input-json file://fargate-task.json \
     --region us-east-1

Etapa 4: criar um serviço do Amazon ECS

Use o comando create-service para criar um serviço.

Primeiro, crie um arquivo chamado service-bluegreen.json com os conteúdos a seguir.


{
    "cluster": "tutorial-bluegreen-cluster",
    "serviceName": "service-bluegreen",
    "taskDefinition": "tutorial-task-def",
    "loadBalancers": [
        {
            "targetGroupArn": "arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget1/209a844cd01825a4",
            "containerName": "sample-app",
            "containerPort": 80
        }
    ],
    "launchType": "FARGATE",
    "schedulingStrategy": "REPLICA",
    "deploymentController": {
        "type": "CODE_DEPLOY"
    },
    "platformVersion": "LATEST",
    "networkConfiguration": {
       "awsvpcConfiguration": {
          "assignPublicIp": "ENABLED",
          "securityGroups": [ "sg-abcd1234" ],
          "subnets": [ "subnet-abcd1234", "subnet-abcd5678" ]
       }
    },
    "desiredCount": 1
}

Em seguida, crie o seu serviço usando o arquivo service-bluegreen.json que você criou.


aws ecs create-service \
     --cli-input-json file://service-bluegreen.json \
     --region us-east-1

A saída inclui o ARN do serviço, com o seguinte formato:

arn:aws:ecs:region:aws_account_id:service/service-bluegreen

Obtenha o nome do DNS do balanceador de carga usando o comando a seguir.


 aws elbv2 describe-load-balancers --name bluegreen-alb  --query 'LoadBalancers[*].DNSName'

Insira o nome do DNS no seu navegador da Web e você deverá ver uma página da Web que exibe a aplicação de amostra com um fundo azul.

Etapa 5: criar os recursos do AWS CodeDeploy

Use as etapas a seguir para criar a aplicação do CodeDeploy, o grupo de destino do Application Load Balancer para o grupo de implantação do CodeDeploy e o grupo de implantação do CodeDeploy.

Para criar recursos do CodeDeploy

Use o comando create-application para criar uma aplicação do CodeDeploy. Especifique a plataforma de computação ECS.


aws deploy create-application \
     --application-name tutorial-bluegreen-app \
     --compute-platform ECS \
     --region us-east-1

A saída inclui o ID do aplicativo, com o seguinte formato:

{
    "applicationId": "b8e9c1ef-3048-424e-9174-885d7dc9dc11"
}

Use o comando create-target-group para criar um segundo grupo de destino do Application Load Balancer, que será usado quando for criado o grupo de implantação do CodeDeploy.


aws elbv2 create-target-group \
     --name bluegreentarget2 \
     --protocol HTTP \
     --port 80 \
     --target-type ip \
     --vpc-id "vpc-0b6dd82c67d8012a1" \
     --region us-east-1

A saída inclui o ARN para o grupo de destino, com o seguinte formato:

arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget2/708d384187a3cfdc

Use o comando create-deployment-group para criar um grupo de implantação do CodeDeploy.

Primeiro, crie um arquivo chamado tutorial-deployment-group.json com os conteúdos a seguir. Este exemplo usa o recurso que você criou. Para o serviceRoleArn, especifique o ARN da função do IAM do CodeDeploy do Amazon ECS. Para ter mais informações, consulte Função do IAM para CodeDeploy do Amazon ECS.


{
   "applicationName": "tutorial-bluegreen-app",
   "autoRollbackConfiguration": {
      "enabled": true,
      "events": [ "DEPLOYMENT_FAILURE" ]
   },
   "blueGreenDeploymentConfiguration": {
      "deploymentReadyOption": {
         "actionOnTimeout": "CONTINUE_DEPLOYMENT",
         "waitTimeInMinutes": 0
      },
      "terminateBlueInstancesOnDeploymentSuccess": {
         "action": "TERMINATE",
         "terminationWaitTimeInMinutes": 5
      }
   },
   "deploymentGroupName": "tutorial-bluegreen-dg",
   "deploymentStyle": {
      "deploymentOption": "WITH_TRAFFIC_CONTROL",
      "deploymentType": "BLUE_GREEN"
   },
   "loadBalancerInfo": {
      "targetGroupPairInfoList": [
        {
          "targetGroups": [
             {
                 "name": "bluegreentarget1"
             },
             {
                 "name": "bluegreentarget2"
             }
          ],
          "prodTrafficRoute": {
              "listenerArns": [
                  "arn:aws:elasticloadbalancing:region:aws_account_id:listener/app/bluegreen-alb/e5ba62739c16e642/665750bec1b03bd4"
              ]
          }
        }
      ]
   },
   "serviceRoleArn": "arn:aws:iam::aws_account_id:role/ecsCodeDeployRole",
   "ecsServices": [
       {
           "serviceName": "service-bluegreen",
           "clusterName": "tutorial-bluegreen-cluster"
       }
   ]
}

Em seguida, cria um grupo de implantação do CodeDeploy.


aws deploy create-deployment-group \
     --cli-input-json file://tutorial-deployment-group.json \
     --region us-east-1

A saída inclui o ID do grupo de implantação, com o seguinte formato:

{
    "deploymentGroupId": "6fd9bdc6-dc51-4af5-ba5a-0a4a72431c88"
}

Etapa 6: criar e monitorar uma implantação do CodeDeploy

Antes de criar uma implantação do CodeDeploy, atualize a definição da tarefa command em fargate-task.json da forma a seguir para alterar a cor de fundo da aplicação de amostra para verde.


{
    ...
        "containerDefinitions": [
            {
                ...
                "command": [
                    "/bin/sh -c \"echo '<html> <head> <title>Amazon ECS Sample App</title> <style>body {margin-top: 40px; background-color: #097969;} </style> </head><body> <div style=color:white;text-align:center> <h1>Amazon ECS Sample App</h1> <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p> </div></body></html>' >  /usr/local/apache2/htdocs/index.html && httpd-foreground\""
                ]
            }
        ],
       ...
}

Registre a definição de tarefa atualizada usando o comando a seguir.


aws ecs register-task-definition \
     --cli-input-json file://fargate-task.json \
     --region us-east-1

Agora, use as etapas a seguir para criar e carregar um arquivo de especificação de aplicação (arquivo AppSpec) e uma implantação do CodeDeploy.

Para criar e monitorar uma implantação do CodeDeploy

Crie e faça upload de um arquivo AppSpec usando as etapas a seguir.

Crie um arquivo denominado appspec.yaml com o conteúdo do grupo de implantação do CodeDeploy. Este exemplo usa a definição de tarefa atualizada.


version: 0.0
Resources:
  - TargetService:
      Type: AWS::ECS::Service
      Properties:
        TaskDefinition: "arn:aws:ecs:region:aws_account_id:task-definition/tutorial-task-def:2"
        LoadBalancerInfo:
          ContainerName: "sample-app"
          ContainerPort: 80
        PlatformVersion: "LATEST"

Use o comando s3 mb para criar um bucket do Amazon S3 para o arquivo AppSpec.
```
aws s3 mb s3://tutorial-bluegreen-bucket
```
Use o comando s3 cp para carregar o arquivo AppSpec para o bucket do Amazon S3.
```
aws s3 cp ./appspec.yaml s3://tutorial-bluegreen-bucket/appspec.yaml
```

Crie a implantação do CodeDeploy usando as etapas a seguir.

Crie um arquivo denominado create-deployment.json com o conteúdo da implantação do CodeDeploy. Este exemplo usa os recursos criados por você anteriormente no tutorial.


{
    "applicationName": "tutorial-bluegreen-app",
    "deploymentGroupName": "tutorial-bluegreen-dg",
    "revision": {
        "revisionType": "S3",
        "s3Location": {
            "bucket": "tutorial-bluegreen-bucket",
            "key": "appspec.yaml",
            "bundleType": "YAML"
        }
    }
}

Use o comando create-deployment para criar uma implantação.


aws deploy create-deployment \
     --cli-input-json file://create-deployment.json \
     --region us-east-1

A saída inclui o ID de implantação, com o seguinte formato:

{
    "deploymentId": "d-RPCR1U3TW"
}

Use o comando get-deployment-target para obter os detalhes da implantação, especificando o deploymentId da saída anterior.


aws deploy get-deployment-target \
--deployment-id "d-IMJU3A8TW" \
--target-id tutorial-bluegreen-cluster:service-bluegreen \
--region us-east-1

Inicialmente, o status de implantação é InProgress. O tráfego é direcionado para o conjunto de tarefas original, que tem um taskSetLabel de BLUE, um status de PRIMARY e um trafficWeight de 100.0. O conjunto de tarefas de substituição tem um taskSetLabel de GREEN, um status de ACTIVE e um trafficWeight de 0.0. O navegador da Web em que você inseriu o nome do DNS ainda exibe a aplicação de amostra com um fundo azul.

{
"deploymentTarget": {
"deploymentTargetType": "ECSTarget",
"ecsTarget": {
    "deploymentId": "d-RPCR1U3TW",
    "targetId": "tutorial-bluegreen-cluster:service-bluegreen",
    "targetArn": "arn:aws:ecs:region:aws_account_id:service/service-bluegreen",
    "lastUpdatedAt": "2023-08-10T12:07:24.797000-05:00",
    "lifecycleEvents": [
        {
            "lifecycleEventName": "BeforeInstall",
            "startTime": "2023-08-10T12:06:22.493000-05:00",
            "endTime": "2023-08-10T12:06:22.790000-05:00",
            "status": "Succeeded"
        },
        {
            "lifecycleEventName": "Install",
            "startTime": "2023-08-10T12:06:22.936000-05:00",
            "status": "InProgress"
        },
        {
            "lifecycleEventName": "AfterInstall",
            "status": "Pending"
        },
        {
            "lifecycleEventName": "BeforeAllowTraffic",
            "status": "Pending"
        },
        {
            "lifecycleEventName": "AllowTraffic",
            "status": "Pending"
        },
        {
            "lifecycleEventName": "AfterAllowTraffic",
            "status": "Pending"
        }
    ],
    "status": "InProgress",
    "taskSetsInfo": [
        {
            "identifer": "ecs-svc/9223370493423413672",
            "desiredCount": 1,
            "pendingCount": 0,
            "runningCount": 1,
            "status": "ACTIVE",
            "trafficWeight": 0.0,
            "targetGroup": {
                "name": "bluegreentarget2"
            },
            "taskSetLabel": "Green"
        },
        {
            "identifer": "ecs-svc/9223370493425779968",
            "desiredCount": 1,
            "pendingCount": 0,
            "runningCount": 1,
            "status": "PRIMARY",
            "trafficWeight": 100.0,
            "targetGroup": {
                "name": "bluegreentarget1"
            },
            "taskSetLabel": "Blue"
        }
    ]
}
}
}

Continue a recuperar os detalhes de implantação usando o comando até que o status de implantação seja Succeeded, como mostrado na saída a seguir. O tráfego agora é redirecionado para o conjunto de tarefas de substituição, que agora tem um status de PRIMARY e um trafficWeight de 100.0. Atualize o navegador da Web em que você inseriu o nome do DNS do balanceador de carga e agora você deverá ver a aplicação de amostra com um fundo verde.

{
"deploymentTarget": {
"deploymentTargetType": "ECSTarget",
"ecsTarget": {
    "deploymentId": "d-RPCR1U3TW",
    "targetId": "tutorial-bluegreen-cluster:service-bluegreen",
    "targetArn": "arn:aws:ecs:region:aws_account_id:service/service-bluegreen",
    "lastUpdatedAt": "2023-08-10T12:07:24.797000-05:00",
    "lifecycleEvents": [
        {
            "lifecycleEventName": "BeforeInstall",
            "startTime": "2023-08-10T12:06:22.493000-05:00",
            "endTime": "2023-08-10T12:06:22.790000-05:00",
            "status": "Succeeded"
        },
        {
            "lifecycleEventName": "Install",
            "startTime": "2023-08-10T12:06:22.936000-05:00",
            "endTime": "2023-08-10T12:08:25.939000-05:00",
            "status": "Succeeded"
        },
        {
            "lifecycleEventName": "AfterInstall",
            "startTime": "2023-08-10T12:08:26.089000-05:00",
            "endTime":  "2023-08-10T12:08:26.403000-05:00",
            "status": "Succeeded"
        },
        {
            "lifecycleEventName": "BeforeAllowTraffic",
            "startTime": "2023-08-10T12:08:26.926000-05:00",
            "endTime":  "2023-08-10T12:08:27.256000-05:00",
            "status": "Succeeded"
        },
        {
            "lifecycleEventName": "AllowTraffic",
            "startTime": "2023-08-10T12:08:27.416000-05:00",
            "endTime": "2023-08-10T12:08:28.195000-05:00",
            "status": "Succeeded"
        },
        {
            "lifecycleEventName": "AfterAllowTraffic",
            "startTime": "2023-08-10T12:08:28.715000-05:00",
            "endTime":  "2023-08-10T12:08:28.994000-05:00",
            "status": "Succeeded"
        }
    ],
    "status": "Succeeded",
    "taskSetsInfo": [
        {
            "identifer": "ecs-svc/9223370493425779968",
            "desiredCount": 1,
            "pendingCount": 0,
            "runningCount": 1,
            "status": "ACTIVE",
            "trafficWeight": 0.0,
            "targetGroup": {
                "name": "bluegreentarget1"
            },
            "taskSetLabel": "Blue"
        },
        {
            "identifer": "ecs-svc/9223370493423413672",
            "desiredCount": 1,
            "pendingCount": 0,
            "runningCount": 1,
            "status": "PRIMARY",
            "trafficWeight": 100.0,
            "targetGroup": {
                "name": "bluegreentarget2"
            },
            "taskSetLabel": "Green"
        }
    ]
}
}
}

Etapa 7: limpar

Ao concluir este tutorial, limpe os recursos associados a ele para evitar cobranças por recursos que você não está usando.

Limpando os recursos do tutorial

Use o comando delete-deployment-group para excluir o grupo de implantação do CodeDeploy.


aws deploy delete-deployment-group \
     --application-name tutorial-bluegreen-app \
     --deployment-group-name tutorial-bluegreen-dg \
     --region us-east-1

Use o comando delete-application para excluir a aplicação do CodeDeploy.


aws deploy delete-application \
     --application-name tutorial-bluegreen-app \
     --region us-east-1

Use o comando delete-service para excluir o serviço do Amazon ECS. Usar o sinalizador --force permite que você exclua um serviço, ainda que ele não tenha sido reduzido a zero tarefas.
```
aws ecs delete-service \
     --service arn:aws:ecs:region:aws_account_id:service/service-bluegreen \
     --force \
     --region us-east-1
```

Use o comando delete-cluster para excluir o cluster do Amazon ECS.


aws ecs delete-cluster \
     --cluster tutorial-bluegreen-cluster \
     --region us-east-1

Use o comando s3 rm para excluir o arquivo AppSpec do bucket do Amazon S3.
```
aws s3 rm s3://tutorial-bluegreen-bucket/appspec.yaml
```
Use o comando s3 rb para excluir o bucket do Amazon S3.
```
aws s3 rb s3://tutorial-bluegreen-bucket
```

Use o comando delete-load-balancer para excluir o Application Load Balancer.


aws elbv2 delete-load-balancer \
     --load-balancer-arn arn:aws:elasticloadbalancing:region:aws_account_id:loadbalancer/app/bluegreen-alb/e5ba62739c16e642 \
     --region us-east-1

Use o comando delete-target-group para excluir os dois grupos de destino do Application Load Balancer.


aws elbv2 delete-target-group \
     --target-group-arn arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget1/209a844cd01825a4 \
     --region us-east-1


aws elbv2 delete-target-group \
     --target-group-arn arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget2/708d384187a3cfdc \
     --region us-east-1

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Implantações azuis/verdes

Implantações externas