Tutorial: implementación de una aplicación en Amazon ECS - Amazon CodeCatalyst

Tutorial: implementación de una aplicación en Amazon ECS

En este tutorial, aprenderá a implementar una aplicación sin servidor en Amazon Elastic Container Service (Amazon ECS) mediante un flujo de trabajo, Amazon ECS y algunos otros servicios de AWS. La aplicación implementada es un sencillo sitio web Hello World creado a partir de una imagen de Docker del servidor web de Apache. El tutorial explica el trabajo de preparación necesario, como la configuración de un clúster, y luego describe cómo crear un flujo de trabajo para crear e implementar la aplicación.

sugerencia

En lugar de seguir este tutorial, puede utilizar un esquema que realice una configuración completa de Amazon ECS por usted. Deberá utilizar el esquema de API para Node.js con AWS Fargate o API para Java conAWS Fargate. Para obtener más información, consulte Creación de un proyecto con un esquema.

Requisitos previos

Antes de empezar

  • Necesita un espacio de CodeCatalyst con una cuenta de AWS conectada. Para obtener más información, consulte Creación de un espacio.

  • En su espacio, necesita un proyecto vacío llamado:

    codecatalyst-ecs-project

    Use la opción Empezar desde cero para crear este proyecto.

    Para obtener más información, consulte Creación de un proyecto vacío en Amazon CodeCatalyst.

  • En su proyecto, necesita un entorno de CodeCatalyst llamado:

    codecatalyst-ecs-environment

    Configure este entorno de la siguiente manera:

    • Elija cualquier tipo, como Sin producción.

    • Conecte su cuenta de AWS al entorno.

    • En Rol de IAM predeterminado, elija cualquier rol. Especificará un rol diferente más adelante.

    Para obtener más información, consulte Implementación en Cuentas de AWS y VPC.

Paso 1: configurar un usuario de AWS y AWS CloudShell

El primer paso de este tutorial consiste en crear un usuario de AWS IAM Identity Center y lanzar una instancia de AWS CloudShell como este usuario. En este tutorial, CloudShell es el equipo de desarrollo y es donde se configuran los recursos y los servicios de AWS. Elimine este usuario después de completar el tutorial.

nota

No utilice el usuario raíz para este tutorial. Debe crear un usuario distinto o, de lo contrario, podría tener problemas al realizar acciones en la AWS Command Line Interface (CLI) más adelante.

Para obtener más información sobre los usuarios de IAM Identity Center y CloudShell, consulte la Guía del usuario de AWS IAM Identity Center y la Guía del usuario de AWS CloudShell.

Creación de un rol de IAM Identity Center
  1. Inicie sesión en la AWS Management Console y abra la consola de AWS IAM Identity Center en https://console.aws.amazon.com/singlesignon/.

    nota

    Asegúrese de iniciar sesión con la Cuenta de AWS que está conectada a su espacio de CodeCatalyst. Para comprobar qué cuenta está conectada, vaya a su espacio y elija la pestaña Cuentas de AWS. Para obtener más información, consulte Creación de un espacio.

  2. En el panel de navegación, elija Users y luego elija la opción Add user.

  3. En Nombre de usuario, escriba:

    CodeCatalystECSUser
  4. En Contraseña, elija Generar una contraseña de un solo uso que pueda compartir con este usuario.

  5. En Dirección de correo electrónico y Confirmar dirección de correo electrónico, introduzca una dirección de correo electrónico que no exista aún en IAM Identity Center.

  6. En Nombre y Apellidos, introduzca:

    CodeCatalystECSUser
  7. En Nombre de visualización, mantenga el nombre generado automáticamente:

    CodeCatalystECSUser CodeCatalystECSUser
  8. Elija Siguiente.

  9. En la página Agregar usuarios a grupos, elija Siguiente.

  10. En la página Revisar y agregar usuario, compruebe la información que ha introducido y seleccione Agregar usuario.

    Aparece el cuadro de diálogo Contraseña de un solo uso.

  11. Seleccione Copiar y, a continuación, pegue la información de inicio de sesión, incluida la URL del portal de acceso de AWS y la contraseña de un solo uso.

  12. Elija Close.

Creación de un conjunto de permisos

Asignará este conjunto de permisos a CodeCatalystECSUser más adelante.

  1. En el panel de navegación, elija Conjuntos de permisos y, a continuación, elija Crear conjunto de permisos.

  2. En Conjunto de permisos predefinido, seleccione AdministratorAccess. Esta política concede permisos completos a todos los Servicios de AWS.

  3. Elija Siguiente.

  4. En Nombre del conjunto de permisos, introduzca:

    CodeCatalystECSPermissionSet
  5. Elija Siguiente.

  6. En la página Revisión, revise la información y, a continuación, elija Crear grupo.

Asignación del conjunto de permisos a CodeCatalystECSUser
  1. En el panel de navegación, elija Cuentas de AWS y, a continuación, seleccione la casilla de verificación situada junto a la Cuenta de AWS en la que ha iniciado sesión.

  2. Seleccione Asignar usuarios o grupos.

  3. Elija la pestaña Users.

  4. Seleccione la casilla situada junto a CodeCatalystECSUser.

  5. Elija Siguiente.

  6. Seleccione la casilla situada junto a CodeCatalystECSPermissionSet.

  7. Elija Siguiente.

  8. Revise la información y seleccione Enviar.

    Ahora ha asignado CodeCatalystECSUser y CodeCatalystECSPermissionSet a su Cuenta de AWS, combinándolos.

Cierre de sesión y nuevo inicio de sesión como CodeCatalystECSUser
  1. Antes de cerrar sesión, asegúrese de tener la URL del portal de acceso de AWS y el nombre de usuario y la contraseña de un solo uso para CodeCatalystECSUser. Debería haber copiado esta información en un editor de texto anteriormente.

    nota

    Si no dispone de esta información, vaya a la página de detalles de CodeCatalystECSUser en IAM Identity Center, elija Restablecer contraseña, Generar una contraseña de un solo uso [...] y de nuevo Restablecer contraseña para que aparezca la información en la pantalla.

  2. Cierre la sesión de AWS.

  3. Pegue la URL del portal de acceso a AWS en la barra de direcciones del navegador.

  4. Inicie sesión con el nombre de usuario y la contraseña de un solo uso de CodeCatalystECSUser.

  5. En Nueva contraseña, introduzca una contraseña y elija Establecer nueva contraseña.

    Aparece un cuadro de Cuenta de AWS en la pantalla.

  6. Elija Cuenta de AWS y, a continuación, elija el nombre de la Cuenta de AWS a la que asignó el usuario CodeCatalystECSUser y el conjunto de permisos.

  7. Junto a CodeCatalystECSPermissionSet, seleccione Consola de administración.

    Aparecerá la AWS Management Console. Ahora ha iniciado sesión como CodeCatalystECSUser con los permisos correspondientes.

