Tutorial: Implementación de una aplicación en Amazon ECS - Amazon CodeCatalyst
Requisitos previosPaso 1: Configurar un AWS usuario y AWS CloudShellPaso 2: implementar una aplicación de marcador de posición en Amazon ECSPaso 3: Crear un repositorio de imágenes de Amazon ECRPaso 4: Crear, construir e implementar rolesPaso 5: Añadir AWS roles a CodeCatalystPaso 6: Crear un repositorio de código fuentePaso 7: Añadir los archivos fuentePaso 8: Crear y ejecutar un flujo de trabajoPaso 9: Realice un cambio en sus archivos fuenteLimpieza

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 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. AWS La aplicación implementada es un sencillo sitio web de Hello World creado a partir de una imagen de Docker del servidor web 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 plano que realice una configuración completa de Amazon ECS por usted. Deberá utilizar la API de Node.js con AWS Fargate o la API de Java con el AWS Fargate blueprint. Para obtener más información, consulte Crear un proyecto con un plano.

Requisitos previos

Antes de empezar

Paso 1: Configura un AWS usuario y AWS CloudShell

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

nota

No utilice su usuario root para este tutorial. Debe crear un usuario independiente 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 del IAM Identity Center CloudShell, consulte la Guía del AWS IAM Identity Center usuario y la Guía AWS CloudShell del usuario.

Para crear un usuario del Centro de Identidad de IAM

  1. Inicie sesión en la AWS IAM Identity Center consola AWS Management Console y ábrala en https://console.aws.amazon.com/singlesignon/.

    nota

    Asegúrate de iniciar sesión con el Cuenta de AWS que está conectado a tu CodeCatalyst espacio. 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 Creando un espacio.

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

  3. En Nombre de usuario, introduzca:

    CodeCatalystECSUser

  4. En Contraseña, selecciona Generar una contraseña de un solo uso que puedas 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 el Centro de identidades de IAM.

  6. En Nombre y apellidos, introduzca:

    CodeCatalystECSUser

  7. En Nombre para mostrar, mantenga el nombre generado automáticamente:

    CodeCatalystECSUser CodeCatalystECSUser

  8. Elija Siguiente.

  9. En la página Añadir usuario a grupos, seleccione Siguiente.

  10. En la página Revisar y agregar usuario, revise la información y elija Agregar usuario.

    Aparece un cuadro de diálogo de 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 AWS acceso y la contraseña de un solo uso.

  12. Elija Close.

Para crear 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. Elija un conjunto de permisos predefinido y, a continuación, seleccione AdministratorAccess. Esta política proporciona permisos completos a todos 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.

Para asignar el conjunto de permisos a CodeCatalyst ECSUser

  1. En el panel de navegación, elija y Cuentas de AWS, a continuación, active la casilla de verificación situada junto a la casilla en la Cuenta de AWS que ha iniciado sesión actualmente.

  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 tienes asignada CodeCatalystECSUser y CodeCatalystECSPermissionSet a la tuya Cuenta de AWS, uniéndolas.

Para cerrar sesión y volver a iniciarla como CodeCatalyst ECSUser

  1. Antes de cerrar sesión, asegúrese de tener la URL del portal de AWS acceso, así como el nombre de usuario y la contraseña de un solo uso. CodeCatalystECSUser Deberías 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 CodeCatalystECSUser detalles del Centro de Identidad de IAM, seleccione Restablecer la contraseña, Generar una contraseña de un solo uso [...] y vuelva a restablecer la contraseña para que aparezca la información en la pantalla.

  2. Cerrar sesión en AWS.

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

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

  5. En Nueva contraseña, introduce una contraseña y selecciona Establecer nueva contraseña.

    Aparece un cuadro de Cuenta de AWS en la pantalla.

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

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

    AWS Management Console Aparece el. Ahora ha iniciado sesión CodeCatalystECSUser con los permisos correspondientes.

Para lanzar una AWS CloudShell instancia

  1. Pues CodeCatalystECSUser bien, en la barra de navegación superior, selecciona el AWS icono ( AWS icon ).

    AWS Management Console Aparece la página principal del.

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

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

    nota

    Si no ves el CloudShell icono, asegúrate de que estás 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).

Para comprobar que AWS CLI está instalado

  1. En la CloudShell terminal, introduzca:

    aws --version

  2. Compruebe que aparezca una versión.

    Ya AWS CLI está configurada para el usuario actualCodeCatalystECSUser, por lo que no es necesario configurar AWS CLI claves y credenciales, 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.

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

Para crear el rol de ejecución de tareas

