Tutorial: Crear una canalización con un origen de Amazon ECR y una implementación de ECS-to-CodeDeploy

Para crear una imagen

1. Inicie sesión en la instancia de Linux en la que se ha instalado Docker.

   Despliegue una imagen de nginx. Este comando proporciona la imagen de nginx:latest:

   docker pull nginx

2. Ejecuta docker images. Debería ver la imagen en la lista.

   docker images

Para crear un repositorio de Amazon ECR y enviar la imagen

1. Cree un repositorio de Amazon ECR para almacenar la imagen . Anote el repositoryUri en la salida.

   aws ecr create-repository --repository-name nginx

   Salida:

   {
       "repository": {
           "registryId": "aws_account_id",
           "repositoryName": "nginx",
           "repositoryArn": "arn:aws:ecr:us-east-1:aws_account_id:repository/nginx",
           "createdAt": 1505337806.0,
           "repositoryUri": "aws_account_id.dkr.ecr.us-east-1.amazonaws.com/nginx"
       }
   }

2. Etiquete la imagen con el valor de repositoryUri del paso anterior.

   docker tag nginx:latest aws_account_id.dkr.ecr.us-east-1.amazonaws.com/nginx:latest

3. Ejecute el comando aws ecr get-login-password, tal como se muestra en este ejemplo de la región de us-west-2 y el ID de cuenta 111122223333.

   aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-west-2.amazonaws.com/nginx

4. Envíe la imagen a Amazon ECR utilizando el repositoryUri del paso anterior.

   docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/nginx:latest

Para crear una definición de tareas para la imagen

1. Cree un archivo denominado taskdef.json con el siguiente contenido. En image, introduzca el nombre de su imagen, por ejemplo nginx. Este valor se actualiza cuando se ejecuta la canalización.

   nota

   Asegúrese de que el rol de ejecución especificado en la definición de la tarea contiene AmazonECSTaskExecutionRolePolicy. Para obtener más información, consulte Rol de IAM de ejecución de tareas de Amazon ECS en la Guía para desarrolladores de Amazon ECS.

   {
       "executionRoleArn": "arn:aws:iam::account_ID:role/ecsTaskExecutionRole",
       "containerDefinitions": [
           {
               "name": "sample-website",
               "image": "nginx",
               "essential": true,
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ]
           }
       ],
       "requiresCompatibilities": [
           "FARGATE"
       ],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512",
       "family": "ecs-demo"
   }

2. Registre la definición de tareas con el archivo taskdef.json.

   aws ecs register-task-definition --cli-input-json file://taskdef.json

3. Después de registrar la definición de tareas, edite el archivo para eliminar el nombre de la imagen e incluya el texto del marcador de posición <IMAGE1_NAME> en el campo de la imagen.

   {
       "executionRoleArn": "arn:aws:iam::account_ID:role/ecsTaskExecutionRole",
       "containerDefinitions": [
           {
               "name": "sample-website",
               "image": "<IMAGE1_NAME>",
               "essential": true,
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ]
           }
       ],
       "requiresCompatibilities": [
           "FARGATE"
       ],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512",
       "family": "ecs-demo"
   }

Para crear un archivo AppSpec