Lanzamiento de una instancia de AWS CloudShell
  1. Como CodeCatalystECSUser, en la barra de navegación superior, elija el icono de AWS ( AWS icon ).

    Aparecerá la página principal de la AWS Management Console.

  2. En la barra de navegación superior, elija el icono de AWS CloudShell ( CloudShell icon ).

    Se abre CloudShell. Espere a que se cree el entorno de CloudShell.

    nota

    Si no ve el icono de CloudShell, asegúrese de que se encuentra en una región compatible con CloudShell. En este tutorial se da por sentado que está en la región de Oeste de EE. UU. (Oregón).

Comprobación de que la AWS CLI está instalada
  1. En el terminal de CloudShell, introduzca:

    aws --version
  2. Compruebe que aparezca una versión.

    La AWS CLI ya está configurada para el usuario actual, CodeCatalystECSUser, por lo que no es necesario configurar las claves y credenciales de AWS CLI, como suele ser el caso.

Paso 2: implementar una aplicación de marcador de posición en Amazon ECS

En esta sección, implementará manualmente una aplicación de marcador de posición en Amazon ECS. Esta aplicación de marcador de posición se sustituirá por la aplicación Hello World implementada en su flujo de trabajo. La aplicación de marcador de posición es Apache Web Server.

Para obtener más información sobre Amazon ECS, consulte la Guía para desarrolladores de Amazon Elastic Container Service.

Realice la siguiente serie de procedimientos para implementar la aplicación de marcador de posición.

Creación del rol de ejecución de tareas

Este rol concede a Amazon ECS y AWS Fargate permiso para realizar llamadas a la API en su nombre.

  1. Cree una política de confianza:

    1. En AWS CloudShell, escriba el siguiente comando:

      cat > codecatalyst-ecs-trust-policy.json

      Aparece una línea de comandos parpadeante en el terminal de CloudShell.

    2. En la línea de comandos, escriba el código siguiente:

      { "Version": "2012-10-17", "Statement": [ { "Sid": "", "Effect": "Allow", "Principal": { "Service": "ecs-tasks.amazonaws.com" }, "Action": "sts:AssumeRole" } ] }
    3. Coloque el cursor después del último corchete (}).

    4. Pulse Enter y, a continuación, Ctrl+d para guardar el archivo y salir de cat.

  2. Cree un rol de ejecución de tareas:

    aws iam create-role \ --role-name codecatalyst-ecs-task-execution-role \ --assume-role-policy-document file://codecatalyst-ecs-trust-policy.json
  3. Asocie la política AWS administrada de AmazonECSTaskExecutionRolePolicy al rol:

    aws iam attach-role-policy \ --role-name codecatalyst-ecs-task-execution-role \ --policy-arn arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy
  4. Muestre los detalles del rol:

    aws iam get-role \ --role-name codecatalyst-ecs-task-execution-role
  5. Anote el valor de "Arn": del rol (por ejemplo, arn:aws:iam::111122223333:role/codecatalyst-ecs-task-execution-role). Necesitará este Nombre de recurso de Amazon (ARN) más adelante.

Creación de un clúster de Amazon ECS

Este clúster contendrá la aplicación de marcador de posición de Apache y, más adelante, la aplicación Hello World.

  1. Como CodeCatalystECSUser, en AWS CloudShell, cree un clúster vacío:

    aws ecs create-cluster --cluster-name codecatalyst-ecs-cluster
  2. (Opcional) Compruebe que el clúster se haya creado correctamente:

    aws ecs list-clusters

    El ARN del clúster de codecatalyst-ecs-cluster debe aparecer en la lista, lo que indica que la creación se ha realizado correctamente.

Creación de un nuevo archivo de definición de tareas

El archivo de definición de tareas indica que se debe ejecutar la imagen de Docker Servidor web Apache 2.4 (httpd:2.4), que se extrae de DockerHub.

  1. Como CodeCatalystECSUser, en AWS CloudShell, cree un archivo de definición de tareas:

    cat > taskdef.json
  2. En la línea de comandos, pegue el código siguiente:

    { "executionRoleArn": "arn:aws:iam::111122223333:role/codecatalyst-ecs-task-execution-role", "containerDefinitions": [ { "name": "codecatalyst-ecs-container", "image": "httpd:2.4", "essential": true, "portMappings": [ { "hostPort": 80, "protocol": "tcp", "containerPort": 80 } ] } ], "requiresCompatibilities": [ "FARGATE" ], "cpu": "256", "family": "codecatalyst-ecs-task-def", "memory": "512", "networkMode": "awsvpc" }

    En el código anterior, sustituya arn:aws:iam::111122223333:role/codecatalyst-ecs-task-execution-role

    por el ARN del rol de ejecución de tareas que anotó en Creación del rol de ejecución de tareas.

  3. Coloque el cursor después del último corchete (}).

  4. Pulse Enter y, a continuación, Ctrl+d para guardar el archivo y salir de cat.

Registro del archivo de definición de tareas con Amazon ECS
  1. Como CodeCatalystECSUser, en AWS CloudShell, registre la definición de tareas:

    aws ecs register-task-definition \ --cli-input-json file://taskdef.json
  2. (Opcional) Compruebe que se haya registrado la definición de la tareas:

    aws ecs list-task-definitions

    La definición de tareas codecatalyst-ecs-task-def debe aparecer en la lista.

Creación de un servicio de Amazon ECS

