Tutorial: Implementación estándar de Amazon ECS con CodePipeline

Este tutorial le ayuda a crear una canalización de despliegue end-to-end continuo (CD) completa con Amazon ECS con CodePipeline.

importante

Como parte de la creación de una canalización en la consola, para los artefactos se utilizará un depósito de artefactos CodePipeline de S3. (Es diferente del bucket que se usa para una acción de origen de S3). Si el depósito de artefactos de S3 está en una cuenta diferente a la de tu canalización, asegúrate de que el depósito de artefactos de S3 pertenezca a una Cuentas de AWS persona segura y fiable.

nota

Este tutorial es para la acción de implementación estándar de Amazon ECS para CodePipeline. Para ver un tutorial en el que se utiliza Amazon ECS para realizar una acción de implementación CodeDeploy azul/verde CodePipeline, consulte. Tutorial: Creación de una canalización con una fuente y ECS-to-CodeDeploy una implementación de Amazon ECR

nota

Este tutorial es para la acción de implementación estándar de Amazon ECS CodePipeline con una acción de origen. Para ver un tutorial en el que se utiliza la acción de ECSstandard despliegue de Amazon junto con la acción de ECRBuild AndPublish creación CodePipeline para insertar la imagen, consulteTutorial: Cree e inserte una imagen de Docker en Amazon ECR con CodePipeline.

Requisitos previos

Para poder usar este tutorial para crear su propia canalización de implementación continua debe tener instalados algunos recursos. Esto es lo que necesita para empezar:

nota

Todos estos recursos deben crearse en la misma AWS región.

• Un repositorio de control de código fuente (se utiliza en este tutorial CodeCommit) con el Dockerfile y el código fuente de la aplicación. Para obtener más información, consulte Crear un CodeCommit repositorio en la Guía del AWS CodeCommit usuario.

• Un repositorio de imágenes de Docker (este tutorial utiliza Amazon ECR) que contenga una imagen que haya creado desde el origen de Dockerfile y de la aplicación. Para obtener más información, consulte Creación de un repositorio e Inserción de una imagen en la Guía del usuario de Amazon Elastic Container Registry.

• Una definición de tarea de Amazon ECS que haga referencia a la imagen de Docker alojada en su repositorio de imágenes. Para obtener más información, consulte Creación de una definición de tarea en la Guía para desarrolladores de Amazon Elastic Container Service.

  importante

  La acción de despliegue estándar de Amazon ECS CodePipeline crea su propia revisión de la definición de la tarea en función de la revisión utilizada por el servicio Amazon ECS. Si crea nuevas revisiones para la definición de la tarea sin actualizar el servicio Amazon ECS, la acción de implementación ignorará esas revisiones.

  A continuación, se muestra un ejemplo de definición de tarea utilizada en este tutorial. El valor que utiliza para name y family se utilizará en el siguiente paso del archivo de especificaciones de compilación.

  {
    "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": []
  }

• Un clúster de Amazon ECS que ejecute un servicio que utilice la definición de tarea mencionada anteriormente. Para obtener más información, consulte Creación de un clúster y Creación de un servicio en la Guía para desarrolladores de Amazon Elastic Container Service.

Una vez satisfechos estos requisitos previos, puede continuar con el tutorial y crear su canalización de implementación continua.

Paso 1: Añadir un archivo de especificación de compilación a su repositorio de código fuente

Este tutorial se utiliza CodeBuild para crear su imagen de Docker y enviarla a Amazon ECR. Añada un archivo buildspec.yml al repositorio del código fuente que indique a CodeBuild cómo hacerlo. La siguiente especificación de compilación de ejemplo hace lo siguiente:

• Etapa previa a la compilación:

  • Inicie sesión en Amazon ECR.

  • Establece el URI del repositorio en la imagen de ECR y añade una etiqueta de imagen con los siete primeros caracteres del ID de confirmación de Git del código fuente.

• Etapa de compilación:

  • Crea la imagen de Docker y etiqueta la imagen como latest y con el ID de confirmación de Git.

• Etapa posterior a la compilación:

  • Inserta la imagen en el repositorio de ECR con ambas etiquetas.

  • Escribe un archivo denominado imagedefinitions.json en la raíz de la compilación con el nombre del contenedor del servicio de Amazon ECS y la imagen y la etiqueta. La etapa de implementación de la canalización de implementación continua utiliza esta información para crear una nueva revisión de la definición de tarea del servicio y, a continuación, actualiza el servicio para usar la nueva definición de tarea. El archivo imagedefinitions.json es necesario para el proceso de trabajo de ECS.

Pegue este texto de ejemplo para crear el archivo buildspec.yml y sustituya los valores de la imagen y la definición de la tarea. En este texto, se utiliza el ID de cuenta de ejemplo 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

La especificación de compilación se ha creado para el siguiente ejemplo de definición de tarea proporcionada en Requisitos previos, usada por el servicio de Amazon ECS para este tutorial. El valor de REPOSITORY_URI se corresponde con el repositorio image (sin etiquetas de imagen) y el valor hello-world situado cerca del final del archivo se corresponde con el nombre de contenedor de la definición de tarea.

Para añadir un archivo buildspec.yml a su repositorio de código fuente

1. Abra un editor de texto y copie y pegue la especificación de compilación anterior en un nuevo archivo.

2. Sustituya el valor de REPOSITORY_URI (012345678910.dkr.ecr.us-west-2.amazonaws.com/hello-world) por el URI de su repositorio de Amazon ECR (sin etiquetas de imagen) para la imagen de Docker. Sustituya hello-world por el nombre de contenedor de la definición de tarea del servicio que hace referencia a la imagen de Docker.