• El archivo AppSpec se utiliza para las implementaciones de CodeDeploy. El archivo, que incluye campos opcionales, utiliza este formato:

  version: 0.0
  Resources:
    - TargetService:
        Type: AWS::ECS::Service
        Properties:
          TaskDefinition: "task-definition-ARN"
          LoadBalancerInfo:
            ContainerName: "container-name"
            ContainerPort: container-port-number
  # Optional properties
          PlatformVersion: "LATEST"
          NetworkConfiguration:
              AwsvpcConfiguration:
                Subnets: ["subnet-name-1", "subnet-name-2"]
                SecurityGroups: ["security-group"]
                AssignPublicIp: "ENABLED"
  Hooks:
  - BeforeInstall: "BeforeInstallHookFunctionName"
  - AfterInstall: "AfterInstallHookFunctionName"
  - AfterAllowTestTraffic: "AfterAllowTestTrafficHookFunctionName"
  - BeforeAllowTraffic: "BeforeAllowTrafficHookFunctionName"
  - AfterAllowTraffic: "AfterAllowTrafficHookFunctionName"

  Para obtener más información acerca del archivo AppSpec, incluidos ejemplos, consulte Referencia de AppSpec File de CodeDeploy.

  Cree un archivo denominado appspec.yaml con el siguiente contenido. Para TaskDefinition, no cambie el texto del marcador de posición <TASK_DEFINITION>. Este valor se actualiza cuando se ejecuta la canalización.

  version: 0.0
  Resources:
    - TargetService:
        Type: AWS::ECS::Service
        Properties:
          TaskDefinition: <TASK_DEFINITION>
          LoadBalancerInfo:
            ContainerName: "sample-website"
            ContainerPort: 80

Para enviar archivos al repositorio de CodeCommit

1. Envíe o cargue los archivos en el repositorio de CodeCommit. Estos archivos son el artefacto de origen creado por el asistente Crear canalización para la acción de implementación en CodePipeline. Sus archivos deberían ser parecidos a estos en su directorio local:

   /tmp
     |my-demo-repo
       |-- appspec.yaml
       |-- taskdef.json

2. Elija el método que desea usar para cargar los archivos:

   1. Para utilizar la línea de comandos de Git desde un repositorio clonado en el equipo local:

      1. Cambie los directorios a su repositorio local:

         (For Linux, macOS, or Unix) cd /tmp/my-demo-repo
         (For Windows) cd c:\temp\my-demo-repo

      2. Ejecute el siguiente comando para preparar todos los archivos de una vez:

         git add -A

      3. Ejecute el siguiente comando para confirmar los archivos con un mensaje de confirmación:

         git commit -m "Added task definition files"

      4. Ejecute el siguiente comando para enviar los archivos de su repositorio local al repositorio de CodeCommit:

         git push

   2. Para utilizar la consola de CodeCommit para cargar los archivos:

      1. Abra la consola de CodeCommit y elija el repositorio en la lista Repositorios.

      2. Elija Add file (Añadir archivo) y, a continuación, Upload file (Cargar archivo).

      3. Elija Choose file (Elegir archivo) y luego busque el archivo. Para confirmar el cambio, introduzca su nombre de usuario y la dirección de correo electrónico. Seleccione Confirmar cambios.

      4. Repita este paso para cada archivo que desee cargar.

Para verificar la VPC predeterminada y las subredes públicas

1. Inicie sesión en la Consola de administración de AWS y abra la consola de Amazon VPC en https://console.aws.amazon.com/vpc/.

2. Compruebe la VPC predeterminada que se va a utilizar. En el panel de navegación, elija Your VPCs (Sus VPC). Fíjese en qué VPC muestra Yes (Sí) en la columna Default VPC (VPC predeterminada). Esta es la VPC predeterminada. Contiene subredes predeterminadas para que pueda seleccionarlas.

3. Elija Subnets (Subredes). Elija dos subredes que muestren Yes (Sí) en la columna Default subnet (Subred predeterminada).

   nota

   Anote los ID de subred. Los necesitará más adelante en este tutorial.

4. Elija las subredes y, a continuación, elija la pestaña Description (Descripción). Compruebe que las subredes que desea utilizar se encuentran en diferentes zonas de disponibilidad.

5. Elija las subredes y, a continuación, elija la pestaña Route Table (Tabla de ruteo). Para verificar que cada subred que desea utilizar es una subred pública, confirme que se haya incluido una fila con el gateway en la tabla de ruteo.

Para crear un Equilibrador de carga de aplicación de Amazon EC2

1. Inicie sesión en la Consola de administración de AWS y abra la consola de Amazon EC2 en https://console.aws.amazon.com/ec2/.