El servicio Amazon ECS ejecuta las tareas (y los contenedores de Docker asociados) de la aplicación de marcador de posición Apache y, posteriormente, de la aplicación Hello World.

  1. Como CodeCatalystECSUser, cambie a la consola de Amazon Elastic Container Service si aún no lo ha hecho.

  2. Elija el clúster que creó anteriormente, codecatalyst-ecs-cluster.

  3. En la pestaña Servicios, elija Crear.

  4. En la página Crear, haga lo siguiente:

    1. Mantenga todas las opciones predeterminadas excepto las que se indican a continuación.

    2. En Launch type (Tipo de lanzamiento), elija FARGATE.

    3. En Definición de tarea, en la lista desplegable Familia, elija:

      codecatalyst-ecs-task-def

    4. En Nombre del servicio, escriba:

      codecatalyst-ecs-service
    5. En Tareas deseadas, escriba:

      3

      En este tutorial, cada tarea lanza un único contenedor de Docker.

    6. Expanda la sección Redes.

    7. En VPC, elija cualquier VPC.

    8. En Subredes, elija cualquier subred.

      nota

      Especifique solo una subred. Eso es todo lo que se necesita para este tutorial.

      nota

      Si no dispone de una VPC ni una subred, créelas. Consulte Crear una VPC y Crear una subred en la VPC en la Guía del usuario de Amazon VPC.

    9. En Grupo de seguridad, elija Crear un nuevo grupo de seguridad y, a continuación, haga lo siguiente:

      1. En Nombre del grupo de seguridad, introduzca:

        codecatalyst-ecs-security-group
      2. En Descripción del grupo de seguridad, introduzca:

        CodeCatalyst ECS security group
      3. Seleccione Agregar regla. En Tipo, elija HTTP y, en Origen, elija Cualquier lugar.

    10. En la parte inferior, elija Crear.

    11. Espere a que se cree el servicio. Puede que tarde unos minutos.

  5. Elija la pestaña Tareas y, a continuación, elija el botón Actualizar. Compruebe que la columna Último estado de las tres tareas esté establecida en En ejecución.

(Opcional) Comprobación de que la aplicación de marcador de posición de Apache se esté ejecutando
  1. En la pestaña Tareas, elija una de las tres tareas.

  2. En el campo IP pública, elija dirección abierta.

    Aparecerá una página It Works! Esto indica que el servicio de Amazon ECS inició correctamente una tarea que lanzó un contenedor de Docker con la imagen de Apache.

    En este punto del tutorial, ha implementado manualmente un clúster, un servicio y una definición de tareas de Amazon ECS, además de una aplicación de marcador de posición de Apache. Con todos estos elementos listos, ya puede crear un flujo de trabajo que sustituya la aplicación de marcador de posición de Apache por la aplicación Hello World del tutorial.

Paso 3: crear un repositorio de imágenes de Amazon ECR

En esta sección, creará un repositorio de imágenes privado en Amazon Elastic Container Registry (Amazon ECR). Este repositorio almacena la imagen de Docker del tutorial, que sustituirá a la imagen de marcador de posición de Apache que implementó anteriormente.

Para obtener más información sobre Amazon ECR, consulte la Guía del usuario de Amazon Elastic Container Registry.

Creación de un repositorio de imágenes en Amazon ECR
  1. Como CodeCatalystECSUser, en AWS CloudShell, cree un repositorio vacío en Amazon ECR:

    aws ecr create-repository --repository-name codecatalyst-ecs-image-repo
  2. Muestre los detalles del repositorio de Amazon ECR:

    aws ecr describe-repositories \ --repository-names codecatalyst-ecs-image-repo
  3. Anote el valor de “repositoryUri”: (por ejemplo, 111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-ecs-image-repo).

    Lo necesitará más adelante cuando añada el repositorio a su flujo de trabajo.

Paso 4: crear roles de AWS

En esta sección, creará los roles de AWS IAM que necesitará su flujo de trabajo de CodeCatalyst para funcionar. Estos roles son:

  • Rol de compilación: concede a la acción de compilación de CodeCatalyst (en el flujo de trabajo) permiso para acceder a su cuenta de AWS y escribir en Amazon ECR y Amazon EC2.

  • Rol de implementación: concede a la acción de CodeCatalyst Implementar en ECS (en el flujo de trabajo) permiso para acceder a su cuenta de AWS, Amazon ECS y algunos otros servicios de AWS.

Para obtener más información sobre los roles de IAM, consulte Roles de IAM en la Guía del usuario de AWS Identity and Access Management.

nota

Para ahorrar tiempo, puede crear un único rol, denominado rol CodeCatalystWorkflowDevelopmentRole-spaceName, en lugar de los dos roles indicados anteriormente. Para obtener más información, consulte Creación del rol CodeCatalystWorkflowDevelopmentRole-spaceName para su cuenta y su espacio. Tenga en cuenta que el rol CodeCatalystWorkflowDevelopmentRole-spaceName tiene permisos muy amplios, lo que puede suponer un riesgo para la seguridad. Le recomendamos que utilice este rol solo en tutoriales y situaciones en las que la seguridad no sea un problema. En este tutorial se presupone que va a crear los dos roles indicados anteriormente.

Para crear los roles de compilación e implementación, puede usar la AWS Management Console o la AWS CLI.

AWS Management Console

Para crear los roles de compilación e implementación, realice la siguiente serie de procedimientos.

