Implementación de un servicio Amazon ECS mediante una implementación azul/verde - Amazon Elastic Container Service
Requisitos previosPaso 1: Crear un Application Load BalancerPaso 2: Crear un clúster de Amazon ECSPaso 3: Registrar una definición de tareasPaso 4: Crear un servicio de Amazon ECSPaso 5: Crear los recursos de AWS CodeDeployPaso 6: Crear y monitorear una implementación de CodeDeployPaso 7: limpiar

Implementación de un servicio Amazon ECS mediante una implementación azul/verde

Obtenga información sobre cómo crear un servicio de Amazon ECS que contenga una tarea de Fargate que utilice el tipo de implementación azul/verde a través de la AWS CLI.

nota

Se ha añadido soporte para realizar una implementación green/blue en AWS CloudFormation. Para obtener más información, consulte Realización de implementaciones “blue/green” (azul/verde) de Amazon ECS a través de CodeDeploy mediante AWS CloudFormation en la Guía del usuario de AWS CloudFormation.

Requisitos previos

En este tutorial se supone que se han completado los siguientes requisitos previos:

Paso 1: Crear un Application Load Balancer

Los servicios Amazon ECS que utilizan el tipo de implementación “blue/green” requieren la utilización de un Application Load Balancer o un Network Load Balancer. En este tutorial, se utiliza un Application Load Balancer.

Para crear un Application Load Balancer de

  1. Utilice el comando create-load-balancer para crear un Application Load Balancer. Especifique dos subredes que no formen parte de la misma zona de disponibilidad, así como un grupo de seguridad.

    aws elbv2 create-load-balancer \
     --name bluegreen-alb \
     --subnets subnet-abcd1234 subnet-abcd5678 \
     --security-groups sg-abcd1234 \
     --region us-east-1

    El resultado contiene el nombre de recurso de Amazon (ARN) del equilibrador de carga con el siguiente formato:

    arn:aws:elasticloadbalancing:region:aws_account_id:loadbalancer/app/bluegreen-alb/e5ba62739c16e642

  2. Utilice el comando create-target-group para crear un grupo de destino. Este grupo de destino dirigirá el tráfico a las tareas originales definidas en su servicio.

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

    El resultado contiene el ARN del grupo de destino con el siguiente formato:

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

  3. Utilice el comando create-listener para crear un agente de escucha del balanceador de carga con una regla predeterminada que reenvíe las solicitudes al 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

    El resultado incluye el ARN del agente de escucha con el siguiente formato:

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

Paso 2: Crear un clúster de Amazon ECS

Utilice el comando create-cluster para crear un clúster denominado tutorial-bluegreen-cluster.

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

El resultado incluye el ARN del clúster con el siguiente formato:

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

Paso 3: Registrar una definición de tareas

Utilice el comando register-task-definition para registrar una definición de tareas compatible con Fargate. Se necesita utilizar el modo de red awsvpc. A continuación, se muestra el ejemplo de definición de tareas utilizado en este tutorial.

En primer lugar, cree un archivo denominado fargate-task.json con el siguiente contenido. Asegúrese de que utiliza el ARN del rol de ejecución de la tarea. Para obtener más información, consulte Rol de IAM de ejecución de tareas de Amazon ECS.

{
    "family": "sample-fargate", 
    "networkMode": "awsvpc", 
    "containerDefinitions": [
        {
            "name": "sample-app", 
            "image": "public.ecr.aws/docker/library/httpd:latest", 
            "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: #333;} </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"
}

A continuación, registre la definición de tarea mediante el archivo fargate-task.json que ha creado.

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

Paso 4: Crear un servicio de Amazon ECS

Ejecute el comando create-service para crear un servicio.

En primer lugar, cree un archivo denominado service-bluegreen.json con el siguiente contenido.

{
    "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
}

A continuación, cree el servicio mediante el archivo service-bluegreen.json que ha creado.

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

El resultado incluye el ARN del servicio con el siguiente formato:

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

Obtenga el nombre DNS del equilibrador de carga mediante el siguiente comando. 

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

Ingrese el nombre DNS en el navegador web. Debe aparecer una página en la que se muestre la aplicación de muestra con un fondo azul.

Paso 5: Crear los recursos de AWS CodeDeploy

Siga los pasos que se describen a continuación para crear la aplicación CodeDeploy, el grupo de destino del Application Load Balancer para el grupo de implementaciones de CodeDeploy y el grupo de implementaciones de CodeDeploy.

Para crear recursos de CodeDeploy

  1. Utilice el comando create-application para crear una aplicación de CodeDeploy. Especifique la plataforma informática de ECS.

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

    El resultado incluye el ID de aplicación con el siguiente formato:

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

  2. Utilice el comando create-target-group para crear un segundo grupo de destino para el Application Load Balancer, que se utilizará al crear el grupo de implementación de CodeDeploy.

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

    El resultado contiene el ARN del grupo de destino con el siguiente formato:

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

  3. Ejecute el comando create-deployment-group para crear un grupo de implementación de CodeDeploy:

    En primer lugar, cree un archivo denominado tutorial-deployment-group.json con el siguiente contenido. En el ejemplo se utiliza el recurso que ha creado. En serviceRoleArn, especifique el ARN del rol de IAM de CodeDeploy de Amazon ECS. Para obtener más información, consulte Rol de IAM de CodeDeploy de 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"
       }
   ]
}

    A continuación, cree el grupo de implementación de CodeDeploy.

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

    El resultado incluye el ID del grupo de implementación con el siguiente formato:

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