2. En el panel de navegación, seleccione Equilibradores de carga.

3. Elija Crear equilibrador de carga.

4. Elija Equilibrador de carga de aplicación y a continuación, Crear.

5. En Nombre, especifique el nombre del equilibrador de carga.

6. En Scheme (Esquema), elija Internet-facing (Expuesto a Internet).

7. En IP address type (Tipo de dirección IP), elija ipv4.

8. Configure dos puertos de agentes de escucha para su equilibrador de carga:

   1. En Protocolo de equilibrador de carga, elija HTTP. En Puerto del equilibrador de carga, escriba 80.

   2. Elija Agregar oyente.

   3. En Protocolo de equilibrador de carga del segundo agente de escucha, elija HTTP. En Puerto del equilibrador de carga, escriba 8080.

9. En Availability Zones (Zonas de disponibilidad), en VPC, elija la VPC predeterminada. A continuación, seleccione las dos subredes predeterminadas que desea utilizar.

10. Elija Next: Configure Security Settings (Siguiente: Establecer la configuración de seguridad).

11. Elija Next: Configure Security Groups (Siguiente: configurar grupos de seguridad).

12. Elija Select an existing security group (Seleccionar un grupo de seguridad existente) y tome nota del ID del grupo de seguridad.

13. Elija Next: Configure Routing (Siguiente: Configuración del enrutamiento).

14. En Target group (Grupo de destino), elija New target group (Nuevo grupo de destino) y configure su primer grupo de destino:

    1. En Name (Nombre), introduzca un nombre de grupo de destino (por ejemplo, target-group-1).

    2. En Target type (Tipo de destino), elija IP.

    3. En Protocol (Protocolo), elija HTTP. En Port (Puerto), introduzca 80.

    4. Elija Next: Register Targets (Siguiente: Registrar destinos).

15. Elija Next: Review (Siguiente: análisis) y, a continuación, seleccione Create (Crear).

Para crear un segundo grupo de destino para el equilibrador de carga

1. Después de aprovisionar el equilibrador de carga, abra la consola de Amazon EC2. En el panel de navegación, elija Target Groups.

2. Elija Crear grupo de destino.

3. En Name (Nombre), introduzca un nombre de grupo de destino (por ejemplo, target-group-2).

4. En Target type (Tipo de destino), elija IP.

5. En Protocol (Protocolo), elija HTTP. En Port (Puerto), introduzca 8080.

6. En VPC, elija la VPC predeterminada.

7. Seleccione Crear.

   nota

   Para que la implementación se ejecute, debe tener dos grupos de destino creados para el equilibrador de carga. Solo tiene que tomar nota del ARN de su primer grupo de destino. Este ARN se utiliza en el archivo JSON de create-service en el siguiente paso.

Para actualizar el equilibrador de carga para incluir el segundo grupo de destino

1. Abra la consola de Amazon EC2. En el panel de navegación, seleccione Equilibradores de carga.

2. Elija el equilibrador de carga y, a continuación, elija la pestaña Agentes de escucha. Elija el agente de escucha con el puerto 8080 y, a continuación, elija Edit (Editar).

3. Elija el icono del lápiz que aparece junto a Forward to (Reenviar a). Elija su segundo grupo de destino y, a continuación, elija la marca de verificación. Elija Update (Actualizar) para guardar las actualizaciones.

Creación de un clúster de Amazon ECS

1. Abra la consola clásica de Amazon ECS en https://console.aws.amazon.com/ecs/.

2. En el panel de navegación, seleccione Clusters (Clústeres).

3. Elija Create cluster.

4. Elija la plantilla de clúster Solo redes que utiliza AWS Fargate y, a continuación, elija Paso siguiente.

5. Escriba un nombre de clúster en la página Configure cluster (Configurar el clúster), Puede añadir una etiqueta opcional al recurso. Seleccione Crear.