Creación de un rol de compilación
  1. Cree una política para el rol del modo siguiente:

    1. Inicie sesión en AWS.

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

    3. En el panel de navegación, seleccione Políticas.

    4. Elija Create Policy (Crear política).

    5. Seleccione la pestaña JSON.

    6. Elimine el código existente.

    7. Pegue el siguiente código:

      { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "ecr:*", "ec2:*" ], "Resource": "*" } ] }
      nota

      La primera vez que utilice el rol para ejecutar acciones de flujo de trabajo, use el comodín en la instrucción de política de recursos y, a continuación, precise el ámbito de la política con el nombre del recurso cuando esté disponible.

      "Resource": "*"
    8. Elija Siguiente: Etiquetas.

    9. Elija Siguiente: Revisar.

    10. En Nombre, escriba:

      codecatalyst-ecs-build-policy
    11. Elija Crear política.

      Ahora ha creado una política de permisos.

  2. Cree el rol de compilación de la siguiente manera:

    1. En el panel de navegación, seleccione Roles y luego seleccione Crear rol.

    2. Elija Política de confianza personalizada.

    3. Elimine la política de confianza personalizada existente.

    4. Añada la siguiente política de confianza personalizada:

      { "Version": "2012-10-17", "Statement": [ { "Sid": "", "Effect": "Allow", "Principal": { "Service": [ "codecatalyst-runner.amazonaws.com", "codecatalyst.amazonaws.com" ] }, "Action": "sts:AssumeRole" } ] }
    5. Elija Siguiente.

    6. En Políticas de permisos, busque codecatalyst-ecs-build-policy y active su casilla de verificación.

    7. Elija Siguiente.

    8. En Nombre del rol, escriba:

      codecatalyst-ecs-build-role
    9. En Descripción del rol, escriba:

      CodeCatalyst ECS build role
    10. Elija Crear rol.

    Ahora ha creado un rol de compilación con una política de permisos y una política de confianza.

  3. Obtenga el ARN del rol de compilación de la siguiente manera:

    1. Seleccione Roles en el panel de navegación.

    2. En el cuadro de búsqueda, introduzca el nombre del rol que acaba de crear (codecatalyst-ecs-build-role).

    3. Elija el rol de la lista.

      Aparece la página Resumen del rol.

    4. En la parte superior, copie el valor de ARN. Lo necesitará más adelante.

Creación de un rol de implementación
  1. Cree una política para el rol del modo siguiente:

    1. Inicie sesión en AWS.

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

    3. En el panel de navegación, seleccione Políticas.

    4. Seleccione Crear política.

    5. Seleccione la pestaña JSON.

    6. Elimine el código existente.

    7. Pegue el siguiente código:

      { "Version": "2012-10-17", "Statement": [{ "Action":[ "ecs:DescribeServices", "ecs:CreateTaskSet", "ecs:DeleteTaskSet", "ecs:ListClusters", "ecs:RegisterTaskDefinition", "ecs:UpdateServicePrimaryTaskSet", "ecs:UpdateService", "elasticloadbalancing:DescribeTargetGroups", "elasticloadbalancing:DescribeListeners", "elasticloadbalancing:ModifyListener", "elasticloadbalancing:DescribeRules", "elasticloadbalancing:ModifyRule", "lambda:InvokeFunction", "lambda:ListFunctions", "cloudwatch:DescribeAlarms", "sns:Publish", "sns:ListTopics", "s3:GetObject", "s3:GetObjectVersion", "codedeploy:CreateApplication", "codedeploy:CreateDeployment", "codedeploy:CreateDeploymentGroup", "codedeploy:GetApplication", "codedeploy:GetDeployment", "codedeploy:GetDeploymentGroup", "codedeploy:ListApplications", "codedeploy:ListDeploymentGroups", "codedeploy:ListDeployments", "codedeploy:StopDeployment", "codedeploy:GetDeploymentTarget", "codedeploy:ListDeploymentTargets", "codedeploy:GetDeploymentConfig", "codedeploy:GetApplicationRevision", "codedeploy:RegisterApplicationRevision", "codedeploy:BatchGetApplicationRevisions", "codedeploy:BatchGetDeploymentGroups", "codedeploy:BatchGetDeployments", "codedeploy:BatchGetApplications", "codedeploy:ListApplicationRevisions", "codedeploy:ListDeploymentConfigs", "codedeploy:ContinueDeployment" ], "Resource":"*", "Effect":"Allow" },{"Action":[ "iam:PassRole" ], "Effect":"Allow", "Resource":"*", "Condition":{"StringLike":{"iam:PassedToService":[ "ecs-tasks.amazonaws.com", "codedeploy.amazonaws.com" ] } } }] }
      nota

      La primera vez que utilice el rol para ejecutar acciones de flujo de trabajo, use el comodín en la instrucción de política de recursos. A continuación, puede delimitar la política con el nombre del recurso una vez que esté disponible.

      "Resource": "*"
    8. Elija Siguiente: Etiquetas.

    9. Elija Siguiente: Revisar.

    10. En Nombre, escriba:

      codecatalyst-ecs-deploy-policy
    11. Elija Crear política.

      Ahora ha creado una política de permisos.

  2. Cree el rol de implementación de la siguiente manera:

    1. En el panel de navegación, seleccione Roles y luego seleccione Crear rol.

    2. Elija Política de confianza personalizada.

    3. Elimine la política de confianza personalizada existente.

    4. Añada la siguiente política de confianza personalizada:

      { "Version": "2012-10-17", "Statement": [ { "Sid": "", "Effect": "Allow", "Principal": { "Service": [ "codecatalyst-runner.amazonaws.com", "codecatalyst.amazonaws.com" ] }, "Action": "sts:AssumeRole" } ] }
    5. Elija Siguiente.

    6. En Políticas de permisos, busque codecatalyst-ecs-deploy-policy y active su casilla de verificación.

    7. Elija Siguiente.

    8. En Nombre del rol, escriba:

      codecatalyst-ecs-deploy-role
    9. En Descripción del rol, escriba:

      CodeCatalyst ECS deploy role
    10. Elija Crear rol.

    Ahora ha creado un rol de implementación con una política de confianza.

  3. Obtenga el ARN del rol de implementación de la siguiente manera:

    1. Seleccione Roles en el panel de navegación.

    2. En el cuadro de búsqueda, introduzca el nombre del rol que acaba de crear (codecatalyst-ecs-deploy-role).

    3. Elija el rol de la lista.

      Aparece la página Resumen del rol.

    4. En la parte superior, copie el valor de ARN. Lo necesitará más adelante.

AWS CLI

Para crear los roles de compilación e implementación, realice la siguiente serie de procedimientos.

Creación de una política de confianza para ambos roles

Como CodeCatalystECSUser, en AWS CloudShell, cree un archivo de política de confianza:

  1. Cree el archivo:

    cat > codecatalyst-ecs-trust-policy.json
  2. En la línea de comandos del terminal, pegue el código siguiente:

    { "Version": "2012-10-17", "Statement": [ { "Sid": "", "Effect": "Allow", "Principal": { "Service": [ "codecatalyst-runner.amazonaws.com", "codecatalyst.amazonaws.com" ] }, "Action": "sts:AssumeRole" } ] }
  3. Coloque el cursor después del último corchete (}).

  4. Pulse Enter y, a continuación, Ctrl+d para guardar el archivo y salir de cat.