Esta función otorga a Amazon ECS AWS Fargate (Fargate) permiso para realizar llamadas a la API en su nombre.

  1. Cree una política de confianza:

    1. En AWS CloudShell, introduzca el siguiente comando:

      cat > codecatalyst-ecs-trust-policy.json

      Aparece un mensaje parpadeante en la CloudShell terminal.

    2. Introduzca el siguiente código cuando se le solicite:

      {
  "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, Ctrl+d a continuación, 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. Adjunte la AmazonECSTaskExecutionRolePolicy política AWS gestionada 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. Muestra los detalles del rol:

    aws iam get-role \
      --role-name codecatalyst-ecs-task-execution-role

  5. Anote el "Arn": valor 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.

Para crear un clúster de Amazon ECS

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

  1. ComoCodeCatalystECSUser, en AWS CloudShell, crea 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 codecatalyst-ecs-cluster clúster debe aparecer en la lista, lo que indica que la creación se ha realizado correctamente.

Para crear un archivo de definición de tareas

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

  1. ComoCodeCatalystECSUser, en AWS CloudShell, crear un archivo de definición de tareas:

    cat > taskdef.json

  2. Pegue el siguiente código cuando se le solicite:

    {
    "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/ -role codecatalyst-ecs-task-execution

    con el ARN de la función de ejecución de tareas que indicó en. Para crear el rol de ejecución de tareas

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

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

Para registrar el archivo de definición de tareas en Amazon ECS

  1. ComoCodeCatalystECSUser, en AWS CloudShell, registre la definición de la tarea:

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

  2. (Opcional) Compruebe que se haya registrado la definición de la tarea:

    aws ecs list-task-definitions

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

Para crear el servicio Amazon ECS

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

  1. O bienCodeCatalystECSUser, cámbiese 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, selecciona Crear.

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

    1. Mantenga todos los ajustes predeterminados excepto los 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, introduzca:

      codecatalyst-ecs-service

    5. Para las tareas deseadas, introduzca:

      3

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

    6. Amplíe la sección Redes.

    7. Para VPC, elija cualquier VPC.

    8. En el caso de las subredes, elija cualquier subred.

      nota

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

      nota

      Si no tiene 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 la descripción del grupo de seguridad, introduzca:

        CodeCatalyst ECS security group

      3. Seleccione Agregar regla. En Tipo, elija HTTP y, en Fuente, elija Anywhere.

    10. En la parte inferior, selecciona Crear.

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

  5. Seleccione la pestaña Tareas y, a continuación, pulse el botón de actualización. Compruebe que la columna Último estado de las tres tareas esté configurada como En ejecución.

(Opcional) Para comprobar que la aplicación de marcadores 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 la dirección abierta.

    Aparece una It Works! página. Esto indica que el servicio Amazon ECS inició correctamente una tarea que lanzó un contenedor 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, así como una aplicación de marcadores de posición de Apache. Con todos estos elementos listos, ya puede crear un flujo de trabajo que sustituya la aplicación de marcadores 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.

Para crear un repositorio de imágenes en Amazon ECR

  1. ComoCodeCatalystECSUser, en AWS CloudShell, crear un repositorio vacío en Amazon ECR:

    aws ecr create-repository --repository-name codecatalyst-ecs-image-repo

  2. Muestra los detalles del repositorio de Amazon ECR:

    aws ecr describe-repositories \
      --repository-names codecatalyst-ecs-image-repo

  3. Anote el “repositoryUri”: valor, 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 AWS roles

En esta sección, creará las funciones de AWS IAM que necesitará su CodeCatalyst flujo de trabajo para funcionar. Estas funciones son:

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

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

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

nota

Para ahorrar tiempo, puede crear un único rol, denominado CodeCatalystWorkflowDevelopmentRole-spaceName rol, en lugar de los dos roles enumerados anteriormente. Para obtener más información, consulte Crear el CodeCatalystWorkflowDevelopmentRole-spaceNamerol para su cuenta y su espacio. Tenga en cuenta que el CodeCatalystWorkflowDevelopmentRole-spaceName rol tiene permisos muy amplios, lo que puede suponer un riesgo para la seguridad. Le recomendamos que utilice esta función únicamente en los tutoriales y situaciones en las que la seguridad sea un problema menor. En este tutorial se da por sentado que está creando los dos roles enumerados anteriormente.

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

AWS Management Console

Para crear las funciones de creación e implementación, complete la siguiente serie de procedimientos.

Para crear un rol de compilación

  1. Cree una política para el rol, de la siguiente manera:

    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 Crear política.

    5. Seleccione la pestaña JSON.

    6. Elimina 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 se utilice el rol para ejecutar acciones de flujo de trabajo, utilice el comodín en la declaración de política de recursos y, a continuación, defina la política con el nombre del recurso cuando esté disponible.

      "Resource": "*"

    8. Elija Siguiente: Etiquetas.

    9. Elija Siguiente: Revisar.

    10. En Nombre, introduzca:

      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 permisoscodecatalyst-ecs-build-policy, busque y active su casilla de verificación.

    7. Elija Siguiente.

    8. En Nombre del rol, escriba:

      codecatalyst-ecs-build-role

    9. En la descripción del rol, introduzca:

      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, introduce el nombre del rol que acabas de crear (codecatalyst-ecs-build-role).

    3. Elija el rol de la lista.

      Aparece la página de resumen del rol.

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

Para crear un rol de despliegue

  1. Cree una política para el rol, de la siguiente manera:

    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. Elimina 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 se utilice el rol para ejecutar acciones de flujo de trabajo, utilice el comodín de la declaració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, introduzca:

      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 una 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 permisoscodecatalyst-ecs-deploy-policy, busque y active su casilla de verificación.

    7. Elija Siguiente.

    8. En Nombre del rol, escriba:

      codecatalyst-ecs-deploy-role

    9. En la descripción del rol, introduzca:

      CodeCatalyst ECS deploy role

    10. Elija Crear rol.

    Ahora ha creado un rol de despliegue 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, introduce el nombre del rol que acabas de crear (codecatalyst-ecs-deploy-role).

    3. Elija el rol de la lista.

      Aparece la página de resumen del rol.

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

AWS CLI

Para crear las funciones de creación e implementación, complete la siguiente serie de procedimientos.

Para crear una política de confianza para ambos roles

ComoCodeCatalystECSUser, en AWS CloudShell, crear 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 siguiente código:

    {
    "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, Ctrl+d a continuación, para guardar el archivo y salir de cat.

Para crear la política de creación y el rol de creación

  1. Cree la política de construcción:

    1. ComoCodeCatalystECSUser, en AWS CloudShell, crea un archivo de política de compilación:

      cat > codecatalyst-ecs-build-policy.json

    2. Cuando se le solicite, introduzca el siguiente código:

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

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

    4. Pulse Enter y, Ctrl+d a continuación, 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 "arn": valor, por ejemplo,arn:aws:iam::111122223333:policy/codecatalyst-ecs-build-policy. Necesitará este ARN más adelante.

  4. Cree el rol de creación y asígnele la 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. Adjunte la política de creación a la función de creació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/ se sustituye por el ARN de la política de compilación codecatalyst-ecs-build-policy que mencionaste anteriormente.

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

    aws iam get-role \
      --role-name codecatalyst-ecs-build-role

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

Para crear la política de despliegue y el rol de despliegue

  1. Cree una política de despliegue:

    1. En AWS CloudShell, cree un archivo de política de despliegue:

      cat > codecatalyst-ecs-deploy-policy.json

    2. Cuando se le solicite, introduzca 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 se utilice el rol para ejecutar acciones de flujo de trabajo, utilice el comodín en la declaración de política de recursos y, a continuación, defina la política con el nombre del recurso cuando esté disponible.

      "Resource": "*"

    3. Sitúe el cursor tras el último corchete ()}.

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

  2. Añada la política de despliegue 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 "arn": valor de la política de despliegue, por ejemplo,arn:aws:iam::111122223333:policy/codecatalyst-ecs-deploy-policy. Necesitará este ARN más adelante.

  4. Cree el rol de despliegue y asígnele la 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. Adjunte la política de implementación a la función de implementación, donde arn:aws:iam: :111122223333:policy/ codecatalyst-ecs-deploy-policy se reemplaza por el ARN de la política de implementación que indicó anteriormente.

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

  6. Muestra los detalles del rol de despliegue:

    aws iam get-role \
      --role-name codecatalyst-ecs-deploy-role

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

Paso 5: Añadir AWS funciones a CodeCatalyst

En este paso, debe 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 CodeCatalyst cuentas de su espacio.

Para añadir funciones de creación e implementación a la conexión de tu cuenta

  1. En CodeCatalyst, navega hasta tu espacio.

  2. Elige AWS cuentas. Aparece una lista de conexiones de cuentas.

  3. Elija la conexión de cuenta que represente la AWS cuenta en la que creó las funciones de creación e implementación.

  4. Seleccione Administrar roles en la consola de AWS administración.

    Aparece la página Añadir función de IAM a Amazon CodeCatalyst Space. Puede que tengas que iniciar sesión para acceder a la página.

  5. Selecciona Añadir un rol existente que hayas creado en IAM.

    Aparece una lista desplegable. La lista muestra todas las funciones de IAM con una política de confianza que incluye a los directores de codecatalyst.amazonaws.com servicio codecatalyst-runner.amazonaws.com y a los directores de servicio.

  6. En la lista desplegablecodecatalyst-ecs-build-role, elija y elija Agregar función.

    nota

    Si lo veThe security token included in the request is invalid, es posible que se deba a que no tiene los permisos adecuados. Para solucionar este problema, cierra sesión AWS como vuelve a iniciar sesión con la AWS cuenta que utilizaste al crear tu CodeCatalyst espacio.

  7. Selecciona Añadir función de IAM, selecciona Añadir una función existente que hayas creado en IAM y, en la lista desplegable, selecciona. codecatalyst-ecs-deploy-role Seleccione Add role (Añadir rol).

    Ahora ha agregado las funciones de creación e implementación a su espacio.

  8. Copia el valor del nombre CodeCatalyst mostrado de Amazon. Necesitarás este valor más adelante, al crear tu flujo de trabajo.

Paso 6: Crea un repositorio de código fuente

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

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

Para crear un repositorio de origen

  1. Abra la CodeCatalyst consola en https://codecatalyst.aws/.

  2. Navegue hasta 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, ingresa:

    codecatalyst-ecs-source-repository

  6. Seleccione Crear.

Paso 7: Añadir los archivos fuente

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

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

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

  • Un taskdef.json archivo: 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 CodeCatalyst consola, pero puede utilizar Git si lo prefiere. Para obtener más detalles, consulte Clonación de un repositorio fuente.

index.html

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

Para añadir el archivo index.html

  1. En la CodeCatalyst consola, vaya al repositorio de código fuente,codecatalyst-ecs-source-repository.

  2. En Archivos, selecciona Crear archivo.

  3. En Nombre de archivo, introduzca:

    public-html/index.html
    importante

    Asegúrese de incluir el public-html/ prefijo para crear una carpeta con el mismo nombre. index.htmlSe espera que 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. Selecciona Confirmar y, a continuación, selecciona Confirmar de nuevo.

    index.htmlSe añade a tu repositorio en una public-html carpeta.

Dockerfile

El Dockerfile describe la imagen base de Docker que se debe utilizar y los comandos de Docker que se deben aplicar a ella. Para obtener más información sobre el Dockerfile, consulta 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 fuente llamado index.html a una carpeta del servidor Apache que sirve páginas web. La EXPOSE instrucción del Dockerfile indica a Docker que el contenedor está escuchando en el puerto 80.

Para añadir el Dockerfile

  1. En el repositorio de origen, selecciona Crear archivo.

  2. En Nombre de archivo, ingresa:

    Dockerfile

    No incluya una extensión de archivo.

    importante

    El Dockerfile debe residir en la carpeta raíz del repositorio. El Docker build comando 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. Selecciona Confirmar y, a continuación, selecciona Confirmar de nuevo.

    El Dockerfile se añade a tu repositorio.

taskdef.json

El taskdef.json archivo que añada en este paso es el mismo que ya especificó, 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 image: campo (httpd:2.4), la definición de la tarea aquí utiliza un par de variables para indicar la imagen: y. $REPOSITORY_URI $IMAGE_TAG Estas variables se sustituirán por valores reales generados por la acción de creación del flujo de trabajo cuando ejecute el flujo de trabajo en un paso posterior.

Para obtener más información 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.

Para añadir el archivo taskdef.json

  1. En tu repositorio de origen, selecciona Crear archivo.

  2. En Nombre de archivo, ingresa:

    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/ -role codecatalyst-ecs-task-execution

    con el ARN de la función de ejecución de tareas que indicó en. Para crear el rol de ejecución de tareas

  4. Elija Confirmar y, a continuación, vuelva a elegir Confirmar.

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

Paso 8: Crear y ejecutar un flujo de trabajo

En este paso, crea un flujo de trabajo que toma los archivos 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 marcadores de posición de Apache existente.

El flujo de trabajo consta de los siguientes componentes básicos que se ejecutan de forma secuencial:

  • Un disparador: este activador inicia la ejecución automática del flujo de trabajo al introducir un cambio en el repositorio de origen. Para obtener más información acerca de los disparadores, consulte Iniciar un flujo de trabajo, ejecutarlo automáticamente con activadores.

  • 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 creación también actualiza el image campo taskdef.json con el valor correcto y, a continuación, crea un artefacto de salida de este archivo. Este artefacto se utiliza como entrada para la acción de despliegue, que es la siguiente.

    Para obtener más información sobre la acción de creación, consulteConstruir con flujos de trabajo.

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

Para crear un flujo de trabajo

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

  2. Seleccione Crear flujo de trabajo.

  3. En Repositorio de origen, elijacodecatalyst-ecs-source-repository.

  4. Para Branch, elijamain.

  5. Seleccione Crear.

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

  7. Agrega el siguiente código YAML:

    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 codecatalyst-ecs-environmentcon el nombre del entorno en el que creóRequisitos previos.

    • Ambas instancias codecatalyst-account-connectioncon el nombre visible de la conexión de su cuenta. El nombre para mostrar puede ser un número. Para obtener más información, consulte Paso 5: Añadir AWS funciones a CodeCatalyst.

    • codecatalyst-ecs-build-rolecon el nombre del rol de compilación en el que creastePaso 4: Crear AWS roles.

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

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

    • codecatalyst-ecs-deploy-rolecon el nombre de la función de implementación en la que creaste. Paso 4: Crear AWS roles

    • Ambas instancias de us-west-2 con AWS tu código de región. Para obtener una lista de los códigos de región, consulta los puntos finales regionales en. Referencia general de AWS

    nota

    Si ha decidido no crear funciones de creación e implementación, sustituya codecatalyst-ecs-build-roley codecatalyst-ecs-deploy-rolepor el nombre de la CodeCatalystWorkflowDevelopmentRole-spaceName función. Para obtener más información acerca de este rol, consulte Paso 4: Crear AWS roles.

    sugerencia

    En lugar de utilizar los sed comandos find y 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 de definición de tareas Render Amazon ECS para este fin. Para obtener más información, consulte Modificación de un archivo de definición de tareas de Amazon ECS mediante un flujo de trabajo.

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

  9. Elija Commit (Confirmar).

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

    1. En el caso del mensaje de confirmación, elimine el texto e introduzca:

      Add first workflow

    2. En Repositorio, elijacodecatalyst-ecs-source-repository.

    3. Para el nombre de la sucursal, elija principal.

    4. Elija Commit (Confirmar).

    Ahora ha creado un flujo de trabajo. La ejecución de un flujo de trabajo se inicia automáticamente debido al activador definido en la parte superior del flujo de trabajo. En concreto, cuando depositaste (e insertaste) el workflow.yaml archivo en tu repositorio de origen, el desencadenador inició la ejecución del flujo de trabajo.

Para ver el progreso de la ejecución del flujo de trabajo

  1. En el panel de navegación de la CodeCatalyst consola, 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. Elige BuildBackendver el progreso de la compilación.

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

    Para obtener más información sobre la visualización de los detalles de la ejecución, consulteVer el estado y los detalles de la ejecución del flujo de trabajo.

Para verificar el despliegue

  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. Elige una de las tres tareas.

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

    Aparece la página «Hello World» en el navegador, que indica que el servicio Amazon ECS ha implementado correctamente la aplicación.

Paso 9: Realice un cambio en los archivos fuente

En esta sección, realizará un cambio en el index.html archivo de su repositorio de origen. 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 despliegue en Amazon ECS.

Para cambiar el archivo index.html

  1. En la CodeCatalyst consola, en el panel de navegación, selecciona Código, luego elige Repositorios de código fuente y, por último, codecatalyst-ecs-source-repository elige tu repositorio.

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

    index.htmlAparece el contenido de.

  3. Elija Editar.

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

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

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

  6. (Opcional) Ve a la página principal de tu repositorio de origen, selecciona Ver confirmaciones y, a continuación, anota el ID de confirmación del index.html cambio.

  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 ver la última ejecución.

    3. Elija BuildBackendy 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. Elige una de las tres tareas.

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

      Aparece una Tutorial complete! página.

  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 el AWS Management Console, limpie en este orden:

  1. En Amazon ECS, haga lo siguiente:

    1. Eliminarcodecatalyst-ecs-service.

    2. Eliminarcodecatalyst-ecs-cluster.

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

  2. En Amazon ECR, codecatalyst-ecs-image-repo elimínelo.

  3. En Amazon EC2, elimínelo. codecatalyst-ecs-security-group

  4. En el Centro de identidades de IAM, elimine:

    1. CodeCatalystECSUser

    2. CodeCatalystECSPermissionSet

En la CodeCatalyst consola, limpie de la siguiente manera:

  1. Eliminarcodecatalyst-ecs-workflow.

  2. Eliminarcodecatalyst-ecs-environment.

  3. Eliminarcodecatalyst-ecs-source-repository.

  4. Eliminarcodecatalyst-ecs-project.

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