Para crear un servicio de Amazon ECS

Utilice la AWS CLI para crear el servicio en Amazon ECS.

1. Cree un archivo JSON y asígnele el nombre create-service.json. Pegue lo siguiente en el archivo JSON.

   En el campo taskDefinition, cuando se registra una definición de tarea en Amazon ECS, se le asigna una familia. Esto es similar a un nombre para las distintas versiones de la definición de tarea, que se especifican con un número de revisión. En este ejemplo, utilice ecs-demo:1 con la familia y el número de revisión del archivo. Utilice los nombres de subred, el grupo de seguridad y el valor del grupo de destino que creó con el equilibrador de carga en el Paso 3: Crear el equilibrador de carga de aplicaciones y los grupos de destino .

   nota

   Debe incluir el ARN del grupo de destino en este archivo. Abra la consola de Amazon EC2 y, desde el panel de navegación, en LOAD BALANCING (equilibrador de carga), elija Grupos de destino. Elija su primer grupo de destino. Copie el ARN desde la pestaña Description (Descripción).

   {
       "taskDefinition": "family:revision-number",
       "cluster": "my-cluster",
       "loadBalancers": [
           {
               "targetGroupArn": "target-group-arn",
               "containerName": "sample-website",
               "containerPort": 80
           }
       ],
       "desiredCount": 1,
       "launchType": "FARGATE",
       "schedulingStrategy": "REPLICA",
       "deploymentController": {
           "type": "CODE_DEPLOY"
       },
       "networkConfiguration": {
           "awsvpcConfiguration": {
               "subnets": [
                   "subnet-1",
                   "subnet-2"
               ],
               "securityGroups": [
                   "security-group"
               ],
               "assignPublicIp": "ENABLED"
           }
       }
   }

2. Ejecute el comando create-service y especifique el archivo JSON:

   importante

   Asegúrese de incluir file:// antes del nombre de archivo. Es obligatorio en este comando.

   En este ejemplo, se crea un servicio denominado my-service.

   nota

   Este comando de ejemplo crea un servicio denominado my-service. Si ya tiene un servicio con este nombre, el comando devuelve un error.

   aws ecs create-service --service-name my-service --cli-input-json file://create-service.json

   La salida devuelve los campos de descripción de su servicio.

3. Ejecute el comando describe-services para comprobar que se ha creado el servicio.

   aws ecs describe-services --cluster cluster-name --services service-name

Para crear una aplicación de CodeDeploy

1. Abra la consola de CodeDeploy y elija Crear aplicación.

2. En Application name (Nombre de aplicación), escriba el nombre que desea utilizar.

3. En Compute platform (Plataforma de computación), elija Amazon ECS.

4. Elija Creación de aplicación.

Para crear el grupo de implementación de CodeDeploy

1. En la página de la aplicación, en la pestaña Deployment groups (Grupos de implementaciones), elija Create deployment group (Crear grupo de implementaciones).

2. En Nombre de grupo de implementación, introduzca un nombre que describa el grupo de implementación.

3. En Rol de servicio, elija un rol de servicio que conceda acceso a CodeDeploy a Amazon ECS. Para crear un nuevo rol de servicio, siga estos pasos:

   1. Abra la consola de IAM en https://console.aws.amazon.com/iam/.

   2. En el panel de la consola, elija Roles.

   3. Seleccione Crear rol.

   4. En Seleccionar el tipo de entidad de confianza, seleccione Servicio de AWS. En Choose a use case (Elija un caso de uso), seleccione CodeDeploy. En Select your use case (Seleccione el caso de uso), elija CodeDeploy - ECS. Elija Siguiente: permisos. La política administrada AWSCodeDeployRoleForECS ya está asociada al rol.

   5. Elija Next: Tags (Siguiente: Etiquetas) y Next: Review (Siguiente: Revisar).

   6. Especifique un nombre para el rol (por ejemplo, CodeDeployECSRole) y elija Create role (Crear rol).