Creación de la política y el rol de compilación
  1. Cree la política de compilación:

    1. Como CodeCatalystECSUser, en AWS CloudShell, cree un archivo de política de compilación:

      cat > codecatalyst-ecs-build-policy.json
    2. En la línea de comandos, escriba el código siguiente:

      { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "ecr:*", "ec2:*" ], "Resource": "*" } ] }
    3. Coloque el cursor después del último corchete (}).

    4. Pulse Enter y, a continuación, Ctrl+d para guardar el archivo y salir de cat.

  2. Añada la política de compilación a AWS:

    aws iam create-policy \ --policy-name codecatalyst-ecs-build-policy \ --policy-document file://codecatalyst-ecs-build-policy.json
  3. En el resultado del comando, anote el valor de "arn": (por ejemplo, arn:aws:iam::111122223333:policy/codecatalyst-ecs-build-policy). Necesitará este ARN más adelante.

  4. Cree un rol de compilación y asóciele una política de confianza:

    aws iam create-role \ --role-name codecatalyst-ecs-build-role \ --assume-role-policy-document file://codecatalyst-ecs-trust-policy.json
  5. Asocie la política de compilación al rol de compilación:

    aws iam attach-role-policy \ --role-name codecatalyst-ecs-build-role \ --policy-arn arn:aws:iam::111122223333:policy/codecatalyst-ecs-build-policy

    Donde arn:aws:iam::111122223333:policy/codecatalyst-ecs-build-policy se sustituye por el ARN de la política de compilación que anotó anteriormente.

  6. Muestre los detalles del rol de compilación:

    aws iam get-role \ --role-name codecatalyst-ecs-build-role
  7. Anote el valor de "Arn": del rol (por ejemplo, arn:aws:iam::111122223333:role/codecatalyst-ecs-build-role). Necesitará este ARN más adelante.

Creación de una política y un rol de implementación
  1. Cree una política de implementación:

    1. En AWS CloudShell, cree un archivo de política de implementación:

      cat > codecatalyst-ecs-deploy-policy.json
    2. En la línea de comandos, escriba el código siguiente:

      { "Version": "2012-10-17", "Statement": [{ "Action":[ "ecs:DescribeServices", "ecs:CreateTaskSet", "ecs:DeleteTaskSet", "ecs:ListClusters", "ecs:RegisterTaskDefinition", "ecs:UpdateServicePrimaryTaskSet", "ecs:UpdateService", "elasticloadbalancing:DescribeTargetGroups", "elasticloadbalancing:DescribeListeners", "elasticloadbalancing:ModifyListener", "elasticloadbalancing:DescribeRules", "elasticloadbalancing:ModifyRule", "lambda:InvokeFunction", "lambda:ListFunctions", "cloudwatch:DescribeAlarms", "sns:Publish", "sns:ListTopics", "s3:GetObject", "s3:GetObjectVersion", "codedeploy:CreateApplication", "codedeploy:CreateDeployment", "codedeploy:CreateDeploymentGroup", "codedeploy:GetApplication", "codedeploy:GetDeployment", "codedeploy:GetDeploymentGroup", "codedeploy:ListApplications", "codedeploy:ListDeploymentGroups", "codedeploy:ListDeployments", "codedeploy:StopDeployment", "codedeploy:GetDeploymentTarget", "codedeploy:ListDeploymentTargets", "codedeploy:GetDeploymentConfig", "codedeploy:GetApplicationRevision", "codedeploy:RegisterApplicationRevision", "codedeploy:BatchGetApplicationRevisions", "codedeploy:BatchGetDeploymentGroups", "codedeploy:BatchGetDeployments", "codedeploy:BatchGetApplications", "codedeploy:ListApplicationRevisions", "codedeploy:ListDeploymentConfigs", "codedeploy:ContinueDeployment" ], "Resource":"*", "Effect":"Allow" },{"Action":[ "iam:PassRole" ], "Effect":"Allow", "Resource":"*", "Condition":{"StringLike":{"iam:PassedToService":[ "ecs-tasks.amazonaws.com", "codedeploy.amazonaws.com" ] } } }] }
      nota

      La primera vez que utilice el rol para ejecutar acciones de flujo de trabajo, use el comodín en la instrucción de política de recursos y, a continuación, precise el ámbito de la política con el nombre del recurso cuando esté disponible.

      "Resource": "*"
    3. Coloque el cursor después del último corchete (}).

    4. Pulse Enter y, a continuación, Ctrl+d para guardar el archivo y salir de cat.

  2. Añada la política de implementación a AWS:

    aws iam create-policy \ --policy-name codecatalyst-ecs-deploy-policy \ --policy-document file://codecatalyst-ecs-deploy-policy.json
  3. En el resultado del comando, anote el valor de "arn": de la política de implementación (por ejemplo, arn:aws:iam::111122223333:policy/codecatalyst-ecs-deploy-policy). Necesitará este ARN más adelante.

  4. Cree un rol de implementación y asóciele una política de confianza:

    aws iam create-role \ --role-name codecatalyst-ecs-deploy-role \ --assume-role-policy-document file://codecatalyst-ecs-trust-policy.json
  5. Asocie la política de implementación al rol de implementación, donde arn:aws:iam::111122223333:policy/codecatalyst-ecs-deploy-policy se sustituye por el ARN de la política de implementación que anotó anteriormente.

    aws iam attach-role-policy \ --role-name codecatalyst-ecs-deploy-role \ --policy-arn arn:aws:iam::111122223333:policy/codecatalyst-ecs-deploy-policy
  6. Muestre los detalles del rol de implementación:

    aws iam get-role \ --role-name codecatalyst-ecs-deploy-role
  7. Anote el valor de "Arn": del rol (por ejemplo, arn:aws:iam::111122223333:role/codecatalyst-ecs-deploy-role). Necesitará este ARN más adelante.

Paso 5: añadir roles de AWS a CodeCatalyst

En este paso, añadirá el rol de compilación (codecatalyst-ecs-build-role) y el rol de implementación (codecatalyst-ecs-deploy-role) a la conexión de cuenta de CodeCatalyst en su espacio.

