Tutorial: Implementación ECS estándar de Amazon 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 ECR permisos de Amazon al CodeBuild rolPaso 4: Probar la canalización

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

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

Este tutorial te ayuda a crear una canalización de despliegue end-to-end continuo (CD) completa con Amazon ECS with 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 depósito 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 cuenta de tu canalización, asegúrate de que el depósito de artefactos de S3 pertenezca Cuentas de AWS a una persona segura y fiable.

nota

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

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 usa AmazonECR) que contiene una imagen que ha creado a partir de su Dockerfile y la fuente 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 ECS tarea de Amazon que hace referencia a la imagen de Docker alojada en tu 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 ECS estándar de Amazon para CodePipeline crea su propia revisión de la definición de la tarea en función de la revisión utilizada por el ECS servicio de Amazon. Si creas nuevas revisiones para la definición de la tarea sin actualizar el ECS servicio de Amazon, la acción de despliegue 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 ECS clúster de Amazon que ejecuta un servicio que usa la definición de tareas 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 tu imagen de Docker y enviarla a AmazonECR. Agrega un buildspec.yml archivo a tu repositorio de código fuente para saber CodeBuild cómo hacerlo. La siguiente especificación de compilación de ejemplo hace lo siguiente:

  • Etapa previa a la compilación:

    • Inicia sesión en AmazonECR.

    • Configura el repositorio URI en tu ECR imagen y añade una etiqueta de imagen con los siete primeros caracteres del ID de confirmación de Git de la 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:

    • Coloca la imagen en tu ECR repositorio con ambas etiquetas.

    • Escribe un archivo llamado root imagedefinitions.json de compilación que contenga el nombre del contenedor de tu ECS servicio de Amazon, 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 imagedefinitions.json archivo es obligatorio para ECS el trabajador.

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 escribió para la definición de tarea de ejemplo que se proporcionó enRequisitos previos, utilizada por el ECS servicio de Amazon 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 REPOSITORY_URI valor (012345678910.dkr.ecr.us-west-2.amazonaws.com/hello-world) por su ECR repositorio de Amazon URI (sin ninguna etiqueta de imagen) para su 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

Usa el CodePipeline asistente para crear las etapas del proceso y conectar el repositorio de origen a tu ECS servicio.

Para crear la canalización

  1. Abre 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: Nombre, 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.

  4. En Tipo de canalización, selecciona V2. Para obtener más información, consulte Tipos de canalización. Elija Next (Siguiente).

  5. En la página Paso 2: Añadir etapa de origen, en Proveedor de origen, elija AWS CodeCommit.

    1. En Nombre del repositorio, elige el nombre del CodeCommit repositorio que deseas usar como ubicación de origen para tu canalización.

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

  6. En la página Paso 3: 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. Deselecciona los CloudWatch registros. Puede que tengas que expandir Avanzado.

    9. Selecciona Continuar a. CodePipeline

    10. Elija Next (Siguiente).

      nota

      El asistente crea un rol CodeBuild de servicio para el proyecto de compilación, denominado codebuild-build-project-name-rol de servicio. Anote el nombre de este rol cuando le añada ECR permisos de Amazon más adelante.

  7. En la página Paso 4: Añadir fase de despliegue, en Proveedor de despliegue, selecciona Amazon ECS.

    1. En Nombre de clúster, elige el ECS clúster de Amazon en el que se ejecuta tu 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.

  8. En la página Paso 5: Revisar, revise la configuración de la canalización y elija Crear canalización 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 ECR permisos de Amazon al CodeBuild rol

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

Para añadir ECR permisos de Amazon al CodeBuild rol

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

  2. En el panel de navegación izquierdo, seleccione 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 EC2ContainerRegistryPowerUser 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. Tu canalización debería completarse y tu ECS servicio de Amazon ejecutará la imagen de Docker que se creó a partir del cambio de código.