Paso 6: Crear y monitorear una implementación de CodeDeploy

Antes de crear una implementación de CodeDeploy, actualice la definición de la tarea command en fargate-task.json como se describe a continuación para cambiar el color de fondo de la aplicación de muestra a 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 la definición de tarea actualizada con el siguiente comando. 

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

Ahora siga estos pasos para crear y cargar un archivo de especificación de la aplicación (archivo AppSpec) y una implementación de CodeDeploy.

Para crear y supervisar una implementación de CodeDeploy

  1. Cree y cargue un archivo AppSpec con los pasos que se describen a continuación.

    1. Cree un archivo con el nombre appspec.yaml que incluya el contenido del grupo de implementación de CodeDeploy. En este ejemplo, se utiliza la definición de tarea actualizada.

      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"

    2. Utilice el comando s3 mb para crear un bucket de Amazon S3 para el archivo AppSpec.

      aws s3 mb s3://tutorial-bluegreen-bucket

    3. Utilice el comando s3 cp para cargar el archivo AppSpec en el bucket de Amazon S3.

      aws s3 cp ./appspec.yaml s3://tutorial-bluegreen-bucket/appspec.yaml

  2. Siga estos pasos para crear la implementación de CodeDeploy.

    1. Cree un archivo con el nombre create-deployment.json que incluya el contenido de la implementación de CodeDeploy. En este ejemplo se utilizan los recursos que creó previamente en el tutorial.

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

    2. Utilice el comando create-deployment para crear la implementación.

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

      El resultado incluye el ID de la implementación con el siguiente formato:

      {
    "deploymentId": "d-RPCR1U3TW"
}

  3. Utilice el comando get-deployment-target para obtener los detalles de la implementación, especificando el deploymentId del resultado anterior.

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

    Inicialmente, el estado de implementación es InProgress. El tráfico se dirige al conjunto de tareas original, que tiene una taskSetLabel de BLUE, un estado de PRIMARY y un trafficWeight de 100.0. El conjunto de tareas de reemplazo tiene un taskSetLabel de GREEN, un estado de ACTIVE y un trafficWeight de 0.0. El navegador web en el que introdujo el nombre DNS sigue mostrando la aplicación de muestra con un fondo 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"
        }
    ]
}
}
}

    Continúe recuperando los detalles de la implementación utilizando el comando hasta que el estado de implementación sea Succeeded, tal y como se muestra en el siguiente resultado. El tráfico ahora se redirige al conjunto de tareas de reemplazo, que tiene un estado de PRIMARY y un trafficWeight de 100.0. Actualice el navegador web en el que introdujo el nombre DNS del equilibrador de carga y verá la aplicación de muestra con un fondo 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"
        }
    ]
}
}
}

Paso 7: limpiar

Cuando termine este tutorial, debe limpiar los recursos asociados para evitar incurrir en cargos por recursos que no está utilizando.

Limpieza de los recursos del tutorial

  1. Utilice el comando delete-deployment-group para eliminar el grupo de implementación de CodeDeploy.

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

  2. Utilice el comando delete-application para eliminar la aplicación de CodeDeploy.

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

  3. Utilice el comando delete-service para eliminar el servicio de Amazon ECS. El uso de la marca --force le permite eliminar un servicio aunque no se haya escalado a cero tareas.

    aws ecs delete-service \
     --service arn:aws:ecs:region:aws_account_id:service/service-bluegreen \
     --force \
     --region us-east-1

  4. Utilice el comando delete-cluster para eliminar el clúster de Amazon ECS.

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

  5. Utilice el comando s3 rm para eliminar el archivo AppSpec del bucket de Amazon S3.

    aws s3 rm s3://tutorial-bluegreen-bucket/appspec.yaml

  6. Utilice el comando s3 rb para eliminar el bucket de Amazon S3.

    aws s3 rb s3://tutorial-bluegreen-bucket

  7. Utilice el comando delete-load-balancer para eliminar el 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

  8. Utilice el comando delete-target-group para eliminar los dos grupos de destino del 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