Incorporación de roles de compilación e implementación a la conexión de cuenta
  1. En CodeCatalyst, vaya a su espacio.

  2. Elija Cuentas de AWS. Aparecerá una lista de conexiones de cuenta.

  3. Elija la conexión de cuenta que represente la cuenta de AWS en la que creó los roles de compilación e implementación.

  4. Elija Administrar roles desde la Consola de administración de AWS.

    Aparece la página Agregar el rol de IAM al espacio de Amazon CodeCatalyst. Es posible que tenga que iniciar sesión para acceder a la página.

  5. Seleccione Agregar un rol existente que haya creado en IAM.

    Se muestra una lista desplegable. La lista muestra todos los roles de IAM con una política de confianza que incluye las entidades principales de los servicios codecatalyst-runner.amazonaws.com y codecatalyst.amazonaws.com.

  6. En la lista desplegable, elija codecatalyst-ecs-build-role y, a continuación, elija Agregar rol.

    nota

    Si aparece The security token included in the request is invalid, es posible que se deba a que no tiene los permisos adecuados. Para solucionar este problema, cierre la sesión de AWS y vuelva a iniciar sesión con la cuenta de AWS que utilizó al crear el espacio de CodeCatalyst.

  7. Seleccione Agregar rol de IAM, seleccione Agregar un rol existente que haya creado en IAM y, en la lista desplegable, elija codecatalyst-ecs-deploy-role. Seleccione Add role (Añadir rol).

    Ahora ha añadido los roles de compilación e implementación a su espacio.

  8. Copie el valor del nombre de visualización de Amazon CodeCatalyst. Necesitará este valor más adelante, cuando cree el flujo de trabajo.

Paso 6: crear un repositorio de código fuente

En este paso, creará un repositorio de código fuente en CodeCatalyst. Este repositorio almacena los archivos de código fuente del tutorial, como el archivo de definición de tareas.

Para obtener más información sobre los repositorios de código fuente, consulte Creación de un repositorio de código fuente.

Creación de un repositorio de código fuente
  1. Abra la consola de CodeCatalyst en https://codecatalyst.aws/.

  2. Vaya a su proyecto, codecatalyst-ecs-project.

  3. En el panel de navegación, elija Código y, a continuación, elija Repositorios de origen.

  4. Elija Agregar repositorio y, a continuación, elija Crear repositorio.

  5. En Nombre del repositorio, escriba:

    codecatalyst-ecs-source-repository
  6. Seleccione Crear.

Paso 7: añadir archivos de código fuente

En esta sección, añadirá los archivos de código fuente de Hello World a su repositorio de CodeCatalyst, codecatalyst-ecs-source-repository. Constan de:

  • Un archivo index.html: muestra un mensaje Hello World en el navegador.

  • Un Dockerfile: describe la imagen base que se va a usar para la imagen de Docker y los comandos de Docker que se le aplicarán.

  • Un archivo taskdef.json: define la imagen de Docker que se utilizará al lanzar tareas en el clúster.

La estructura de carpetas es la siguiente:

. |— public-html | |— index.html |— Dockerfile |— taskdef.json
nota

Las siguientes instrucciones le muestran cómo añadir los archivos mediante la consola de CodeCatalyst, pero puede usar Git si lo prefiere. Para obtener más información, consulte Clonación de un repositorio de código fuente.

index.html

El archivo index.html muestra un mensaje Hello World en el navegador.

Adición del archivo index.html
  1. En la consola de CodeCatalyst, vaya al repositorio de código fuente, codecatalyst-ecs-source-repository.

  2. En Archivos, elija Crear archivo.

  3. En Nombre del archivo, escriba:

    public-html/index.html
    importante

    Asegúrese de incluir el prefijo public-html/ para crear una carpeta con el mismo nombre. Se espera que el archivo index.html esté en esta carpeta.

  4. En el cuadro de texto, introduzca el siguiente código:

    <html> <head> <title>Hello World</title> <style> body { background-color: black; text-align: center; color: white; font-family: Arial, Helvetica, sans-serif; } </style> </head> <body> <h1>Hello World</h1> </body> </html>
  5. Seleccione Confirmar y, a continuación, vuelva a seleccionar Confirmar.

    El archivo index.html se añade al repositorio en una carpeta public-html.

Dockerfile

El Dockerfile describe la imagen base que se va a usar para la imagen de Docker y los comandos de Docker que se le aplicarán. Para obtener más información acerca del Dockerfile, consulte la Referencia de Dockerfile.

El Dockerfile especificado aquí indica que se debe usar la imagen base de Apache 2.4 (httpd). También incluye instrucciones para copiar un archivo de código fuente llamado index.html en una carpeta del servidor de Apache que sirve páginas web. La instrucción EXPOSE del Dockerfile indica a Docker que el contenedor está escuchando en el puerto 80.

Adición del Dockerfile
  1. En el repositorio de código fuente, seleccione Crear archivo.

  2. En Nombre del archivo, escriba:

    Dockerfile

    No incluya la extensión del archivo.

    importante

    El Dockerfile debe residir en la carpeta raíz de su repositorio. El comando Docker build del flujo de trabajo espera que esté ahí.

  3. En el cuadro de texto, introduzca el siguiente código:

    FROM httpd:2.4 COPY ./public-html/index.html /usr/local/apache2/htdocs/index.html EXPOSE 80
  4. Seleccione Confirmar y, a continuación, vuelva a seleccionar Confirmar.

    El Dockerfile se añade a su repositorio.

taskdef.json

El archivo taskdef.json que añade en este paso es el mismo que ya especificó en Paso 2: implementar una aplicación de marcador de posición en Amazon ECS con la siguiente diferencia:

En lugar de especificar un nombre de imagen de Docker codificado en el campo image: (httpd:2.4), la definición de tarea utiliza aquí un par de variables para indicar la imagen: $REPOSITORY_URI y $IMAGE_TAG. Estas variables se sustituirán por valores reales generados por la acción de compilación del flujo de trabajo cuando ejecute el flujo de trabajo en un paso posterior.

Para obtener información detallada sobre los parámetros de definición de tareas, consulte Parámetros de definición de tareas en la Guía para desarrolladores de Amazon Elastic Container Service.