4. En Configuración de entorno, elija el nombre del clúster y el nombre del servicio de Amazon ECS.

5. En Equilibradores de carga), seleccione el nombre del equilibrador de carga que sirve el tráfico a su servicio de Amazon ECS.

6. En Production listener port (Puerto del agente de escucha de producción), elija el puerto y el protocolo del agente de escucha que sirve el tráfico de producción a su servicio ECS de Amazon. En Test listener port (Puerto de agente de escucha de prueba), elija y el puerto y el protocolo del agente de escucha de prueba.

7. En Target group 1 name (Nombre de grupo de destino 1) y Target group 2 name (Nombre de grupo de destino 2), elija los grupos de destino utilizados para dirigir el tráfico durante su implementación. Asegúrese de que se trata de los grupos de destino que ha creado para el equilibrador de carga.

8. Elija Redirigir el tráfico inmediatamente para determinar cuánto tiempo debe transcurrir después de una implementación correcta antes de redirigir el tráfico hacia la tarea de Amazon ECS actualizada.

9. Elija Crear grupo de implementación.

Para crear una canalización de dos etapas con el asistente

1. Inicie sesión en la Consola de administración de AWS y abra la consola de CodePipeline en http://console.aws.amazon.com/codesuite/codepipeline/home.

2. En la página Bienvenido, Introducción o Canalizaciones, elija Crear canalización.

3. En la página Paso 1: elección de la opción de creación, en Opciones de creación, seleccione la opción Crear una canalización personalizada. Elija Siguiente.

4. En Paso 2: elegir la configuración de la canalización, en Nombre de la canalización, escriba MyImagePipeline.

5. CodePipeline proporciona canalizaciones de tipo V1 y V2, que difieren en características y precio. El tipo V2 es el único tipo que puede elegir en la consola. Para obtener más información, consulte Tipos de canalización. Para obtener más información acerca de los precios de CodePipeline, consulte Precios.

6. En Rol de servicio, elija Nuevo rol de servicio para permitir que CodePipeline cree un rol de servicio en IAM.

7. En Advanced settings (Configuración avanzada), deje los valores predeterminados y elija Next (Siguiente).

8. En Paso 3: agregar la etapa de origen, en Proveedor de origen, elija AWS CodeCommit. En Nombre de repositorio, elija el nombre del repositorio de CodeCommit que ha creado en Paso 1: Crear un repositorio de CodeCommit. En Nombre de ramificación, elija el nombre de la ramificación que incluye la última actualización del código.

   Elija Siguiente.

9. En Paso 4: agregar la etapa de compilación, elija Omitir la etapa de compilación y, a continuación, acepte el mensaje de advertencia eligiendo Omitir una vez más. Elija Siguiente.

10. En Paso 5: agregación de la etapa de prueba, elija Omitir la etapa de prueba y, a continuación, acepte el mensaje de advertencia eligiendo Omitir una vez más.

    Elija Siguiente.

11. En Paso 6: agregar la etapa de implementación:

    1. En Deploy provider (Proveedor de implementación), elija Amazon ECS (Blue/Green) (Amazon ECS (azul/verde)). En Application name (Nombre de aplicación), elija el nombre de la aplicación en la lista como, por ejemplo, codedeployapp. En Deployment group (Grupo de implementación), escriba o elija el nombre de un grupo de implementaciones en la lista como, por ejemplo, codedeploydeplgroup.

       nota

       El nombre "Deploy" es el nombre predeterminado de la etapa creada en el paso Step 4: Deploy (Paso 4: Implementar) y "Source" es el nombre que recibe la primera etapa de la canalización.

    2. En Amazon ECS task definition (Definición de tareas de Amazon ECS), elija SourceArtifact. En el campo, introduzca taskdef.json.

    3. En Archivo AppSpec de AWS CodeDeploy), elija SourceArtifact. En el campo, introduzca appspec.yaml.

       nota

       En este momento, no rellene ninguna información en Dynamically update task definition image (Actualizar dinámicamente imagen de definición de tareas).

    4. Elija Siguiente.

