Amazon ya no CodeCatalyst está abierto a nuevos clientes. Los clientes existentes pueden seguir utilizando el servicio con normalidad. Para obtener más información, consulte [Cómo migrar desde CodeCatalyst](migration.md).

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.

# Implementación en Amazon ECS con un flujo de trabajo
<a name="deploy-action-ecs"></a>

En esta sección se describe cómo implementar una aplicación contenerizada en un clúster de Amazon Elastic Container Service mediante un CodeCatalyst flujo de trabajo. Para ello, debe añadir la acción **Implementar en Amazon ECS** a su flujo de trabajo. Esta acción registra un archivo de [definición de tareas](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html#welcome-task-definitions) que usted proporciona. Tras el registro, el [servicio de Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html) que se ejecuta en el [clúster de Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html#welcome-clusters) crea una instancia de la definición de la tarea. “Crear una instancia de una definición de tarea” equivale a implementar una aplicación en Amazon ECS.

Para utilizar esta acción, debe tener preparado un archivo de definición de tareas, servicio y clúster de Amazon ECS.

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

**sugerencia**  
Para ver un tutorial que muestra cómo utilizar la acción **Implementar en Amazon ECS**, consulte [Tutorial: implementación de una aplicación en Amazon ECS](deploy-tut-ecs.md).

**sugerencia**  
Para ver un ejemplo práctico de la acción **Implementar en Amazon ECS**, cree un proyecto con el esquema de la **API para Node.js con AWS Fargate** o la **API para Java con AWS Fargate**. Para obtener más información, consulte [Creación de un proyecto con un esquema](projects-create.md#projects-create-console-template).

**Topics**
+ [Imagen del entorno en tiempo de ejecución utilizada por la acción 'Implementar en Amazon ECS'](#deploy-action-ecs-runtime)
+ [Tutorial: implementación de una aplicación en Amazon ECS](deploy-tut-ecs.md)
+ [Incorporación de la acción 'Implementar en Amazon ECS'](deploy-action-ecs-adding.md)
+ [Variables de “Implementar en Amazon ECS”](deploy-action-ecs-variables.md)
+ [Acción 'Implementar en Amazon ECS' de YAML](deploy-action-ref-ecs.md)

## Imagen del entorno en tiempo de ejecución utilizada por la acción 'Implementar en Amazon ECS'
<a name="deploy-action-ecs-runtime"></a>

La acción **Implementar en Amazon ECS** se ejecuta en una [imagen de noviembre de 2022](build-images.md#build.previous-image). Para obtener más información, consulte [Imágenes activas](build-images.md#build-curated-images).

# Tutorial: implementación de una aplicación en Amazon ECS
<a name="deploy-tut-ecs"></a>

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 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 con AWS Fargate**. Para obtener más información, consulte [Creación de un proyecto con un esquema](projects-create.md#projects-create-console-template).

**Topics**
+ [Requisitos previos](#deploy-tut-ecs-prereqs)
+ [Paso 1: Configura un AWS usuario y AWS CloudShell](#deploy-tut-ecs-user-cloudshell)
+ [Paso 2: implementación de una aplicación de marcador de posición en Amazon ECS](#deploy-tut-ecs-placeholder)
+ [Paso 3: creación de un repositorio de imágenes de Amazon ECR](#deploy-tut-ecs-ecr)
+ [Paso 4: Crear roles AWS](#deploy-tut-ecs-build-deploy-roles)
+ [Paso 5: Añadir AWS funciones a CodeCatalyst](#deploy-tut-ecs-import-roles)
+ [Paso 6: creación de un repositorio de código fuente](#deploy-tut-ecs-source-repo)
+ [Paso 7: incorporación de archivos de código fuente](#deploy-tut-ecs-source-files)
+ [Paso 8: creación y ejecución de un flujo de trabajo](#deploy-tut-ecs-workflow)
+ [Paso 9: realización de un cambio en los archivos de código fuente](#deploy-tut-ecs-change)
+ [Limpieza](#deploy-tut-ecs-cleanup)

## Requisitos previos
<a name="deploy-tut-ecs-prereqs"></a>

Antes de empezar:
+ Necesita un CodeCatalyst **espacio** con una AWS cuenta conectada. Para obtener más información, consulte [Creación de un espacio](spaces-create.md).
+ 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 [Crear un proyecto vacío en Amazon CodeCatalyst](projects-create.md#projects-create-empty).
+ En tu proyecto, necesitas un CodeCatalyst **entorno** llamado:

  ```
  codecatalyst-ecs-environment
  ```

  Configure este entorno de la siguiente manera:
  + Elija cualquier tipo, como **Sin producción**.
  + Conecta tu AWS cuenta a ella.
  + 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 VPCs](deploy-environments.md).

## Paso 1: Configura un AWS usuario y AWS CloudShell
<a name="deploy-tut-ecs-user-cloudshell"></a>

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 el usuario raíz 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*. 

**Creación de un rol de IAM Identity Center**

1. Inicie sesión en Consola de administración de AWS y abra la AWS IAM Identity Center consola en [https://console.aws.amazon.com/singlesignon/](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 [Creación de un espacio](spaces-create.md).

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

1. En **Nombre de usuario**, escriba:

   ```
   CodeCatalystECSUser
   ```

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

1. 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.

1. En **Nombre** y **Apellidos**, introduzca:

   ```
   CodeCatalystECSUser
   ```

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

   ```
   CodeCatalystECSUser CodeCatalystECSUser
   ```

1. Elija **Siguiente**.

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

1. 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**.

1. 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.

1. Seleccione **Cerrar**.

**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**.

1. Elija un conjunto de **permisos predefinido** y, a continuación, seleccione **AdministratorAccess**. Esta política concede permisos completos a todos los Servicios de AWS. 

1. Elija **Siguiente**.

1. En **Nombre del conjunto de permisos**, introduzca:

   ```
   CodeCatalystECSPermissionSet
   ```

1. Elija **Siguiente**.

1. 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.

1. Seleccione **Asignar usuarios o grupos**.

1. Elija la pestaña **Users**.

1. Seleccione la casilla situada junto a `CodeCatalystECSUser`.

1. Elija **Siguiente**.

1. Seleccione la casilla situada junto a `CodeCatalystECSPermissionSet`.

1. Elija **Siguiente**.

1. 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í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.

1. Cerrar sesión en AWS.

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

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

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

   Aparece un cuadro de **Cuenta de AWS** en la pantalla.

1. Elija y **Cuenta de AWS**, a continuación, elija el nombre del usuario Cuenta de AWS al que ha asignado el conjunto de permisos y el `CodeCatalystECSUser` usuario.

1. Junto a `CodeCatalystECSPermissionSet`, seleccione **Consola de administración**.

    Consola de administración de AWS Aparece el. Ahora ha iniciado sesión como `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\]](http://docs.aws.amazon.com/es_es/codecatalyst/latest/userguide/images/deploy/aws-logo.png)).

    Consola de administración de AWS Aparece la página principal del.

1. En la barra de navegación superior, selecciona el AWS CloudShell icono (![\[CloudShell icon\]](http://docs.aws.amazon.com/es_es/codecatalyst/latest/userguide/images/deploy/CloudShell.png)).

   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](https://docs.aws.amazon.com/cloudshell/latest/userguide/faq-list.html#regions-available). 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
   ```

1. Compruebe que aparezca una versión.

   El ya AWS CLI está configurado para el usuario actual`CodeCatalystECSUser`, por lo que no es necesario configurar AWS CLI claves y credenciales, como suele ser el caso.

## Paso 2: implementación de una aplicación de marcador de posición en Amazon ECS
<a name="deploy-tut-ecs-placeholder"></a>

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.<a name="deploy-tut-ecs-create-task-execution-role"></a>

**Creación del rol de ejecución de tareas**

Esta función otorga a Amazon ECS AWS 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.

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

------
#### [ JSON ]

****  

      ```
      {
        "Version":"2012-10-17",		 	 	 
        "Statement": [
          {
            "Sid": "",
            "Effect": "Allow",
            "Principal": {
              "Service": "ecs-tasks.amazonaws.com"
            },
            "Action": "sts:AssumeRole"
          }
        ]
      }
      ```

------

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

   1. Pulse **Enter** y, a continuación, **Ctrl\$1d** para guardar el archivo y salir de cat.

1. 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
   ```

1. 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
   ```

1. Muestre los detalles del rol:

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

1. 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, crear un clúster vacío:

   ```
   aws ecs create-cluster --cluster-name codecatalyst-ecs-cluster
   ```

1. (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 Docker (`httpd:2.4`) [del servidor web Apache 2.4](https://hub.docker.com/_/httpd), de la que se extrae DockerHub.

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

   ```
   cat > taskdef.json
   ```

1. 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](#deploy-tut-ecs-create-task-execution-role).

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

1. Pulse **Enter** y, a continuación, **Ctrl\$1d** 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 la tarea:

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

1. (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.

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

1. En la pestaña **Servicios**, elija **Crear**.

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

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

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

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

      `codecatalyst-ecs-task-def`

   1. En **Nombre del servicio**, escriba:

      ```
      codecatalyst-ecs-service
      ```

   1. En **Tareas deseadas**, escriba:

      ```
      3
      ```

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

   1. Expanda la sección **Redes**.

   1. En **VPC**, elija cualquier VPC.

   1. 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](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html#Create-VPC) y [Crear una subred en la VPC](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html#AddaSubnet) en la *Guía del usuario de Amazon VPC*.

   1. 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
         ```

      1. En **Descripción del grupo de seguridad**, introduzca:

         ```
         CodeCatalyst ECS security group
         ```

      1. Seleccione **Agregar regla**. En **Tipo**, elija **HTTP** y, en **Origen**, elija **Cualquier lugar**.

   1. En la parte inferior, elija **Crear**.

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

1. 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.

1. 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: creación de un repositorio de imágenes de Amazon ECR
<a name="deploy-tut-ecs-ecr"></a>

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, crear un repositorio vacío en Amazon ECR:

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

1. Muestre los detalles del repositorio de Amazon ECR:

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

1. 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 AWS
<a name="deploy-tut-ecs-build-deploy-roles"></a>

En esta sección, creará las funciones de AWS IAM que necesitará su CodeCatalyst flujo de trabajo para funcionar. Estos roles 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 los roles de IAM, consulte [Roles de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) 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](ipa-iam-roles.md#ipa-iam-roles-service-create). 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 las funciones de creación e implementación, puede utilizar las funciones Consola de administración de AWS o las AWS CLI.

------
#### [ Consola de administración de AWS ]

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.

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

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

   1. Elija **Crear política**.

   1. Seleccione la pestaña **JSON**.

   1. Elimine el código existente.

   1. Pegue el siguiente código:

------
#### [ JSON ]

****  

      ```
      {
          "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": "*"
      ```

   1. Elija **Siguiente: Etiquetas**.

   1. Elija **Siguiente: Revisar**.

   1. En **Nombre**, escriba:

      ```
      codecatalyst-ecs-build-policy
      ```

   1. Elija **Crear política**.

      Ahora ha creado una política de permisos.

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

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

   1. Elija **Política de confianza personalizada**.

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

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

   1. Elija **Siguiente**.

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

   1. Elija **Siguiente**.

   1. En **Nombre del rol**, escriba:

      ```
      codecatalyst-ecs-build-role
      ```

   1. En **Descripción del rol**, escriba:

      ```
      CodeCatalyst ECS build role
      ```

   1. Elija **Crear rol**.

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

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

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

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

   1. Elija el rol de la lista.

      Aparece la página **Resumen** del rol.

   1. 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.

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

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

   1. Seleccione **Crear política**.

   1. Seleccione la pestaña **JSON**.

   1. Elimine el código existente.

   1. Pegue el siguiente código:

------
#### [ JSON ]

****  

      ```
      {
          "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": "*"
      ```

   1. Elija **Siguiente: Etiquetas**.

   1. Elija **Siguiente: Revisar**.

   1. En **Nombre**, escriba:

      ```
      codecatalyst-ecs-deploy-policy
      ```

   1. Elija **Crear política**.

      Ahora ha creado una política de permisos.

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

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

   1. Elija **Política de confianza personalizada**.

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

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

   1. Elija **Siguiente**.

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

   1. Elija **Siguiente**.

   1. En **Nombre del rol**, escriba:

      ```
      codecatalyst-ecs-deploy-role
      ```

   1. En **Descripción del rol**, escriba:

      ```
      CodeCatalyst ECS deploy role
      ```

   1. Elija **Crear rol**.

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

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

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

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

   1. Elija el rol de la lista.

      Aparece la página **Resumen** del rol.

   1. 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**

Al `CodeCatalystECSUser` iniciar sesión AWS CloudShell, cree un archivo de política de confianza:

1. Cree el archivo:

   ```
   cat > codecatalyst-ecs-trust-policy.json
   ```

1. En la línea de comandos del terminal, pegue el código siguiente:

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

1. Pulse **Enter** y, a continuación, **Ctrl\$1d** 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, crea un archivo de políticas de compilación:

      ```
      cat > codecatalyst-ecs-build-policy.json
      ```

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

------
#### [ JSON ]

****  

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

------

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

   1. Pulse **Enter** y, a continuación, **Ctrl\$1d** para guardar el archivo y salir de cat.

1. 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
   ```

1. 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.

1. 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
   ```

1. 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
   ```

   Where *arn:aws:iam::111122223333:policy/codecatalyst-ecs-build-policy* se sustituye por el ARN de la política de construcción que mencionaste anteriormente.

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

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

1. 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 despliegue:

      ```
      cat > codecatalyst-ecs-deploy-policy.json
      ```

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

------
#### [ JSON ]

****  

      ```
      {
          "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": "*"
      ```

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

   1. Pulse **Enter** y, a continuación, **Ctrl\$1d** para guardar el archivo y salir de cat.

1. 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
   ```

1. 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.

1. 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
   ```

1. 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
   ```

1. Muestre los detalles del rol de implementación:

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

1. 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 AWS funciones a CodeCatalyst
<a name="deploy-tut-ecs-import-roles"></a>

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.

**Incorporación de roles de compilación e implementación a la conexión de cuenta**

1. En CodeCatalyst, navega hasta tu espacio.

1. Elija **Cuentas de AWS **. Aparecerá una lista de conexiones de cuenta.

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

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

   Aparece la página **Añadir función de IAM a Amazon CodeCatalyst Space**. Es posible que tenga que iniciar sesión para acceder a la página.

1. 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`.

1. 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, cierra sesión AWS como vuelve a iniciar sesión con la AWS cuenta que utilizaste al crear tu CodeCatalyst espacio.

1. 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.

1. Copia el valor del **nombre CodeCatalyst mostrado de Amazon**. Necesitará este valor más adelante, cuando cree el flujo de trabajo.

## Paso 6: creación de un repositorio de código fuente
<a name="deploy-tut-ecs-source-repo"></a>

En este paso, crearás un repositorio de origen 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](source-repositories-create.md).

**Creación de un repositorio de código fuente**

1. Abra la CodeCatalyst consola en [https://codecatalyst.aws/](https://codecatalyst.aws/).

1. Vaya a su proyecto, `codecatalyst-ecs-project`.

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

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

1. En **Nombre del repositorio**, escriba:

   ```
   codecatalyst-ecs-source-repository
   ```

1. Seleccione **Crear**.

## Paso 7: incorporación de archivos de código fuente
<a name="deploy-tut-ecs-source-files"></a>

En esta sección, agregas los archivos fuente de Hello World a tu CodeCatalyst repositorio,`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 CodeCatalyst consola, pero puede utilizar Git si lo prefiere. Para obtener más información, consulte [Clonación de un repositorio de código fuente](source-repositories-clone.md). 

**Topics**
+ [index.html](#deploy-tut-ecs-source-files-index)
+ [Dockerfile](#deploy-tut-ecs-source-files-dockerfile)
+ [taskdef.json](#deploy-tut-ecs-source-files-taskdef)

### index.html
<a name="deploy-tut-ecs-source-files-index"></a>

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

**Adición del archivo index.html**

1. En la CodeCatalyst consola, ve a tu repositorio de código fuente,`codecatalyst-ecs-source-repository`.

1. En **Archivos**, elija **Crear archivo**.

1. 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.

1. 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>
   ```

1. 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
<a name="deploy-tut-ecs-source-files-dockerfile"></a>

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](https://docs.docker.com/engine/reference/builder/).

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**.

1. 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í.

1. 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
   ```

1. Seleccione **Confirmar** y, a continuación, vuelva a seleccionar **Confirmar**.

   El Dockerfile se añade a su repositorio. 

### taskdef.json
<a name="deploy-tut-ecs-source-files-taskdef"></a>

El archivo `taskdef.json` que añade en este paso es el mismo que ya especificó en [Paso 2: implementación de una aplicación de marcador de posición en Amazon ECS](#deploy-tut-ecs-placeholder) 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](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html) 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**.

1. En **Nombre del archivo**, escriba:

   ```
   taskdef.json
   ```

1. 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\$1ID: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](#deploy-tut-ecs-create-task-execution-role).

1. Seleccione **Confirmar** y, a continuación, vuelva a seleccionar **Confirmar**.

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

## Paso 8: creación y ejecución de un flujo de trabajo
<a name="deploy-tut-ecs-workflow"></a>

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 desencadenadores, consulte [Inicio de un flujo de trabajo y ejecución automática mediante desencadenadores](workflows-add-trigger.md).
+ 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](build-workflow-actions.md).
+ 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 CodeCatalyst consola, en el panel de navegación, elija **CI/CD** y, a continuación, elija Flujos de trabajo.**

1. Seleccione **Crear flujo de trabajo**.

1. En **Repositorio de código fuente**, elija `codecatalyst-ecs-source-repository`.

1. En **Ramificación**, elija `main`.

1. Seleccione **Crear**.

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

1. 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 AWS funciones a CodeCatalyst](#deploy-tut-ecs-import-roles). Para obtener más información sobre cómo configurar un entorno con un rol de IAM predeterminado, consulte [Creación de un entorno](deploy-environments-creating-environment.md).

   ```
   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 o *codecatalyst-ecs-environment* con el nombre del entorno en el que creó. [Requisitos previos](#deploy-tut-ecs-prereqs)
   + Ambas instancias *codecatalyst-account-connection* con el nombre visible de la conexión de su cuenta. El nombre de visualización puede ser un número. Para obtener más información, consulte [Paso 5: Añadir AWS funciones a CodeCatalyst](#deploy-tut-ecs-import-roles).
   + *codecatalyst-ecs-build-role*con el nombre del rol de compilación en el que creaste[Paso 4: Crear roles AWS](#deploy-tut-ecs-build-deploy-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 [Paso 3: creación de un repositorio de imágenes de Amazon ECR](#deploy-tut-ecs-ecr) el que lo creó.
   + *111122223333.dkr.ecr.us-west-2.amazonaws.com*(en el `Run: aws ecr` comando) con el URI del repositorio de Amazon ECR sin el sufijo de imagen ()`/codecatalyst-ecs-image-repo`.
   + *codecatalyst-ecs-deploy-role*con el nombre de la función de implementación en la que creó. [Paso 4: Crear roles AWS](#deploy-tut-ecs-build-deploy-roles)
   + Ambas instancias o *us-west-2* con el código de su AWS región. Para obtener una lista de códigos de región, consulte [Puntos de conexión regionales](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints) en la *Referencia general de AWS*.
**nota**  
Si decidió no crear funciones de creación e implementación, *codecatalyst-ecs-build-role* *codecatalyst-ecs-deploy-role* sustitúyalas por el nombre de la `CodeCatalystWorkflowDevelopmentRole-spaceName` función. Para obtener más información acerca de este rol, consulte [Paso 4: Crear roles AWS](#deploy-tut-ecs-build-deploy-roles).
**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](render-ecs-action.md).

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

1. Elija **Confirmar**.

1. 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
      ```

   1. En **Repositorio**, elija `codecatalyst-ecs-source-repository`.

   1. En **Nombre de la ramificación**, elija principal.

   1. Elija **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 CodeCatalyst consola, elija **CI/CD** y, a continuación, elija Flujos de trabajo.**

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

1. Elija **BuildBackend**ver el progreso de la compilación.

1. 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](workflows-view-run.md).

**Verificación de la implementación**

1. Abra la consola clásica de Amazon ECS en [https://console.aws.amazon.com/ecs/](https://console.aws.amazon.com/ecs/).

1. Elija su clúster, `codecatalyst-ecs-cluster`.

1. Elija la pestaña **Tareas**. 

1. Elija una de las tres tareas.

1. 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: realización de un cambio en los archivos de código fuente
<a name="deploy-tut-ecs-change"></a>

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 CodeCatalyst consola, en el panel de navegación, elija **Código**, luego elija **Repositorios de origen** y, a continuación, `codecatalyst-ecs-source-repository` elija su repositorio.

1. Haga clic en `public-html` y luego en `index.html`.

   Aparece el contenido de `index.html`.

1. Elija **Edit (Edición de)**. 

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

1. 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. 

1. (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`.

1. 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**.

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

   1. Elija **BuildBackend**y **DeployToECS** para ver el progreso de la ejecución del flujo de trabajo.

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

   1. Abra la consola clásica de Amazon ECS en [https://console.aws.amazon.com/ecs/](https://console.aws.amazon.com/ecs/).

   1. Elija su clúster, `codecatalyst-ecs-cluster`.

   1. Elija la pestaña **Tareas**. 

   1. Elija una de las tres tareas.

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

      Aparece una página `Tutorial complete!`

1. (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
<a name="deploy-tut-ecs-cleanup"></a>

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

En el Consola de administración de AWS, límpielo en este orden:

1. En Amazon ECS, haga lo siguiente:

   1. Elimine `codecatalyst-ecs-service`.

   1. Elimine `codecatalyst-ecs-cluster`.

   1. Anular registro `codecatalyst-ecs-task-definition`.

1. En Amazon ECR, elimine `codecatalyst-ecs-image-repo`.

1. En Amazon EC2, elimine `codecatalyst-ecs-security-group`.

1. En IAM Identity Center, elimine:

   1. `CodeCatalystECSUser`

   1. `CodeCatalystECSPermissionSet`

En la CodeCatalyst consola, limpie de la siguiente manera:

1. Elimine `codecatalyst-ecs-workflow`.

1. Elimine `codecatalyst-ecs-environment`.

1. Elimine `codecatalyst-ecs-source-repository`.

1. Elimine `codecatalyst-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**.

# Incorporación de la acción 'Implementar en Amazon ECS'
<a name="deploy-action-ecs-adding"></a>

Siga estas instrucciones para añadir la acción **Implementar en Amazon ECS** a su flujo de trabajo. 

------
#### [ Visual ]

**Incorporación de la acción 'Implementar en Amazon ECS' con el editor visual**

1. [Abra la CodeCatalyst consola en https://codecatalyst.aws/.](https://codecatalyst.aws/)

1. Elija el proyecto.

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

1. Elija el nombre del flujo de trabajo. Puede filtrar por el nombre del repositorio de código fuente o la ramificación donde esté definido el flujo de trabajo, o bien por el nombre o el estado del flujo de trabajo.

1. Elija **Edit (Edición de)**.

1. Elija **Visual**.

1. En la parte superior izquierda, seleccione **\$1 Acciones** para abrir el catálogo de acciones.

1. En la lista desplegable, selecciona **Amazon CodeCatalyst**.

1. Busque la acción **Implementar en Amazon ECS** y realice una de las siguientes acciones:
   + Elija el signo más (**\$1**) para añadir la acción al diagrama de flujo de trabajo y abrir su panel de configuración.

     O
   + Elija **Implementar en Amazon ECS**. Aparecerá el cuadro de diálogo de detalles de la acción. En este cuadro de diálogo:
     + (Opcional) Seleccione **Descargar** para [ver el código fuente de la acción](workflows-view-source.md#workflows-view-source.title).
     + Seleccione **Añadir al flujo de trabajo** para añadir la acción al diagrama de flujo de trabajo y abrir su panel de configuración.

1. En las pestañas **Entradas** y **Configuración**, complete los campos según sus necesidades. Para obtener una descripción de cada uno de los campos, consulte la [Acción 'Implementar en Amazon ECS' de YAML](deploy-action-ref-ecs.md). Esta referencia proporciona información detallada sobre cada campo (y el valor de la propiedad de YAML correspondiente) tal como aparece en el editor visual y el de YAML.

1. (Opcional) Seleccione **Validar** para validar el código de YAML del flujo de trabajo antes de confirmarlo.

1. Seleccione **Confirmar**, introduzca un mensaje de confirmación y vuelva a seleccionar **Confirmar**.

------
#### [ YAML ]

**Incorporación de la acción 'Implementar en Amazon ECS' con el editor de YAML**

1. Abre la CodeCatalyst consola en [https://codecatalyst.aws/](https://codecatalyst.aws/).

1. Elija el proyecto.

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

1. Elija el nombre del flujo de trabajo. Puede filtrar por el nombre del repositorio de código fuente o la ramificación donde esté definido el flujo de trabajo, o bien por el nombre o el estado del flujo de trabajo.

1. Elija **Edit (Edición de)**.

1. Elija **YAML**.

1. En la parte superior izquierda, seleccione **\$1 Acciones** para abrir el catálogo de acciones.

1. En la lista desplegable, selecciona **Amazon CodeCatalyst**.

1. Busque la acción **Implementar en Amazon ECS** y realice una de las siguientes acciones:
   + Elija el signo más (**\$1**) para añadir la acción al diagrama de flujo de trabajo y abrir su panel de configuración.

     O
   + Elija **Implementar en Amazon ECS**. Aparecerá el cuadro de diálogo de detalles de la acción. En este cuadro de diálogo:
     + (Opcional) Seleccione **Descargar** para [ver el código fuente de la acción](workflows-view-source.md#workflows-view-source.title).
     + Seleccione **Añadir al flujo de trabajo** para añadir la acción al diagrama de flujo de trabajo y abrir su panel de configuración.

1. Modifique las propiedades del código de YAML en función de sus necesidades. Encontrará una explicación de todas las propiedades disponibles en la [Acción 'Implementar en Amazon ECS' de YAML](deploy-action-ref-ecs.md).

1. (Opcional) Seleccione **Validar** para validar el código de YAML del flujo de trabajo antes de confirmarlo.

1. Seleccione **Confirmar**, introduzca un mensaje de confirmación y vuelva a seleccionar **Confirmar**.

------

# Variables de “Implementar en Amazon ECS”
<a name="deploy-action-ecs-variables"></a>

La acción **Implementar en Amazon ECS** produce y establece las siguientes variables en tiempo de ejecución. Se conocen como *variables predefinidas*.

Para obtener información sobre cómo hacer referencia a estas variables en un flujo de trabajo, consulte [Uso de variables predefinidas](workflows-using-predefined-variables.md).


| Clave | Valor | 
| --- | --- | 
|  clúster  |  El nombre del clúster de Amazon ECS en el que se implementó durante la ejecución del flujo de trabajo. Ejemplo: `codecatalyst-ecs-cluster`  | 
|  deployment-platform  |  El nombre de la plataforma de implementación. Codificado en `AWS:ECS`.  | 
|  servicio  |  El nombre del servicio de Amazon ECS en el que se implementó durante la ejecución del flujo de trabajo. Ejemplo: `codecatalyst-ecs-service`  | 
|  task-definition-arn  |  El Nombre de recurso de Amazon (ARN) de la definición de tarea que se registró durante la ejecución del flujo de trabajo. Ejemplo: `arn:aws:ecs:us-west-2:111122223333:task-definition/codecatalyst-task-def:8`El `:8` en el ejemplo anterior indica la revisión que se registró.  | 
|  deployment-url  |  Un enlace a la pestaña **Eventos** de la consola de Amazon ECS, donde puede ver los detalles de la implementación de Amazon ECS asociada a la ejecución del flujo de trabajo. Ejemplo: `https://console.aws.amazon.com/ecs/home?region=us-west-2#/clusters/codecatalyst-ecs-cluster/services/codecatalyst-ecs-service/events`  | 
|  region  |  El código de región en el Región de AWS que se implementó durante la ejecución del flujo de trabajo. Ejemplo: `us-west-2`  | 

# Acción 'Implementar en Amazon ECS' de YAML
<a name="deploy-action-ref-ecs"></a>

La siguiente es la definición en YAML de la acción **Implementar en Amazon ECS**. Para obtener información sobre cómo utilizar esta acción, consulte [Implementación en Amazon ECS con un flujo de trabajo](deploy-action-ecs.md).

Esta definición de acción existe como una sección dentro de un archivo de definición de flujo de trabajo más amplio. Para obtener más información acerca de este archivo, consulte [Definición de flujo de trabajo en YAML](workflow-reference.md).

**nota**  
La mayoría de las propiedades de YAML que se muestran a continuación tienen elementos de interfaz de usuario correspondientes en el editor visual. Para buscar un elemento de la interfaz de usuario, use **Ctrl\$1F**. El elemento aparecerá en la lista con su propiedad de YAML asociada.

```
# The workflow definition starts here.
# See Propiedades de nivel superior for details.
        
Name: MyWorkflow
SchemaVersion: 1.0 
Actions:

# The action definition starts here.   
  ECSDeployAction\$1nn: 
    Identifier: aws/ecs-deploy@v1
    DependsOn:
      - build-action
    Compute:  
      Type: EC2 | Lambda
      Fleet: fleet-name
    Timeout: timeout-minutes
    Environment:
      Name: environment-name
      Connections:
        - Name: account-connection-name
          Role: iam-role-name
    Inputs:
      # Specify a source or an artifact, but not both.
      Sources:
        - source-name-1
      Artifacts:
        - task-definition-artifact
    Configuration: 
      region: us-east-1 
      cluster: ecs-cluster
      service: ecs-service
      task-definition: task-definition-path
      force-new-deployment: false|true
      codedeploy-appspec: app-spec-file-path
      codedeploy-application: application-name
      codedeploy-deployment-group: deployment-group-name
      codedeploy-deployment-description: deployment-description
```

## ECSDeployAction
<a name="deploy.action.ecs.name"></a>

(Obligatorio) 

Especifique el nombre de la acción. Todos los nombres de las acciones deben ser únicos dentro del flujo de trabajo. Los nombres de las acciones están limitados a caracteres alfanuméricos (a-z, A-Z y 0-9), guiones (-) y guiones bajos (\$1). No se permiten espacios. No puede utilizar comillas para permitir caracteres especiales ni espacios en los nombres de las acciones.

Predeterminado: `ECSDeployAction_nn`.

Interfaz de usuario correspondiente: pestaña Configuración/**Nombre de visualización de la acción**

## Identifier
<a name="deploy.action.ecs.identifier"></a>

(*ECSDeployAction*/**Identifier**)

(Obligatorio)

Identifica la acción. No cambie esta propiedad a menos que desee cambiar la versión. Para obtener más información, consulte [Especificación de la versión de la acción que se va a utilizar](workflows-action-versions.md).

Predeterminado: `aws/ecs-deploy@v1`.

**Interfaz de usuario correspondiente: diagrama ECSDeploy de flujo de trabajo/action\$1nn/ aws/ecs-deploy @v1 label**

## DependsOn
<a name="deploy.action.ecs.dependson"></a>

(*ECSDeployAction*/**DependsOn**)

(Opcional)

Especifique la acción, el grupo de acciones o la puerta que debe ejecutarse correctamente para que esta acción se ejecute.

Para obtener más información sobre la funcionalidad “depende de”, consulte [Secuenciación de acciones](workflows-depends-on.md).

Interfaz de usuario correspondiente: pestaña Entradas/**Depende de (opcional)**

## Compute
<a name="deploy.action.ecs.computename"></a>

(*ECSDeployAction*/**Compute**)

(Opcional)

El motor de computación utilizado para ejecutar las acciones del flujo de trabajo. Puede especificar el motor de computación en el nivel del flujo de trabajo o en el nivel de acción, pero no en ambos. Cuando se especifica en el nivel de flujo de trabajo, la configuración del motor de computación se aplica a todas las acciones definidas en el flujo de trabajo. En el nivel de flujo de trabajo, también puede ejecutar varias acciones en la misma instancia. Para obtener más información, consulte [Uso compartido de recursos de computación entre acciones](compute-sharing.md).

Interfaz de usuario correspondiente: *ninguna*

## Type
<a name="deploy.action.ecs.computetype"></a>

(*ECSDeployAction*/Compute/**Type**)

(Obligatorio si se incluye [Compute](#deploy.action.ecs.computename))

El tipo de motor de computación. Puede utilizar uno de los siguientes valores:
+ **EC2** (editor visual) o `EC2` (editor de YAML)

  Optimizado para ofrecer flexibilidad durante las ejecuciones de acciones.
+ **Lambda** (editor visual) o `Lambda` (editor de YAML)

  Velocidades de inicio de acciones optimizadas.

Para obtener más información sobre los tipos de computación, consulte [Tipos de computación](workflows-working-compute.md#compute.types).

Interfaz de usuario correspondiente: Configuración: **opcional/tipo de** cálculo tab/Advanced 

## Fleet
<a name="deploy.action.ecs.computefleet"></a>

(*ECSDeployAction*/Compute/**Fleet**)

(Opcional)

Especifique la máquina o la flota que ejecutará el flujo de trabajo o las acciones del flujo de trabajo. Con las flotas bajo demanda, cuando se inicia una acción, el flujo de trabajo aprovisiona los recursos que necesita y las máquinas se destruyen cuando finaliza la acción. Ejemplos de flotas bajo demanda: `Linux.x86-64.Large`, `Linux.x86-64.XLarge`. Para obtener más información sobre las flotas bajo demanda, consulte [Propiedades de las flotas bajo demanda](workflows-working-compute.md#compute.on-demand).

Con las flotas aprovisionadas, configura un conjunto de máquinas dedicadas para ejecutar las acciones del flujo de trabajo. Estas máquinas permanecen inactivas, listas para procesar acciones de forma inmediata. Para obtener más información sobre las flotas aprovisionadas, consulte [Propiedades de flotas aprovisionadas](workflows-working-compute.md#compute.provisioned-fleets).

Si `Fleet` se omite, el valor predeterminado es `Linux.x86-64.Large`.

**Interfaz de usuario correspondiente: Configuración: opcional/flota de tab/Advanced cómputo**

## Timeout
<a name="deploy.action.ecs.timeout"></a>

(*ECSDeployAction*/**Timeout**)

(Opcional)

Especifique la cantidad de tiempo en minutos (editor YAML) o en horas y minutos (editor visual) que la acción puede ejecutarse antes de que CodeCatalyst finalice la acción. El mínimo es 5 minutos y el máximo se describe en [Cuotas para flujos de trabajo en CodeCatalyst](workflows-quotas.md). El tiempo de espera predeterminado es el mismo que el tiempo de espera máximo.

Interfaz de usuario correspondiente: pestaña Configuración/**Tiempo de espera (opcional)**

## Environment
<a name="deploy.action.ecs.environment"></a>

(*ECSDeployAction*/**Environment**)

(Obligatorio) 

Especifica el CodeCatalyst entorno que se va a usar con la acción. La acción se conecta a Cuenta de AWS la Amazon VPC opcional especificada en el entorno elegido. La acción utiliza la función de IAM predeterminada especificada en el entorno para conectarse a Cuenta de AWS, y utiliza la función de IAM especificada en la [conexión de Amazon VPC](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-vpcs.add.html) para conectarse a la Amazon VPC.

**nota**  
Si el rol de IAM predeterminado no tiene los permisos necesarios para la acción, puede configurarla para que utilice un rol diferente. Para obtener más información, consulte [Cambio del rol de IAM de una acción](deploy-environments-switch-role.md).

Para obtener más información sobre los entornos, consulte [Implementación en Cuentas de AWS y VPCs](deploy-environments.md) y [Creación de un entorno](deploy-environments-creating-environment.md).

Interfaz de usuario correspondiente: pestaña Configuración/**Entorno**

## Name
<a name="deploy.action.ecs.environment.name"></a>

(*ECSDeployAction*/Environment/**Name**)

(Obligatorio si se incluye [Environment](#deploy.action.ecs.environment))

Especifique el nombre del entorno existente que desea asociar a la acción.

Interfaz de usuario correspondiente: pestaña Configuración/**Entorno**

## Connections
<a name="deploy.action.ecs.environment.connections"></a>

(*ECSDeployAction*/Environment/**Connections**)

(Opcional en las versiones más recientes de la acción; obligatorio en las versiones más antiguas)

Especifique la conexión de cuenta que desee asociar a la acción. Puede especificar un máximo de una conexión de cuenta en `Environment`.

Si no especifica una conexión de cuenta:
+ La acción utiliza la Cuenta de AWS conexión y la función de IAM predeterminada especificadas en el entorno de la consola. CodeCatalyst Para obtener información sobre cómo añadir una conexión de cuenta y un rol de IAM predeterminado al entorno, consulte [Creación de un entorno](deploy-environments-creating-environment.md).
+ El rol de IAM predeterminado debe incluir las políticas y los permisos que requiere la acción. Para determinar cuáles son esas políticas y permisos, consulte la descripción de la propiedad **Role** en la documentación de la definición de YAML de la acción.

Para obtener más información sobre las conexiones de cuenta, consulte [Permitir el acceso a AWS los recursos con conexión Cuentas de AWS](ipa-connect-account.md). Para obtener más información sobre cómo añadir una conexión de cuenta a un entorno, consulte [Creación de un entorno](deploy-environments-creating-environment.md).

Interfaz de usuario correspondiente: una de las siguientes, según la versión de la acción.
+ (Versiones más recientes) ¿tab/Environment/WhatLa configuración está lista? *my-environment* **/menú de tres puntos/ Cambiar rol**
+ **(Versiones anteriores) Pestaña de configuración/' '/ conexión de cuenta Environment/account/role AWS **

## Name
<a name="deploy.action.ecs.environment.connections.name"></a>

(*ECSDeployAction*/Environment/Connections/**Name**)

(Obligatorio si se incluye [Connections](#deploy.action.ecs.environment.connections))

Especifique el nombre de la conexión de cuenta.

Interfaz de usuario correspondiente: una de las siguientes, según la versión de la acción.
+ (Versiones más recientes) ¿La configuración está lista? tab/Environment/What *my-environment* **/menú de tres puntos/ Cambiar rol**
+ **(Versiones anteriores) Pestaña de configuración/' '/ conexión de cuenta Environment/account/role AWS **

## Role
<a name="deploy.action.ecs.environment.connections.role"></a>

(*ECSDeployAction*/Environment/Connections/**Role**)

(Obligatorio si se incluye [Connections](#deploy.action.ecs.environment.connections))

Especifique el nombre del rol de IAM que la acción **Implementar en Amazon ECS** utiliza para acceder a AWS. Asegúrese de haber [agregado el rol a su CodeCatalyst espacio](ipa-connect-account-addroles.md) y de que el rol incluya las siguientes políticas.

Si no especifica un rol de IAM, la acción utilizará el rol de IAM predeterminado que aparece en el [entorno](deploy-environments.md) de la consola. CodeCatalyst Si usa el rol predeterminado en el entorno, asegúrese de que tenga las siguientes políticas.
+ La siguiente política de permisos:
**aviso**  
Limite los permisos a los que se muestran en la siguiente política. El uso de un rol con permisos más amplios puede suponer un riesgo de seguridad.

------
#### [ JSON ]

****  

  ```
  {
      "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, use el siguiente 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": "*"
  ```
+ La siguiente política de confianza personalizada:

**nota**  
Puede usar el rol `CodeCatalystWorkflowDevelopmentRole-spaceName` con esta acción, si así lo desea. Para obtener más información acerca de este rol, consulte [Creación del rol **CodeCatalystWorkflowDevelopmentRole-*spaceName*** para su cuenta y su espacio](ipa-iam-roles.md#ipa-iam-roles-service-create). Tenga en cuenta que el rol `CodeCatalystWorkflowDevelopmentRole-spaceName` tiene permisos de acceso total, 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. 

Interfaz de usuario correspondiente: una de las siguientes, según la versión de la acción.
+ (Versiones más recientes) ¿tab/Environment/WhatLa configuración está lista? *my-environment* **/menú de tres puntos/ Cambiar rol**
+ **(Versiones anteriores) Pestaña de configuración/' '/ Rol Environment/account/role**

## Inputs
<a name="deploy.action.ecs.inputs"></a>

(*ECSDeployAction*/**Inputs**)

(Opcional)

La sección `Inputs` define los datos que necesita la acción `ECSDeployAction` durante la ejecución de un flujo de trabajo.

**nota**  
Solo se permite una entrada (ya sea un código fuente o un artefacto) para cada acción **Implementar en Amazon ECS**.

Interfaz de usuario correspondiente: pestaña **Entradas**

## Sources
<a name="deploy.action.ecs.inputs.sources"></a>

(*ECSDeployAction*/Inputs/**Sources**)

(Obligatorio si el archivo de definición de la tarea está almacenado en un repositorio de código fuente)

Si el archivo de definición de la tarea está almacenado en un repositorio de código fuente, especifique la etiqueta de dicho repositorio. Actualmente, la única etiqueta admitida es `WorkflowSource`.

Si el archivo de definición de la tarea no está incluido en un repositorio de código fuente, debe residir en un artefacto generado por otra acción.

Para obtener más información sobre orígenes, consulte [Conexión de repositorios de código fuente a flujos de trabajo](workflows-sources.md).

Interfaz de usuario correspondiente: pestaña Entradas/**Orígenes (opcional)**

## Artifacts - input
<a name="deploy.action.ecs.inputs.artifacts"></a>

(*ECSDeployAction*/Inputs/**Artifacts**)

(Obligatorio si el archivo de definición de la tarea está almacenado en un [artefacto de salida](workflows-working-artifacts-output.md) de una acción anterior)

Si el archivo de definición de la tarea que desea implementar está incluido en un artefacto generado por una acción anterior, especifique ese artefacto aquí. Si el archivo de definición de la tarea no está incluido en un artefacto, debe residir en el repositorio de código fuente.

Para obtener más información sobre los artefactos, incluidos ejemplos, consulte [Cómo compartir artefactos y archivos entre acciones](workflows-working-artifacts.md).

Interfaz de usuario correspondiente: pestaña Configuración/**Artefactos (opcional)**

## Configuration
<a name="deploy.action.ecs.configuration"></a>

(*ECSDeployAction*/**Configuration**)

(Obligatorio)

Una sección en la que puede definir las propiedades de configuración de la acción.

Interfaz de usuario correspondiente: pestaña **Configuración**

## region
<a name="deploy.action.ecs.region"></a>

(Configuration/**region**)

(Obligatorio) 

Especifique la AWS región en la que residen el clúster y el servicio de Amazon ECS. Para obtener una lista de códigos de región, consulte [Puntos de conexión regionales](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints) en la *Referencia general de AWS*.

Interfaz de usuario correspondiente: pestaña Configuración/**Región**

## cluster
<a name="deploy.action.ecs.cluster"></a>

(*ECSDeployAction*/Configuration/**cluster**)

(Obligatorio)

Especifique el nombre de un clúster de Amazon ECS existente. La acción **Implementar en Amazon ECS** implementará la aplicación basada en contenedores como una tarea en este clúster. Para obtener más información sobre los clústeres de Amazon ECS, consulte [Clusters](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html#welcome-clusters) en la *Guía para desarrolladores de Amazon Elastic Container Service*.

Interfaz de usuario correspondiente: pestaña Configuración/**Clúster**

## service
<a name="deploy.action.ecs.service"></a>

(*ECSDeployAction*/Configuration/**service**)

(Obligatorio)

Especifique el nombre del servicio de Amazon ECS existente que creará la instancia del archivo de definición de la tarea. Este servicio debe residir en el clúster especificado en el campo `cluster`. Para obtener más información sobre los servicios de Amazon ECS, consulte [Amazon ECS services](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html) en la *Guía para desarrolladores de Amazon Elastic Container Service*.

Interfaz de usuario correspondiente: pestaña Configuración/**Servicio**

## task-definition
<a name="deploy.action.ecs.task.definition"></a>

(*ECSDeployAction*/Configuration/**task-definition**)

(Obligatorio)

Especifique la ruta a un archivo de definición de la tarea existente. Si el archivo reside en el repositorio de código fuente, la ruta es relativa a la carpeta raíz del repositorio de código fuente. Si el archivo reside en un artefacto de una acción del flujo de trabajo anterior, la ruta es relativa a la carpeta raíz del artefacto. Para obtener más información sobre los archivos de definición de tareas, consulte [Task definitions](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html#welcome-task-definitions) en la *Guía para desarrolladores de Amazon Elastic Container Service*.

Interfaz de usuario correspondiente: pestaña Configuración/**Definición de tarea**

## force-new-deployment
<a name="deploy.action.ecs.forcenewdeployment"></a>

(*ECSDeployAction*/Configuration/**force-new-deployment**)

(Obligatorio)

Si está habilitado, el servicio de Amazon ECS puede iniciar nuevas implementaciones sin cambios en la definición del servicio. Al forzar una implementación, el servicio detiene todas las tareas que se están ejecutando actualmente y lanza nuevas tareas. Para obtener más información sobre cómo forzar nuevas implementaciones, consulte [Updating a service](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/update-service.html) en la *Guía para desarrolladores de Amazon Elastic Container Service*.

Valor predeterminado: `false`

Interfaz de usuario correspondiente: pestaña Configuración/**Forzar una nueva implementación del servicio**

## codedeploy-appspec
<a name="deploy.action.ecs.codedeploy.appspec"></a>

(*ECSDeployAction*/Configuration/**codedeploy-appspec**)

(Obligatorio si ha configurado su servicio Amazon ECS para usar blue/green implementaciones; de lo contrario, omita)

Especifique el nombre y la ruta de un archivo de especificación de CodeDeploy la aplicación (AppSpec) existente. Este archivo debe residir en la raíz del repositorio de CodeCatalyst origen. Para obtener más información sobre AppSpec los archivos, consulte los [archivos de especificación de la CodeDeploy aplicación (AppSpec)](https://docs.aws.amazon.com/codedeploy/latest/userguide/application-specification-files.html) en la *Guía del AWS CodeDeploy usuario*.

**nota**  
Proporcione CodeDeploy información únicamente si ha configurado el servicio Amazon ECS para realizar blue/green despliegues. En el caso de las implementaciones de actualizaciones sucesivas (la opción predeterminada), CodeDeploy omita la información. Para obtener más información sobre las implementaciones de Amazon ECS, consulte [Amazon ECS deployment types](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html) en la *Guía para desarrolladores de Amazon Elastic Container Service*.

**nota**  
Es posible que los **CodeDeploy**campos estén ocultos en el editor visual. Para hacer que estén visibles, consulte [¿Por qué faltan CodeDeploy campos en el editor visual?](troubleshooting-workflows.md#troubleshooting-workflows-codedeploy).

Interfaz de usuario correspondiente: pestaña de configuración/ **CodeDeploy AppSpec**

## codedeploy-application
<a name="deploy.action.ecs.codedeploy.application"></a>

(*ECSDeployAction*/Configuration/**codedeploy-application**)

(Obligatorio si se incluye `codedeploy-appspec`)

Especifique el nombre de una CodeDeploy aplicación existente. Para obtener más información sobre CodeDeploy las aplicaciones, consulte [Trabajar con aplicaciones CodeDeploy en](https://docs.aws.amazon.com/codedeploy/latest/userguide/applications.html) la *Guía del AWS CodeDeploy usuario*.

**Interfaz de usuario correspondiente: pestaña de configuración/aplicación CodeDeploy **

## codedeploy-deployment-group
<a name="deploy.action.ecs.codedeploy.deploymentgroup"></a>

(*ECSDeployAction*/Configuration/**codedeploy-deployment-group**)

(Obligatorio si se incluye `codedeploy-appspec`)

Especifique el nombre de un grupo de CodeDeploy implementación existente. Para obtener más información sobre los grupos de CodeDeploy despliegue, consulte [Trabajar con grupos de despliegue CodeDeploy en](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-groups.html) la *Guía del AWS CodeDeploy usuario*.

Interfaz de usuario correspondiente: pestaña de configuración/grupo **CodeDeploy de despliegue**

## codedeploy-deployment-description
<a name="deploy.action.ecs.codedeploy.deploymentdescription"></a>

(*ECSDeployAction*/Configuration/**codedeploy-deployment-description**)

(Opcional)

Especifique una descripción de la implementación que creará esta acción. Para obtener más información, consulte [Trabajar con implementaciones CodeDeploy en](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployments.html) la Guía del *AWS CodeDeploy usuario*.

**Interfaz de usuario correspondiente: pestaña de configuración/descripción CodeDeploy de la implementación**