Adición del archivo taskdef.json
  1. En el repositorio de código fuente, seleccione Crear archivo.

  2. En Nombre del archivo, escriba:

    taskdef.json
  3. En el cuadro de texto, introduzca el siguiente código:

    { "executionRoleArn": "arn:aws:iam::account_ID:role/codecatalyst-ecs-task-execution-role", "containerDefinitions": [ { "name": "codecatalyst-ecs-container", # The $REPOSITORY_URI and $IMAGE_TAG variables will be replaced # by the workflow at build time (see the build action in the # workflow) "image": $REPOSITORY_URI:$IMAGE_TAG, "essential": true, "portMappings": [ { "hostPort": 80, "protocol": "tcp", "containerPort": 80 } ] } ], "requiresCompatibilities": [ "FARGATE" ], "networkMode": "awsvpc", "cpu": "256", "memory": "512", "family": "codecatalyst-ecs-task-def" }

    En el código anterior, sustituya:

    arn:aws:iam::account_ID:role/codecatalyst-ecs-task-execution-role

    por el ARN del rol de ejecución de tareas que anotó en Creación del rol de ejecución de tareas.

  4. Seleccione Confirmar y, a continuación, vuelva a seleccionar Confirmar.

    El archivo taskdef.json se añade a su repositorio.

Paso 8: crear y ejecutar un flujo de trabajo

En este paso, creará un flujo de trabajo que toma los archivos de código fuente, los compila en una imagen de Docker y, a continuación, implementa la imagen en su clúster de Amazon ECS. Esta implementación reemplaza a la aplicación de marcador de posición de Apache existente.

El flujo de trabajo consta de los siguientes componentes que se ejecutarán en orden:

  • Un desencadenador: este desencadenador inicia la ejecución automática del flujo de trabajo cuando se introduce un cambio en el repositorio de código fuente. Para obtener más información acerca de los disparadores, consulte Inicio de un flujo de trabajo y ejecución automática mediante desencadenadores.

  • Una acción de compilación (BuildBackend): al activarse, la acción crea la imagen de Docker mediante el Dockerfile y envía la imagen a Amazon ECR. La acción de compilación también actualiza el image con el valor del campo taskdef.json correcto y, a continuación, crea un artefacto de salida de este archivo. Este artefacto se utiliza como entrada para la acción de implementación, que es la siguiente.

    Para obtener más información sobre la acción de compilación, consulte Compilación con flujos de trabajo.

  • Una acción de implementación (DeployToECS): al completarse la acción de compilación, la acción de implementación busca el artefacto de salida generado por la acción de compilación (TaskDefArtifact), encuentra el archivo taskdef.json que contiene y lo registra en el servicio de Amazon ECS. A continuación, el servicio sigue las instrucciones del archivo taskdef.json para ejecutar las tres tareas de Amazon ECS (y los contenedores de Docker de Hello World asociados) dentro del clúster de Amazon ECS.

Creación de un flujo de trabajo
  1. En la consola de CodeCatalyst, en el panel de navegación, elija CI/CD y, a continuación, elija Flujos de trabajo.

  2. Seleccione Crear flujo de trabajo.

  3. En Repositorio de código fuente, elija codecatalyst-ecs-source-repository.

  4. En Ramificación, elija main.

  5. Seleccione Crear.

  6. Elimine el código de ejemplo de YAML.

  7. Añada el código de YAML siguiente:

    nota

    En el código de YAML que se muestra a continuación, puede omitir las secciones Connections: si lo desea. Si omite estas secciones, debe asegurarse de que el rol especificado en el campo Rol de IAM predeterminado del entorno incluya los permisos y las políticas de confianza de ambos roles que se describen en Paso 5: añadir roles de AWS a CodeCatalyst. Para obtener más información sobre cómo configurar un entorno con un rol de IAM predeterminado, consulte Creación de un entorno.

    Name: codecatalyst-ecs-workflow SchemaVersion: 1.0 Triggers: - Type: PUSH Branches: - main Actions: BuildBackend: Identifier: aws/build@v1 Environment: Name: codecatalyst-ecs-environment Connections: - Name: codecatalyst-account-connection Role: codecatalyst-ecs-build-role Inputs: Sources: - WorkflowSource Variables: - Name: REPOSITORY_URI Value: 111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-ecs-image-repo - Name: IMAGE_TAG Value: ${WorkflowSource.CommitId} Configuration: Steps: #pre_build: - Run: echo Logging in to Amazon ECR... - Run: aws --version - Run: aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-west-2.amazonaws.com #build: - Run: echo Build started on `date` - Run: echo Building the Docker image... - Run: docker build -t $REPOSITORY_URI:latest . - Run: docker tag $REPOSITORY_URI:latest $REPOSITORY_URI:$IMAGE_TAG #post_build: - Run: echo Build completed on `date` - Run: echo Pushing the Docker images... - Run: docker push $REPOSITORY_URI:latest - Run: docker push $REPOSITORY_URI:$IMAGE_TAG # Replace the variables in taskdef.json - Run: find taskdef.json -type f | xargs sed -i "s|\$REPOSITORY_URI|$REPOSITORY_URI|g" - Run: find taskdef.json -type f | xargs sed -i "s|\$IMAGE_TAG|$IMAGE_TAG|g" - Run: cat taskdef.json # The output artifact will be a zip file that contains a task definition file. Outputs: Artifacts: - Name: TaskDefArtifact Files: - taskdef.json DeployToECS: DependsOn: - BuildBackend Identifier: aws/ecs-deploy@v1 Environment: Name: codecatalyst-ecs-environment Connections: - Name: codecatalyst-account-connection Role: codecatalyst-ecs-deploy-role Inputs: Sources: [] Artifacts: - TaskDefArtifact Configuration: region: us-west-2 cluster: codecatalyst-ecs-cluster service: codecatalyst-ecs-service task-definition: taskdef.json

    En el código anterior, sustituya:

    • Ambas instancias de codecatalyst-ecs-environment por el nombre del entorno que ha creado en Requisitos previos.

    • Ambas instancias de codecatalyst-account-connection por el nombre de visualización de su conexión de cuenta. El nombre de visualización puede ser un número. Para obtener más información, consulte Paso 5: añadir roles de AWS a CodeCatalyst.

    • codecatalyst-ecs-build-role por el nombre del rol de compilación que creó en Paso 4: crear roles de AWS.

    • 111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-ecs-image-repo (en la propiedad Value:) por el URI del repositorio de Amazon ECR que creó en Paso 3: crear un repositorio de imágenes de Amazon ECR.

    • 111122223333.dkr.ecr.us-west-2.amazonaws.com (en el comando Run: aws ecr) por el URI del repositorio de Amazon ECR sin el sufijo de imagen (/codecatalyst-ecs-image-repo).

    • codecatalyst-ecs-deploy-role por el nombre del rol de implementación que creó en Paso 4: crear roles de AWS.

    • Ambas instancias de us-west-2 por el código de su región de AWS. Para obtener una lista de códigos de región, consulte Puntos de conexión regionales en la Referencia general de AWS.

    nota

    Si decidió no crear roles de compilación e implementación, sustituya codecatalyst-ecs-build-role y codecatalyst-ecs-deploy-role por el nombre del rol de CodeCatalystWorkflowDevelopmentRole-spaceName. Para obtener más información acerca de este rol, consulte Paso 4: crear roles de AWS.

    sugerencia

    En lugar de utilizar los comandos sed y find que se muestran en el código del flujo de trabajo anterior para actualizar el repositorio y el nombre de la imagen, puede utilizar la acción Representar la definición de tareas de Amazon ECS para este fin. Para obtener más información, consulte Modificación de una definición de tarea de Amazon ECS.

  8. (Opcional) Seleccione Validar para asegurarse de que el código de YAML es válido antes de confirmarlo.

  9. Elija Commit (Confirmar).

  10. En el cuadro de diálogo Confirmar flujo de trabajo, escriba lo siguiente:

    1. En Mensaje de confirmación, elimine el texto e introduzca:

      Add first workflow
    2. En Repositorio, elija codecatalyst-ecs-source-repository.

    3. En Nombre de la ramificación, elija principal.

    4. Elija Commit (Confirmar).

    Ahora ha creado un flujo de trabajo. La ejecución del flujo de trabajo se inicia automáticamente debido al desencadenador definido en la parte superior del flujo de trabajo. En concreto, cuando confirmó (e incorporó) el archivo workflow.yaml en su repositorio de código fuente, el desencadenador inició la ejecución del flujo de trabajo.

Consulta del progreso de la ejecución del flujo de trabajo
  1. En el panel de navegación de la consola de CodeCatalyst, elija CI/CD y, a continuación, elija Flujos de trabajo.

  2. Elija el flujo de trabajo que acaba de crear, codecatalyst-ecs-workflow.

  3. Elija BuildBackend para ver el progreso de la compilación.

  4. Elija DeployToECS para ver el progreso de la implementación.

    Para obtener más información sobre cómo ver los detalles de ejecución, consulte Visualización del estado y los detalles de la ejecución de un flujo de trabajo.

Verificación de la implementación
  1. Abra la consola de Amazon ECS en https://console.aws.amazon.com/ecs/.

  2. Elija su clúster, codecatalyst-ecs-cluster.

  3. Elija la pestaña Tareas.

  4. Elija una de las tres tareas.

  5. En el campo IP pública, elija dirección abierta.

    Aparece una página “Hello World” en el navegador, que indica que el servicio de Amazon ECS ha implementado correctamente la aplicación.

Paso 9: realizar un cambio en los archivos de código fuente

En esta sección, realizará un cambio en el archivo index.html de su repositorio de código fuente. Este cambio hace que el flujo de trabajo cree una nueva imagen de Docker, la etiquete con un ID de confirmación, la envíe a Amazon ECR y la implemente en Amazon ECS.

Cambio del archivo index.html
  1. En la consola de CodeCatalyst, en el panel de navegación, elija Código, elija Repositorios de código fuente y, a continuación, elija su repositorio, codecatalyst-ecs-source-repository.

  2. Haga clic en public-html y luego en index.html.

    Aparece el contenido de index.html.

  3. Elija Editar.

  4. En la línea 14, cambie el texto Hello World a Tutorial complete!

  5. Seleccione Confirmar y, a continuación, vuelva a seleccionar Confirmar.

    La confirmación hace que se inicie una nueva ejecución del flujo de trabajo.

  6. (Opcional) Vaya a la página principal de su repositorio de código fuente, seleccione Ver confirmaciones y, a continuación, anote el ID de confirmación del cambio de index.html.

  7. Observe el progreso de la implementación:

    1. En el panel de navegación, elija CI/CD y, a continuación, elija Flujos de trabajo.

    2. Elija codecatalyst-ecs-workflow para ver la última ejecución.

    3. Seleccione BuildBackend y DeployToECS para ver el progreso de la ejecución del flujo de trabajo.

  8. Compruebe que la aplicación se haya actualizado de la siguiente manera:

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

    2. Elija su clúster, codecatalyst-ecs-cluster.

    3. Elija la pestaña Tareas.

    4. Elija una de las tres tareas.

    5. En el campo IP pública, elija dirección abierta.

      Aparece una página Tutorial complete!

  9. (Opcional) En AWS, cambie a la consola Amazon ECR y compruebe que la nueva imagen de Docker esté etiquetada con el ID de confirmación del paso 6.

Limpieza

Limpie los archivos y servicios utilizados en este tutorial para evitar que le cobren por ellos.

En la AWS Management Console, limpie en este orden:

  1. En Amazon ECS, haga lo siguiente:

    1. Elimine codecatalyst-ecs-service.

    2. Elimine codecatalyst-ecs-cluster.

    3. Anular registro codecatalyst-ecs-task-definition.

  2. En Amazon ECR, elimine codecatalyst-ecs-image-repo.

  3. En Amazon EC2, elimine codecatalyst-ecs-security-group.

  4. En IAM Identity Center, elimine:

    1. CodeCatalystECSUser

    2. CodeCatalystECSPermissionSet

En la consola de CodeCatalyst, limpie lo siguiente:

  1. Elimine codecatalyst-ecs-workflow.

  2. Elimine codecatalyst-ecs-environment.

  3. Elimine codecatalyst-ecs-source-repository.

  4. Elimine codecatalyst-ecs-project.

En este tutorial, ha aprendido a implementar una aplicación en un servicio de Amazon ECS mediante un flujo de trabajo de CodeCatalyst y una acción Implementar en Amazon ECS.