Tutorial: Implementación estándar de Amazon ECS con CodePipeline - AWS CodePipeline
Requisitos previosPaso 1: Añadir un archivo de especificación de compilación a su repositorio de código fuentePaso 2: Crear la canalización de implementación continuaPaso 3: Añadir permisos de Amazon ECR al rol de CodeBuildPaso 4: Probar la canalización

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

Este tutorial le ayuda a crear una canalización completa de implementación continua (CD) de extremo a extremo con Amazon ECS con CodePipeline.

importante

Como parte de la creación de una canalización en la consola, CodePipeline utilizará un bucket de artefactos de S3 para los artefactos. (Es diferente del bucket que se usa para una acción de origen de S3). Si el bucket de artefactos de S3 se encuentra en una cuenta diferente a la cuenta de su canalización, asegúrese de que el bucket de artefactos de S3 pertenezca a Cuentas de AWS que sean seguras y fiables.

nota

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

nota

Este tutorial es para la acción de implementación estándar de Amazon ECS para CodePipeline con una acción de origen. Si lo que necesita es un tutorial donde se utilice la acción de implementación ECSstandard junto con la acción de compilación ECRBuildAndPublish en CodePipeline para insertar su imagen, consulte Tutorial: compilación e inserción de una imagen de Docker en Amazon ECR con CodePipeline (tipo V2).

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 región de AWS.

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

  • 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 implementación estándar de Amazon ECS para 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 utiliza CodeBuild para crear la imagen de Docker e insertarla en 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 asistente de CodePipeline para crear las fases de la canalización y conecte su repositorio de origen al servicio de ECS.

Para crear la canalización

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

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

    Si es la primera vez que utiliza CodePipeline , aparece 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 Siguiente.

  4. En el paso 2: elección de la configuración de la canalización, en Nombre de la canalización, escriba un nombre para su 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 Siguiente.

  6. En la página Paso 3: agregar la etapa de origen, en Proveedor de origen, elija AWS CodeCommit.

    1. En Nombre del repositorio, elija el nombre del repositorio de 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 una fase de compilación, de Proveedor de compilación, elija AWS CodeBuild y, a continuación, seleccione 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. Anule la selección de CloudWatch Logs. Puede que tengas que expandir Avanzado.

    9. Elija Continue to CodePipeline (Continuar en CodePipeline).

    10. Elija Siguiente.

      nota

      El asistente crea un rol de servicio de CodeBuild para el 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: Agregar una fase de implementación, en Proveedor de implementación, 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 rol de CodeBuild predeterminado creado por el asistente no tiene permisos para ejecutar todos los comandos incluidos en el archivo buildspec.yml, 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 de CodeBuild

El asistente de CodePipeline creó un rol de IAM para el proyecto de compilación de CodeBuild denominado codebuild-build-project-name-service-role. En este tutorial, el nombre es codebuild-hello-world-service-role. 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 de 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 campo de búsqueda, escriba codebuild- y elija el rol creado por el asistente de CodePipeline. 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. Seleccione la casilla situada a la izquierda de la política AmazonEC2ContainerRegistryPowerUser y elija Attach policy.

Paso 4: Probar la canalización

Su canalización debería tener todo lo necesario para ejecutar una implementación continua de AWS nativa de extremo a extremo. 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 consola de CodePipeline 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.