12. En Step 7: Review, revise la información y después elija Create pipeline.

Para añadir una acción de origen de Amazon ECR a la canalización

Vea la canalización y añada una acción de origen de Amazon ECR a la canalización.

1. Elija la canalización. En la parte superior izquierda, elija Editar.

2. En la etapa de código fuente, elija Edit stage (Editar etapa).

3. Añada una acción en paralelo eligiendo + Añadir acción junto a su acción de origen de CodeCommit.

4. En Nombre de la acción, escriba un nombre (por ejemplo, Image).

5. En Action provider (Proveedor de acción), elija Amazon ECR.

   

6. En Nombre de repositorio, elija el nombre de su repositorio de Amazon ECR.

7. En Image tag (Etiqueta de imagen), especifique el nombre de la imagen y la versión, si es diferente de la última.

8. En Output artifacts (Artefactos de salida), elija el valor predeterminado del artefacto de salida (por ejemplo, MyImage), que contiene el nombre de la imagen y la información del URI del repositorio que desea que utilice la siguiente etapa.

9. Elija Save (Guardar) en la pantalla de acciones. Elija Done (Listo) en la pantalla de etapas. Elija Save (Guardar) en la canalización. Se muestra un mensaje con la regla de Eventos de Amazon CloudWatch que se creará para la acción de origen de Amazon ECR.

Para conectar los artefactos de código fuente con la acción de implementación

1. Elija Editar en la etapa de implementación y elija el icono para editar la acción de Amazon ECS (azul/verde).

2. Desplácese hasta el final del panel. En Input artifacts (Artefactos de entrada), elija Add (Añadir). Añada el artefacto de origen desde su nuevo repositorio de Amazon ECR (por ejemplo, MyImage).

3. En Task Definition (Definición de tareas), elija SourceArtifact y luego compruebe que se ha introducido taskdef.json.

4. En Archivo AppSpec de AWS CodeDeploy), elija SourceArtifact, y, a continuación, verifique que se ha introducido appspec.yaml.

5. En Dynamically update task definition image (Actualizar dinámicamente imagen de definición de tareas), en Input Artifact with Image URI (Introducir artefacto con URI de imagen), elija MyImage y, a continuación, escriba el texto del marcador de posición que se utiliza en el archivo taskdef.json: IMAGE1_NAME. Seleccione Save.

6. En el panel AWS CodePipeline, elija Guardar cambio de canalización y, a continuación, Guardar cambio. Consulte la canalización actualizada.

   Después de crear esta canalización de ejemplo, la configuración de la acción de las entradas de la consola aparece en la estructura de la canalización tal y como se indica a continuación:

   "configuration": {
     "AppSpecTemplateArtifact": "SourceArtifact",
     "AppSpecTemplatePath": "appspec.yaml",
     "TaskDefinitionTemplateArtifact": "SourceArtifact",
     "TaskDefinitionTemplatePath": "taskdef.json",
     "ApplicationName": "codedeployapp",
     "DeploymentGroupName": "codedeploydeplgroup",
     "Image1ArtifactName": "MyImage",
     "Image1ContainerName": "IMAGE1_NAME"
   },
   

7. Para enviar los cambios y comenzar una compilación de canalización, seleccione Publicar modificación y, a continuación, Publicar.

8. Elija la acción de implementación para verla en CodeDeploy y consulte el progreso del cambio de tráfico.

   nota

   Es posible que vea un paso de implementación que muestre un tiempo de espera opcional. De forma predeterminada, CodeDeploy espera una hora después de una implementación correcta antes de terminar el conjunto de tareas originales. Puede utilizar este tiempo para revertir o terminar la tarea, pero la implementación se completa cuando finaliza el conjunto de tareas.