3. Confirme la operación e inserte el archivo buildspec.yml en el repositorio de código fuente.

   1. Añada el archivo.

      git add .

   2. Valide el cambio con.

      git commit -m "Adding build specification."

   3. Envíe la confirmación.

      git push

Paso 2: Crear la canalización de implementación continua

Utilice el CodePipeline asistente para crear las etapas de la canalización y conectar el repositorio de origen a su servicio de ECS.

Para crear la canalización

1. Abra la CodePipeline consola en https://console.aws.amazon.com/codepipeline/.

2. En la página Welcome, elija Create pipeline.

   Si es la primera vez que la utiliza CodePipeline, aparecerá una página de introducción en lugar de Bienvenida. Seleccione Get Started Now.

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 Next (Siguiente).

4. En el paso 2: elige la configuración de la canalización, en Nombre de la canalización, escribe el nombre de la canalización. En este tutorial, el nombre de la canalización es hello-world.

5. En Tipo de canalización, mantenga la selección predeterminada en V2. Los tipos de canalización difieren en características y precio. Para obtener más información, consulte Tipos de canalización. Elija Next (Siguiente).

6. En la página Paso 3: Añadir fase de origen, selecciona Proveedor de origen AWS CodeCommit.

   1. En Repository name (Nombre del repositorio), elija el nombre del repositorio de CodeCommit que desea utilizar como ubicación de origen para la canalización.

   2. En Branch name (Nombre de ramificación), elija la ramificación que desea usar y seleccione Next (Siguiente).

7. En la página Paso 4: Agregar la etapa de compilación, en Proveedor de compilación AWS CodeBuild, elija y, a continuación, elija Crear proyecto.

   1. En Project name, elija un nombre exclusivo para su proyecto de compilación. En este tutorial, el nombre del proyecto es hello-world.

   2. En Environment image (Imagen de entorno), elija Managed image (Imagen administrada).

   3. En Operating system (Sistema operativo), elija Amazon Linux 2.

   4. En Runtime(s) (Tiempo de ejecución), elija Standard (Estándar).

   5. Para Imagen, elija aws/codebuild/amazonlinux2-x86_64-standard:3.0.

   6. En Image version (Versión de imagen) y Environment type (Tipo de entorno), utilice los valores predeterminados.

   7. Seleccione Enable this flag if you want to build Docker images or want your builds to get elevated privileges (Habilite este indicador si desea compilar imágenes de Docker o que sus compilaciones tengan privilegios elevados).

   8. Deseleccione los CloudWatch registros. Puede que tengas que expandir Avanzado.

   9. Selecciona Continuar a. CodePipeline

   10. Elija Next (Siguiente).

       nota

       El asistente crea un rol de CodeBuild servicio para tu proyecto de compilación, denominado codebuild- build-project-name -service-role. Anote este nombre de rol, ya que le añadirá los permisos de Amazon ECR más adelante.

8. En la página Paso 5: Añadir fase de despliegue, para Proveedor de despliegue, elija Amazon ECS.

   1. En Nombre del clúster, elija el clúster de en el que se ejecuta el servicio. En este tutorial, el clúster es default.

   2. En Service name (Nombre de servicio), elija el servicio que desea actualizar y seleccione Next (Siguiente). En este tutorial, el nombre del servicio es hello-world.

9. En la página Step 6: Review, revise la configuración de la canalización y elija Create pipeline para crear la canalización.

   nota

   Ahora que se ha creado la canalización, intenta ejecutarse a través de las diferentes etapas de canalización. Sin embargo, el CodeBuild rol predeterminado creado por el asistente no tiene permisos para ejecutar todos los comandos contenidos en el buildspec.yml archivo, por lo que se produce un error en la etapa de compilación. En la siguiente sección se añaden los permisos para la etapa de compilación.

Paso 3: Añadir permisos de Amazon ECR al rol CodeBuild

El CodePipeline asistente creó un rol de IAM para el proyecto de compilación, denominado CodeBuild codebuild - -service-role. build-project-name En este tutorial, el nombre es -role. codebuild-hello-world-service Dado que el archivo buildspec.yml realiza llamadas a operaciones de la API de Amazon ECR, el rol debe tener una política que conceda permisos para realizar estas llamadas a Amazon ECR. El siguiente procedimiento le ayuda a asociar los permisos adecuados al rol.

Para añadir permisos de Amazon ECR al rol CodeBuild

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

2. En el panel de navegación izquierdo, elija Roles.

3. En el cuadro de búsqueda, escriba codebuild- y elija el rol que creó el CodePipeline asistente. En este tutorial, el nombre del rol es codebuild-hello-world-service-role.

4. En la página Summary (Resumen), elija Attach policies (Asociar políticas).

5. Selecciona la casilla situada a la izquierda de la EC2 ContainerRegistryPowerUser política de Amazon y selecciona Adjuntar política.

Paso 4: Probar la canalización

Su proceso debe tener todo lo necesario para ejecutar un despliegue AWS continuo end-to-end nativo. Ahora, pruebe su funcionalidad enviando un cambio de código al repositorio de código fuente.

Para probar la canalización

1. Realice una modificación del código en el repositorio de código fuente configurado, valide y envíe el cambio.

2. Abra la CodePipeline consola en https://console.aws.amazon.com/codepipeline/.

3. Seleccione su canalización de la lista.

4. Vea el progreso en la canalización a través de sus etapas. Su canalización debería completarse y el servicio de Amazon ECS debería ejecutar la imagen de Docker que se creó a partir de la modificación del código.