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 con flujos de trabajo
<a name="deploy"></a>



Con [CodeCatalyst los flujos de trabajo](workflow.md), puede implementar aplicaciones y otros recursos en varios objetivos AWS Lambda, como Amazon ECS y más. 

## ¿Cómo implemento una aplicación?
<a name="deploy-concepts"></a>

Para implementar una aplicación o un recurso CodeCatalyst, primero debe crear un flujo de trabajo y, a continuación, especificar una acción de implementación dentro del mismo. Una *acción de despliegue* es un componente básico del flujo de trabajo que define *qué* es lo que se quiere implementar, *dónde* se quiere implementar y *cómo* se quiere implementar (por ejemplo, mediante un blue/green esquema). Puedes añadir una acción de despliegue a tu flujo de trabajo mediante el editor visual de la CodeCatalyst consola o el editor YAML.

Los pasos generales para implementar una aplicación o recurso son los siguientes.

**Implementación de una aplicación (tareas generales)**

1. En tu CodeCatalyst proyecto, **agregas el código fuente** de la aplicación que deseas implementar. Para obtener más información, consulte [Almacenar el código fuente en los repositorios de un proyecto en CodeCatalyst](source-repositories.md).

1. En su CodeCatalyst proyecto, debe **añadir un entorno** que defina el objetivo Cuenta de AWS y la Amazon Virtual Private Cloud (VPC) opcional en la que desea realizar la implementación. Para obtener más información, consulte [Implementación en Cuentas de AWS y VPCs](deploy-environments.md).

1. En su CodeCatalyst proyecto, **crea un flujo** de trabajo. El flujo de trabajo es el lugar en el que puede definir cómo compilar, probar e implementar la aplicación. Para obtener más información, consulte [Introducción a los flujos de trabajo](workflows-getting-started.md).

1. En el flujo de trabajo, **añada un desencadenador**, una **acción de compilación** y, de forma opcional, una **acción de prueba**. Para obtener más información, consulte [Inicio de un flujo de trabajo y ejecución automática mediante desencadenadores](workflows-add-trigger.md), [Cómo añadir la acción de compilación](build-add-action.md) y [Cómo añadir la acción de prueba](test-add-action.md).

1. En el flujo de trabajo, **añada una acción de implementación**. Puede elegir entre varias acciones de implementación CodeCatalyst proporcionadas para su aplicación en diferentes destinos, como Amazon ECS. (También puede usar una acción de compilación o una GitHub acción para implementar la aplicación. Para obtener más información sobre la acción de creación y GitHub las acciones, consulte[Alternativas a las acciones de implementación](#deploy-concepts-alternatives).)

1. **Inicie el flujo de trabajo** de forma manual o automática mediante un desencadenador. El flujo de trabajo ejecuta las acciones de compilación, prueba e implementación por orden para implementar la aplicación y los recursos en el destino. Para obtener más información, consulte [Inicio manual de la ejecución de un flujo de trabajo](workflows-manually-start.md).

## Lista de acciones de implementación
<a name="deploy-concepts-action-supported"></a>

Están disponibles las siguientes acciones de implementación:
+ Implementar CloudFormation pila: esta acción crea una CloudFormation pila en AWS función de una [CloudFormation plantilla](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-specification.html) o [AWS Serverless Application Model plantilla](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-guide.html) que proporciones. Para obtener más información, consulte [Implementación de una CloudFormation pila](deploy-action-cfn.md).
+ Implementar en Amazon ECS: 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. Para obtener más información, consulte [Implementación en Amazon ECS con un flujo de trabajo](deploy-action-ecs.md).
+ Implementar en clúster de Kubernetes: esta acción implementa una aplicación en un clúster de Amazon Elastic Kubernetes Service. Para obtener más información, consulte [Implementación en Amazon EKS con un flujo de trabajo](deploy-action-eks.md).
+ AWS CDK implementar: esta acción implementa una [AWS CDK aplicación](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_concepts) en AWS. Para obtener más información, consulte [Implementación de una AWS CDK aplicación con un flujo de trabajo](cdk-dep-action.md).

**nota**  
Existen otras CodeCatalyst acciones que pueden implementar recursos; sin embargo, no se consideran acciones de *implementación* porque su información de implementación no aparece en la página **Entornos.** Para obtener más información sobre la página **Entornos** y sobre cómo ver las implementaciones, consulte [Implementación en Cuentas de AWS y VPCs](deploy-environments.md) y [Consulta de la información de implementación](deploy-view-deployment-info.md).

## Ventajas de las acciones de implementación
<a name="deploy-concepts-why-use"></a>

El uso de acciones de implementación en un flujo de trabajo tiene las siguientes ventajas:
+ **Historial de implementación**: consulte un historial de sus implementaciones para ayudarlo a administrar y comunicar los cambios en el software implementado. 
+ **Trazabilidad**: realice un seguimiento del estado de sus despliegues a través de la CodeCatalyst consola y compruebe cuándo y dónde se implementó cada revisión de la aplicación.
+ **Reversiones:** revierta las implementaciones automáticamente si hay errores. También puede configurar alarmas para activar las reversiones de implementación.
+ **Supervisión**: observe su implementación a medida que avanza por las distintas etapas de su flujo de trabajo.
+ **Integración con otras CodeCatalyst funciones**: almacene el código fuente y, a continuación, compruébelo, pruébelo e impleméntelo, todo desde una sola aplicación.

## Alternativas a las acciones de implementación
<a name="deploy-concepts-alternatives"></a>

No es necesario utilizar las acciones de implementación, si bien se recomiendan porque ofrecen las ventajas descritas en la sección anterior. En su lugar, puede utilizar las siguientes [CodeCatalyst acciones](workflows-actions.md#workflows-actions-types-cc):
+ Una acción de **compilación**.

  Por lo general, las acciones de compilación se utilizan si se quiere realizar la implementación en un destino para el que no existe la acción de implementación correspondiente o si se desea tener más control sobre el procedimiento de implementación. Para obtener más información sobre el uso de acciones de implementación para implementar recursos, consulte [Compilación con flujos de trabajo](build-workflow-actions.md).
+ Una **GitHub acción**.

  Puede usar una [GitHub acción](workflows-actions.md#workflows-actions-types-github) dentro de un CodeCatalyst flujo de trabajo para implementar aplicaciones y recursos (en lugar de una CodeCatalyst acción). Para obtener información sobre cómo utilizar GitHub las acciones dentro de un CodeCatalyst flujo de trabajo, consulte [Integración con GitHub acciones](integrations-github-actions.md)

También puedes usar los siguientes AWS servicios para implementar tu aplicación, si no quieres usar un CodeCatalyst flujo de trabajo para hacerlo:
+ AWS CodeDeploy — consulte [¿Qué es CodeDeploy?](https://docs.aws.amazon.com/codedeploy/latest/userguide/welcome.html)
+ AWS CodeBuild y AWS CodePipeline — consulte [¿Qué es AWS CodeBuild?](https://docs.aws.amazon.com/codebuild/latest/userguide/welcome.html) y [¿Qué es AWS CodePipeline?](https://docs.aws.amazon.com/codepipeline/latest/userguide/welcome.html)
+ CloudFormation — ver [¿Qué es CloudFormation?](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html)

Uso CodeDeploy CodeBuild y CodePipeline CloudFormation servicios para despliegues empresariales complejos.

**Topics**
+ [¿Cómo implemento una aplicación?](#deploy-concepts)
+ [Lista de acciones de implementación](#deploy-concepts-action-supported)
+ [Ventajas de las acciones de implementación](#deploy-concepts-why-use)
+ [Alternativas a las acciones de implementación](#deploy-concepts-alternatives)
+ [Implementación en Amazon ECS con un flujo de trabajo](deploy-action-ecs.md)
+ [Implementación en Amazon EKS con un flujo de trabajo](deploy-action-eks.md)
+ [Implementación de una CloudFormation pila](deploy-action-cfn.md)
+ [Implementación de una AWS CDK aplicación con un flujo de trabajo](cdk-dep-action.md)
+ [Cómo iniciar una AWS CDK aplicación con un flujo de trabajo](cdk-boot-action.md)
+ [Publicación de archivos en Amazon S3 con un flujo de trabajo](s3-pub-action.md)
+ [Implementación en Cuentas de AWS y VPCs](deploy-environments.md)
+ [Visualización de la URL de la aplicación en el diagrama de flujo de trabajo](deploy-app-url.md)
+ [Eliminación de un destino de implementación](deploy-remove-target.md)
+ [Seguimiento del estado de la implementación por confirmación](track-changes.md)
+ [Visualización de los registros de implementación](deploy-deployment-logs.md)
+ [Consulta de la información de implementación](deploy-view-deployment-info.md)

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

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

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

En esta sección, se describe cómo implementar una aplicación en contenedores en un clúster de Kubernetes mediante un flujo de trabajo. CodeCatalyst Para ello, debe añadir la acción **Implementar en clúster de Kubernetes** a su flujo de trabajo. Esta acción implementa la aplicación en un clúster de Kubernetes que haya configurado en Amazon Elastic Kubernetes Service (EKS) mediante uno o varios archivos de manifiesto de Kubernetes. Para ver un manifiesto de ejemplo, consulte [deployment.yaml](deploy-tut-eks.md#deploy-tut-eks-source-files-deployment-yml) en [Tutorial: implementación de una aplicación en Amazon EKS](deploy-tut-eks.md).

Para obtener más información sobre Kubernetes, consulte la [documentación de Kubernetes](https://kubernetes.io/docs/home/).

Para obtener más información sobre Amazon EKS, consulte [¿Qué es Amazon EKS?](https://docs.aws.amazon.com/eks/latest/userguide/what-is-eks.html) en la *Guía del usuario de Amazon EKS*.

**Topics**
+ [Cómo funciona la acción 'Implementar en clúster de Kubernetes'](#deploy-action-eks-howitworks)
+ [Imagen del entorno en tiempo de ejecución utilizada por la acción 'Implementar en Amazon EKS'](#deploy-action-eks-runtime)
+ [Tutorial: implementación de una aplicación en Amazon EKS](deploy-tut-eks.md)
+ [Incorporación de la acción 'Implementar en clúster de Kubernetes'](deploy-action-eks-adding.md)
+ [Variables de 'Implementar en clúster de Kubernetes'](deploy-action-eks-variables.md)
+ [Acción 'Implementar en clúster de Kubernetes' de YAML](deploy-action-ref-eks.md)

## Cómo funciona la acción 'Implementar en clúster de Kubernetes'
<a name="deploy-action-eks-howitworks"></a>

La acción **Implementar en clúster de Kubernetes** funciona de la siguiente manera:

1. En tiempo de ejecución, la acción instala la `kubectl` utilidad Kubernetes en la máquina de procesamiento en la que se ejecuta la acción. CodeCatalyst La acción configura `kubectl` para que apunte al clúster de Amazon EKS que proporcionó al configurar la acción. A continuación, se necesita la utilidad `kubectl` para ejecutar el comando `kubectl apply`.

1. La acción ejecuta el `kubectl apply -f my-manifest.yaml` comando, que ejecuta las instrucciones *my-manifest.yaml* para implementar la aplicación como un conjunto de contenedores y pods en el clúster configurado. Para obtener más información sobre este comando, consulte el tema [kubectl apply](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#apply) en la *documentación de referencia de Kubernetes*.

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

La acción **Implementar en Amazon EKS** 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 EKS
<a name="deploy-tut-eks"></a>

En este tutorial, aprenderá a implementar una aplicación en contenedores en Amazon Elastic Kubernetes Service mediante CodeCatalyst un flujo de trabajo de Amazon, Amazon EKS y algunos otros servicios. AWS La aplicación implementada es un sencillo sitio web “Hello, World\$1” 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 una máquina de desarrollo y un clúster de Amazon EKS, y luego describe cómo crear un flujo de trabajo para crear la aplicación e implementarla en el clúster.

Una vez completada la implementación inicial, el tutorial le indica cómo realizar un cambio en el código fuente de la aplicación. Este cambio hace que se cree una nueva imagen de Docker y se envíe a su repositorio de imágenes de Docker con la nueva información de revisión. A continuación, la nueva revisión de la imagen de Docker se implementa en Amazon EKS.

**sugerencia**  
En lugar de seguir este tutorial, puede utilizar un esquema que realice una configuración completa de Amazon EKS por usted. Deberá utilizar el esquema **Implementación de aplicaciones de EKS**. 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-eks-prereqs)
+ [Paso 1: configuración de la máquina de desarrollo](#deploy-tut-eks-dev-env-create)
+ [Paso 2: creación de un clúster de Amazon EKS](#deploy-tut-eks-cluster)
+ [Paso 3: creación de un repositorio de imágenes de Amazon ECR](#deploy-tut-eks-ecr)
+ [Paso 4: incorporación de archivos de código fuente](#deploy-tut-eks-source-files)
+ [Paso 5: Crear roles AWS](#deploy-tut-eks-roles)
+ [Paso 6: Añadir AWS roles a CodeCatalyst](#deploy-tut-eks-import-roles)
+ [Paso 7: actualice el ConfigMap](#deploy-tut-eks-configmap)
+ [Paso 8: creación y ejecución de un flujo de trabajo](#deploy-tut-eks-workflow)
+ [Paso 9: realización de un cambio en los archivos de código fuente](#deploy-tut-eks-change)
+ [Limpieza](#deploy-tut-eks-cleanup)

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

Antes de comenzar este tutorial:
+ Necesitas un CodeCatalyst **espacio** en Amazon 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-eks-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 **repositorio de CodeCatalyst código fuente** vacío llamado:

  ```
  codecatalyst-eks-source-repository
  ```

  Para obtener más información, consulte [Almacene código y colabore en él con los repositorios de código fuente en CodeCatalystAlmacenamiento de código y colaboración con los repositorios de código fuente](source.md).
+ En su proyecto, necesita un entorno de CodeCatalyst CI/CD (no un **entorno** de desarrollo) llamado:

  ```
  codecatalyst-eks-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: configuración de la máquina de desarrollo
<a name="deploy-tut-eks-dev-env-create"></a>

El primer paso de este tutorial consiste en configurar una máquina de desarrollo con algunas herramientas que utilizará a lo largo de este tutorial. Estos roles son:
+ la utilidad `eksctl`: para la creación del clúster
+ la utilidad `kubectl`: un requisito previo para `eksctl`
+ el AWS CLI ... también es un requisito previo para `eksctl`

Puede instalar estas herramientas en su máquina de desarrollo actual si tiene una, o puede usar un entorno de CodeCatalyst desarrollo, que está basado en la nube. La ventaja de un CodeCatalyst entorno de desarrollo es que es fácil de configurar y desmontar, y está integrado con otros CodeCatalyst servicios, lo que te permite completar este tutorial en menos pasos.

En este tutorial se asume que utilizarás un entorno CodeCatalyst de desarrollo.

Las siguientes instrucciones describen una forma rápida de lanzar un CodeCatalyst entorno de desarrollo y configurarlo con las herramientas necesarias, pero si desea obtener instrucciones detalladas, consulte:
+ [Creación de un entorno de desarrollo](devenvironment-create.md) en esta guía.
+ [Instalación de kubectl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) en la **Guía del usuario de Amazon EKS**.
+ [Instalación o actualización de eksctl](https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html) en la **Guía del usuario de Amazon EKS**.
+ [Instalación o actualización de la versión más reciente de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) en la *Guía del usuario de AWS Command Line Interface *.

**Lanzamiento de un entorno de desarrollo**

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

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

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

1. Elija el nombre del repositorio de código fuente, `codecatalyst-eks-source-repository`.

1. Cerca de la parte superior, elija **Crear entorno de desarrollo** y, a continuación, elija **AWS Cloud9 (en el navegador)**.

1. Asegúrese de que estén seleccionadas la opción **Trabajar en una ramificación existente** y la ramificación **principal** y, a continuación, elija **Crear**.

   Su entorno de desarrollo se abre en una nueva pestaña del navegador y el repositorio (`codecatalyst-eks-source-repository`) se clona en él.

**Instalación y configuración de kubectl**

1. En el terminal del entorno de desarrollo, escriba:

   ```
   curl -o kubectl https://amazon-eks.s3.us-west-2.amazonaws.com/1.18.9/2020-11-02/bin/linux/amd64/kubectl
   ```

1. Escriba:

   ```
   chmod +x ./kubectl
   ```

1. Escriba:

   ```
   mkdir -p $HOME/bin && cp ./kubectl $HOME/bin/kubectl && export PATH=$PATH:$HOME/bin
   ```

1. Escriba:

   ```
   echo 'export PATH=$PATH:$HOME/bin' >> ~/.bashrc
   ```

1. Escriba:

   ```
   kubectl version --short --client
   ```

1. Compruebe que aparezca una versión.

   Ahora ha instalado `kubectl`.

**Instalación y configuración de eksctl**
**nota**  
`eksctl` no es estrictamente obligatorio porque se puede utilizar `kubectl` en su lugar. Sin embargo, `eksctl` tiene la ventaja de automatizar gran parte de la configuración del clúster y, por lo tanto, es la herramienta recomendada para este tutorial.

1. En el terminal del entorno de desarrollo, escriba:

   ```
   curl --silent --location "https://github.com/weaveworks/eksctl/releases/latest/download/eksctl_$(uname -s)_amd64.tar.gz" | tar xz -C /tmp
   ```

1. Escriba:

   ```
   sudo cp /tmp/eksctl /usr/bin
   ```

1. Escriba:

   ```
   eksctl version
   ```

1. Compruebe que aparezca una versión.

   Ahora ha instalado `eksctl`.

**Para comprobar que AWS CLI está instalado**

1. En el terminal del entorno de desarrollo, escriba:

   ```
   aws --version
   ```

1. Compruebe que aparezca una versión para comprobar que AWS CLI está instalada.

   Complete los procedimientos restantes para configurarlo AWS CLI con los permisos de acceso necesarios AWS.

**Para configurar el AWS CLI**

Debe configurarlo AWS CLI con claves de acceso y un token de sesión para darle acceso a AWS los servicios. Las siguientes instrucciones proporcionan una forma rápida de configurar las claves y el token, pero si desea obtener instrucciones detalladas, consulte [Configuración de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) en la *Guía del usuario de AWS Command Line Interface *.

1. Cree un usuario de IAM Identity Center del modo siguiente:

   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/).

      (Puede que tenga que seleccionar **Activar** si nunca ha iniciado sesión en IAM Identity Center con anterioridad).
**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:

      ```
      codecatalyst-eks-user
      ```

   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**, escriba:

      ```
      codecatalyst-eks-user
      ```

   1. En **Apellidos**, escriba:

      ```
      codecatalyst-eks-user
      ```

   1. En **Nombre de visualización**, mantenga:

      ```
      codecatalyst-eks-user codecatalyst-eks-user
      ```

   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 en un archivo de texto. La información de inicio de sesión consta de la URL del portal de AWS acceso, un nombre de usuario y una contraseña de un solo uso.

   1. Seleccione **Cerrar**.

1. Cree un conjunto de permisos de la siguiente manera:

   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**, elimine `AdministratorAccess` e introduzca:

      ```
      codecatalyst-eks-permission-set
      ```

   1. Elija **Siguiente**.

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

1. Asigne el conjunto de permisos a `codecatalyst-eks-user` de la siguiente manera:

   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 `codecatalyst-eks-user`.

   1. Elija **Siguiente**.

   1. Seleccione la casilla situada junto a `codecatalyst-eks-permission-set`.

   1. Elija **Siguiente**.

   1. Revise la información y seleccione **Enviar**.

      Ahora tienes asignada `codecatalyst-eks-user` y `codecatalyst-eks-permission-set` a la tuya Cuenta de AWS, uniéndolas.

1. Obtenga las claves de acceso de `codecatalyst-eks-user` y el token de sesión de la siguiente manera:

   1. Asegúrese de tener la URL del portal de AWS acceso y el nombre de usuario y la contraseña de un solo uso del mismo`codecatalyst-eks-user`. 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 `codecatalyst-eks-user` 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:
      + **Nombre de usuario**:

        ```
        codecatalyst-eks-user
        ```
      + **Contraseña**:

        *one-time-password*

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

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

   1. Elija **Cuenta de AWS** y, a continuación, elija el nombre de la Cuenta de AWS a la que asignó el usuario `codecatalyst-eks-user` y el conjunto de permisos.

   1. Junto a `codecatalyst-eks-permission-set`, seleccione **Línea de comandos o acceso mediante programación**.

   1. Copie los comandos del centro de la página. Tendrán un aspecto similar al siguiente:

      ```
      export AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE" 
      export AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY" 
      export AWS_SESSION_TOKEN="session-token"
      ```

      ... donde *session-token* hay una cadena aleatoria larga.

1. Añada las claves de acceso y el token de sesión al AWS CLI, de la siguiente manera:

   1. Regrese a su CodeCatalyst entorno de desarrollo.

   1. En la línea de comandos del terminal, pegue los comandos que ha copiado. Pulse Intro.

      Ahora lo ha configurado AWS CLI con claves de acceso y un token de sesión. Ahora puede utilizarla AWS CLI para completar las tareas requeridas en este tutorial.
**importante**  
Si en algún momento de este tutorial ve mensajes similares a:  
`Unable to locate credentials. You can configure credentials by running "aws configure".`  
O bien:  
`ExpiredToken: The security token included in the request is expired`  
... es porque tu AWS CLI sesión ha caducado. En este caso, *no* ejecute el comando `aws configure`. En lugar de ello, siga las instrucciones del paso 4 de este procedimiento, que comienza con `Obtain codecatalyst-eks-user's access key and session token` para actualizar la sesión.

## Paso 2: creación de un clúster de Amazon EKS
<a name="deploy-tut-eks-cluster"></a>

En esta sección, creará un clúster en Amazon EKS. En las instrucciones siguientes se describe una forma rápida de crear el clúster mediante `eksctl`, pero si desea obtener instrucciones detalladas, consulte:
+ [Introducción a eksctl](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html) en la **Guía del usuario de Amazon EKS**

  o
+ [Introducción a la consola y a la AWS CLI](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-console.html) en la **Guía del usuario de Amazon EKS** (en este tema se proporcionan instrucciones de `kubectl` para crear el clúster) 

**nota**  
La CodeCatalyst integración con Amazon EKS no admite [clústeres privados](https://docs.aws.amazon.com/eks/latest/userguide/private-clusters.html).

**Antes de empezar**

Asegúrese de haber realizado las siguientes tareas en su máquina de desarrollo:
+ Ha instalado la utilidad `eksctl`.
+ Ha instalado la utilidad `kubectl`.
+ Lo instalé AWS CLI y lo configuré con claves de acceso y un token de sesión.

Para obtener más información sobre como realizar estas tareas, consulte [Paso 1: configuración de la máquina de desarrollo](#deploy-tut-eks-dev-env-create).

**Para crear un clúster**
**importante**  
No utilice la interfaz de usuario del servicio de Amazon EKS para crear el clúster, ya que el clúster no se configurará correctamente. Utilice la utilidad `eksctl` tal y como se describe en los pasos siguientes.

1. Vaya a su entorno de desarrollo.

1. Cree un clúster y los nodos:

   ```
   eksctl create cluster --name codecatalyst-eks-cluster --region us-west-2
   ```

   Donde:
   + *codecatalyst-eks-cluster*se sustituye por el nombre que desee darle a su clúster.
   + *us-west-2*se sustituye por tu región.

   Después de 10-20 minutos, aparecerá un mensaje similar al siguiente: 

   `EKS cluster "codecatalyst-eks-cluster" in "us-west-2" region is ready`
**nota**  
Verá varios mensajes `waiting for CloudFormation stack` mientras AWS crea el clúster. Esto es normal.

1. Compruebe que el clúster se haya creado correctamente:

   ```
   kubectl cluster-info
   ```

   Verá un mensaje similar al siguiente, que indica que la creación del clúster se ha realizado correctamente:

   ```
   Kubernetes master is running at https://long-string.gr7.us-west-2.eks.amazonaws.com
   CoreDNS is running at https://long-string.gr7.us-west-2.eks.amazonaws.com/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy
   ```

## Paso 3: creación de un repositorio de imágenes de Amazon ECR
<a name="deploy-tut-eks-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.

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. Vaya a su entorno de desarrollo.

1. Cree un repositorio vacío en Amazon ECR:

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

   *codecatalyst-eks-image-repo*Sustitúyalo por el nombre que desee asignar al repositorio de Amazon ECR.

   En este tutorial se asume que el repositorio se llama `codecatalyst-eks-image-repo`.

1. Muestre los detalles del repositorio de Amazon ECR:

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

1. Anote el valor de `“repositoryUri”:` (por ejemplo, `111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-eks-image-repo`).

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

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

En esta sección, añadirá los archivos de código fuente de la aplicación al repositorio de código fuente (`codecatalyst-eks-source-repository`). Constan de:
+ Un archivo `index.html`: muestra un mensaje “Hello, world\$1” 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 `deployment.yaml`: el manifiesto de Kubernetes que define el servicio y la implementación de Kubernetes. 

La estructura de carpetas es la siguiente:

```
|— codecatalyst-eks-source-repository
   |— Kubernetes
      |— deployment.yaml
   |— public-html
   |  |— index.html
   |— Dockerfile
```

**Topics**
+ [index.html](#deploy-tut-eks-source-files-index)
+ [Dockerfile](#deploy-tut-eks-source-files-dockerfile)
+ [deployment.yaml](#deploy-tut-eks-source-files-deployment-yml)

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

El archivo `index.html` muestra un mensaje “Hello, world\$1” en el navegador. 

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

1. Vaya a su entorno de desarrollo.

1. En `codecatalyst-eks-source-repository`, cree una carpeta llamada `public-html`.

1. En `/public-html`, cree un archivo llamado `index.html` con el siguiente contenido:

   ```
   <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. En la línea de comandos del terminal, escriba:

   ```
   cd /projects/codecatalyst-eks-source-repository
   ```

1. Añada, confirme y envíe:

   ```
   git add .
   git commit -m "add public-html/index.html"
   git push
   ```

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

### Dockerfile
<a name="deploy-tut-eks-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 `codecatalyst-eks-source-repository`, cree un archivo llamado `Dockerfile` con el siguiente contenido:

   ```
   FROM httpd:2.4
   COPY ./public-html/index.html /usr/local/apache2/htdocs/index.html
   EXPOSE 80
   ```

   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. Añada, confirme y envíe:

   ```
   git add .
   git commit -m "add Dockerfile"
   git push
   ```

   El Dockerfile se añade a su repositorio.

### deployment.yaml
<a name="deploy-tut-eks-source-files-deployment-yml"></a>

En esta sección, añadirá un archivo `deployment.yaml` al repositorio. El archivo `deployment.yaml` es un manifiesto de Kubernetes que define dos tipos o *clases* de recursos de Kubernetes que se van a ejecutar: un “servicio” y una “implementación”.
+ El “servicio” implementa un equilibrador de carga en Amazon EC2. El equilibrador de carga le proporciona una URL pública con acceso a Internet y un puerto estándar (puerto 80) que puede usar para examinar el mensaje “Hello, World\$1”. "Hello, World\$1". 
+ La “implementación” implementa tres pods y cada uno de ellos incluirá un contenedor de Docker con el mensaje “Hello, World\$1”. "Hello, World\$1". Los tres pods se implementan en los nodos que se crearon al crear el clúster.

El manifiesto de este tutorial es breve; sin embargo, un manifiesto puede incluir cualquier número de tipos de recursos de Kubernetes, como pods, trabajos, entradas y políticas de red. Además, puede usar varios archivos de manifiesto si la implementación es compleja.

**Adición de un archivo deployment.yaml**

1. En `codecatalyst-eks-source-repository`, cree una carpeta llamada `Kubernetes`.

1. En `/Kubernetes`, cree un archivo llamado `deployment.yaml` con el siguiente contenido:

   ```
   apiVersion: v1
   kind: Service
   metadata:
     name: my-service
     labels:
       app: my-app
   spec:
     type: LoadBalancer
     selector:
       app: my-app
     ports:
       - protocol: TCP
         port: 80
         targetPort: 80
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: my-deployment
     labels:
       app: my-app
   spec:
     replicas: 3
     selector:
       matchLabels:
         app: my-app
     template:
       metadata:
         labels:
           app: my-app
       spec:
         containers:
         - name: codecatalyst-eks-container
           # The $REPOSITORY_URI and $IMAGE_TAG placeholders will be replaced by actual values supplied by the build action in your workflow
           image: $REPOSITORY_URI:$IMAGE_TAG
           ports:
           - containerPort: 80
   ```

1. Añada, confirme y envíe:

   ```
   git add .
   git commit -m "add Kubernetes/deployment.yaml"
   git push
   ```

   El archivo `deployment.yaml` se añade al repositorio en una carpeta llamada `Kubernetes`. 

Ahora ha añadido todos los archivos de código fuente.

Dedique unos minutos a comprobar su trabajo y a asegurarse de que ha colocado todos los archivos en las carpetas correctas. La estructura de carpetas es la siguiente:

```
|— codecatalyst-eks-source-repository
   |— Kubernetes
      |— deployment.yaml
   |— public-html
   |  |— index.html
   |— Dockerfile
```

## Paso 5: Crear roles AWS
<a name="deploy-tut-eks-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 el clúster de Kubernetes** (en el flujo de trabajo) el permiso para acceder a su cuenta AWS y a Amazon EKS.

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 los roles de compilación e implementación, realice la siguiente serie de procedimientos.

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

1. Vaya a su entorno de desarrollo.

1. En el directorio `Cloud9-long-string`, cree un archivo llamado `codecatalyst-eks-trust-policy.json` con el siguiente contenido:

**2. Creación de la política de compilación para el rol de compilación**
+ En el directorio `Cloud9-long-string`, cree un archivo llamado `codecatalyst-eks-build-policy.json` con el siguiente contenido:

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

**3. Creación de una política de implementación para el rol de implementación**
+ En el directorio `Cloud9-long-string`, cree un archivo llamado `codecatalyst-eks-deploy-policy.json` con el siguiente contenido:

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

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [
          {
              "Effect": "Allow",
              "Action": [
                  "eks:DescribeCluster",
                  "eks:ListClusters"
              ],
              "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": "*"
  ```

Ahora ha añadido tres documentos de política a su entorno de desarrollo. La estructura de directorios ahora debería ser similar a la siguiente:

```
|— Cloud9-long-string
   |— .c9
   |— codecatalyst-eks-source-repository
      |— Kubernetes
      |— public-html
      |— Dockerfile
   codecatalyst-eks-build-policy.json
   codecatalyst-eks-deploy-policy.json
   codecatalyst-eks-trust-policy.json
```

**4. Para añadir la política de compilación a AWS**

1. En el terminal del entorno de desarrollo, escriba:

   ```
   cd /projects
   ```

1. Escriba:

   ```
   aws iam create-policy \
       --policy-name codecatalyst-eks-build-policy \
       --policy-document file://codecatalyst-eks-build-policy.json
   ```

1. Pulse **Intro**.

1. En el resultado del comando, anote el valor de `"arn":` (por ejemplo, `arn:aws:iam::111122223333:policy/codecatalyst-eks-build-policy`). Necesitará este ARN más adelante.

**5. Para añadir la política de despliegue a AWS**

1. Escriba:

   ```
   aws iam create-policy \
       --policy-name codecatalyst-eks-deploy-policy \
       --policy-document file://codecatalyst-eks-deploy-policy.json
   ```

1. Pulse **Intro**.

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-eks-deploy-policy`). Necesitará este ARN más adelante.

**6. Creación del rol de compilación**

1. Escriba: 

   ```
   aws iam create-role \
         --role-name codecatalyst-eks-build-role \
         --assume-role-policy-document file://codecatalyst-eks-trust-policy.json
   ```

1. Pulse **Intro**.

1. Escriba:

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

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

1. Pulse **Intro**.

1. En la línea de comandos del terminal, escriba:

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

1. Pulse **Intro**.

1. Anote el valor de `"Arn":` del rol (por ejemplo, `arn:aws:iam::111122223333:role/codecatalyst-eks-build-role`). Necesitará este ARN más adelante.

**7. Creación del rol de implementación**

1. Escriba:

   ```
   aws iam create-role \
         --role-name codecatalyst-eks-deploy-role \
         --assume-role-policy-document file://codecatalyst-eks-trust-policy.json
   ```

1. Pulse **Intro**.

1. Escriba:

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

   Where *arn:aws:iam::111122223333:policy/codecatalyst-eks-deploy-policy* se sustituye por el ARN de la política de despliegue que indicó anteriormente.

1. Pulse **Intro**.

1. Escriba:

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

1. Pulse **Intro**.

1. Anote el valor de `"Arn":` del rol (por ejemplo, `arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role`). Necesitará este ARN más adelante.

Ahora ha creado las funciones de creación e implementación y ha anotado sus ARNs funciones.

## Paso 6: Añadir AWS roles a CodeCatalyst
<a name="deploy-tut-eks-import-roles"></a>

En este paso, agrega el rol de compilación (`codecatalyst-eks-build-role`) y el rol de implementación (`codecatalyst-eks-deploy-role`) al rol Cuenta de AWS que conectó a su espacio. Esto permite que los roles se puedan usar en el flujo de trabajo.

**Para añadir funciones de creación e implementación a su Cuenta de AWS**

1. En la CodeCatalyst consola, navega hasta tu espacio.

1. En la parte superior, elija **Configuración**.

1. En el panel de navegación, elija **Cuentas de AWS **. Aparece una lista de cuentas.

1. En la columna **Nombre CodeCatalyst para mostrar de Amazon**, copia el nombre para mostrar del Cuenta de AWS lugar en el que creaste las funciones de creación e implementación. (Puede ser un número). Necesitará este valor más adelante, cuando cree el flujo de trabajo.

1. Elija el nombre de visualización.

1. Selecciona **Administrar roles desde la consola AWS de 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 los roles de compilación e implementación, y todos los demás 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, añada:
   + `codecatalyst-eks-build-role`
   + `codecatalyst-eks-deploy-role`
**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. Vuelve a la CodeCatalyst consola y actualiza la página.

   Los roles de compilación e implementación deberían aparecer ahora en **Roles de IAM**.

   Estas funciones ahora están disponibles para su uso en los CodeCatalyst flujos de trabajo.

## Paso 7: actualice el ConfigMap
<a name="deploy-tut-eks-configmap"></a>

Debe añadir el rol de implementación que creó en `ConfigMap` al archivo [Paso 5: Crear roles AWS](#deploy-tut-eks-roles) de Kubernetes para que la acción **Implementar en clúster de Kubernetes** (en su flujo de trabajo) pueda acceder a su clúster e interactuar con él. Puede utilizar `eksctl` o `kubectl` para realizar esta tarea.

**Para configurar el archivo de ConfigMap Kubernetes mediante eksctl**
+ En el terminal del entorno de desarrollo, escriba: 

  ```
  eksctl create iamidentitymapping --cluster codecatalyst-eks-cluster --arn arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role --group system:masters --username codecatalyst-eks-deploy-role --region us-west-2
  ```

  Donde:
  + *codecatalyst-eks-cluster*se sustituye por el nombre del clúster de Amazon EKS.
  +  *arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role*se sustituye por el ARN de la función de implementación en la que creaste. [Paso 5: Crear roles AWS](#deploy-tut-eks-roles)
  +  *codecatalyst-eks-deploy-role*(junto a`--username`) se sustituye por el nombre de la función de implementación en [Paso 5: Crear roles AWS](#deploy-tut-eks-roles) la que creaste.
**nota**  
Si ha decidido no crear un rol de despliegue, *codecatalyst-eks-deploy-role* sustitúyalo por el nombre del `CodeCatalystWorkflowDevelopmentRole-spaceName` rol. Para obtener más información acerca de este rol, consulte [Paso 5: Crear roles AWS](#deploy-tut-eks-roles).
  +  *us-west-2*se sustituye por su región.

  Para obtener más información sobre este comando, consulte [Administración de usuarios y roles de IAM](https://eksctl.io/usage/iam-identity-mappings/).

  Aparecerá un mensaje similar al siguiente:

  ```
  2023-06-09 00:58:29 [ℹ]  checking arn arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role against entries in the auth ConfigMap
  2023-06-09 00:58:29 [ℹ]  adding identity "arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role" to auth ConfigMap
  ```

**Para configurar el archivo de Kubernetes ConfigMap mediante kubectl**

1. En el terminal del entorno de desarrollo, escriba:

   ```
   kubectl edit configmap -n kube-system aws-auth
   ```

   El archivo aparece en la pantalla ConfigMap .

1. Añada el texto en cursiva de color rojo:

   ```
   # Please edit the object below. Lines beginning with a '#' will be ignored,
   # and an empty file will abort the edit. If an error occurs while saving this file will be
   # reopened with the relevant failures.
   #
   apiVersion: v1
   data:
     mapRoles: |
       - groups:
         - system:bootstrappers
         - system:nodes
         rolearn: arn:aws:iam::111122223333:role/eksctl-codecatalyst-eks-cluster-n-NodeInstanceRole-16BC456ME6YR5
         username: system:node:{{EC2PrivateDNSName}}
       - groups:
         - system:masters
         rolearn: arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role
         username: codecatalyst-eks-deploy-role
     mapUsers: |
       []
   kind: ConfigMap
   metadata:
     creationTimestamp: "2023-06-08T19:04:39Z"
     managedFields:
     ...
   ```

   Donde:
   +  *arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role*se sustituye por el ARN de la función de implementación en la que creaste. [Paso 5: Crear roles AWS](#deploy-tut-eks-roles) 
   +  *codecatalyst-eks-deploy-role*(junto a`username:`) se sustituye por el nombre de la función de implementación en [Paso 5: Crear roles AWS](#deploy-tut-eks-roles) la que creaste.
**nota**  
Si ha decidido no crear un rol de despliegue, *codecatalyst-eks-deploy-role* sustitúyalo por el nombre del `CodeCatalystWorkflowDevelopmentRole-spaceName` rol. Para obtener más información acerca de este rol, consulte [Paso 5: Crear roles AWS](#deploy-tut-eks-roles).

   Para obtener más información, consulte [Habilitación del acceso de la entidad principal de IAM a un clúster](https://docs.aws.amazon.com/eks/latest/userguide/add-user-role.html) en la **Guía del usuario de Amazon EKS**.

Ahora ha proporcionado al rol de implementación y, por extensión, a la acción **Implementar en Amazon EKS**, permisos `system:masters` para su clúster de Kubernetes.

## Paso 8: creación y ejecución de un flujo de trabajo
<a name="deploy-tut-eks-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 tres pods en su clúster de Amazon EKS.

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 las variables `$REPOSITORY_URI` y `$IMAGE_TAG` en el archivo `Kubernetes` con los valores correctos y, a continuación, crea un artefacto de salida de este archivo y en los demás archivos de la carpeta `deployment.yaml`. En este tutorial, el único archivo de la carpeta `Kubernetes` es `deployment.yaml`, pero puede incluir más archivos. El 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 (`DeployToEKS`): 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 (`Manifests`) y encuentra el archivo `deployment.yaml` que contiene. A continuación, la acción sigue las instrucciones del archivo `deployment.yaml` para ejecutar tres pods, cada uno de los cuales contiene un único mensaje “Hello, World\$1”. Contenedor de Docker: dentro de su clúster de Amazon EKS. 

**Para crear un flujo de trabajo**

1. Ve a la CodeCatalyst consola.

1. Vaya a su proyecto (`codecatalyst-eks-project`).

1. 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-eks-source-repository`.

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

1. Seleccione **Crear**.

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

1. Añada el siguiente código de YAML para crear un nuevo archivo de definición de flujo de trabajo:
**nota**  
Para obtener más información sobre el archivo de definición del flujo de trabajo, consulte [Definición de flujo de trabajo en YAML](workflow-reference.md).
**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 6: Añadir AWS roles a CodeCatalyst](#deploy-tut-eks-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-eks-workflow
   SchemaVersion: 1.0
   
   Triggers:
     - Type: PUSH
       Branches:
         - main
   Actions:
     BuildBackend:
       Identifier: aws/build@v1
       Environment:
         Name: codecatalyst-eks-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-eks-build-role
       Inputs:
         Sources:
           - WorkflowSource
         Variables:
           - Name: REPOSITORY_URI
             Value: 111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-eks-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 deployment.yaml
           - Run: find Kubernetes/ -type f | xargs sed -i "s|\$REPOSITORY_URI|$REPOSITORY_URI|g"
           - Run: find Kubernetes/ -type f | xargs sed -i "s|\$IMAGE_TAG|$IMAGE_TAG|g"
           - Run: cat Kubernetes/*
           # The output artifact will be a zip file that contains Kubernetes manifest files.
       Outputs:
         Artifacts:
           - Name: Manifests
             Files: 
               - "Kubernetes/*"
     DeployToEKS:
       DependsOn: 
         - BuildBackend
       Identifier: aws/kubernetes-deploy@v1
       Environment:
         Name: codecatalyst-eks-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-eks-deploy-role
       Inputs:
         Artifacts:
           - Manifests
       Configuration:
         Namespace: default
         Region: us-west-2
         Cluster: codecatalyst-eks-cluster
         Manifests: Kubernetes/
   ```

   En el código anterior, sustituya:
   + Ambas instancias o *codecatalyst-eks-environment* con el nombre del entorno en el que creaste[Requisitos previos](#deploy-tut-eks-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 6: Añadir AWS roles a CodeCatalyst](#deploy-tut-eks-import-roles).
   + *codecatalyst-eks-build-role*con el nombre del rol de compilación en el que creaste[Paso 5: Crear roles AWS](#deploy-tut-eks-roles).
   + *111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-eks-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-eks-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-eks-image-repo`.
   + *codecatalyst-eks-deploy-role*con el nombre de la función de implementación en la que creó. [Paso 5: Crear roles AWS](#deploy-tut-eks-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) en la *Referencia general de AWS*.
**nota**  
Si decidió no crear funciones de creación e implementación, *codecatalyst-eks-build-role* *codecatalyst-eks-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 5: Crear roles AWS](#deploy-tut-eks-roles).

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-eks-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-eks-workflow`.

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

1. Elija **DeployToEKS** 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 de Amazon EC2 en [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. A la izquierda, cerca de la parte inferior, seleccione **Equilibradores de carga**.

1. Seleccione el equilibrador de carga que se creó como parte de la implementación de Kubernetes. Si no está seguro de qué equilibrador de carga elegir, busque las siguientes etiquetas en la pestaña **Etiquetas**:
   + `kubernetes.io/service-name`
   + `kubernetes.io/cluster/ekstutorialcluster`

1. Con el equilibrador de carga correcto seleccionado, elija la pestaña **Descripción**.

1. Copie y pegue el valor del **nombre de DNS** en la barra de dirección del navegador.

   Aparece la página web “Hello World\$1” en el navegador, lo que indica que la aplicación se ha implementado correctamente.

## Paso 9: realización de un cambio en los archivos de código fuente
<a name="deploy-tut-eks-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. Vaya a su entorno de desarrollo.

1. En la línea de comandos del terminal, cambie a su repositorio de código fuente:

   ```
   cd /projects/codecatalyst-eks-source-repository
   ```

1.  Incorpore los cambios más recientes en el flujo de trabajo:

   ```
   git pull
   ```

1. Abra `codecatalyst-eks-source-repository/public-html/index.html`.

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

1. Añada, confirme y envíe:

   ```
   git add .
   git commit -m "update index.html title"
   git push
   ```

   Se inicia automáticamente una ejecución del flujo de trabajo.

1. (Opcional) Escriba:

   ```
   git show HEAD
   ```

   Anote el ID de confirmación del cambio de `index.html`. Este ID de confirmación se etiquetará en la imagen de Docker que se implementará en la ejecución del flujo de trabajo que acaba de iniciar.

1. Observe el progreso de la implementación:

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

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

   1. Elija y **BuildBackend**haga clic en **DeployToEKS** 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 de Amazon EC2 en [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

   1. A la izquierda, cerca de la parte inferior, seleccione **Equilibradores de carga**.

   1. Seleccione el equilibrador de carga que se creó como parte de la implementación de Kubernetes.

   1. Copie y pegue el valor del **nombre de DNS** en la barra de dirección del navegador.

      Aparece la página web “Tutorial Complete\$1” en el navegador, lo que indica que ha implementado correctamente una nueva revisión de la aplicación.

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 7 de este procedimiento.

## Limpieza
<a name="deploy-tut-eks-cleanup"></a>

Debe limpiar su entorno para que no se le cobre innecesariamente por los recursos de almacenamiento y computación utilizados en este tutorial.

**Eliminación**

1. Eliminar el clúster:

   1. En el terminal del entorno de desarrollo, escriba:

     ```
     eksctl delete cluster --region=us-west-2 --name=codecatalyst-eks-cluster
     ```

     Donde:
     + *us-west-2*se sustituye por tu región.
     + *codecatalyst-eks-cluster*se sustituye por el nombre del clúster que ha creado.

     Después de 5 a 10 minutos, se eliminan el clúster y los recursos asociados, incluidos, entre otros, las CloudFormation pilas, los grupos de nodos (en Amazon EC2) y los balanceadores de carga.
**importante**  
Si el `eksctl delete cluster` comando no funciona, es posible que deba actualizar sus AWS credenciales o sus credenciales. `kubectl` Si no está seguro de qué credenciales actualizar, actualice primero las AWS credenciales. Para actualizar sus credenciales de AWS , consulte [¿Cómo puedo corregir los errores «No se pueden localizar las credenciales» y ExpiredToken «»?](troubleshooting-workflows.md#troubleshooting-workflows-auth-errors-eks). Para actualizar sus credenciales de `kubectl`, consulte [¿Cómo puedo corregir los errores de tipo Unable to connect to the server?](troubleshooting-workflows.md#troubleshooting-workflows-unable-connect-eks).

1. En la AWS consola, limpie de la siguiente manera:

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

   1. En IAM Identity Center, elimine:

      1. `codecatalyst-eks-user`

      1. `codecatalyst-eks-permission-set`

   1. En IAM, elimine:
      + `codecatalyst-eks-build-role`
      + `codecatalyst-eks-deploy-role`
      + `codecatalyst-eks-build-policy`
      + `codecatalyst-eks-deploy-policy`

1. En la CodeCatalyst consola, limpie de la siguiente manera:

   1. Elimine `codecatalyst-eks-workflow`.

   1. Elimine `codecatalyst-eks-environment`.

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

   1. Elimine el entorno de desarrollo.

   1. Elimine `codecatalyst-eks-project`.

En este tutorial, aprendió a implementar una aplicación en un servicio de Amazon EKS mediante un CodeCatalyst flujo de trabajo y una acción de **implementación en un clúster de Kubernetes.**

# Incorporación de la acción 'Implementar en clúster de Kubernetes'
<a name="deploy-action-eks-adding"></a>

Siga estas instrucciones para añadir la acción **Implementar en clúster de Kubernetes** a su flujo de trabajo. 

**Antes de empezar**

Antes de añadir la acción **Implementar en clúster de Kubernetes** a su flujo de trabajo, debe tener preparado lo siguiente:

**sugerencia**  
Para configurar estos requisitos previos rápidamente, sigue las instrucciones de [Tutorial: implementación de una aplicación en Amazon EKS](deploy-tut-eks.md).
+ Un clúster de Kubernetes en Amazon EKS. Para obtener más información sobre los clústeres, consulte [Amazon EKS clusters](https://docs.aws.amazon.com/eks/latest/userguide/clusters.html) en la **Guía del usuario de Amazon EKS**.
+ Al menos un Dockerfile que describa cómo ensamblar la aplicación en una imagen de Docker. Para obtener más información acerca de los archivos Docker, consulte la [referencia de Docker](https://docs.docker.com/engine/reference/builder/).
+ Al menos un archivo de manifiesto de Kubernetes, que se denomina *archivo de configuración* o *configuración* en la documentación de Kubernetes. Para obtener más información, consulte [Managing resources](https://kubernetes.io/docs/concepts/cluster-administration/manage-deployment/) en la documentación de Kubernetes.
+ Un rol de IAM que proporcione a la acción **Implementar en clúster de Kubernetes** la capacidad de acceder a su clúster de Amazon EKS e interactuar con él. Para obtener más información, consulte el tema [Role](deploy-action-ref-eks.md#deploy.action.eks.environment.connections.role) en la [Acción 'Implementar en clúster de Kubernetes' de YAML](deploy-action-ref-eks.md).

  Tras crear este rol, debe añadirlo a:
  + Tu ConfigMap archivo de Kubernetes. Para obtener información sobre cómo añadir un rol a un ConfigMap archivo, consulte [Habilitar el acceso principal de IAM a su clúster](https://docs.aws.amazon.com/eks/latest/userguide/add-user-role.html) en la **Guía del usuario de Amazon EKS**.
  + CodeCatalyst. Para obtener información sobre cómo añadir una función de IAM a CodeCatalyst, consulte[Adición de roles de IAM a las conexiones de cuentas](ipa-connect-account-addroles.md).
+ Un CodeCatalyst espacio, un proyecto y un entorno. Tanto el espacio como el entorno deben estar conectados a la AWS cuenta en la que vaya a implementar la aplicación. Para obtener más información, consulte [Creación de un espacio](spaces-create.md), [Crear un proyecto vacío en Amazon CodeCatalyst](projects-create.md#projects-create-empty) y [Implementación en Cuentas de AWS y VPCs](deploy-environments.md).
+ Un repositorio de código fuente compatible con CodeCatalyst. El repositorio almacena los archivos de código fuente de la aplicación, los Dockerfiles y los manifiestos de Kubernetes. Para obtener más información, consulte [Almacene código y colabore en él con los repositorios de código fuente en CodeCatalystAlmacenamiento de código y colaboración con los repositorios de código fuente](source.md).

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

**Incorporación de la acción 'Implementar en clúster de Kubernetes' 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 clúster de Kubernetes** 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 clúster de Kubernetes**. 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 clúster de Kubernetes' de YAML](deploy-action-ref-eks.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 clúster de Kubernetes' 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 clúster de Kubernetes** 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 clúster de Kubernetes**. 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 clúster de Kubernetes' de YAML](deploy-action-ref-eks.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 clúster de Kubernetes'
<a name="deploy-action-eks-variables"></a>

La acción **Implementar en clúster de Kubernetes** 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 de recurso de Amazon (ARN) del clúster de Amazon EKS en el que se implementó durante la ejecución del flujo de trabajo. Ejemplo: `arn:aws:eks:us-west-2:111122223333:cluster/codecatalyst-eks-cluster`  | 
|  deployment-platform  |  El nombre de la plataforma de implementación. Codificado en `AWS:EKS`.  | 
|  metadatos  |  Reservado. Metadatos con formato JSON relacionados con el clúster implementado durante la ejecución del flujo de trabajo.  | 
|  namespace  |  El espacio de nombres de Kubernetes en el que se implementó el clúster. Ejemplo: `default`  | 
|  recursos  |  Reservado. Metadatos con formato JSON relacionados con los recursos implementados durante la ejecución del flujo de trabajo.  | 
|  server  |  El nombre del punto de conexión del servidor de API que puede usar para comunicarse con su clúster mediante herramientas de administración como `kubectl`. Para obtener más información sobre el punto de conexión del servicio de la API, consulte [Control de acceso al punto de conexión del clúster de Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/cluster-endpoint.html) en la **Guía del usuario de Amazon EKS**. Ejemplo: `https://random-string.gr7.us-west-2.eks.amazonaws.com`  | 

# Acción 'Implementar en clúster de Kubernetes' de YAML
<a name="deploy-action-ref-eks"></a>

La siguiente es la definición en YAML de la acción **Implementar en clúster de Kubernetes**. Para obtener información sobre cómo utilizar esta acción, consulte [Implementación en Amazon EKS con un flujo de trabajo](deploy-action-eks.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.   
  DeployToKubernetesCluster\$1nn: 
    Identifier: aws/kubernetes-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: DeployToEKS
    Inputs:
      # Specify a source or an artifact, but not both.
      Sources:
        - source-name-1
      Artifacts:
        - manifest-artifact
    Configuration:
      Namespace: namespace
      Region: us-east-1 
      Cluster: eks-cluster
      Manifests: manifest-path
```

## DeployToKubernetesCluster
<a name="deploy.action.eks.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: `DeployToKubernetesCluster_nn`.

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

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

(*DeployToKubernetesCluster*/**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/kubernetes-deploy@v1`.

Interfaz de usuario correspondiente: Diagrama de flujo de trabajo/DeployToKubernetesCluster\$1nn/etiqueta **aws/kubernetes-deploy@v1**

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

(*DeployToKubernetesCluster*/**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.eks.computename"></a>

(*DeployToKubernetesCluster*/**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.eks.computetype"></a>

(*DeployToKubernetesCluster*/Compute/**Type**)

(Obligatorio si se incluye [Compute](#deploy.action.eks.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 informático tab/Advanced **

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

(*DeployToKubernetesCluster*/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.eks.timeout"></a>

(*DeployToKubernetesCluster*/**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.eks.environment"></a>

(*DeployToKubernetesCluster*/**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.eks.environment.name"></a>

(*DeployToKubernetesCluster*/Environment/**Name**)

(Obligatorio si se incluye [Environment](#deploy.action.eks.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.eks.environment.connections"></a>

(*DeployToKubernetesCluster*/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.eks.environment.connections.name"></a>

(*DeployToKubernetesCluster*/Environment/Connections/**Name**)

(Opcional)

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.eks.environment.connections.role"></a>

(*DeployToKubernetesCluster*/Environment/Connections/**Role**)

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

Especifique el nombre del rol de IAM que la acción **Implementar en clúster de Kubernetes** 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": [
          {
              "Effect": "Allow",
              "Action": [
                  "eks:DescribeCluster",
                  "eks:ListClusters"
              ],
              "Resource": "*"
          }
      ]
  }
  ```

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

Asegúrese de añadir este rol a:
+ Su conexión de cuenta. Para obtener más información sobre cómo añadir un rol de IAM a una conexión de cuenta, consulte [Adición de roles de IAM a las conexiones de cuentas](ipa-connect-account-addroles.md).
+ Tu Kubernetes. ConfigMap Para obtener más información sobre cómo añadir un rol de IAM a un ConfigMap, consulte [Administrar usuarios y roles de IAM](https://eksctl.io/usage/iam-identity-mappings/) en la documentación. `eksctl`

**sugerencia**  
Consulte también las [Tutorial: implementación de una aplicación en Amazon EKS](deploy-tut-eks.md) instrucciones sobre cómo añadir un rol de IAM a una conexión de cuenta y. ConfigMap

**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.eks.inputs"></a>

(*DeployToKubernetesCluster*/**Inputs**)

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

La sección `Inputs` define los datos que necesita la acción `DeployToKubernetesCluster` 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 EKS**.

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

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

(*DeployToKubernetesCluster*/Inputs/**Sources**)

(Obligatorio si el archivo de manifiesto está almacenado en un repositorio de código fuente)

Si el archivo o los archivos de manifiesto de Kubernetes están almacenados en un repositorio de código fuente, especifique la etiqueta de dicho repositorio. Actualmente, la única etiqueta admitida es `WorkflowSource`.

Si los archivos de manifiesto no están incluidos en un repositorio de código fuente, deben 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.eks.inputs.artifacts"></a>

(*DeployToKubernetesCluster*/Inputs/**Artifacts**)

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

Si el archivo o los archivos de manifiesto de Kubernetes están incluidos en un artefacto generado por una acción anterior, especifique ese artefacto aquí. Si los archivos de manifiesto no están incluidos en un artefacto, deben 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.eks.configuration"></a>

(*DeployToKubernetesCluster*/**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**

## Namespace
<a name="deploy.action.eks.namespace"></a>

(*DeployToKubernetesCluster*/Configuration/**Namespace**)

(Opcional)

Especifique el espacio de nombres de Kubernetes en el que se implementará la aplicación de Kubernetes. Use `default` si no utiliza espacios de nombres con el clúster. Para obtener más información sobre los espacios de nombres, consulte [Subdividing your cluster using Kubernetes namespaces](https://kubernetes.io/docs/tasks/administer-cluster/namespaces/#subdividing-your-cluster-using-kubernetes-namespaces) en la documentación de Kubernetes.

Si omite el espacio de nombres, se usará el valor de `default`.

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

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

(*DeployToKubernetesCluster*/Configuration/**Region**)

(Obligatorio) 

Especifique la AWS región en la que residen el clúster y el servicio de Amazon EKS. 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#region-names-codes) en la *Referencia general de AWS*.

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

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

(*DeployToKubernetesCluster*/Configuration/**Cluster**)

(Obligatorio)

Especifique el nombre de un clúster de Amazon EKS existente. La acción **Implementar en clúster de Kubernetes** implementará la aplicación basada en contenedores en este clúster. Para obtener más información sobre los clústeres de Amazon EKS, consulte [Clústeres](https://docs.aws.amazon.com/eks/latest/userguide/clusters.html) en la **Guía del usuario de Amazon EKS**.

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

## Manifests
<a name="deploy.action.eks.manifest"></a>

(*DeployToKubernetesCluster*/Configuration/**Manifests**)

(Obligatorio)

Especifique la ruta a los archivos de manifiesto de Kubernetes con formato YAML, que se denominan *archivos de configuración*, *archivos config* o, simplemente, *configuraciones* en la documentación de Kubernetes.

Si utiliza varios archivos de manifiesto, colóquelos en una sola carpeta y haga referencia a esa carpeta. Kubernetes procesa los archivos de manifiesto de forma alfanumérica, así que asegúrese de anteponer números o letras en orden ascendente a los nombres de los archivos para controlar el orden de procesamiento. Por ejemplo:

`00-namespace.yaml`

`01-deployment.yaml`

Si los archivos de manifiesto residen en el repositorio de código fuente, la ruta es relativa a la carpeta raíz del repositorio de código fuente. Si los archivos residen en un artefacto de una acción del flujo de trabajo anterior, la ruta es relativa a la carpeta raíz del artefacto. 

Ejemplos:

`Manifests/`

`deployment.yaml`

`my-deployment.yml`

No utilice comodines (`*`).

**nota**  
No se admiten [gráficos de Helm](https://helm.sh/docs/topics/charts/) ni [archivos kustomization](https://kubernetes.io/docs/tasks/manage-kubernetes-objects/kustomization/).

Para obtener más información sobre los archivos de manifiesto, consulte [Organizing resource configurations](https://kubernetes.io/docs/concepts/cluster-administration/manage-deployment/#organizing-resource-configurations) en la documentación de Kubernetes.

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

# Implementación de una CloudFormation pila
<a name="deploy-action-cfn"></a>

En esta sección se describe cómo implementar una AWS CloudFormation pila mediante un CodeCatalyst flujo de trabajo. Para ello, debe añadir la acción **Implementar CloudFormation pila** a su flujo de trabajo. La acción despliega una CloudFormation pila de recursos en AWS función de la plantilla que proporciones. La plantilla puede ser una de las siguientes:
+ CloudFormation plantilla: para obtener más información, consulte [Trabajar con CloudFormation plantillas](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-guide.html).
+ AWS SAM plantilla: para obtener más información, consulte la [especificación AWS Serverless Application Model (AWS SAM)](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-specification.html).
**nota**  
Para usar una AWS SAM plantilla, primero debe empaquetar la AWS SAM aplicación mediante la `[sam package](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-package.html)` operación. Para ver un tutorial que te muestra cómo empaquetar este paquete automáticamente como parte de un CodeCatalyst flujo de trabajo de Amazon, consulta[Tutorial: implementación de una aplicación sin servidor](deploy-tut-lambda.md).

Si la pila ya existe, la acción ejecuta la CloudFormation `[CreateChangeSet](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateChangeSet.html)` operación y, a continuación, la `[ExecuteChangeSet](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_ExecuteChangeSet.html)` operación. A continuación, la acción espera a que se implementen los cambios y se marca como correcta o fallida, en función de los resultados.

Usa la acción **Implementar CloudFormation pila** si ya tienes una AWS SAM plantilla CloudFormation o plantilla que contenga los recursos que te gustaría implementar, o si planeas generar una automáticamente como parte de una [acción de creación](build-add-action.md) de un flujo de trabajo con herramientas como AWS SAM y [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/latest/guide/home.html).

No hay restricciones en cuanto a la plantilla que puedes usar: puedes crearla CloudFormation o AWS SAM usarla con la acción **Implementar CloudFormation pila**.

**sugerencia**  
Para ver un tutorial que muestra cómo implementar una aplicación sin servidor mediante la acción **Implementar CloudFormation pila**, consulte. [Tutorial: implementación de una aplicación sin servidor](deploy-tut-lambda.md)

**Topics**
+ [Imagen de tiempo de ejecución utilizada por la acción «Implementar pila» CloudFormation](#deploy-action-cfn-runtime)
+ [Tutorial: implementación de una aplicación sin servidor](deploy-tut-lambda.md)
+ [Añadir la acción «Desplegar CloudFormation pila»](deploy-action-cfn-adding.md)
+ [Configuración de reversiones](deploy-consumption-enable-alarms.md)
+ [Variables de «implementar CloudFormation pila»](deploy-action-cfn-variables.md)
+ [Acción «Desplegar CloudFormation pila» YAML](deploy-action-ref-cfn.md)

## Imagen de tiempo de ejecución utilizada por la acción «Implementar pila» CloudFormation
<a name="deploy-action-cfn-runtime"></a>

La acción **Implementar CloudFormation pila** 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 sin servidor
<a name="deploy-tut-lambda"></a>

En este tutorial, aprenderá a crear, probar e implementar una aplicación sin servidor como una CloudFormation pila mediante un flujo de trabajo.

La aplicación de este tutorial es una aplicación web sencilla que genera un mensaje “Hello World”. Se compone de una AWS Lambda función y un Amazon API Gateway, y se crea mediante [AWS Serverless Application Model (AWS SAM)](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html), que es una extensión de [CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html).

**Topics**
+ [Requisitos previos](#deploy-tut-lambda-cfn-prereqs)
+ [Paso 1: creación de un repositorio de código fuente](#deploy-tut-lambda-cfn-source)
+ [Paso 2: Crear roles AWS](#deploy-tut-lambda-cfn-roles)
+ [Paso 3: Añada AWS funciones a CodeCatalyst](#deploy-tut-lambda-cfn-roles-add)
+ [Paso 4: creación de un bucket de Amazon S3](#deploy-tut-lambda-cfn-s3)
+ [Paso 5: incorporación de archivos de código fuente](#deploy-tut-lambda-cfn-files)
+ [Paso 6: creación y ejecución de un flujo de trabajo](#deploy-tut-lambda-cfn-workflow)
+ [Paso 7: realización de un cambio](#deploy-tut-lambda-cfn-change)
+ [Limpieza](#deploy-tut-lambda-cfn-clean-up)

## Requisitos previos
<a name="deploy-tut-lambda-cfn-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-cfn-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-cfn-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: creación de un repositorio de código fuente
<a name="deploy-tut-lambda-cfn-source"></a>

En este paso, crearás un repositorio de origen en CodeCatalyst. Este repositorio se utiliza para almacenar los archivos de código fuente del tutorial, como el archivo de funciones de Lambda. 

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. En CodeCatalyst, 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-cfn-source-repository
   ```

1. Seleccione **Crear**.

Ahora ha creado un repositorio llamado `codecatalyst-cfn-source-repository`.

## Paso 2: Crear roles AWS
<a name="deploy-tut-lambda-cfn-roles"></a>

En este paso, creará las siguientes funciones de AWS IAM:
+ **Función de implementación**: otorga a la acción CodeCatalyst **Deploy CloudFormation stack** el permiso para acceder a la AWS cuenta y al CloudFormation servicio en los que se implementará la aplicación sin servidor. La acción **Implementar CloudFormation pila** forma parte de tu flujo de trabajo.
+ **Función de creación**: concede a la acción de CodeCatalyst creación el permiso para acceder a su AWS cuenta y escribir en Amazon S3, donde se almacenará el paquete de aplicaciones sin servidor. La acción de compilación forma parte de su flujo de trabajo.
+ **Función de pila**: otorga CloudFormation permiso para leer y modificar los recursos especificados en la AWS SAM plantilla que proporcionará más adelante. También concede permiso a CloudWatch.

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 tres 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 tres roles indicados anteriormente.

**nota**  
También se requiere un [rol de ejecución de Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html), pero no es necesario que lo cree ahora porque el archivo `sam-template.yml` lo crea automáticamente cuando ejecuta el flujo de trabajo en el paso 5.



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

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

   1. Elimine el código existente.

   1. Pegue el siguiente código:
**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-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-deploy-policy` y active su casilla de verificación.

   1. Elija **Siguiente**.

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

      ```
      codecatalyst-deploy-role
      ```

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

      ```
      CodeCatalyst deploy role
      ```

   1. Seleccione **Crear rol**.

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

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

   Ahora ha creado el rol de implementación con los permisos adecuados y ha obtenido su ARN.

**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:
**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-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-build-policy` y active su casilla de verificación.

   1. Elija **Siguiente**.

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

      ```
      codecatalyst-build-role
      ```

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

      ```
      CodeCatalyst build role
      ```

   1. Seleccione **Crear rol**.

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

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

   Ahora ha creado el rol de compilación con los permisos adecuados y ha obtenido su ARN.<a name="deploy-tut-lambda-cfn-roles-stack"></a>

**Creación de un rol de pila**

1. Inicia sesión AWS con la cuenta en la que quieres implementar tu stack.

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

1. Cree el rol de pila de la siguiente manera:

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

   1. Elija **Crear rol**.

   1. Elija **Servicio de AWS **.

   1. En la sección **Casos de uso**, elige una opción **CloudFormation**de la lista desplegable.

   1. Seleccione el botón de opción **CloudFormation**.

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

   1. En el cuadro de búsqueda, busque las siguientes políticas de permisos y, a continuación, active las casillas de verificación correspondientes.
**nota**  
Si busca una política y no aparece, asegúrese de seleccionar **Borrar filtros** e inténtelo de nuevo.
      + **CloudWatchFullAccess**
      + **AWS CloudFormationFullAccess**
      + **IAMFullAcceso**
      + **AWS Lambda\$1 FullAccess**
      + **APIGatewayAdministrador de Amazon**
      + **Amazon S3 FullAccess**
      + **AmazonEC2ContainerRegistryFullAccess**

      La primera política permite el acceso CloudWatch a para permitir la reversión de las pilas cuando se produce una alarma.

      Las políticas restantes permiten acceder AWS SAM a los servicios y recursos de la pila que se implementarán en este tutorial. Para obtener más información, consulte [Permisos](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-permissions.html) en la *Guía para desarrolladores de AWS Serverless Application Model *.

   1. Elija **Siguiente**.

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

      ```
      codecatalyst-stack-role
      ```

   1. Seleccione **Crear rol**.

1. Obtenga el ARN del rol de pila 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-stack-role`).

   1. Elija el rol de la lista.

   1. En la sección **Resumen**, copie el valor de **ARN**. Lo necesitará más adelante.

   Ahora ha creado el rol de pila con los permisos adecuados y ha obtenido su ARN.

## Paso 3: Añada AWS funciones a CodeCatalyst
<a name="deploy-tut-lambda-cfn-roles-add"></a>

En este paso, agrega el rol de creación (`codecatalyst-build-role`) y el rol de implementación (`codecatalyst-deploy-role`) a la conexión de CodeCatalyst cuentas de su espacio.

**nota**  
No es necesario añadir el rol de pila (`codecatalyst-stack-role`) a la conexión. Esto se debe a que el rol de pila lo usa *CloudFormation*(no CodeCatalyst), *después de* que ya se haya establecido una conexión entre CodeCatalyst y AWS utilizando el rol de despliegue. Como el rol de pila no lo utiliza CodeCatalyst para acceder a él AWS, no es necesario que esté asociado a una conexión de cuenta.

**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-build-role` y, a continuación, elija **Agregar rol**.

1. Seleccione **Agregar rol de IAM**, seleccione **Agregar un rol existente que haya creado en IAM** y, en la lista desplegable, elija `codecatalyst-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 4: creación de un bucket de Amazon S3
<a name="deploy-tut-lambda-cfn-s3"></a>

En este paso, creará un bucket de Amazon S3 en el que se almacenará el archivo .zip del paquete de implementación de la aplicación sin servidor.

**Creación de un bucket de Amazon S3**

1. Abra la consola de Amazon S3 en [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. En el panel principal, elija **Crear bucket**.

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

   ```
   codecatalyst-cfn-s3-bucket
   ```

1. En **AWS Región**, seleccione una región. En este tutorial, se asume que ha elegido **Oeste de EE. UU. (Oregón) us-west-2**. Para obtener más información sobre las regiones admitidas en Amazon S3, consulte [Puntos de conexión y cuotas de Amazon Simple Storage Service](https://docs.aws.amazon.com/general/latest/gr/s3.html) en la *Referencia general de AWS*.

1. En la parte inferior de la página, elija **Crear bucket**.

Ahora ha creado un bucket llamado **codecatalyst-cfn-s3-bucket** en la región Oeste de EE. UU. (Oregón) us-west-2.

## Paso 5: incorporación de archivos de código fuente
<a name="deploy-tut-lambda-cfn-files"></a>

En este paso, añadirá varios archivos fuente de la aplicación a su repositorio CodeCatalyst de código fuente. La carpeta `hello-world` contiene los archivos de la aplicación que va a implementar. La carpeta `tests` contiene las pruebas unitarias. La estructura de carpetas es la siguiente:

```
.
|— hello-world
|  |— tests
|     |— unit
|        |— test-handler.js
|  |— app.js
|— .npmignore
|— package.json
|— sam-template.yml
|— setup-sam.sh
```

### Archivo .npmignore
<a name="deploy-tut-lambda-cfn-files-npmignore"></a>

El `.npmignore` archivo indica qué archivos y carpetas debe excluir npm del paquete de la aplicación. En este tutorial, npm excluye la carpeta `tests` porque no forma parte de la aplicación.

**Adición del .npmignore**

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

1. Elija el proyecto, `codecatalyst-cfn-project`.

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

1. En la lista de repositorios de código fuente, elija su repositorio, `codecatalyst-cfn-source-repository`. 

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

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

   ```
   .npmignore
   ```

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

   ```
   tests/*
   ```

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

   Ahora ha creado un archivo llamado `.npmignore` en la raíz del repositorio.

### Archivo package.json
<a name="deploy-tut-lambda-cfn-files-package-json"></a>

El archivo `package.json` contiene metadatos importantes sobre su proyecto de Node, como el nombre del proyecto, el número de versión, la descripción, las dependencias y otros detalles que describen cómo interactuar con la aplicación y cómo ejecutarla.

El archivo `package.json` de este tutorial incluye una lista de dependencias y un script `test`. El script de prueba hace lo siguiente:
+ Mediante [mocha](https://mochajs.org/), el script de prueba ejecuta las pruebas unitarias especificadas en `hello-world/tests/unit/` y escribe los resultados en un archivo `junit.xml` mediante el generador de informes [xunit]().
+ Usando [Istanbul (nyc)](https://istanbul.js.org/), el script de prueba genera un informe de cobertura de código (`clover.xml`) utilizando el generador de informes [clover](https://openclover.org/doc/manual/4.2.0/general--about-openclover.html). Para obtener más información, consulte [Using alternative reporters](https://istanbul.js.org/docs/advanced/alternative-reporters/#clover) en la documentación de Istanbul.

**Adición del archivo package.json**

1. En el repositorio, en **Archivos**, seleccione **Crear archivo**.

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

   ```
   package.json
   ```

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

   ```
   {
     "name": "hello_world",
     "version": "1.0.0",
     "description": "hello world sample for NodeJS",
     "main": "app.js",
     "repository": "https://github.com/awslabs/aws-sam-cli/tree/develop/samcli/local/init/templates/cookiecutter-aws-sam-hello-nodejs",
     "author": "SAM CLI",
     "license": "MIT",
     "dependencies": {
       "axios": "^0.21.1",
       "nyc": "^15.1.0"
     },
     "scripts": {
       "test": "nyc --reporter=clover mocha hello-world/tests/unit/ --reporter xunit --reporter-option output=junit.xml"
     },
     "devDependencies": {
       "aws-sdk": "^2.815.0",
       "chai": "^4.2.0",
       "mocha": "^8.2.1"
     }
   }
   ```

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

   Ahora ha añadido un archivo llamado `package.json` en la raíz del repositorio.

### Archivo sam-template.yml
<a name="deploy-tut-lambda-cfn-files-sam-template-yml"></a>

El archivo `sam-template.yml` contiene las instrucciones para implementar la función de Lambda y la instancia de API Gateway y configurarlas juntas. Sigue la [especificación de la AWS Serverless Application Model plantilla](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-specification.html), que amplía la especificación CloudFormation de la plantilla.

En este tutorial, utilizarás una AWS SAM plantilla en lugar de una CloudFormation plantilla normal porque AWS SAM ofrece un útil tipo de recurso [AWS: :Serverless: :Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html). Este tipo realiza una gran parte behind-the-scenes de la configuración que normalmente hay que escribir para usar la sintaxis básica. CloudFormation Por ejemplo, el recurso `AWS::Serverless::Function` crea una función de Lambda, un rol de ejecución de Lambda y asignaciones de orígenes de eventos que inician la función. Tienes que codificar todo esto si quieres escribirlo usando la básica CloudFormation.

Aunque en este tutorial se utiliza una plantilla prediseñada, puede generar una como parte de su flujo de trabajo mediante una acción de compilación. Para obtener más información, consulte [Implementación de una CloudFormation pila](deploy-action-cfn.md).

**Adición del archivo sam-template.yml**

1. En el repositorio, en **Archivos**, seleccione **Crear archivo**.

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

   ```
   sam-template.yml
   ```

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

   ```
   AWSTemplateFormatVersion: '2010-09-09'
   Transform: AWS::Serverless-2016-10-31
   Description: >
     serverless-api
   
     Sample SAM Template for serverless-api
     
   # More info about Globals: https://github.com/awslabs/serverless-application-model/blob/master/docs/globals.rst
   Globals:
     Function:
       Timeout: 3
   
   Resources:
     HelloWorldFunction:
       Type: AWS::Serverless::Function # For details on this resource type, see https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#awsserverlessfunction
       Properties:
         CodeUri: hello-world/
         Handler: app.lambdaHandler
         Runtime: nodejs12.x
         Events:
           HelloWorld:
             Type: Api # For details on this event source type, see https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#api
             Properties:
               Path: /hello
               Method: get
   
   Outputs:
     # ServerlessRestApi is an implicit API created out of the events key under Serverless::Function
     # Find out about other implicit resources you can reference within AWS SAM at
     # https://github.com/awslabs/serverless-application-model/blob/master/docs/internals/generated_resources.rst#api
     HelloWorldApi:
       Description: "API Gateway endpoint URL for the Hello World function"
       Value: !Sub "https://${ServerlessRestApi}.execute-api.${AWS::Region}.amazonaws.com/Prod/hello/"
     HelloWorldFunction:
       Description: "Hello World Lambda function ARN"
       Value: !GetAtt HelloWorldFunction.Arn
     HelloWorldFunctionIamRole:
       Description: "Implicit Lambda execution role created for the Hello World function"
       Value: !GetAtt HelloWorldFunctionRole.Arn
   ```

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

   Ahora ha añadido un archivo llamado `sam-template.yml` en la carpeta raíz del repositorio.

### Archivo setup-sam.sh
<a name="deploy-tut-lambda-cfn-files-setup-sam"></a>

El `setup-sam.sh` archivo contiene las instrucciones para descargar e instalar la utilidad AWS SAM CLI. El flujo de trabajo usa esta utilidad para empaquetar el código fuente de `hello-world`.

**Adición del archivo setup-sam.sh**

1. En el repositorio, en **Archivos**, seleccione **Crear archivo**.

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

   ```
   setup-sam.sh
   ```

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

   ```
   #!/usr/bin/env bash
   echo "Setting up sam"
   
   yum install unzip -y
   
   curl -LO https://github.com/aws/aws-sam-cli/releases/latest/download/aws-sam-cli-linux-x86_64.zip
   unzip -qq aws-sam-cli-linux-x86_64.zip -d sam-installation-directory
   
   ./sam-installation-directory/install; export AWS_DEFAULT_REGION=us-west-2
   ```

   En el código anterior, *us-west-2* sustitúyalo por tu AWS región.

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

   Ahora ha añadido un archivo llamado `setup-sam.sh` en la raíz del repositorio.

### Archivo app.js
<a name="deploy-tut-lambda-cfn-files-app-js"></a>

El archivo `app.js` contiene el código de la función de Lambda. En este tutorial, el código devuelve el texto `hello world`.

**Adición del archivo app.js**

1. En el repositorio, en **Archivos**, seleccione **Crear archivo**.

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

   ```
   hello-world/app.js
   ```

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

   ```
   // const axios = require('axios')
   // const url = 'http://checkip.amazonaws.com/';
   let response;
   
   /**
    *
    * Event doc: https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html#api-gateway-simple-proxy-for-lambda-input-format
    * @param {Object} event - API Gateway Lambda Proxy Input Format
    *
    * Context doc: https://docs.aws.amazon.com/lambda/latest/dg/nodejs-prog-model-context.html 
    * @param {Object} context
    *
    * Return doc: https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html
    * @returns {Object} object - API Gateway Lambda Proxy Output Format
    * 
    */
   exports.lambdaHandler = async (event, context) => {
       try {
           // const ret = await axios(url);
           response = {
               'statusCode': 200,
               'body': JSON.stringify({
                   message: 'hello world',
                   // location: ret.data.trim()
               })
           }
       } catch (err) {
           console.log(err);
           return err;
       }
   
       return response
   };
   ```

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

   Ahora ha creado una carpeta llamada `hello-world` y un archivo llamado `app.js`.

### Archivo test-handler.js
<a name="deploy-tut-lambda-cfn-files-test-handler-js"></a>

El archivo `test-handler.js` contiene pruebas unitarias para la función de Lambda.

**Adición del archivo test-handler.js**

1. En el repositorio, en **Archivos**, seleccione **Crear archivo**.

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

   ```
   hello-world/tests/unit/test-handler.js
   ```

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

   ```
   'use strict';
   
   const app = require('../../app.js');
   const chai = require('chai');
   const expect = chai.expect;
   var event, context;
   
   describe('Tests index', function () {
       it('verifies successful response', async () => {
           const result = await app.lambdaHandler(event, context)
   
           expect(result).to.be.an('object');
           expect(result.statusCode).to.equal(200);
           expect(result.body).to.be.an('string');
   
           let response = JSON.parse(result.body);
   
           expect(response).to.be.an('object');
           expect(response.message).to.be.equal("hello world");
           // expect(response.location).to.be.an("string");
       });
   });
   ```

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

   Ahora ha añadido un archivo llamado `test-handler.js` en la carpeta `hello-world/tests/unit`.

Ahora ha añadido todos los archivos de código fuente.

Dedique unos minutos a comprobar su trabajo y a asegurarse de que ha colocado todos los archivos en las carpetas correctas. La estructura de carpetas es la siguiente:

```
.
|— hello-world
|  |— tests
|     |— unit
|        |— test-handler.js
|  |— app.js
|— .npmignore
|— README.md
|— package.json
|— sam-template.yml
|— setup-sam.sh
```

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

En este paso, creará un flujo de trabajo que empaquetará el código fuente de Lambda y lo implementará. 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 prueba (`Test`): al activarse, esta acción instala el [administrador de paquetes de Node (npm)](https://www.npmjs.com/) y, a continuación, ejecuta el comando `npm run test`. Este comando indica a npm que ejecute el script `test` definido en el archivo `package.json`. El script `test`, a su vez, ejecuta las pruebas unitarias y genera dos informes: un informe de prueba (`junit.xml`) y un informe de cobertura de código (`clover.xml`). Para obtener más información, consulte [Archivo package.json](#deploy-tut-lambda-cfn-files-package-json).

  A continuación, la acción de prueba transforma los informes XML en CodeCatalyst informes y los muestra en la CodeCatalyst consola, en la pestaña **Informes** de la acción de prueba.

  Para obtener más información sobre la acción de prueba, consulte [Pruebas con flujos de trabajoPruebas con flujos de trabajo](test-workflow-actions.md).
+ Una acción de compilación (`BuildBackend`): al finalizar la acción de prueba, la acción de compilación descarga e instala la AWS SAM CLI, empaqueta el `hello-world` código fuente y copia el paquete en su bucket de Amazon S3, donde el servicio Lambda espera que esté. La acción también genera un nuevo archivo de AWS SAM plantilla llamado `sam-template-packaged.yml` y lo coloca en un artefacto de salida denominado. `buildArtifact`

  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 despliegue (`DeployCloudFormationStack`): al finalizar la acción de creación, la acción de despliegue busca el artefacto de salida generado por la acción de creación (`buildArtifact`), encuentra la AWS SAM plantilla que contiene y, a continuación, ejecuta la plantilla. La AWS SAM plantilla crea una pila que despliega la aplicación sin servidor.

**Para crear un flujo de trabajo**

1. 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-cfn-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 2: Crear roles AWS](#deploy-tut-lambda-cfn-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-cfn-workflow
   SchemaVersion: 1.0
   
   Triggers:
     - Type: PUSH
       Branches:
         - main   
   Actions:
     Test:
       Identifier: aws/managed-test@v1
       Inputs:
         Sources:
           - WorkflowSource
       Outputs:
         Reports:
           CoverageReport:
             Format: CLOVERXML
             IncludePaths:
               - "coverage/*"
           TestReport:
             Format: JUNITXML
             IncludePaths:
               - junit.xml
       Configuration:
         Steps:
           - Run: npm install
           - Run: npm run test  
     BuildBackend:
       Identifier: aws/build@v1
       DependsOn:
         - Test
       Environment:
         Name: codecatalyst-cfn-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-build-role
       Inputs:
         Sources:
           - WorkflowSource
       Configuration: 
         Steps:
           - Run: . ./setup-sam.sh
           - Run: sam package --template-file sam-template.yml --s3-bucket codecatalyst-cfn-s3-bucket --output-template-file sam-template-packaged.yml --region us-west-2
       Outputs:
         Artifacts:
           - Name: buildArtifact
             Files:
               - "**/*"
     DeployCloudFormationStack:
       Identifier: aws/cfn-deploy@v1
       DependsOn: 
         - BuildBackend
       Environment:
         Name: codecatalyst-cfn-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-deploy-role
       Inputs:
         Artifacts:
           - buildArtifact
         Sources: []
       Configuration:
         name: codecatalyst-cfn-stack
         region: us-west-2
         role-arn: arn:aws:iam::111122223333:role/StackRole
         template: ./sam-template-packaged.yml
         capabilities: CAPABILITY_IAM,CAPABILITY_AUTO_EXPAND
   ```

   En el código anterior, sustituya:
   + Ambas instancias o *codecatalyst-cfn-environment* con el nombre de su entorno.
   + 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 3: Añada AWS funciones a CodeCatalyst](#deploy-tut-lambda-cfn-roles-add).
   + *codecatalyst-build-role* por el nombre del rol de compilación que creó en [Paso 2: Crear roles AWS](#deploy-tut-lambda-cfn-roles).
   + *codecatalyst-cfn-s3-bucket*con el nombre del bucket de Amazon S3 en el que lo creaste[Paso 4: creación de un bucket de Amazon S3](#deploy-tut-lambda-cfn-s3).
   + Ambas instancias *us-west-2* con la región en la que reside su bucket de Amazon S3 (primera instancia) y en la que se implementará su pila (segunda instancia). Estas regiones pueden ser diferentes. En este tutorial se asume que ambas regiones están establecidas en `us-west-2`. Para obtener más información sobre las regiones compatibles con Amazon S3 CloudFormation, consulte los [puntos de enlace y las cuotas del *Referencia general de AWS*servicio](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) en.
   + *codecatalyst-deploy-role* por el nombre del rol de implementación que creó en [Paso 2: Crear roles AWS](#deploy-tut-lambda-cfn-roles).
   + *codecatalyst-cfn-environment*con el nombre del entorno en [Requisitos previos](#deploy-tut-lambda-cfn-prereqs) el que creó.
   + *arn:aws:iam::111122223333:role/StackRole*con el nombre de recurso de Amazon (ARN) del rol de pila en el que creaste. [Paso 2: Crear roles AWS](#deploy-tut-lambda-cfn-roles)
**nota**  
Si decidió no crear funciones de creación, implementación y apilamiento *codecatalyst-build-role**codecatalyst-deploy-role*, sustituya y *arn:aws:iam::111122223333:role/StackRole* por el nombre o el ARN de la `CodeCatalystWorkflowDevelopmentRole-spaceName` función. Para obtener más información acerca de este rol, consulte [Paso 2: Crear roles AWS](#deploy-tut-lambda-cfn-roles).

   Para obtener información sobre las propiedades del código mostrado anteriormente, consulte el [Acción «Desplegar CloudFormation pila» YAML](deploy-action-ref-cfn.md).

1. (Opcional) Seleccione **Validar** para asegurarse de que el código de YAML del flujo de trabajo 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 **Nombre del archivo de flujo de trabajo**, deje el valor predeterminado, `codecatalyst-cfn-workflow`.

   1. En **Mensaje de confirmación**, escriba:

      ```
      add initial workflow file
      ```

   1. En **Repositorio**, elija **codecatalyst-cfn-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 `codecatalyst-cfn-workflow.yaml` en su repositorio de código fuente, el desencadenador inició la ejecución del flujo de trabajo.

**Consulta de la ejecución del flujo de trabajo en curso**

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

1. Elija el flujo de trabajo que acaba de crear: `codecatalyst-cfn-workflow`.

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

1. En la columna **ID de ejecución**, elija el ID de ejecución.

1. Elija **Prueba** para ver el progreso de las pruebas.

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

1. Elija **DeployCloudFormationStack**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).

1. Cuando finalice la **DeployCloudFormationStack**acción, haga lo siguiente:
   + Si la ejecución del flujo de trabajo se realizó correctamente, vaya al siguiente procedimiento.
   + Si la ejecución del flujo de trabajo falló en la **prueba** o la **BuildBackend**acción, selecciona **Registros** para solucionar el problema.
   + Si la ejecución del flujo de trabajo falló en la **DeployCloudFormationStack**acción, elija la acción de despliegue y, a continuación, elija la pestaña **Resumen**. Desplázate hasta la sección de **CloudFormation eventos** para ver el mensaje de error detallado. Si se ha producido una reversión, elimina la `codecatalyst-cfn-stack` pila a través de la CloudFormation consola AWS antes de volver a ejecutar el flujo de trabajo.

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

1. Tras una implementación correcta, seleccione **Variables (7)** en la barra de menú horizontal situada cerca de la parte superior. (No elija **Variables** en el panel de la derecha).

1. Junto a **HelloWorldApi**, pega la `https://` URL en un navegador.

   Aparece un mensaje JSON **hello world** de la función de Lambda, que indica que el flujo de trabajo implementó y configuró correctamente la función de Lambda y la instancia de API Gateway.
**sugerencia**  
Puedes hacer que se CodeCatalyst muestre esta URL en el diagrama de flujo de trabajo con unas cuantas configuraciones pequeñas. Para obtener más información, consulte [Visualización de la URL de la aplicación en el diagrama de flujo de trabajo](deploy-app-url.md).

**Verificación de los resultados de las pruebas unitarias y la cobertura del código**

1. En el diagrama de flujo de trabajo, elija **Probar** y, a continuación, elija **Informes**.

1. Elija **TestReport**ver los resultados de las pruebas unitarias o los detalles de la cobertura del código de los archivos que se están probando, en este caso, `app.js` y`test-handler.js`. **CoverageReport**

**Verificación de los recursos implementados**

1. Inicie sesión en la consola de API Gateway Consola de administración de AWS y ábrala en [https://console.aws.amazon.com/apigateway/](https://console.aws.amazon.com/apigateway/). 

1. Observe la **codecatalyst-cfn-stack**API que creó la AWS SAM plantilla. El nombre de la API proviene del valor `Configuration/name` del archivo de definición del flujo de trabajo (`codecatalyst-cfn-workflow.yaml`).

1. Abre la AWS Lambda consola en [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).

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

1. Elija su función de Lambda, `codecatalyst-cfn-stack-HelloWorldFunction-string`.

1. Puede ver cómo la instancia de API Gateway es un desencadenador de la función. Esta integración se configuró automáticamente según el tipo de AWS SAM `AWS::Serverless::Function` recurso.

## Paso 7: realización de un cambio
<a name="deploy-tut-lambda-cfn-change"></a>

En este paso, realizará un cambio en el código fuente de Lambda y lo confirmará. Esta confirmación inicia una nueva ejecución del flujo de trabajo. Esta ejecución implementa la nueva función de Lambda en un esquema azul-verde que usa la configuración de cambio de tráfico predeterminada especificada en la consola de Lambda.

**Realización de un cambio en el código fuente de Lambda**

1. En CodeCatalyst, navega hasta tu proyecto.

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

1. Elija su repositorio de código fuente `codecatalyst-cfn-source-repository`.

1. Cambie el archivo de la aplicación:

   1. Elija la carpeta `hello-world`.

   1. Seleccione el archivo `app.js`.

   1. Seleccione **Editar**.

   1. En la línea 23, cambie `hello world` por **Tutorial complete\$1**

   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. Esta ejecución fallará porque no ha actualizado las pruebas unitarias para que reflejen el cambio de nombre.

1. Actualice las pruebas unitarias:

   1. Elija `hello-world\tests\unit\test-handler.js`.

   1. Seleccione **Editar**.

   1. En la línea 19, cambie `hello world` por **Tutorial complete\$1**

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

      La confirmación hace que se inicie otra ejecución del flujo de trabajo. Esta ejecución se realizará correctamente.

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

1. Elija `codecatalyst-cfn-workflow` y, a continuación, **Ejecuciones**.

1. Elija el ID de ejecución de la última ejecución. Debería estar todavía en curso.

1. Selecciona **Probar** y verás el progreso **DeployCloudFormationStack**de la ejecución del flujo de trabajo. **BuildBackend**

1. Cuando finalice el flujo de trabajo, elija **Variables** (7) cerca de la parte superior.

1. Junto a **HelloWorldApi**, pega la `https://` URL en un navegador.

   Aparece un mensaje `Tutorial complete!` en el navegador, lo que indica que la aplicación se ha implementado correctamente.

## Limpieza
<a name="deploy-tut-lambda-cfn-clean-up"></a>

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

**Para limpiar en la CodeCatalyst consola**

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

1. Elimine `codecatalyst-cfn-workflow`.

1. Elimine `codecatalyst-cfn-environment`.

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

1. Elimine `codecatalyst-cfn-project`.

**Para limpiar en el Consola de administración de AWS**

1. Limpie en CloudFormation, de la siguiente manera:

   1. Abre la CloudFormation consola en [https://console.aws.amazon.com/cloudformation.](https://console.aws.amazon.com/cloudformation/)

   1. Elimine la `codecatalyst-cfn-stack`.

      Al eliminar la pila, se eliminan todos los recursos del tutorial de los servicios de API Gateway y Lambda.

1. Limpie Amazon S3 de la siguiente manera:

   1. Abra la consola de Amazon S3 en [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

   1. Elija el icono `codecatalyst-cfn-s3-bucket`.

   1. Elimine el contenido del bucket.

   1. Elimine el bucket .

1. Limpie IAM de la siguiente manera:

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

   1. Elimine la `codecatalyst-deploy-policy`.

   1. Elimine la `codecatalyst-build-policy`.

   1. Elimine la `codecatalyst-stack-policy`.

   1. Elimine la `codecatalyst-deploy-role`.

   1. Elimine la `codecatalyst-build-role`.

   1. Elimine la `codecatalyst-stack-role`.

En este tutorial, aprendió a implementar una aplicación sin servidor como una CloudFormation pila mediante un CodeCatalyst flujo de trabajo y una acción de **implementación CloudFormation ** de una pila.

# Añadir la acción «Desplegar CloudFormation pila»
<a name="deploy-action-cfn-adding"></a>

Siga las siguientes instrucciones para añadir la acción **Implementar CloudFormation pila** a su flujo de trabajo. 

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

**Para añadir la acción «Desplegar CloudFormation pila» mediante 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. Busca la acción **Implementar CloudFormation pila** y realiza 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
   + Seleccione **Implementar CloudFormation pila**. 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 «Desplegar CloudFormation pila» YAML](deploy-action-ref-cfn.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 ]

**Para añadir la acción «Desplegar CloudFormation pila» mediante el editor YAML**

1. [Abre la consola en https://codecatalyst.aws/ CodeCatalyst .](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. Busca la acción **Implementar CloudFormation pila** y realiza 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
   + Seleccione **Implementar CloudFormation pila**. 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 «Desplegar CloudFormation pila» YAML](deploy-action-ref-cfn.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**.

------

# Configuración de reversiones
<a name="deploy-consumption-enable-alarms"></a>

De forma predeterminada, si la acción **Desplegar CloudFormation pila** falla, se revertirá la pila al último estado estable conocido. CloudFormation Puede cambiar el comportamiento para que las reversiones se produzcan no solo cuando la acción falle, sino también cuando se produzca una CloudWatch alarma de Amazon específica. Para obtener más información sobre CloudWatch las alarmas, consulta [Uso de CloudWatch alarmas de Amazon](https://docs.aws.amazon.com/) en la *Guía del CloudWatch usuario de Amazon*.

También puedes cambiar el comportamiento predeterminado para que CloudFormation no se revierta la pila si la acción falla. 

Siga estas instrucciones para configurar las reversiones.

**nota**  
No puede iniciar una reversión manualmente.

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

**Antes de empezar**

1. Asegúrese de tener un [flujo de trabajo](workflow.md) que incluya una acción de **implementación de CloudFormation pila** que funcione. Para obtener más información, consulte [Implementación de una CloudFormation pila](deploy-action-cfn.md).

1. En el rol especificado en el campo **Función de pila: opcional** de la acción **Implementar CloudFormation pila**, asegúrate de incluir el **CloudWatchFullAccess**permiso. Para obtener más información sobre cómo crear este rol con los permisos adecuados, consulte [Paso 2: Crear roles AWS](deploy-tut-lambda.md#deploy-tut-lambda-cfn-roles).

**Para configurar las alarmas de reversión para la acción «Implementar pila» CloudFormation**

1. [Abra la consola en https://codecatalyst.aws/ CodeCatalyst .](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. Elija su acción de **despliegue de CloudFormation pila**.

1. En el panel de detalles, elija **Configuración**.

1. En la parte inferior, expanda **Avanzada**.

1. En **Supervisar alarma ARNs**, selecciona **Añadir alarma**.

1. Escriba información en los siguientes campos:
   + **ARN de la alarma**

     Especifique el nombre de recurso de Amazon (ARN) de una CloudWatch alarma de Amazon para utilizarla como activador de reversión. Por ejemplo, `arn:aws:cloudwatch::123456789012:alarm/MyAlarm`. Puede añadir un máximo de cinco desencadenadores de reversión.
**nota**  
Si especificas un CloudWatch ARN de alarma, también tendrás que configurar permisos adicionales para permitir el acceso de la acción. CloudWatch Para obtener más información, consulte [Configuración de reversiones](#deploy-consumption-enable-alarms).
   + **Tiempo de monitoreo**

     Especifique un período de tiempo, de 0 a 180 minutos, durante el cual se CloudFormation supervisarán las alarmas especificadas. La supervisión comienza *después* de que se hayan implementado todos los recursos de la pila. Si la alarma se produce dentro del tiempo de supervisión especificado, se produce un error en la implementación y se CloudFormation revierte toda la operación de apilado.

     Predeterminado: 0. CloudFormation solo supervisa las alarmas mientras se despliegan los recursos de la pila, no después.

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

**Para configurar los activadores de reversión para la acción «Implementar pila» CloudFormation**

1. [Abra la consola en https://codecatalyst.aws/ CodeCatalyst .](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 de un flujo de trabajo que incluya la acción **Implementar pila de CloudFormation **. 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. Añada las propiedades `monitor-alarm-arns` y `monitor-timeout-in-minutes` en el código de YAML para añadir desencadenadores de reversión. Para obtener una explicación de cada propiedad, consulte [Acción «Desplegar CloudFormation pila» YAML](deploy-action-ref-cfn.md).

1. En el rol especificado en la `role-arn` propiedad de la acción **Implementar CloudFormation pila**, asegúrate de incluir el **CloudWatchFullAccess**permiso. Para obtener más información sobre cómo crear este rol con los permisos adecuados, consulte [Paso 2: Crear roles AWS](deploy-tut-lambda.md#deploy-tut-lambda-cfn-roles).

------

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

**Para desactivar las reversiones de la acción «Desplegar pila» CloudFormation**

1. [Abre la consola en https://codecatalyst.aws/ CodeCatalyst .](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 de un flujo de trabajo que incluya la acción **Implementar pila de CloudFormation **. 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. Elija su acción de **despliegue de CloudFormation pila**.

1. En el panel de detalles, elija **Configuración**.

1. En la parte inferior, expanda **Avanzada**.

1. Active **Desactivar la reversión**.

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

**Para desactivar las reversiones de la acción «Desplegar pila» CloudFormation**

1. [Abre la consola en https://codecatalyst.aws/ CodeCatalyst .](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 de un flujo de trabajo que incluya la acción **Implementar pila de CloudFormation **. 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. Añada la propiedad `disable-rollback: 1` en el código de YAML para detener las reversiones. Para obtener una explicación de esta propiedad, consulte [Acción «Desplegar CloudFormation pila» YAML](deploy-action-ref-cfn.md).

------

# Variables de «implementar CloudFormation pila»
<a name="deploy-action-cfn-variables"></a>

La acción **Implementar CloudFormation pila** 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 | 
| --- | --- | 
|  deployment-platform  |  El nombre de la plataforma de implementación. Codificado en `AWS:CloudFormation`.  | 
|  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`  | 
|  stack-id  |  El Nombre de recurso de Amazon (ARN) de la pila implementada. Ejemplo: `arn:aws:cloudformation:us-west-2:111122223333:stack/codecatalyst-cfn-stack/6aad4380-100a-11ec-a10a-03b8a84d40df`  | 

# Acción «Desplegar CloudFormation pila» YAML
<a name="deploy-action-ref-cfn"></a>

**La siguiente es la definición en YAML de la acción Implementar pila. CloudFormation ** Para obtener información sobre cómo utilizar esta acción, consulte [Implementación de una CloudFormation pila](deploy-action-cfn.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.    
  DeployCloudFormationStack:  
    Identifier: aws/cfn-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: DeployRole
    Inputs:
      Sources:
        - source-name-1
      Artifacts:
        - CloudFormation-artifact
    Configuration:
      name: stack-name
      region: us-west-2
      template: template-path
      role-arn: arn:aws:iam::123456789012:role/StackRole        
      capabilities: CAPABILITY_IAM,CAPABILITY_NAMED_IAM,CAPABILITY_AUTO_EXPAND
      parameter-overrides: KeyOne=ValueOne,KeyTwo=ValueTwo | path-to-JSON-file
      no-execute-changeset: 1|0
      fail-on-empty-changeset: 1|0
      disable-rollback: 1|0
      termination-protection: 1|0
      timeout-in-minutes: minutes
      notification-arns: arn:aws:sns:us-east-1:123456789012:MyTopic,arn:aws:sns:us-east-1:123456789012:MyOtherTopic
      monitor-alarm-arns: arn:aws:cloudwatch::123456789012:alarm/MyAlarm,arn:aws:cloudwatch::123456789012:alarm/MyOtherAlarm
      monitor-timeout-in-minutes: minutes       
      tags: '[{"Key":"MyKey1","Value":"MyValue1"},{"Key":"MyKey2","Value":"MyValue2"}]'
```

## DeployCloudFormationStack
<a name="deploy.action.cfn.deploycloudformationstack"></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: `DeployCloudFormationStack_nn`.

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

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

(*DeployCloudFormationStack*/**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/cfn-deploy@v1`.

Interfaz de usuario correspondiente: Diagrama de flujo de trabajo/DeployCloudFormationStack\$1nn/etiqueta **aws/cfn-deploy@v1**

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

(*DeployCloudFormationStack*/**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.cfn.computename"></a>

(*DeployCloudFormationStack*/**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.cfn.computetype"></a>

(*DeployCloudFormationStack*/Compute/**Type**)

(Obligatorio si se incluye [Compute](#deploy.action.cfn.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 tab/Advanced : opcional/tipo de procesamiento**

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

(*DeployCloudFormationStack*/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.cfn.timeout"></a>

(*DeployCloudFormationStack*/**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 en minutos (opcional)**

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

(*DeployCloudFormationStack*/**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.cfn.environment.name"></a>

(*DeployCloudFormationStack*/Environment/**Name**)

(Obligatorio si se incluye [Environment](#deploy.action.cfn.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.cfn.environment.connections"></a>

(*DeployCloudFormationStack*/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.cfn.environment.connections.name"></a>

(*DeployCloudFormationStack*/Environment/Connections/**Name**)

(Obligatorio si se incluye [Connections](#deploy.action.cfn.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.cfn.environment.connections.role"></a>

(*DeployCloudFormationStack*/Environment/Connections/**Role**)

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

Especifique el nombre de la función de IAM que la acción de **implementación de la CloudFormation pila** utiliza para acceder AWS al servicio. CloudFormation 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.
**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.cfn.inputs"></a>

(*DeployCloudFormationStack*/**Inputs**)

(Opcional)

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

**nota**  
Se permite un máximo de cuatro entradas (una fuente y tres artefactos) por cada acción de la pila de **implementación CloudFormation **.

Si necesita hacer referencia a archivos que se encuentran en entradas diferentes (por ejemplo, un código fuente y un artefacto), la entrada de código fuente es la entrada principal y el artefacto es la entrada secundaria. Las referencias a los archivos en las entradas secundarias llevan un prefijo especial para distinguirlas de las principales. Para obtener más información, consulte [Ejemplo: Referencia a archivos en varios artefactos](workflows-working-artifacts-ex.md#workflows-working-artifacts-ex-ref-file).

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

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

(*DeployCloudFormationStack*/Inputs/**Sources**)

(Necesario si tu AWS SAM plantilla CloudFormation o plantilla está almacenada en un repositorio de origen)

Si su AWS SAM plantilla CloudFormation o plantilla está almacenada en un repositorio de origen, especifique la etiqueta de ese repositorio de origen. Actualmente, la única etiqueta admitida es `WorkflowSource`.

Si su AWS SAM plantilla CloudFormation o su plantilla no se encuentran en un repositorio de origen, deben residir en un artefacto generado por otra acción o en un bucket de Amazon S3.

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.cfn.inputs.artifacts"></a>

(*DeployCloudFormationStack*/Inputs/**Artifacts**)

(Obligatorio si su AWS SAM plantilla CloudFormation o plantilla está almacenada en un [artefacto de salida](workflows-working-artifacts-output.md) de una acción anterior)

Si la AWS SAM plantilla CloudFormation o que desea implementar está incluida en un artefacto generado por una acción anterior, especifique ese artefacto aquí. Si la CloudFormation plantilla no está incluida en un artefacto, debe residir en el repositorio de origen o en un bucket de Amazon S3.

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.cfn.configuration"></a>

(*DeployCloudFormationStack*/**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**

## name
<a name="deploy.action.cfn.stackname"></a>

(*DeployCloudFormationStack*/Configuration/**name**)

(Obligatorio) 

Especifique un nombre para la CloudFormation pila que la acción **Implementar CloudFormation pila** crea o actualiza.

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

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

(*DeployCloudFormationStack*/Configuration/**region**)

(Obligatorio) 

Especifique el lugar Región de AWS en el que se desplegará la pila. Para ver una lista de códigos de regiones, consulte [Puntos de conexión regionales](https://docs.aws.amazon.com/general/latest/gr/rande.html#region-names-codes).

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

## template
<a name="deploy.action.cfn.templatepath"></a>

(*DeployCloudFormationStack*/Configuration/**template**)

(Obligatorio) 

Especifique el nombre y la ruta de su archivo CloudFormation o AWS SAM de plantilla. La plantilla puede estar en formato JSON o YAML y puede residir en un repositorio de código fuente, un artefacto de una acción anterior o un bucket de Amazon S3. Si el archivo de plantilla está en un repositorio de código fuente o un artefacto, la ruta es relativa a la raíz del código fuente o artefacto. Si la plantilla está en un bucket de Amazon S3, la ruta es el valor **URL del objeto** de la plantilla.

Ejemplos:

`./MyFolder/MyTemplate.json`

`MyFolder/MyTemplate.yml`

`https://MyBucket.s3.us-west-2.amazonaws.com/MyTemplate.yml`

**nota**  
Puede que tenga que añadir un prefijo a la ruta de la plantilla para indicar en qué artefacto o código fuente se encuentra. Para obtener más información, consulte [Referencia a los archivos del repositorio de código fuente](workflows-sources-reference-files.md) y [Referencia a archivos en un artefacto](workflows-working-artifacts-refer-files.md).

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

## role-arn
<a name="deploy.action.cfn.stackrolearn"></a>

(*DeployCloudFormationStack*/Configuration/**role-arn**)

(Obligatorio) 

Especifique el nombre de recurso de Amazon (ARN) de la función de pila. CloudFormation utiliza este rol para acceder a los recursos de la pila y modificarlos. Por ejemplo: `arn:aws:iam::123456789012:role/StackRole`.

Asegúrese de que el rol de la pila incluya:
+ Una o varias políticas de permisos. Las políticas dependen de los recursos que haya en la pila. Por ejemplo, si su pila incluye una AWS Lambda función, debe añadir permisos que permitan el acceso a Lambda. Si ha seguido el tutorial que se describe en [Tutorial: implementación de una aplicación sin servidor](deploy-tut-lambda.md), este incluye un procedimiento denominado [Creación de un rol de pila](deploy-tut-lambda.md#deploy-tut-lambda-cfn-roles-stack) que muestra los permisos que necesita el rol de la pila si va a implementar una pila de aplicación sin servidor típica.
**aviso**  
Limite los permisos a los requeridos por el CloudFormation servicio para acceder a los recursos de su pila. El uso de un rol con permisos más amplios puede suponer un riesgo de seguridad.
+ La siguiente política de confianza:

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

****  

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

------

Si lo desea, asocie este rol a la conexión de su cuenta. Para obtener más información sobre cómo asociar un rol de IAM con una conexión de cuenta, consulte [Adición de roles de IAM a las conexiones de cuentas](ipa-connect-account-addroles.md). Si no asocia el rol de la pila a la conexión de cuenta, este no aparecerá en la lista desplegable **Rol de la pila** del editor visual; sin embargo, el ARN del rol aún se puede especificar en el campo `role-arn` mediante el editor de YAML.

**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: pestaña Configuración/**Rol de pila (opcional)**

## capabilities
<a name="deploy.action.cfn.capabilities"></a>

(*DeployCloudFormationStack*/Configuration/**capabilities**)

(Obligatorio) 

Especifique una lista de las capacidades de IAM necesarias para poder CloudFormation crear determinadas pilas. En la mayoría de los casos, puede dejar `capabilities` con el valor predeterminado de `CAPABILITY_IAM,CAPABILITY_NAMED_IAM,CAPABILITY_AUTO_EXPAND`.

Si aparece `##[error] requires capabilities: [capability-name]` en los registros de la acción **Implementar pila de CloudFormation **, consulte [¿Cómo puedo corregir los errores de las capacidades de IAM?](troubleshooting-workflows.md#troubleshooting-workflows-capabilities) para obtener más información sobre cómo solucionar el problema.

*Para obtener más información sobre las capacidades de IAM, consulte [Reconocimiento de los recursos de IAM en las CloudFormation plantillas](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html#using-iam-capabilities) de la Guía del usuario de IAM.*

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

## parameter-overrides
<a name="deploy.action.cfn.parameter.overrides"></a>

(*DeployCloudFormationStack*/Configuration/**parameter-overrides**)

(Opcional)

Especifique los parámetros de su CloudFormation AWS SAM plantilla que no tengan valores predeterminados o para los que desee especificar valores no predeterminados. Para obtener más información sobre los parámetros, consulte [Parámetros](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/parameters-section-structure.html) en la *Guía del AWS CloudFormation usuario*.

La propiedad `parameter-overrides` acepta:
+ Un archivo JSON que contiene los parámetros y valores.
+ Una lista de parámetros y valores separados por comas.

**Especificación de un archivo JSON**

1. Asegúrese de que el archivo JSON utilice una de las siguientes sintaxis:

   ```
   {
     "Parameters": {
       "Param1": "Value1",
       "Param2": "Value2",
       ...
     }
   }
   ```

   O bien…

   ```
   [
     {
        "ParameterKey": "Param1",
        "ParameterValue": "Value1"
     },
     ...
   ]
   ```

   (Existen otras sintaxis, pero no las admiten CodeCatalyst en el momento de escribir este artículo). Para obtener más información sobre cómo especificar CloudFormation los parámetros en un archivo JSON, consulte la [Sintaxis JSON admitida](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/cloudformation/deploy/index.html#supported-json-syntax) en la *Referencia de AWS CLI comandos*.

1. Especifique la ruta del archivo JSON con uno de los siguientes formatos:
   + Si el archivo JSON reside en un artefacto de salida de una acción anterior, utilice:

     `file:///artifacts/current-action-name/output-artifact-name/path-to-json-file`

     Consulte el **ejemplo 1** para obtener más información.
   + Si el archivo JSON reside en el repositorio de código fuente, utilice:

     `file:///sources/WorkflowSource/path-to-json-file`

     Consulte el **ejemplo 2** para obtener más información.

     **Ejemplo 1**: el archivo JSON reside en un artefacto de salida

     ```
     ##My workflow YAML
     ...
     Actions:
       MyBuildAction:
         Identifier: aws/build@v1
         Outputs:
           Artifacts:
             - Name: ParamArtifact
               Files:
                 - params.json
         Configuration:
         ...
       MyDeployCFNStackAction:
         Identifier: aws/cfn-deploy@v1
         Configuration:
           parameter-overrides: file:///artifacts/MyDeployCFNStackAction/ParamArtifact/params.json
     ```

     **Ejemplo 2**: el archivo JSON reside en el repositorio de código fuente, en una carpeta llamada `my/folder`

     ```
     ##My workflow YAML
     ...
     Actions:
       MyDeployCloudFormationStack:
         Identifier: aws/cfn-deploy@v1
         Inputs:
           Sources:
             - WorkflowSource
         Configuration:
           parameter-overrides: file:///sources/WorkflowSource/my/folder/params.json
     ```

**Uso de una lista de parámetros separados por comas**
+ Añada pares de nombre-valor de los parámetros a la propiedad `parameter-overrides` con el siguiente formato:

  `param-1=value-1,param-2=value-2`

  Por ejemplo, suponiendo la siguiente CloudFormation plantilla:

  ```
  ##My CloudFormation template
  
  Description: My CloudFormation template
  
  Parameters:
    InstanceType:
      Description: Defines the Amazon EC2 compute for the production server.
      Type: String
      Default: t2.micro
      AllowedValues:
        - t2.micro
        - t2.small
        - t3.medium
      
  Resources:
  ...
  ```

  ...puede establecer la propiedad `parameter-overrides` de la siguiente manera:

  ```
  ##My workflow YAML
  ...
  Actions:
  ...
    DeployCloudFormationStack:
      Identifier: aws/cfn-deploy@v1
      Configuration:
        parameter-overrides: InstanceType=t3.medium,UseVPC=true
  ```
**nota**  
Puede especificar un nombre de parámetro sin el valor correspondiente utilizando `undefined` como valor. Por ejemplo:  
`parameter-overrides: MyParameter=undefined`  
 El efecto es que, durante una actualización de la pila, CloudFormation utiliza el valor del parámetro existente para el nombre del parámetro dado.

Interfaz de usuario correspondiente:
+ Pestaña Configuración/Avanzada/**Anulaciones de parámetros**
+ La configuración tab/Advanced/Parameter anula o **especifique las anulaciones mediante** un archivo
+ **Anulaciones de tab/Advanced/Parameter configuración/ Especifique las anulaciones mediante un conjunto de valores**

## no-execute-changeset
<a name="deploy.action.cfn.noexecutechangeset"></a>

(*DeployCloudFormationStack*/Configuration/**no-execute-changeset**)

(Opcional)

Especifique si desea crear el conjunto de CloudFormation cambios y, CodeCatalyst a continuación, detenerlo antes de ejecutarlo. Esto le da la oportunidad de revisar el conjunto de cambios en la CloudFormation consola. Si determina que el conjunto de cambios se ve bien, desactive esta opción y, a continuación, vuelva a ejecutar el flujo de trabajo para CodeCatalyst poder crear y ejecutar el conjunto de cambios sin detenerlo. De forma predeterminada, el conjunto de cambios se crea y ejecuta sin detenerse. Para obtener más información, consulte el parámetro de CloudFormation [despliegue](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deploy/index.html) en la *Referencia de AWS CLI comandos*. Para obtener más información sobre cómo ver los conjuntos de cambios, consulte [Visualización de un conjunto de cambios](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-changesets-view.html) en la *Guía del usuario de AWS CloudFormation *.

Interfaz de usuario correspondiente: pestaña Configuración/Avanzada/**Ninguna ejecución del conjunto de cambios**

## fail-on-empty-changeset
<a name="deploy.action.cfn.failonemptychangeset"></a>

(*DeployCloudFormationStack*/Configuration/**fail-on-empty-changeset**)

(Opcional)

Especifique si desea que se produzca CodeCatalyst un error en la acción de **despliegue de la CloudFormation pila** si el conjunto de CloudFormation cambios está vacío. (Si un conjunto de cambios está vacío, eso significa que no se realizaron cambios en la pila durante la última implementación). La opción predeterminada es permitir que la acción continúe si el conjunto de cambios está vacío y devolver un mensaje `UPDATE_COMPLETE` aunque la pila no se haya actualizado.

Para obtener más información sobre esta configuración, consulte el parámetro de CloudFormation [despliegue](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deploy/index.html) en la *Referencia de AWS CLI comandos*. Para obtener más información sobre los conjuntos de cambios, consulte [Actualización de pilas con conjuntos de cambios](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-changesets.html) en la *Guía del usuario de AWS CloudFormation *.

Interfaz de usuario correspondiente: pestaña Configuración/Avanzada/**Ningún fallo del conjunto de cambios vacío**

## disable-rollback
<a name="deploy.action.cfn.disablerollback"></a>

(*DeployCloudFormationStack*/Configuration/**disable-rollback**)

(Opcional)

Especifique si desea CodeCatalyst revertir el despliegue de la pila en caso de que se produzca un error. La reversión devuelve la pila al último estado estable conocido. La opción predeterminada es habilitar las reversiones. Para obtener más información sobre esta configuración, consulte el parámetro de CloudFormation [despliegue](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deploy/index.html) en la *Referencia de AWS CLI comandos*.

Para obtener más información sobre cómo la acción **Implementar CloudFormation pila** gestiona las reversiones, consulte[Configuración de reversiones](deploy-consumption-enable-alarms.md).

Para obtener más información sobre cómo revertir una pila, consulte [Opciones de error de una pila](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stack-failure-options.html) en la *Guía del usuario de AWS CloudFormation *.

Interfaz de usuario correspondiente: pestaña Configuración/Avanzada/**Deshabilitar restauración**

## termination-protection
<a name="deploy.action.cfn.terminationprotection"></a>

(*DeployCloudFormationStack*/Configuration/**termination-protection**)

(Opcional)

Especifique si desea que la ** CloudFormation pila Deploy** añada protección de terminación a la pila que está desplegando. Si un usuario intenta eliminar una pila con la protección de terminación habilitada, la eliminación fallará y la pila junto con su estado no cambiarán. La protección de terminación está deshabilitada de forma predeterminada. Para obtener más información, consulte [Protección de las pilas para evitar la eliminación](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-protect-stacks.html) en la *Guía del usuario de AWS CloudFormation *.

Interfaz de usuario correspondiente: pestaña Configuración/Avanzada/**Protección de terminación**

## timeout-in-minutes
<a name="deploy.action.cfn.timeoutinminutes"></a>

(*DeployCloudFormationStack*/Configuration/**timeout-in-minutes**)

(Opcional)

Especifique la cantidad de tiempo, en minutos, que CloudFormation debe transcurrir antes de que se agoten las operaciones de creación de la pila y establezca el estado de la pila en. `CREATE_FAILED` Si CloudFormation no puede crear toda la pila en el tiempo asignado, se produce un error de creación porque el tiempo de espera se agota y la pila vuelve a su estado anterior.

De forma predeterminada, no hay tiempo de espera para la creación de pilas. Sin embargo, puede que determinados recursos individuales tengan sus propios tiempos de espera en función de la naturaleza del servicio que implementan. Por ejemplo, si se agota el tiempo de espera de un recurso individual de la pila, también se agota el tiempo de espera de creación de la pila aunque todavía no se haya agotado el tiempo de espera especificado para la creación de la pila.

**Interfaz de usuario correspondiente: pestaña de configuración/avanzada/tiempo de espera CloudFormation**

## notification-arns
<a name="deploy.action.cfn.notificationarns"></a>

(*DeployCloudFormationStack*/Configuration/**notification-arns**)

(Opcional)

Especifique el ARN de un tema de Amazon SNS al que CodeCatalyst desee enviar los mensajes de notificación. Por ejemplo, `arn:aws:sns:us-east-1:111222333:MyTopic`. Cuando se ejecute la acción **Implementar una CloudFormation pila**, CodeCatalyst coordine con ella CloudFormation para enviar una notificación por cada CloudFormation evento que se produzca durante el proceso de creación o actualización de la pila. (Los eventos están visibles en la pestaña **Eventos** de la CloudFormation consola para la pila). Puede especificar hasta cinco temas. Para obtener más información, consulte [¿Qué es Amazon SNS?](https://docs.aws.amazon.com/sns/latest/dg/welcome.html)

**Interfaz de usuario correspondiente: pestaña de configuración/Avanzada/Notificación ARNs**

## monitor-alarm-arns
<a name="deploy.action.cfn.monitoralarmarns"></a>

(*DeployCloudFormationStack*/Configuration/**monitor-alarm-arns**)

(Opcional)

Especifique el nombre de recurso de Amazon (ARN) de una CloudWatch alarma de Amazon para utilizarla como activador de reversión. Por ejemplo, `arn:aws:cloudwatch::123456789012:alarm/MyAlarm`. Puede añadir un máximo de cinco desencadenadores de reversión.

**nota**  
Si especificas un CloudWatch ARN de alarma, también tendrás que configurar permisos adicionales para permitir el acceso de la acción. CloudWatch Para obtener más información, consulte [Configuración de reversiones](deploy-consumption-enable-alarms.md).

**Interfaz de usuario correspondiente: pestaña de configuración/Avanzada/Monitor de alarma ARNs**

## monitor-timeout-in-minutes
<a name="deploy.action.cfn.monitortimeinminutes"></a>

(*DeployCloudFormationStack*/Configuration/**monitor-timeout-in-minutes**)

(Opcional)

Especifique un período de tiempo, de 0 a 180 minutos, durante el cual CloudFormation se supervisarán las alarmas especificadas. La supervisión comienza *después* de que se hayan implementado todos los recursos de la pila. Si la alarma se produce dentro del tiempo de supervisión especificado, se produce un error en la implementación y se CloudFormation revierte toda la operación de apilado.

Predeterminado: 0. CloudFormation solo monitorea las alarmas mientras se despliegan los recursos de la pila, no después.

Interfaz de usuario correspondiente: pestaña Configuración/Avanzada/**Tiempo de supervisión**

## tags
<a name="deploy.action.cfn.tags"></a>

(*DeployCloudFormationStack*/Configuration/**tags**)

(Opcional)

Especifique las etiquetas que desee adjuntar a la CloudFormation pila. Las etiquetas son pares arbitrarios de clave-valor que se pueden utilizar para identificar la pila para fines como la asignación de costos. Para obtener más información acerca de qué son las etiquetas y cómo se pueden usar, consulte [Etiquetado de los recursos](https://docs.aws.amazon.com/) en la *Guía del usuario de Amazon EC2*. Para obtener más información sobre el etiquetado CloudFormation, consulte [Configuración de las opciones de CloudFormation pila](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-console-add-tags.html) en la *Guía del AWS CloudFormation usuario*.

Una clave puede tener caracteres alfanuméricos o espacios, y puede tener hasta 127 caracteres. Un valor puede tener caracteres alfanuméricos o espacios, y puede tener hasta 255 caracteres.

Puede agregar hasta 50 etiquetas únicas para cada pila.

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

# Implementación de una AWS CDK aplicación con un flujo de trabajo
<a name="cdk-dep-action"></a>

En esta sección, se describe cómo implementar una AWS Cloud Development Kit (AWS CDK) aplicación en tu AWS cuenta mediante un flujo de trabajo. Para ello, debe añadir la acción **Implementación de AWS CDK ** a su flujo de trabajo. La acción de **AWS CDK despliegue** sintetiza y despliega la AWS Cloud Development Kit (AWS CDK) aplicación en. AWS Si tu aplicación ya existe en AWS, la acción la actualiza si es necesario. 

Para obtener información general sobre cómo escribir aplicaciones con AWS CDK, consulta [¿Qué es AWS CDK?](https://docs.aws.amazon.com/cdk/v2/guide/home.html) en la *Guía para AWS Cloud Development Kit (AWS CDK) desarrolladores*.

**Topics**
+ [Cuándo utilizar la acción «AWS CDK desplegar»](#cdk-dep-action-when-to-use)
+ [Cómo funciona la acción de «AWS CDK desplegar»](#cdk-dep-action-how-it-works)
+ [Versiones de CDK CLI utilizadas por la acción de «AWS CDK implementar»](#cdk-dep-action-cdk-version)
+ [Imagen de tiempo de ejecución utilizada por la acción de «despliegue»AWS CDK](#cdk-dep-action-runtime)
+ [¿Cuántas pilas puede implementar la acción?](#cdk-dep-action-how-many-stacks)
+ [Ejemplo: Implementación de una AWS CDK aplicación](cdk-dep-action-example-workflow.md)
+ [Añadir la acción «AWS CDK desplegar»](cdk-dep-action-add.md)
+ [Variables de 'Implementación de AWS CDK '](cdk-dep-action-variables.md)
+ [YAML de la acción 'Implementación de AWS CDK '](cdk-dep-action-ref.md)

## Cuándo utilizar la acción «AWS CDK desplegar»
<a name="cdk-dep-action-when-to-use"></a>

Utilice esta acción si ha desarrollado una aplicación con el AWS CDK y ahora desea implementarla automáticamente como parte de un flujo de trabajo automatizado de integración y entrega continuas (CI/CD). Por ejemplo, es posible que desees implementar tu AWS CDK app automáticamente cada vez que alguien fusione una solicitud de cambios relacionada con la fuente de tu AWS CDK aplicación. 

## Cómo funciona la acción de «AWS CDK desplegar»
<a name="cdk-dep-action-how-it-works"></a>

La **AWS CDK implementación** funciona de la siguiente manera:

1. [En tiempo de ejecución, si especificó la versión 1.0.12 o anterior de la acción, la acción descarga la última CLI de CDK (también denominada kit de herramientas) AWS CDK a la imagen del CodeCatalyst entorno de ejecución.](#cdk-dep-action-runtime)

   Si especificó la versión 1.0.13 o posterior, la acción viene incluida con una [versión específica](#cdk-dep-action-cdk-version) de la CLI de CDK, por lo que no se produce ninguna descarga.

1. La acción utiliza la CLI de CDK para ejecutar el comando `cdk deploy`. Este comando sintetiza y despliega la aplicación en ella. AWS CDK AWS Para obtener más información sobre este comando, consulte el tema [AWS CDK Toolkit (cdk command)](https://docs.aws.amazon.com/cli/latest/reference/s3/sync.html) en la *Guía para desarrolladores de AWS Cloud Development Kit (AWS CDK) *.

## Versiones de CDK CLI utilizadas por la acción de «AWS CDK implementar»
<a name="cdk-dep-action-cdk-version"></a>

En la siguiente tabla se muestra qué versión de la CLI de CDK utilizan de forma predeterminada las diferentes versiones de la acción **Implementación de AWS CDK **.

**nota**  
Puede invalidar la predeterminada. Para obtener más información, consulte [CdkCliVersion](cdk-dep-action-ref.md#cdk.dep.cdk.cli.version) en la [YAML de la acción 'Implementación de AWS CDK '](cdk-dep-action-ref.md).


| Versión de la acción 'Implementación de AWS CDK ' | AWS CDK Versión CLI | 
| --- | --- | 
|  1.0.0 – 1.0.12  |  más reciente  | 
|  1.0.13 o posterior  |  2.99.1  | 

## Imagen de tiempo de ejecución utilizada por la acción de «despliegue»AWS CDK
<a name="cdk-dep-action-runtime"></a>

En la siguiente tabla se muestran las imágenes del entorno de ejecución que se CodeCatalyst utilizan para ejecutar diferentes versiones de la acción de **AWS CDK despliegue**. Las imágenes incluyen diferentes conjuntos de herramientas preinstaladas. Para obtener más información, consulte [Imágenes activas](build-images.md#build-curated-images).

**nota**  
Le recomendamos que actualice la acción **Implementación de AWS CDK ** a la versión 2.x para aprovechar las últimas herramientas disponibles en la imagen de marzo de 2024. Para actualizar la acción, defina su propiedad `Identifier` en `aws/cdk-deploy@v2` en el archivo de definición de flujo de trabajo. Para obtener más información, consulte [YAML de la acción 'Implementación de AWS CDK '](cdk-dep-action-ref.md). 


| Versión de la acción 'Implementación de AWS CDK ' | Imágenes del entorno en tiempo de ejecución | 
| --- | --- | 
|  1.x  |  Imágenes de noviembre de 2022  | 
|  2.x  |  Imágenes de marzo de 2024  | 

## ¿Cuántas pilas puede implementar la acción?
<a name="cdk-dep-action-how-many-stacks"></a>

La acción **Implementación de AWS CDK ** puede implementar una sola pila. Si tu AWS CDK aplicación consta de varias pilas, debes crear una pila principal con pilas anidadas e implementar la principal mediante esta acción.

# Ejemplo: Implementación de una AWS CDK aplicación
<a name="cdk-dep-action-example-workflow"></a>

El siguiente ejemplo de flujo de trabajo incluye la acción **Implementación de AWS CDK ** junto con la acción **Arranque de AWS CDK **. 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. Este repositorio contiene tu AWS CDK aplicación. 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 **AWS CDK arranque** (`CDKBootstrap`): al activarse, la acción despliega la pila de `CDKToolkit` arranque en ella. AWS Si la pila de `CDKToolkit` ya existe en el entorno, se actualizará si es necesario; de lo contrario, no ocurrirá nada y la acción se marcará como correcta.
+ Una acción de **AWS CDK despliegue** (`AWS CDK Deploy`): al finalizar la acción de **AWS CDK arranque**, la acción de **AWS CDK despliegue** sintetiza el código de la AWS CDK aplicación en una CloudFormation plantilla y despliega la pila definida en la plantilla. AWS

**nota**  
El siguiente ejemplo de flujo de trabajo tiene fines ilustrativos y no funcionará sin una configuración adicional.

**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 requeridos por las acciones **Arranque de AWS CDK ** e **Implementación de AWS CDK **. 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). Para obtener más información sobre los permisos y las políticas de confianza que requieren las acciones **Arranque de AWS CDK ** e **Implementación de AWS CDK **, consulte la descripción de la propiedad `Role`en los campos [Acción 'Arranque de AWS CDK ' en YAML](cdk-boot-action-ref.md) y [YAML de la acción 'Implementación de AWS CDK '](cdk-dep-action-ref.md).

```
Name: codecatalyst-cdk-deploy-workflow
SchemaVersion: 1.0

Triggers:
  - Type: PUSH
    Branches:
      - main
Actions:
  CDKBootstrap:
    Identifier: aws/cdk-bootstrap@v2
    Inputs:
      Sources:
        - WorkflowSource
    Environment:
      Name: codecatalyst-cdk-deploy-environment
      Connections:
        - Name: codecatalyst-account-connection
          Role: codecatalyst-cdk-bootstrap-role
    Configuration:
      Region: us-west-2
        
  CDKDeploy:
    Identifier: aws/cdk-deploy@v2
    DependsOn: 
      - CDKBootstrap
    Environment:
      Name: codecatalyst-cdk-deploy-environment
      Connections:
        - Name: codecatalyst-account-connection
          Role: codecatalyst-cdk-deploy-role
    Inputs:
      Sources:
        - WorkflowSource
    Configuration:
      StackName: my-app-stack
      Region: us-west-2
```

# Añadir la acción «AWS CDK desplegar»
<a name="cdk-dep-action-add"></a>

 Siga estas instrucciones para añadir la acción **Implementación de AWS CDK ** a su flujo de trabajo. 

**Antes de empezar**

Para poder añadir la acción **Implementación de AWS CDK ** a su flujo de trabajo, realice las siguientes tareas:

1. **Tenga una AWS CDK aplicación lista**. Puedes escribir tu AWS CDK aplicación usando la AWS CDK v1 o la v2, en cualquier lenguaje de programación compatible con AWS CDK. Asegúrese de que los archivos de la aplicación de AWS CDK estén disponibles en:
   + Un [repositorio CodeCatalyst de código fuente](source.md), o 
   + Un [artefacto CodeCatalyst de salida](workflows-working-artifacts.md) generado por otra acción del flujo de trabajo

1. **Inicie su entorno. AWS ** Para arrancar, puede:
   + Usar uno de los métodos descritos en [How to bootstrap](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html#bootstrapping-howto) en la *Guía para desarrolladores de AWS Cloud Development Kit (AWS CDK) *.
   + Usar la acción **Arranque de AWS CDK **. Puede añadir esta acción al mismo flujo de trabajo que la acción **Implementación de AWS CDK ** o a uno diferente. Solo asegúrese de que la acción de arranque se ejecute al menos una vez antes de ejecutar la acción **Implementación de AWS CDK ** para disponer de los recursos necesarios. Para obtener más información sobre la acción de **AWS CDK arranque**, consulte. [Cómo iniciar una AWS CDK aplicación con un flujo de trabajo](cdk-boot-action.md)

     Para obtener más información acerca del arranque, consulte [Bootstrapping](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html) en la *Guía para desarrolladores de AWS Cloud Development Kit (AWS CDK) *.

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

**Para añadir la acción de «AWS CDK desplegar» mediante 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 **Implementación de AWS CDK ** 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 **Implementación de AWS CDK **. 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 [YAML de la acción 'Implementación de AWS CDK '](cdk-dep-action-ref.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**.
**nota**  
Si la acción **Implementación de AWS CDK ** falla y se produce un error `npm install`, consulte [¿Cómo puedo corregir los errores npm install?](troubleshooting-workflows.md#troubleshooting-workflows-npm) para obtener información sobre cómo corregir el error.

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

**Para añadir la acción de «AWS CDK desplegar» mediante el editor 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 **Implementación de AWS CDK ** 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 **Implementación de AWS CDK **. 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 [YAML de la acción 'Implementación de AWS CDK '](cdk-dep-action-ref.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**.
**nota**  
Si la acción **Implementación de AWS CDK ** falla y se produce un error `npm install`, consulte [¿Cómo puedo corregir los errores npm install?](troubleshooting-workflows.md#troubleshooting-workflows-npm) para obtener información sobre cómo corregir el error.

------

# Variables de 'Implementación de AWS CDK '
<a name="cdk-dep-action-variables"></a>

La acción **Implementación de AWS CDK ** 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 | 
| --- | --- | 
|  stack-id  |  El nombre de recurso de Amazon (ARN) de la pila de AWS CDK aplicaciones en la que se implementó durante la ejecución del flujo de trabajo. Ejemplo: `arn:aws:cloudformation:us-west-2:111122223333:stack/codecatalyst-cdk-app-stack/6aad4380-100a-11ec-a10a-03b8a84d40df`  | 
|  deployment-platform  |  El nombre de la plataforma de implementación. Codificado en `AWS:CloudFormation`.  | 
|  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`  | 
|  SKIP-DEPLOYMENT  |  Un valor de `true` indica que se omitió el despliegue de AWS CDK la pila de aplicaciones durante la ejecución del flujo de trabajo. Se omitirá la implementación de una pila si no se ha producido ningún cambio en la pila desde la última implementación. Esta variable solo se genera si su valor es `true`. Codificado en `true`.  | 
|  *CloudFormation variables*  |  Además de generar las variables enumeradas anteriormente, la acción de **AWS CDK despliegue** también expone las variables de *CloudFormation*salida como variables de *flujo* de trabajo para su uso en acciones de flujo de trabajo posteriores. De forma predeterminada, la acción solo expone las cuatro primeras CloudFormation variables (o menos) que encuentre. Para determinar cuáles se exponen, ejecute la acción **Implementación de AWS CDK ** una vez y, a continuación, consulte la pestaña **Variables** de la página de detalles de la ejecución. Si las variables que aparecen en la pestaña **Variables** no son las que desea, puede configurar otras variables mediante la propiedad `CfnOutputVariables` de YAML. Para obtener más información, consulte la descripción de la operación [CfnOutputVariables](cdk-dep-action-ref.md#cdk.dep.cfn.out) en la [YAML de la acción 'Implementación de AWS CDK '](cdk-dep-action-ref.md).  | 

# YAML de la acción 'Implementación de AWS CDK '
<a name="cdk-dep-action-ref"></a>

La siguiente es la definición en YAML de la acción **Implementación de AWS CDK **. Para obtener información sobre cómo utilizar esta acción, consulte [Implementación de una AWS CDK aplicación con un flujo de trabajo](cdk-dep-action.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.   
  CDKDeploy\$1nn: 
    Identifier: aws/cdk-deploy@v2
    DependsOn:
      - CDKBootstrap
    Compute:  
      Type: EC2 | Lambda
      Fleet: fleet-name
    Timeout: timeout-minutes
    Inputs:
      # Specify a source or an artifact, but not both.
      Sources:
        - source-name-1
      Artifacts:
        - artifact-name
    Outputs:
      Artifacts:
        - Name: cdk_artifact
          Files: 
            - "cdk.out/**/*"
    Environment:
      Name: environment-name
      Connections:
        - Name: account-connection-name
          Role: iam-role-name
    Configuration:
      StackName: my-cdk-stack
      Region: us-west-2
      Tags: '{"key1": "value1", "key2": "value2"}'
      Context: '{"key1": "value1", "key2": "value2"}'
      CdkCliVersion: version
      CdkRootPath: directory-containing-cdk.json-file
      CfnOutputVariables: '["CnfOutputKey1","CfnOutputKey2","CfnOutputKey3"]'
      CloudAssemblyRootPath: path-to-cdk.out
```

## CDKDeploy
<a name="cdk.dep.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: `CDKDeploy_nn`.

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

## Identifier
<a name="cdk.dep.identifier"></a>

(*CDKDeploy*/**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).

**nota**  
Si se especifica `aws/cdk-deploy@v2`, la acción se ejecuta en la [imagen de marzo de 2024](build-images.md#build.default-image), que incluye herramientas más recientes, como Node.js 18. Si se especifica `aws/cdk-deploy@v1`, la acción se ejecuta en la [imagen de noviembre de 2022](build-images.md#build.previous-image), que incluye herramientas más antiguas, como Node.js 16.

Predeterminado: `aws/cdk-deploy@v2`.

Interfaz de usuario correspondiente: diagrama de flujo de trabajo/CDKDeploy\$1nn/etiqueta **aws/cdk-deploy@v2**

## DependsOn
<a name="cdk.dep.dependson"></a>

(*CDKDeploy*/**DependsOn**)

(Opcional)

Especifique la acción, el grupo de acciones o la puerta que debe ejecutarse correctamente para que la acción **Implementación de AWS CDK ** se ejecute. Se recomienda especificar la acción de **Arranque de AWS CDK ** en la propiedad de `DependsOn`, de la siguiente manera:

```
CDKDeploy:
  Identifier: aws/cdk-deploy@v2
  DependsOn:
    - CDKBootstrap
```

**nota**  
El [arranque es un requisito previo obligatorio para implementar una aplicación](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html). AWS CDK Si no incluye la acción **Arranque de AWS CDK ** en su flujo de trabajo, debe buscar otra forma de implementar la pila de arranque de AWS CDK antes de ejecutar la acción **Implementación de AWS CDK **. Para obtener más información, consulta [Añadir la acción «AWS CDK desplegar»](cdk-dep-action-add.md) en [Implementación de una AWS CDK aplicación con un flujo de trabajo](cdk-dep-action.md).

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="cdk.dep.computename"></a>

(*CDKDeploy*/**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="cdk.dep.computetype"></a>

(*CDKDeploy*/Compute/**Type**)

(Obligatorio si se incluye [Compute](#cdk.dep.computename))

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

  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 tab/Advanced : opcional/tipo de cálculo**

## Fleet
<a name="cdk.dep.computefleet"></a>

(*CDKDeploy*/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="cdk.dep.timeout"></a>

(*CDKDeploy*/**Timeout**)

(Obligatorio) 

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

## Inputs
<a name="cdk.dep.inputs"></a>

(*CDKDeploy*/**Inputs**)

(Opcional)

La sección `Inputs` define los datos que necesita la acción `CDKDeploy` 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 Implementación de AWS CDK .

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

## Sources
<a name="cdk.dep.inputs.sources"></a>

(*CDKDeploy*/Inputs/**Sources**)

(Obligatorio si la AWS CDK aplicación que quieres implementar está almacenada en un repositorio de origen)

Si AWS CDK la aplicación está almacenada en un repositorio de origen, especifique la etiqueta de ese repositorio de origen. La acción **Implementación de AWS CDK ** sintetiza la aplicación en este repositorio antes de iniciar el proceso de implementación. Actualmente, la única etiqueta admitida es `WorkflowSource`.

Si tu AWS CDK aplicación no está incluida en un repositorio de origen, 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="cdk.dep.inputs.artifacts"></a>

(*CDKDeploy*/Inputs/**Artifacts**)

(Obligatorio si la AWS CDK aplicación que quieres implementar está almacenada en un [artefacto de salida](workflows-working-artifacts-output.md) de una acción anterior)

Si tu AWS CDK aplicación está incluida en un artefacto generado por una acción anterior, especifica ese artefacto aquí. La acción de **AWS CDK despliegue** sintetiza la aplicación del artefacto especificado en una CloudFormation plantilla antes de iniciar el proceso de despliegue. Si tu AWS CDK aplicación no está incluida en un artefacto, debe residir en tu repositorio de origen.

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 Entradas/**Artefactos (opcional)**

## Outputs
<a name="cdk.dep.outputs"></a>

(*CDKDeploy*/**Outputs**)

(Opcional)

Define los datos que necesita una acción durante la ejecución de un flujo de trabajo.

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

## Artifacts - output
<a name="cdk.dep.outputs.artifacts"></a>

(*CDKDeploy*/Outputs/**Artifacts**

(Opcional)

Especifique el nombre de los artefactos generados por la acción. Puede hacer referencia a estos artefactos como entrada en otras acciones.

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 Salidas/**Artefactos**

## Name
<a name="cdk.dep.outputs.artifacts.name"></a>

(*CDKDeploy*/Outputs/Artifacts/**Name**)

(Obligatorio si se incluye [Artifacts - output](#cdk.dep.outputs.artifacts))

Especifica el nombre del artefacto que contendrá la CloudFormation plantilla sintetizada por la acción de **AWS CDK despliegue** en tiempo de ejecución. El valor predeterminado es `cdk_artifact`. Si no especifica un artefacto, la acción sintetizará la plantilla, pero no la guardará en un artefacto. Considere la posibilidad de guardar la plantilla sintetizada en un artefacto para conservar un registro de la misma para probarla o solucionar problemas.

**Interfaz de usuario correspondiente: genera el nombre del tab/Artifacts/Add artefacto/crea el nombre del artefacto**

## Files
<a name="cdk.dep.outputs.artifacts.files"></a>

(*CDKDeploy*/Outputs/Artifacts/**Files**)

(Obligatorio si se incluye [Artifacts - output](#cdk.dep.outputs.artifacts))

Especifique los archivos que desee incluir en el artefacto. Debes especificar si quieres incluir `"cdk.out/**/*"` la plantilla sintetizada de tu AWS CDK aplicación. CloudFormation 

**nota**  
`cdk.out` es el directorio predeterminado en el que se guardan los archivos sintetizados. Si especificó un directorio de salida distinto de `cdk.out` en el archivo `cdk.json`, especifique ese directorio aquí en lugar de `cdk.out`.

Interfaz de usuario correspondiente: genera tab/Artifacts/Add artefactos o **archivos** producidos por la compilación

## Environment
<a name="cdk.dep.environment"></a>

(*CDKDeploy*/**Environment**)

(Obligatorio) 

Especifica el CodeCatalyst entorno que se va a utilizar 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="cdk.dep.environment.name"></a>

(*CDKDeploy*/Environment/**Name**)

(Obligatorio si se incluye [Environment](#cdk.dep.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="cdk.dep.environment.connections"></a>

(*CDKDeploy*/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="cdk.dep.environment.connections.name"></a>

(*CDKDeploy*/Environment/Connections/**Name**)

(Obligatorio si se incluye [Connections](#cdk.dep.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="cdk.dep.environment.connections.role"></a>

(*CDKDeploy*/Environment/Connections/**Role**)

(Obligatorio si se incluye [Connections](#cdk.dep.environment.connections))

Especifique el nombre de la conexión de cuenta.

Especifique el nombre de la función de IAM que la acción de **AWS CDK despliegue** utiliza para acceder a la pila de aplicaciones AWS e implementarla. AWS CDK 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": [
          {
              "Sid": "VisualEditor0",
              "Effect": "Allow",
              "Action": [
                  "cloudformation:DescribeStackEvents",
                  "cloudformation:DescribeChangeSet",
                  "cloudformation:DescribeStacks",
                  "cloudformation:ListStackResources"
              ],
              "Resource": "*"
          },
          {
              "Sid": "VisualEditor1",
              "Effect": "Allow",
              "Action": "sts:AssumeRole",
              "Resource": "arn:aws:iam::111122223333:role/cdk-*"
          }
      ]
  }
  ```

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

## Configuration
<a name="cdk.dep.configuration"></a>

(*CDKDeploy*/**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**

## StackName
<a name="cdk.dep.stack.name"></a>

(*CDKDeploy*/Configuration/**StackName**)

(Obligatorio) 

El nombre de la pila de AWS CDK aplicaciones, tal como aparece en el archivo de punto de entrada del directorio de la aplicación. AWS CDK `bin` En el siguiente ejemplo, se muestra el contenido de un archivo de TypeScript punto de entrada, con el nombre de la pila resaltado. *red italics* Si el archivo de puntos de entrada está en un lenguaje diferente, tendrá un aspecto similar.

```
import * as cdk from 'aws-cdk-lib';
import { CdkWorksopTypescriptStack } from '../lib/cdk_workshop_typescript-stack';

const app = new cdk.App();
new CdkWorkshopTypescriptStack(app, 'CdkWorkshopTypescriptStack');
```

Solo puede especificar una sola pila.

**sugerencia**  
Si tiene varias pilas, puede crear una pila principal con pilas anidadas. A continuación, puede especificar la pila principal en esta acción para implementar todas las pilas.

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

## Region
<a name="cdk.dep.region"></a>

(*CDKDeploy*/Configuration/**Region**)

(Opcional)

Especifique Región de AWS en qué lugar se desplegará la pila de AWS CDK aplicaciones. Para ver una lista de códigos de regiones, consulte [Puntos de conexión regionales](https://docs.aws.amazon.com/general/latest/gr/rande.html#region-names-codes).

Si no especifica una región, la acción de **AWS CDK despliegue** se despliega en la región especificada en el AWS CDK código. Para obtener más información, consulte [Environments](https://docs.aws.amazon.com/cdk/v2/guide/environments.html) en la *Guía para desarrolladores de AWS Cloud Development Kit (AWS CDK) *.

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

## Tags
<a name="cdk.dep.tags"></a>

(*CDKDeploy*/Configuration/**Tags**)

(Opcional)

Especifique las etiquetas que desee aplicar a AWS los recursos de la pila de AWS CDK aplicaciones. Las etiquetas se aplican a la propia pila, así como a los distintos recursos de la pila. Para obtener más información acerca del etiquetado, consulte [Tagging](https://docs.aws.amazon.com/cdk/v2/guide/tagging.html) en la *Guía para desarrolladores de AWS Cloud Development Kit (AWS CDK) *.

**Interfaz de usuario correspondiente: Configuración tab/Advanced : opcional/ Etiquetas**

## Context
<a name="cdk.dep.context"></a>

(*CDKDeploy*/Configuration/**Context**)

(Opcional)

Especifique los contextos, en forma de pares clave-valor, para asociarlos a la pila de aplicaciones. AWS CDK Para obtener más información sobre los contextos, consulte [Runtime contexts](https://docs.aws.amazon.com/cdk/v2/guide/context.html) en la *Guía para desarrolladores de AWS Cloud Development Kit (AWS CDK) *.

**Interfaz de usuario correspondiente: Configuración tab/Advanced : opcional/contexto**

## CdkCliVersion
<a name="cdk.dep.cdk.cli.version"></a>

(*CDKDeploy*/Configuration/**CdkCliVersion**)

(Opcional)

Esta propiedad está disponible en la versión 1.0.13 o posterior de la acción **Implementación de AWS CDK ** y en la versión 1.0.8 o posterior de la acción **Arranque de AWS CDK **.

Especifique uno de los siguientes valores:
+ La versión completa de la interfaz de línea de AWS Cloud Development Kit (AWS CDK) comandos (CLI) (también denominada AWS CDK kit de herramientas) que desea que utilice esta acción. Ejemplo: `2.102.1`. Considere la posibilidad de especificar una versión completa para garantizar la coherencia y la estabilidad al crear e implementar la aplicación.

  O
+ `latest`. Considere la posibilidad de especificar `latest` para aprovechar las características y correcciones más recientes de la CLI de CDK.

La acción descargará la versión especificada (o la última versión) de la AWS CDK CLI a la [imagen de CodeCatalyst compilación](build-images.md) y, a continuación, utilizará esta versión para ejecutar los comandos necesarios para implementar la aplicación CDK o arrancar el entorno. AWS 

Para obtener una lista de las versiones de CLI de CDK compatibles que puede utilizar, consulte [Versiones de AWS CDK](https://docs.aws.amazon.com/cdk/api/versions.html).

Si omite esta propiedad, la acción utilizará una versión AWS CDK CLI predeterminada que se describe en uno de los temas siguientes:
+ [Versiones de CDK CLI utilizadas por la acción de «AWS CDK implementar»](cdk-dep-action.md#cdk-dep-action-cdk-version) 
+ [Versiones de CDK CLI utilizadas por la acción «AWS CDK bootstrap»](cdk-boot-action.md#cdk-boot-action-cdk-version)

Interfaz de usuario correspondiente: pestaña de configuración/versión **AWS CDK CLI**

## CdkRootPath
<a name="cdk.dep.cdk.root.path"></a>

(*CDKDeploy*/Configuration/**CdkRootPath**)

(Opcional)

La ruta al directorio que contiene el `cdk.json` archivo del AWS CDK proyecto. La acción **Implementación de AWS CDK ** se ejecuta desde esta carpeta y cualquier resultado creado por la acción se añadirá a este directorio. Si no se especifica, la acción de **AWS CDK despliegue** asume que el `cdk.json` archivo está en la raíz del AWS CDK proyecto.

Interfaz de usuario correspondiente: pestaña Configuración/**Directorio donde reside el archivo cdk.json**

## CfnOutputVariables
<a name="cdk.dep.cfn.out"></a>

(*CDKDeploy*/Configuration/**CfnOutputVariables**)

(Opcional)

Especifique qué `CfnOutput` componentes del código de AWS CDK la aplicación desea exponer como variables de salida del flujo de trabajo. A continuación, puede hacer referencia a las variables de salida del flujo de trabajo en acciones posteriores del flujo de trabajo. Para obtener más información sobre las variables en CodeCatalyst, consulte[Uso de variables en flujos de trabajo](workflows-working-with-variables.md).

Por ejemplo, si el código de AWS CDK la aplicación tiene este aspecto:

```
import { Duration, Stack, StackProps, CfnOutput, RemovalPolicy} from 'aws-cdk-lib';
import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
import * as s3 from 'aws-cdk-lib/aws-s3';
import { Construct } from 'constructs';
import * as cdk from 'aws-cdk-lib';
export class HelloCdkStack extends Stack {
  constructor(scope: Construct, id: string, props?: StackProps) {
    super(scope, id, props);
    const bucket = new s3.Bucket(this, 'amzn-s3-demo-bucket', {
      removalPolicy: RemovalPolicy.DESTROY,
    });
    new CfnOutput(this, 'bucketName', {
      value: bucket.bucketName,
      description: 'The name of the s3 bucket',
      exportName: 'amzn-s3-demo-bucket',
    });
    const table = new dynamodb.Table(this, 'todos-table', {
      partitionKey: {name: 'todoId', type: dynamodb.AttributeType.NUMBER},
      billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
      removalPolicy: RemovalPolicy.DESTROY,
    })
    new CfnOutput(this, 'tableName', {
      value: table.tableName,
      description: 'The name of the dynamodb table',
      exportName: 'myDynamoDbTable',
    });
    ...
  }
}
```

...y la propiedad `CfnOutputVariables` tiene este aspecto:

```
Configuration:
  ...
  CfnOutputVariables: '["bucketName","tableName"]'
```

...entonces la acción genera las siguientes variables de salida del flujo de trabajo:


| Clave | Valor | 
| --- | --- | 
|  bucketName  |  `bucket.bucketName`  | 
|  tableName  |  `table.tableName`  | 

A continuación, puede hacer referencia a las variables `bucketName` y `tableName` en acciones posteriores. Para aprender a hacer referencia a las variables de salida del flujo de trabajo en acciones posteriores, consulte [Referencia a una variable predefinida](workflows-working-with-variables-reference-output-vars.md).

Si no especifica ningún `CfnOutput` componente fijo en la `CfnOutputVariables` propiedad, la acción expone las cuatro primeras variables de salida (o menos) que encuentre como variables de CloudFormation salida del flujo de trabajo. Para obtener más información, consulte [Variables de 'Implementación de AWS CDK '](cdk-dep-action-variables.md).

**sugerencia**  
Para obtener una lista de todas las variables de CloudFormation salida que produce la acción, ejecuta el flujo de trabajo que contiene la acción de **AWS CDK despliegue** una vez y, a continuación, consulta la pestaña **Registros** de la acción. Los registros contienen una lista de todas las variables CloudFormation de salida asociadas a tu AWS CDK aplicación. Una vez que sepas cuáles son todas las CloudFormation variables, puedes especificar cuáles quieres convertir en variables de salida del flujo de trabajo mediante la `CfnOutputVariables` propiedad.

Para obtener más información sobre las variables de CloudFormation salida, consulta la documentación de la `CfnOutput` construcción, disponible en la [clase CfnOutput (construcción)](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.CfnOutput.html) de la *referencia de la AWS Cloud Development Kit (AWS CDK) API*.

Interfaz de usuario correspondiente: pestaña de configuración/variables **CloudFormation de salida**

## CloudAssemblyRootPath
<a name="cdk.dep.cloud"></a>

(*CDKDeploy*/Configuration/**CloudAssemblyRootPath**)

(Opcional)

Si ya sintetizó la pila de su AWS CDK aplicación en un ensamblaje en la nube (mediante la `cdk synth` operación), especifique la ruta raíz del directorio del ensamblaje en la nube (`cdk.out`). La CloudFormation plantilla ubicada en el directorio de ensamblaje de nube especificado se implementará mediante la acción de **AWS CDK implementación** Cuenta de AWS mediante el `cdk deploy --app` comando. Cuando la opción `--app` está presente, la operación `cdk synth` no se produce.

Si no especifica un directorio de ensamblado en la nube, la acción **Implementación de AWS CDK ** ejecutará el comando `cdk deploy` sin la opción `--app`. Sin `--app` esta opción, la `cdk deploy` operación sintetizará (`cdk synth`) e implementará tu AWS CDK aplicación en tu Cuenta de AWS. 

**¿Por qué especificaría un ensamblaje de nube sintetizado y existente cuando la acción de «AWS CDK despliegue» puede realizar la síntesis en tiempo de ejecución?**

Es posible que desee especificar un ensamblado en la nube sintetizado existente para:
+ **Asegúrese de implementar exactamente el mismo conjunto de recursos cada vez que se ejecute la acción de «AWS CDK despliegue»**

  Si no especifica un ensamblado en la nube, es posible que la acción **Implementación de AWS CDK ** sintetice e implemente archivos diferentes en función de cuándo se ejecute. Por ejemplo, la acción **Implementación de AWS CDK ** podría sintetizar un ensamblado en la nube con un conjunto de dependencias durante una fase de prueba y otro conjunto de dependencias durante una fase de producción (si esas dependencias cambiaran de una fase a otra). Para garantizar una paridad exacta entre lo que se ha probado y lo que se ha implementado, se recomienda sintetizar una vez y, después, usar el campo **Ruta al directorio de ensamblado en la nube** (editor visual) o la propiedad `CloudAssemblyRootPath` (editor de YAML) para especificar el ensamblado de nube ya sintetizado.
+ **Usar herramientas y administradores de paquetes no estándares con la aplicación de AWS CDK **

  Durante una operación `synth`, la acción **Implementación de AWS CDK ** intenta ejecutar la aplicación con herramientas estándar, como npm o pip. Si la acción no puede ejecutar correctamente la aplicación con esas herramientas, la síntesis no se producirá y la acción fallará. Para solucionar este problema, puedes especificar los comandos exactos necesarios para ejecutar la aplicación correctamente en el `cdk.json` archivo de la AWS CDK aplicación y, a continuación, sintetizarla mediante un método que no implique la acción de **AWS CDK implementación**. Una vez generado el ensamblado en la nube, puede especificarlo en el campo **Ruta al directorio de ensamblado en la nube** (editor visual) o en la propiedad `CloudAssemblyRootPath` (editor de YAML) de la acción **Implementación de AWS CDK **. 

Para obtener información sobre cómo configurar el `cdk.json` archivo para que incluya comandos para instalar y ejecutar la AWS CDK aplicación, consulte [Especificar el comando de la aplicación](https://docs.aws.amazon.com/cdk/v2/guide/cli.html#cli-app-command).

Para obtener información sobre los comandos `cdk deploy` y `cdk synth`, así como sobre la opción `--app`, consulte [Deploying stacks](https://docs.aws.amazon.com/cdk/v2/guide/cli.html#cli-deploy), [Synthesizing stacks](https://docs.aws.amazon.com/cdk/v2/guide/cli.html#cli-synth) y [Skipping synthesis](https://docs.aws.amazon.com/cdk/v2/guide/cli.html#cli-deploy-nosynth) en la *Guía para desarrolladores de AWS Cloud Development Kit (AWS CDK) *.

Para obtener información acerca de los ensamblados en la nube, consulte [Cloud Assembly](https://docs.aws.amazon.com/cdk/api/v2/docs/cloud-assembly-schema-readme.html) en la *Referencia de la API de AWS Cloud Development Kit (AWS CDK) *.

Interfaz de usuario correspondiente: pestaña Configuración/**Ruta al directorio de ensamblado en la nube**

# Cómo iniciar una AWS CDK aplicación con un flujo de trabajo
<a name="cdk-boot-action"></a>

En esta sección se describe cómo iniciar una AWS CDK aplicación mediante un CodeCatalyst flujo de trabajo. Para ello, debe añadir la acción **Arranque de AWS CDK ** a su flujo de trabajo. La acción **Arranque de AWS CDK ** aprovisiona una pila de arranque en su entorno de AWS mediante la [plantilla moderna](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html#bootstrapping-template). Si ya existe una pila de arranque, la acción la actualiza si es necesario. Contar con una pila de bootstrap AWS es un requisito previo para implementar una AWS CDK aplicación.

Para obtener más información acerca del arranque, consulte [Bootstrapping](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html) en la *Guía para desarrolladores de AWS Cloud Development Kit (AWS CDK) *.

**Topics**
+ [¿Cuándo usar la acción «AWS CDK arrancar»](#cdk-boot-action-when-to-use)
+ [Cómo funciona la acción «AWS CDK bootstrap»](#cdk-boot-action-how-it-works)
+ [Versiones de CDK CLI utilizadas por la acción «AWS CDK bootstrap»](#cdk-boot-action-cdk-version)
+ [Imagen de tiempo de ejecución utilizada por la acción «bootstrap»AWS CDK](#cdk-boot-action-runtime)
+ [Ejemplo: iniciar una aplicación AWS CDK](cdk-boot-action-example-workflow.md)
+ [Añadir la acción 'AWS CDK bootstrap'](cdk-boot-action-add.md)
+ [Variables de 'Arranque de AWS CDK '](cdk-boot-action-variables.md)
+ [Acción 'Arranque de AWS CDK ' en YAML](cdk-boot-action-ref.md)

## ¿Cuándo usar la acción «AWS CDK arrancar»
<a name="cdk-boot-action-when-to-use"></a>

Use esta acción si tiene un flujo de trabajo que implementa una AWS CDK aplicación y desea implementar (y actualizar, si es necesario) la pila de bootstrap al mismo tiempo. En este caso, añadiría la acción de **AWS CDK arranque** al mismo flujo de trabajo que el que implementa la aplicación. AWS CDK 

**No** utilice esta acción si se dan alguna de las siguientes circunstancias:
+ Ya ha implementado una pila de arranque mediante otro mecanismo y desea mantenerla intacta (sin actualizaciones).
+ Desea utilizar una [plantilla de arranque personalizada](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html#bootstrapping-customizing) que no es compatible con la acción **Arranque de AWS CDK **.

## Cómo funciona la acción «AWS CDK bootstrap»
<a name="cdk-boot-action-how-it-works"></a>

La acción **Arranque de AWS CDK ** funciona de la siguiente manera:

1. [En tiempo de ejecución, si especificó la versión 1.0.7 o anterior de la acción, la acción descarga la última CLI de CDK (también denominada kit de herramientas) AWS CDK a la imagen de compilación. CodeCatalyst ](build-images.md)

   Si especificó la versión 1.0.8 o posterior, la acción viene incluida con una [versión específica](cdk-dep-action.md#cdk-dep-action-cdk-version) de la CLI de CDK, por lo que no se produce ninguna descarga.

1. La acción utiliza la CLI de CDK para ejecutar el comando `cdk bootstrap`. Este comando realiza las tareas de arranque descritas en el tema [Bootstrapping](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html) de la *Guía para desarrolladores de AWS Cloud Development Kit (AWS CDK) *.

## Versiones de CDK CLI utilizadas por la acción «AWS CDK bootstrap»
<a name="cdk-boot-action-cdk-version"></a>

En la siguiente tabla se muestra qué versión de la CLI de CDK utilizan de forma predeterminada las diferentes versiones de la acción **Arranque de AWS CDK **.

**nota**  
Puede invalidar la predeterminada. Para obtener más información, consulte [CdkCliVersion](cdk-boot-action-ref.md#cdk.boot.cdk.cli.version) en la [Acción 'Arranque de AWS CDK ' en YAML](cdk-boot-action-ref.md).


| Versión de la acción 'Arranque de AWS CDK ' | AWS CDK Versión CLI | 
| --- | --- | 
|  1.0.0 – 1.0.7  |  más reciente  | 
|  1.0.8 o posterior  |  2.99.1  | 

## Imagen de tiempo de ejecución utilizada por la acción «bootstrap»AWS CDK
<a name="cdk-boot-action-runtime"></a>

**La siguiente tabla muestra las imágenes del entorno de ejecución que se CodeCatalyst utilizan para ejecutar diferentes versiones de la AWS CDK acción de arranque.** Las imágenes incluyen diferentes conjuntos de herramientas preinstaladas. Para obtener más información, consulte [Imágenes activas](build-images.md#build-curated-images).

**nota**  
Le recomendamos que actualice la acción **Arranque de AWS CDK ** a la versión 2.x para aprovechar las últimas herramientas disponibles en la imagen de marzo de 2024. Para actualizar la acción, defina su propiedad `Identifier` en `aws/cdk-bootstrap@v2` en el archivo de definición de flujo de trabajo. Para obtener más información, consulte [YAML de la acción 'Implementación de AWS CDK '](cdk-dep-action-ref.md). 


| Versión de la acción 'Arranque de AWS CDK ' | Imágenes del entorno en tiempo de ejecución | 
| --- | --- | 
|  1.x  |  Imágenes de noviembre de 2022  | 
|  2.x  |  Imágenes de marzo de 2024  | 

# Ejemplo: iniciar una aplicación AWS CDK
<a name="cdk-boot-action-example-workflow"></a>

Consulte el [Ejemplo: Implementación de una AWS CDK aplicación](cdk-dep-action-example-workflow.md) en la [Implementación de una AWS CDK aplicación con un flujo de trabajo](cdk-dep-action.md) para ver un flujo de trabajo que incluye la acción **Arranque de AWS CDK **.

# Añadir la acción 'AWS CDK bootstrap'
<a name="cdk-boot-action-add"></a>

 Siga estas instrucciones para añadir la acción **Arranque de AWS CDK ** a su flujo de trabajo. 

**Antes de empezar**

Para poder usar la acción **Arranque de AWS CDK **, asegúrese de tener una aplicación de AWS CDK . La acción de arranque sintetizará la aplicación antes del arranque. AWS CDK Puede escribir la aplicación en cualquier lenguaje de programación compatible con AWS CDK.

Asegúrate de que los archivos de tu AWS CDK aplicación estén disponibles en:
+ Un [repositorio CodeCatalyst de origen](source.md), o 
+ Un [artefacto CodeCatalyst de salida](workflows-working-artifacts.md) generado por otra acción del flujo de trabajo

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

**Para añadir la acción «AWS CDK arrancar» mediante 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 **Arranque de AWS CDK ** 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 **Arranque de AWS CDK **. Aparecerá el cuadro de diálogo de detalles de la acción. En este cuadro de diálogo:
     + (Opcional) Seleccione **Ver código fuente** 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**, **Configuración** y **Salidas**, complete los campos según sus necesidades. Para obtener una descripción de cada uno de los campos, consulte la [Acción 'Arranque de AWS CDK ' en YAML](cdk-boot-action-ref.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**.
**nota**  
Si la acción **Arranque de AWS CDK ** falla y se produce un error `npm install`, consulte [¿Cómo puedo corregir los errores npm install?](troubleshooting-workflows.md#troubleshooting-workflows-npm) para obtener información sobre cómo corregir el error.

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

**Para añadir la acción «AWS CDK bootstrap» mediante el editor YAML**

1. [Abre la consola en https://codecatalyst.aws/ CodeCatalyst .](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 **Arranque de AWS CDK ** y elija **\$1** para añadirla 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 'Arranque de AWS CDK ' en YAML](cdk-boot-action-ref.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**.
**nota**  
Si la acción **Arranque de AWS CDK ** falla y se produce un error `npm install`, consulte [¿Cómo puedo corregir los errores npm install?](troubleshooting-workflows.md#troubleshooting-workflows-npm) para obtener información sobre cómo corregir el error.

------

# Variables de 'Arranque de AWS CDK '
<a name="cdk-boot-action-variables"></a>

La acción **Arranque de AWS CDK ** 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 | 
| --- | --- | 
|  deployment-platform  |  El nombre de la plataforma de implementación. Codificado en `AWS:CloudFormation`.  | 
|  region  |  El código de región en el Región de AWS que se implementó la pila de AWS CDK arranque durante la ejecución del flujo de trabajo. Ejemplo: `us-west-2`  | 
|  stack-id  |  El nombre de recurso de Amazon (ARN) de la pila de AWS CDK bootstrap implementada. Ejemplo: `arn:aws:cloudformation:us-west-2:111122223333:stack/codecatalyst-cdk-bootstrap-stack/6aad4380-100a-11ec-a10a-03b8a84d40df`  | 
|  SKIP-DEPLOYMENT  |  Un valor de `true` indica que se omitió el despliegue de la pila de AWS CDK bootstrap durante la ejecución del flujo de trabajo. Se omitirá la implementación de una pila si no se ha producido ningún cambio en la pila desde la última implementación. Esta variable solo se genera si su valor es `true`. Codificado en `true`.  | 

# Acción 'Arranque de AWS CDK ' en YAML
<a name="cdk-boot-action-ref"></a>

La siguiente es la definición en YAML de la acción **Arranque de AWS CDK **. Para obtener información sobre cómo utilizar esta acción, consulte [Cómo iniciar una AWS CDK aplicación con un flujo de trabajo](cdk-boot-action.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.    
  CDKBootstrapAction\$1nn: 
    Identifier: aws/cdk-bootstrap@v2
    DependsOn:
      - action-name
    Compute:  
      Type: EC2 | Lambda
      Fleet: fleet-name
    Timeout: timeout-minutes
    Inputs:
      # Specify a source or an artifact, but not both.
      Sources:
        - source-name-1
      Artifacts:
        - artifact-name
    Outputs:
      Artifacts:
        - Name: cdk_bootstrap_artifacts
          Files: 
            - "cdk.out/**/*"
    Environment:
      Name: environment-name
      Connections:
        - Name: account-connection-name
          Role: iam-role-name
    Configuration:
      Region: us-west-2
      CdkCliVersion: version
```

## CDKBootstrapAction
<a name="cdk.boot.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: `CDKBootstrapAction_nn`.

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

## Identifier
<a name="cdk.boot.identifier"></a>

(*CDKBootstrapAction*/**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).

**nota**  
Si se especifica `aws/cdk-bootstrap@v2`, la acción se ejecuta en la [imagen de marzo de 2024](build-images.md#build.default-image), que incluye herramientas más recientes, como Node.js 18. Si se especifica `aws/cdk-bootstrap@v1`, la acción se ejecuta en la [imagen de noviembre de 2022](build-images.md#build.previous-image), que incluye herramientas más antiguas, como Node.js 16.

Predeterminado: `aws/cdk-bootstrap@v2`.

Interfaz de usuario correspondiente: Diagrama de flujo de trabajo/CDKBootstrapAction\$1nn/etiqueta **aws/cdk-bootstrap@v2**

## DependsOn
<a name="cdk.boot.dependson"></a>

(*CDKBootstrapAction*/**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="cdk.boot.computename"></a>

(*CDKBootstrapAction*/**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="cdk.boot.computetype"></a>

(*CDKBootstrapAction*/Compute/**Type**)

(Obligatorio si se incluye [Compute](#cdk.boot.computename))

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

  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 tab/Advanced : opcional/tipo de cálculo**

## Fleet
<a name="cdk.boot.computefleet"></a>

(*CDKBootstrapAction*/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="cdk.boot.timeout"></a>

(*CDKBootstrapAction*/**Timeout**)

(Obligatorio) 

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

## Inputs
<a name="cdk.boot.inputs"></a>

(*CDKBootstrapAction*/**Inputs**)

(Opcional)

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

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

**nota**  
Solo se permite una entrada (ya sea un código fuente o un artefacto) para cada acción **Arranque de AWS CDK **.

## Sources
<a name="cdk.boot.inputs.sources"></a>

(*CDKBootstrapAction*/Inputs/**Sources**)

(Obligatorio si AWS CDK la aplicación está almacenada en un repositorio de código fuente)

Si tu AWS CDK aplicación está almacenada en un repositorio de origen, especifica la etiqueta de ese repositorio de origen. La acción **Arranque de AWS CDK ** sintetiza la aplicación en este repositorio antes de iniciar el proceso de arranque. Actualmente, la única etiqueta de repositorio admitida es `WorkflowSource`.

Si tu AWS CDK aplicación no está incluida en un repositorio de origen, 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="cdk.boot.inputs.artifacts"></a>

(*CDKBootstrapAction*/Inputs/**Artifacts**)

(Obligatorio si tu AWS CDK aplicación está almacenada en un [artefacto de salida](workflows-working-artifacts-output.md) de una acción anterior)

Si tu AWS CDK aplicación está incluida en un artefacto generado por una acción anterior, especifica ese artefacto aquí. La acción de **AWS CDK arranque** sintetiza la aplicación del artefacto especificado en una CloudFormation plantilla antes de iniciar el proceso de arranque. Si la aplicación de AWS CDK no está incluida 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 Entradas/**Artefactos (opcional)**

## Outputs
<a name="cdk.boot.outputs"></a>

(*CDKBootstrapAction*/**Outputs**)

(Opcional)

Define los datos que necesita una acción durante la ejecución de un flujo de trabajo.

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

## Artifacts - output
<a name="cdk.boot.outputs.artifacts"></a>

(*CDKBootstrapAction*/Outputs/**Artifacts**)

(Opcional)

Especifique el nombre de los artefactos generados por la acción. Puede hacer referencia a estos artefactos como entrada en otras acciones.

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 Salidas/**Artefactos**

## Name
<a name="cdk.boot.outputs.artifacts.name"></a>

(*CDKBootstrapAction*/Outputs/Artifacts/**Name**)

(Obligatorio si se incluye [Artifacts - output](#cdk.boot.outputs.artifacts))

**Especifique el nombre del artefacto que contendrá la CloudFormation plantilla sintetizada por la acción de arranque en tiempo de ejecución.AWS CDK ** El valor predeterminado es `cdk_bootstrap_artifacts`. Si no especifica un artefacto, la acción sintetizará la plantilla, pero no la guardará en un artefacto. Considere la posibilidad de guardar la plantilla sintetizada en un artefacto para conservar un registro de la misma para probarla o solucionar problemas.

**Interfaz de usuario correspondiente: genera el nombre del artefacto/crea el nombre del tab/Artifacts/Add artefacto**

## Files
<a name="cdk.boot.outputs.artifacts.files"></a>

(*CDKBootstrapAction*/Outputs/Artifacts/**Files**)

(Obligatorio si se incluye [Artifacts - output](#cdk.boot.outputs.artifacts))

Especifique los archivos que desee incluir en el artefacto. Debes especificar si quieres incluir `"cdk.out/**/*"` la plantilla sintetizada de tu AWS CDK aplicación. CloudFormation 

**nota**  
`cdk.out` es el directorio predeterminado en el que se guardan los archivos sintetizados. Si especificó un directorio de salida distinto de `cdk.out` en el archivo `cdk.json`, especifique ese directorio aquí en lugar de `cdk.out`.

Interfaz de usuario correspondiente: genera tab/Artifacts/Add artefactos o **archivos** producidos por la compilación

## Environment
<a name="cdk.boot.environment"></a>

(*CDKBootstrapAction*/**Environment**)

(Obligatorio) 

Especifica el CodeCatalyst entorno que se va a utilizar 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="cdk.boot.environment.name"></a>

(*CDKBootstrapAction*/Environment/**Name**)

(Obligatorio si se incluye [Environment](#cdk.boot.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="cdk.boot.environment.connections"></a>

(*CDKBootstrapAction*/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="cdk.boot.environment.connections.name"></a>

(*CDKBootstrapAction*/Environment/Connections/**Name**)

(Obligatorio si se incluye [Connections](#cdk.boot.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="cdk.boot.environment.connections.role"></a>

(*CDKBootstrapAction*/Environment/Connections/**Role**)

(Obligatorio si se incluye [Connections](#cdk.boot.environment.connections))

Especifique el nombre de la función de IAM que la acción de **AWS CDK arranque utiliza para acceder a la pila de arranque** AWS y añadirla. 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 políticas adecuadas.

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

## Configuration
<a name="cdk.boot.configuration"></a>

(*CDKBootstrapAction*/**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="cdk.boot.region"></a>

(*CDKBootstrapAction*/Configuration/**Region**)

(Obligatorio) 

Especifique el lugar Región de AWS en el que se desplegará la pila de arranque. Esta región debe coincidir con aquella en la que se implementa AWS CDK la aplicación. Para ver una lista de códigos de regiones, consulte [Puntos de conexión regionales](https://docs.aws.amazon.com/general/latest/gr/rande.html#region-names-codes).

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

## CdkCliVersion
<a name="cdk.boot.cdk.cli.version"></a>

(*CDKBootstrapAction*/Configuration/**CdkCliVersion**)

(Opcional)

Esta propiedad está disponible en la versión 1.0.13 o posterior de la acción **Implementación de AWS CDK ** y en la versión 1.0.8 o posterior de la acción **Arranque de AWS CDK **.

Especifique uno de los siguientes valores:
+ La versión completa de la interfaz de línea de AWS Cloud Development Kit (AWS CDK) comandos (CLI) (también denominada AWS CDK kit de herramientas) que desea que utilice esta acción. Ejemplo: `2.102.1`. Considere la posibilidad de especificar una versión completa para garantizar la coherencia y la estabilidad al crear e implementar la aplicación.

  O
+ `latest`. Considere la posibilidad de especificar `latest` para aprovechar las características y correcciones más recientes de la CLI de CDK.

La acción descargará la versión especificada (o la última versión) de la AWS CDK CLI a la [imagen de CodeCatalyst compilación](build-images.md) y, a continuación, utilizará esta versión para ejecutar los comandos necesarios para implementar la aplicación CDK o arrancar el entorno. AWS 

Para obtener una lista de las versiones de CLI de CDK compatibles que puede utilizar, consulte [Versiones de AWS CDK](https://docs.aws.amazon.com/cdk/api/versions.html).

Si omite esta propiedad, la acción utilizará una versión AWS CDK CLI predeterminada que se describe en uno de los temas siguientes:
+ [Versiones de CDK CLI utilizadas por la acción de «AWS CDK implementar»](cdk-dep-action.md#cdk-dep-action-cdk-version) 
+ [Versiones de CDK CLI utilizadas por la acción «AWS CDK bootstrap»](cdk-boot-action.md#cdk-boot-action-cdk-version)

Interfaz de usuario correspondiente: pestaña de configuración/versión **AWS CDK CLI**

# Publicación de archivos en Amazon S3 con un flujo de trabajo
<a name="s3-pub-action"></a>

En esta sección se describe cómo publicar archivos en Amazon S3 mediante un CodeCatalyst flujo de trabajo. Para ello, debe añadir la acción **Amazon S3 publish** a su flujo de trabajo. La acción **Amazon S3 publish** copia los archivos desde un directorio de origen a un bucket de Amazon S3. El directorio de origen puede residir en:
+ un [repositorio de código fuente](source.md); o 
+ un [artefacto de salida](workflows-working-artifacts.md) generado por otra acción del flujo de trabajo.

**Topics**
+ [Cuándo utilizar la acción Amazon S3 publish](#s3-pub-action-when-to-use)
+ [Imagen de tiempo de ejecución utilizada por la acción Amazon S3 publish](#s3-pub-action-runtime)
+ [Ejemplo: Publicación de archivos en Amazon S3](s3-pub-action-example-workflow.md)
+ [Cómo añadir la acción Amazon S3 publish](s3-pub-action-add.md)
+ [Acción Amazon S3 publish en YAML](s3-pub-action-ref.md)

## Cuándo utilizar la acción Amazon S3 publish
<a name="s3-pub-action-when-to-use"></a>

Esta acción se usa si:
+ Tiene un flujo de trabajo que genere los archivos que quiera almacenar en Amazon S3.

  Por ejemplo, es posible que tenga un flujo de trabajo que cree un sitio web estático que quiera alojar en Amazon S3. En este caso, su flujo de trabajo incluiría una [acción de compilación](build-add-action.md) para crear el HTML y los archivos auxiliares del sitio, y una acción **Amazon S3 publish** para copiar los archivos en Amazon S3.
+ Tiene un repositorio de código fuente que contenga los archivos que quiera almacenar en Amazon S3.

  Por ejemplo, puede tener un repositorio de código fuente con archivos de código fuente de las aplicaciones que quiera archivar todas las noches en Amazon S3.

## Imagen de tiempo de ejecución utilizada por la acción Amazon S3 publish
<a name="s3-pub-action-runtime"></a>

La acción **Amazon S3 publish** 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).

# Ejemplo: Publicación de archivos en Amazon S3
<a name="s3-pub-action-example-workflow"></a>

El siguiente flujo de trabajo de ejemplo incluye la acción **Amazon S3 publish**, junto con una acción de compilación. El flujo de trabajo crea un sitio web de documentación estática y después lo publica en Amazon S3, donde está alojado. 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** (`BuildDocs`): al activarla, la acción crea un sitio web de documentación estática (`mkdocs build`) y añade los archivos HTML asociados y los metadatos auxiliares a un artefacto llamado `MyDocsSite`. 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 **Amazon S3 publish** (`PublishToS3`): al finalizar la acción de compilación, esta acción copia el sitio del artefacto `MyDocsSite` a Amazon S3 para su alojamiento.

**nota**  
El siguiente ejemplo de flujo de trabajo tiene fines ilustrativos y no funcionará sin una configuración adicional.

**nota**  
En el código de YAML que aparece a continuación, puede omitir la sección `Connections:` si lo desea. Si omite esta sección, debe asegurarse de que el rol especificado en el campo **Rol de IAM predeterminado** de su entorno incluya los permisos y las políticas de confianza requeridos por la acción **Amazon S3 publish**. 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). Para obtener más información sobre los permisos y las políticas de confianza que requiere la acción **Amazon S3 publish**, consulte la descripción de la propiedad [Role](s3-pub-action-ref.md#s3.pub.environment.connections.role) en la [Acción Amazon S3 publish en YAML](s3-pub-action-ref.md).

```
Name: codecatalyst-s3-publish-workflow
SchemaVersion: 1.0

Triggers:
  - Type: PUSH
    Branches:
      - main
Actions:
  BuildDocs:
    Identifier: aws/build@v1
    Inputs:
      Sources:
        - WorkflowSource
    Configuration:
      Steps:
        - Run: echo BuildDocs started on `date`
        - Run: pip install --upgrade pip
        - Run: pip install mkdocs
        - Run: mkdocs build
        - Run: echo BuildDocs completed on `date`
    Outputs:
      Artifacts:
      - Name: MyDocsSite
        Files:
          - "site/**/*"
        
  PublishToS3:
    Identifier: aws/s3-publish@v1
    Environment:
      Name: codecatalyst-s3-publish-environment
      Connections:
        - Name: codecatalyst-account-connection
          Role: codecatalyst-s3-publish-build-role
    Inputs:
      Sources:
        - WorkflowSource
      Artifacts:
        - MyDocsSite
    Configuration:      
      DestinationBucketName: amzn-s3-demo-bucket
      SourcePath: /artifacts/PublishToS3/MyDocSite/site
      TargetPath: my/docs/site
```

# Cómo añadir la acción Amazon S3 publish
<a name="s3-pub-action-add"></a>

 Siga estas instrucciones para añadir la acción **Amazon S3 publish** a su flujo de trabajo. 

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

**Cómo añadir la acción Amazon S3 publish 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 **Amazon S3 publish** y realice una de las siguientes opciones:
   + 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 **Amazon S3 publish**. Aparecerá el cuadro de diálogo de detalles de la acción. En este cuadro de diálogo:
     + (Opcional) Seleccione **Ver código fuente** 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**, **Configuración** y **Salidas**, complete los campos según sus necesidades. Para obtener una descripción de cada uno de los campos, consulte la [Acción Amazon S3 publish en YAML](s3-pub-action-ref.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 ]

**Cómo añadir la acción Amazon S3 publish 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 **Amazon S3 publish** y realice una de las siguientes opciones:
   + 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 **Amazon S3 publish**. Aparecerá el cuadro de diálogo de detalles de la acción. En este cuadro de diálogo:
     + (Opcional) Seleccione **Ver código fuente** 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 Amazon S3 publish en YAML](s3-pub-action-ref.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**.

------

# Acción Amazon S3 publish en YAML
<a name="s3-pub-action-ref"></a>

La siguiente es la definición en YAML de la acción **Amazon S3 publish**. Para obtener información sobre cómo utilizar esta acción, consulte [Publicación de archivos en Amazon S3 con un flujo de trabajo](s3-pub-action.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.    
  S3Publish\$1nn: 
    Identifier: aws/s3-publish@v1
    DependsOn:
      - build-action
    Compute:  
      Type: EC2 | Lambda
      Fleet: fleet-name
    Timeout: timeout-minutes
    Inputs:
      Sources:
        - source-name-1
      Artifacts:
        - artifact-name
      Variables:
        - Name: variable-name-1
          Value: variable-value-1
        - Name: variable-name-2
          Value: variable-value-2
    Environment:
      Name: environment-name
      Connections:
        - Name: account-connection-name
          Role: iam-role-name
    Configuration:
      SourcePath: my/source
      DestinationBucketName: amzn-s3-demo-bucket
      TargetPath: my/target
```

## S3Publish
<a name="s3.pub.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: `S3Publish_nn`.

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

## Identifier
<a name="s3.pub.identifier"></a>

(*S3Publish*/**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/s3-publish@v1`.

Interfaz de usuario correspondiente: diagrama de flujo de trabajo/S3Publish\$1nn/etiqueta **aws/s3-publish@v1**

## DependsOn
<a name="s3.pub.dependson"></a>

(*S3Publish*/**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="s3.pub.computename"></a>

(*S3Publish*/**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="s3.pub.computetype"></a>

(*S3Publish*/Compute/**Type**)

(Obligatorio si se incluye [Compute](#s3.pub.computename))

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

  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: pestaña Configuración/**Tipo de computación**

## Fleet
<a name="s3.pub.computefleet"></a>

(*S3Publish*/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: pestaña Configuración/**Flota de computación**

## Timeout
<a name="s3.pub.timeout"></a>

(*S3Publish*/**Timeout**)

(Obligatorio) 

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

## Inputs
<a name="s3.pub.inputs"></a>

(*S3Publish*/**Inputs**)

(Opcional)

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

**nota**  
Se permite un máximo de cuatro entradas (un origen y tres artefactos) en cada acción **AWS CDK deploy**. Las variables no se contabilizan en este total.

Si necesita hacer referencia a archivos que se encuentran en entradas diferentes (por ejemplo, un código fuente y un artefacto), la entrada de código fuente es la entrada principal y el artefacto es la entrada secundaria. Las referencias a los archivos en las entradas secundarias llevan un prefijo especial para distinguirlas de las principales. Para obtener más información, consulte [Ejemplo: Referencia a archivos en varios artefactos](workflows-working-artifacts-ex.md#workflows-working-artifacts-ex-ref-file).

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

## Sources
<a name="s3.pub.inputs.sources"></a>

(*S3Publish*/Inputs/**Sources**)

(Obligatorio si los archivos que quiera publicar en Amazon S3 están almacenados en un repositorio de código fuente)

Si los archivos que quiera publicar en Amazon S3 están almacenados en un repositorio de código fuente, especifique la etiqueta de ese repositorio de código fuente. Actualmente, la única etiqueta admitida es `WorkflowSource`.

Si los archivos que quiera publicar en Amazon S3 no están incluidos en un repositorio de código fuente, deben 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="s3.pub.inputs.artifacts"></a>

(*S3Publish*/Inputs/**Artifacts**)

(Obligatorio si los archivos que quiera publicar en Amazon S3 están almacenados en un [artefacto de salida](workflows-working-artifacts-output.md) de una acción anterior)

Si los archivos que quiera publicar en Amazon S3 están contenidos en un artefacto generado por una acción anterior, especifique ese artefacto aquí. Si los archivos no están incluidos en un artefacto, deben 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)**

## Variables - input
<a name="s3.pub.inputs.variables"></a>

(*S3Publish*/Inputs/**Variables**)

(Opcional)

Especifique una secuencia de name/value pares que defina las variables de entrada que desea que estén disponibles para la acción. Los nombres de variables 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 variables.

Para obtener más información sobre las variables, incluidos ejemplos, consulte [Uso de variables en flujos de trabajo](workflows-working-with-variables.md).

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

## Environment
<a name="s3.pub.environment"></a>

(*S3Publish*/**Environment**)

(Obligatorio) 

Especifique el CodeCatalyst entorno que se va a utilizar 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="s3.pub.environment.name"></a>

(*S3Publish*/Environment/**Name**)

(Obligatorio si se incluye [Environment](#s3.pub.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="s3.pub.environment.connections"></a>

(*S3Publish*/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="s3.pub.environment.connections.name"></a>

(*S3Publish*/Environment/Connections/**Name**)

(Obligatorio si se incluye [Connections](#s3.pub.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="s3.pub.environment.connections.role"></a>

(*S3Publish*/Environment/Connections/**Role**)

(Obligatorio si se incluye [Connections](#s3.pub.environment.connections))

Especifique el nombre de la función de IAM que la acción de **publicación de Amazon S3** utiliza para acceder a los archivos de Amazon S3 AWS y copiarlos. 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": [
          {
              "Sid": "VisualEditor0",
              "Effect": "Allow",
              "Action": [
                  "s3:PutObject",
                  "s3:ListBucket",
                  "s3:DeleteObject"
              ],
              "Resource": [
                  "arn:aws:s3:::bucket-name",
                  "arn:aws:s3:::bucket-name/*"
              ]
          }
      ]
  }
  ```

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

## Configuration
<a name="s3.pub.configuration"></a>

(*S3Publish*/**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**

## SourcePath
<a name="s3.pub.source.directory"></a>

(*S3Publish*/Configuration/**SourcePath**)

(Obligatorio) 

Especifique el nombre y la ruta del directorio o archivo que quiera publicar en Amazon S3. El directorio o archivo puede residir en un repositorio de código fuente o en un artefacto de una acción anterior y son relativas a la raíz del repositorio de código fuente o del artefacto.

Ejemplos:

La especificación de `./myFolder/` copia el contenido de `/myFolder` en Amazon S3 y conserva la estructura de directorios subyacente.

La especificación de `./myFolder/myfile.txt` copia *únicamente *`myfile.txt` en Amazon S3. (Se elimina la estructura de directorios).

No puede utilizar caracteres comodín.

**nota**  
Puede que tenga que añadir un prefijo al directorio o ruta del archivo para indicar en qué artefacto u origen debe encontrarlo. Para obtener más información, consulte [Referencia a los archivos del repositorio de código fuente](workflows-sources-reference-files.md) y [Referencia a archivos en un artefacto](workflows-working-artifacts-refer-files.md).

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

## DestinationBucketName
<a name="s3.pub.dest.bucket"></a>

(*S3Publish*/Configuration/**DestinationBucketName**)

(Obligatorio) 

Especifique el nombre del bucket de Amazon S3 donde quiera publicar los archivos.

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

## TargetPath
<a name="s3.pub.dest.directory"></a>

(*S3Publish*/Configuration/**TargetPath**)

(Opcional)

Especifique el nombre y la ruta del directorio de Amazon S3 donde quiera publicar los archivos. Si el directorio no existe, se creará. La ruta del directorio no debe incluir el nombre del bucket.

Ejemplos:

`myS3Folder`

`./myS3Folder/myS3Subfolder`

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

# Implementación en Cuentas de AWS y VPCs
<a name="deploy-environments"></a>

Con [CodeCatalyst los flujos de trabajo](workflow.md), puedes implementar aplicaciones y otros recursos para segmentar Cuenta de AWS s y Amazon VPCs en la AWS nube. Para habilitar estas implementaciones, debe configurar los CodeCatalyst entornos.

Un CodeCatalyst *entorno*, que no debe confundirse con un [entorno de desarrollo](https://docs.aws.amazon.com/codecatalyst/latest/userguide/devenvironment.html), define la Amazon VPC de destino Cuenta de AWS y opcional a la que se conecta un CodeCatalyst [flujo de trabajo](workflow.md). Un entorno también define la [función de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) que necesita un flujo de trabajo para acceder a los AWS servicios y recursos de la cuenta de destino.

Puede configurar varios entornos y asignarles nombres, como desarrollo, pruebas, almacenamiento provisional y producción. Al realizar un despliegue en estos entornos, la información sobre los despliegues aparece en las pestañas **Actividad de CodeCatalyst despliegue** y **Objetivos de despliegue** del entorno.

## ¿Cómo empiezo a utilizar los entornos?
<a name="deploy-environments-get-started"></a>

Los pasos generales para agregar y usar un CodeCatalyst entorno son los siguientes:

1. En tu CodeCatalyst espacio, **conecta una o más AWS cuentas**. Durante este proceso, añada los roles de IAM que requiere su flujo de trabajo para acceder a los recursos de la Cuenta de AWS. Para obtener más información, consulte [Permitir el acceso a AWS los recursos con conexión Cuentas de AWS](ipa-connect-account.md).

1. En su CodeCatalyst proyecto, **cree un entorno** que incluya una de las funciones de Cuenta de AWS s e IAM del paso 1. Para obtener más información, consulte [Creación de un entorno](deploy-environments-creating-environment.md).

1. En tu CodeCatalyst proyecto, en un flujo de trabajo, **añade una [acción](workflows-actions.md) que apunte al entorno** que creaste en el paso 2. Para obtener más información, consulte [Cómo añadir una acción a un flujo de trabajo](workflows-add-action.md).

   Ahora ha configurado un entorno. La acción ahora puede implementar recursos en la Cuenta de AWS especificada en el entorno.

**nota**  
También puede añadir una Amazon VPC al entorno. Para obtener más información, consulte [Agregar conexiones de VPC para un espacio](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-vpcs.add.html) en la *Guía de CodeCatalyst administración* y. [Asociación de una VPC a un entorno](deploy-environments-associate-vpc.md)

## ¿Puede haber varios entornos dentro de un único flujo de trabajo?
<a name="deploy-environments-multiple"></a>

Sí. Si un flujo de trabajo incluye varias acciones, a cada una de ellas se le puede asignar un entorno. Por ejemplo, puede tener un flujo de trabajo que incluya dos acciones de implementación: una asignada a un entorno de `my-staging-enviroment` y otra asignada a un entorno de `my-production-environment`.

## ¿Qué acciones de flujo de trabajo admiten entornos?
<a name="deploy-environments-supported"></a>

Cualquier acción de flujo de trabajo que despliegue recursos en la AWS nube o se comunique con AWS los servicios por otros motivos (como la supervisión y la generación de informes) es compatible con los entornos.

## ¿Qué acciones permiten que se muestre la información de implementación? CodeCatalyst
<a name="deploy-environments-supported-targets"></a>

De las acciones de flujo de trabajo compatibles con los entornos, solo unas pocas permiten que su información de despliegue aparezca en las páginas de **actividad** de **despliegue y objetivos** del despliegue de la CodeCatalyst consola.

Las siguientes acciones del flujo de trabajo permiten que se muestre su información de implementación:
+ Pila ** CloudFormation de implementación**: para obtener más información, consulte [Implementación de una CloudFormation pila](deploy-action-cfn.md)
+ **Implementar en Amazon ECS**: para obtener más información, consulte [Implementación en Amazon ECS con un flujo de trabajo](deploy-action-ecs.md)
+ **Implementar el clúster de Kubernetes**: para obtener más información, consulte [Implementación en Amazon EKS con un flujo de trabajo](deploy-action-eks.md)
+ **AWS CDK implementar**: para obtener más información, consulte [Implementación de una AWS CDK aplicación con un flujo de trabajo](cdk-dep-action.md)

## Regiones admitidas
<a name="deploy-environments-supported-regions"></a>

La página **Entornos** puede mostrar los recursos de cualquier región de AWS .

## ¿Es obligatorio disponer de un entorno?
<a name="deploy-environments-optional-or-mandatory"></a>

Un entorno es obligatorio si la acción de flujo de trabajo a la que se le asigna despliega recursos en la AWS nube o se comunica con AWS los servicios por otros motivos (como la supervisión y la generación de informes).

Por ejemplo, si tiene una acción de compilación que crea una aplicación pero no necesita comunicarse con su VPC Cuenta de AWS o con Amazon VPC, no necesita asignar un entorno a la acción. Sin embargo, si la acción de compilación envía registros al CloudWatch servicio de Amazon que tengas Cuenta de AWS, la acción debe tener un entorno asignado. 

**Topics**
+ [¿Cómo empiezo a utilizar los entornos?](#deploy-environments-get-started)
+ [¿Puede haber varios entornos dentro de un único flujo de trabajo?](#deploy-environments-multiple)
+ [¿Qué acciones de flujo de trabajo admiten entornos?](#deploy-environments-supported)
+ [¿Qué acciones permiten que se muestre la información de implementación? CodeCatalyst](#deploy-environments-supported-targets)
+ [Regiones admitidas](#deploy-environments-supported-regions)
+ [¿Es obligatorio disponer de un entorno?](#deploy-environments-optional-or-mandatory)
+ [Creación de un entorno](deploy-environments-creating-environment.md)
+ [Asociación de un entorno a una acción](deploy-environments-add-app-to-environment.md)
+ [Asociación de una VPC a un entorno](deploy-environments-associate-vpc.md)
+ [Asociar un hombre Cuenta de AWS con un entorno](deploy-environments-associate-account.md)
+ [Cambio del rol de IAM de una acción](deploy-environments-switch-role.md)

# Creación de un entorno
<a name="deploy-environments-creating-environment"></a>

Siga estas instrucciones para crear un entorno que pueda asociar posteriormente a una acción de flujo de trabajo.

**Antes de empezar**

Necesitará lo siguiente:
+ Un CodeCatalyst espacio. Para obtener más información, consulte [Configuración e inicio de sesión en CodeCatalystConfiguración e inicio de sesión en CodeCatalyst](setting-up-topnode.md).
+ Un CodeCatalyst proyecto. Para obtener más información, consulte [Creación de un proyecto con un esquema](projects-create.md#projects-create-console-template).
+ Una conexión de AWS cuenta que incluye las funciones de IAM a las que necesitará acceder AWS tu acción de flujo de trabajo. Para obtener más información sobre la creación de una conexión de cuenta, consulte [Permitir el acceso a AWS los recursos con conexión Cuentas de AWS](ipa-connect-account.md). Puede utilizar como máximo una conexión de cuenta por entorno.
**nota**  
Puede crear un entorno sin una conexión de cuenta; sin embargo, tendrá que volver y añadir la conexión más adelante.
+ Uno de los siguientes CodeCatalyst roles:
  + **Administrador del espacio**
  + **Administrador del proyecto**
  + **Colaborador**
**nota**  
Si tiene el **rol Colaborador**, podrá crear un entorno, pero no podrá asociarlo a una conexión de Cuenta de AWS . Deberás pedirle a alguien con el rol de **administrador del espacio** o **administrador del proyecto** que asocie el entorno a una Cuenta de AWS conexión.

   Para obtener más información acerca de los permisos y roles, consulte [Concesión de permisos de proyecto a los usuarios](projects-members.md).

**Creación de un entorno**

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

1. En **Nombre del entorno**, introduzca un nombre, como **Production** o **Staging**.

1. En **Tipo de entorno**, seleccione una de las siguientes opciones:
   + **No producción**: un entorno en el que puede probar la aplicación para asegurarse de que funcione según lo previsto antes de moverla a producción.
   + **Producción**: un entorno “en vivo” que está disponible públicamente y que aloja la aplicación finalizada.

     Si elige **Producción**, aparecerá el distintivo **Producción** en la interfaz de usuario junto a cualquier acción a la que esté asociado el entorno. El distintivo le ayuda a saber rápidamente qué acciones se están implementando en producción. Aparte de la apariencia del distintivo, no hay diferencias entre los entornos de producción y los que no son de producción.

1. (Opcional) En **Descripción**, escriba una descripción, como **Production environment for the hello-world app**.

1. En **Cuenta de AWS Conexión (opcional)**, elija la conexión de AWS cuenta que desee asociar a este entorno. Las acciones del flujo de trabajo que estén asignadas al entorno podrán conectarse a la Cuenta de AWS asociada. Para obtener más información sobre la creación de Cuenta de AWS conexiones en CodeCatalyst, consulte[Permitir el acceso a AWS los recursos con conexión Cuentas de AWS](ipa-connect-account.md).

   Si la Cuenta de AWS conexión que desea usar no aparece en la lista, es posible que se deba a que no está permitida en su proyecto. Para obtener más información, consulte [Configuración de conexiones de cuentas restringidas por proyectos](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-accounts-restriction.html) en la Guía * CodeCatalyst del administrador de Amazon*.

1. En **Rol de IAM predeterminado**, elija el rol de IAM que desea asociar a este entorno. Las acciones de flujo de trabajo a las que se asigne este entorno heredarán esta función de IAM y podrán utilizarla para conectarse a los servicios y recursos de su entorno. Cuenta de AWS

   Si necesita asignar el entorno a varias acciones y esas acciones requieren roles de IAM distintos de los que se especifican aquí de forma predeterminada, puede especificar los distintos roles en la pestaña **Configuración** de cada acción mediante la opción **Cambiar rol**. Para obtener más información, consulte [Cambio del rol de IAM de una acción](deploy-environments-switch-role.md).

   Si la función de IAM que desea usar como predeterminada no aparece en la lista, es posible que se deba a que aún no la ha agregado a su Cuenta de AWS conexión. Para añadir un rol de IAM a una conexión de cuenta, consulte [Adición de roles de IAM a las conexiones de cuentas](ipa-connect-account-addroles.md).

1. (Opcional) En **Conexión de VPC**, elija la conexión de VPC que desee asociar a este entorno. Para obtener más información sobre la creación de conexiones de VPC, consulte Gestión de [Amazon Virtual Private Clouds](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-vpcs.html) en la Guía * CodeCatalyst del administrador de Amazon*.

   Si la conexión de VPC que quieres usar no aparece en la lista, puede que se deba a que incluye una Cuenta de AWS conexión que no está permitida en tu proyecto. Para obtener más información, consulte [Configuración de conexiones de cuentas restringidas por proyectos](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-accounts-restriction.html) en la Guía * CodeCatalyst del administrador de Amazon*.

1. Seleccione **Crear** entorno. CodeCatalyst crea un entorno vacío.

**Siguientes pasos**
+ Ahora que ha creado un entorno, puede asociarlo a una acción del flujo de trabajo. Para obtener más información, consulte [Asociación de un entorno a una acción](deploy-environments-add-app-to-environment.md).

# Asociación de un entorno a una acción
<a name="deploy-environments-add-app-to-environment"></a>

Al asociar un entorno a una [acción de flujo de trabajo compatible](deploy-environments.md#deploy-environments-supported), el entorno Cuenta de AWS, la función de IAM predeterminada y la Amazon VPC opcional se asignan a la acción. A continuación, la acción puede conectarse e implementarse en la Cuenta de AWS con el rol de IAM y también conectarse a Amazon VPC opcional.

Siga estas instrucciones para asociar un entorno a una acción.

## Paso 1: asociación del entorno a una acción de flujo de trabajo
<a name="deploy-environments-add-app-to-environment-assoc"></a>

Utilice el siguiente procedimiento para asociar un entorno a una acción de flujo de trabajo.

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

**Asociación de un entorno a una acción de flujo de trabajo mediante 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 el diagrama de flujo de trabajo, elija una acción que sea compatible con los entornos. Para obtener más información, consulte [¿Qué acciones permiten que se muestre la información de implementación? CodeCatalyst](deploy-environments.md#deploy-environments-supported-targets).

1. Seleccione la pestaña **Configuración** y especifique la información en el campo **Entorno**, de la siguiente manera.

   **Entorno**

   Especifique el CodeCatalyst entorno que se va a utilizar 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).

1. (Opcional) Cambie el rol de IAM asociado a la acción. Es posible que desee cambiar el rol si contiene un conjunto de permisos incorrecto para la acción.

    Para cambiar el rol:

   1. **En la sección ¿Qué hay de nuevo? *my-environment*** y selecciona el icono de puntos suspensivos verticales (![\[Ellipsis.\]](http://docs.aws.amazon.com/es_es/codecatalyst/latest/userguide/images/flows/elipsis.png)).

   1. Seleccione una de las siguientes opciones:
      +  **Cambiar el rol**. Seleccione esta opción para cambiar el rol de IAM utilizado por esta acción y solo por esta acción. Otras acciones seguirán utilizando el rol de IAM predeterminado especificado en su entorno asociado. Para obtener más información, consulte [Cambio del rol de IAM de una acción](deploy-environments-switch-role.md).
      +  **Editar entorno**. Seleccione esta opción para cambiar el rol de IAM predeterminado que se muestra en el entorno. Si elige esta opción, la acción (y cualquier otra acción asociada al mismo entorno) comienza a utilizar el nuevo rol de IAM predeterminado.
**importante**  
Tenga cuidado al actualizar el rol de IAM predeterminado. Si los permisos del rol no son suficientes para todas las acciones que comparten el entorno, es posible que se produzcan errores en las acciones.

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 ]

**Asociación de un entorno a una acción de flujo de trabajo mediante el editor de YAML**

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

1. En la acción de flujo de trabajo que desea asociar a un entorno, añada un código similar al siguiente:

   ```
   action-name:
     Environment:
       Name: environment-name
   ```

   Para obtener más información, consulte el tema [Tipos de acción](workflows-actions.md#workflows-actions-types). Este tema contiene enlaces a la documentación de cada acción, incluida su referencia de YAML.

1. (Opcional) Si desea que la acción utilice un rol diferente del rol de IAM predeterminado que aparece en el entorno, añada una sección `Connections:` que incluya el rol que quiere usar. Para obtener más información, consulte [Cambio del rol de IAM de una acción](deploy-environments-switch-role.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**.

------

## Paso 2: cumplimentación de la página de actividades de implementación
<a name="deploy-environments-add-app-to-environment-run"></a>

Tras asociar un entorno a una acción de flujo de trabajo, puede rellenar las páginas **Actividad de despliegue** y **Destino del despliegue** en la sección **Entornos** de la CodeCatalyst consola con información sobre el despliegue. Siga estas instrucciones para rellenar estas páginas.

**nota**  
Solo unas pocas acciones permiten que su información de despliegue se muestre en la CodeCatalyst consola. Para obtener más información, consulte [¿Qué acciones permiten que se muestre la información de implementación? CodeCatalyst](deploy-environments.md#deploy-environments-supported-targets).

**Para añadir información de despliegue a CodeCatalyst**

1. Si la ejecución de un flujo de trabajo no se inició automáticamente cuando realizó los cambios en [Paso 1: asociación del entorno a una acción de flujo de trabajo](#deploy-environments-add-app-to-environment-assoc), inicie una ejecución manualmente de la siguiente manera:

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

   La ejecución del flujo de trabajo inicia una nueva implementación, lo que hace CodeCatalyst que se agregue información de implementación a CodeCatalyst.

1. Compruebe que la actividad de despliegue se haya agregado a la CodeCatalyst consola:

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

   1. Elija su entorno (por ejemplo, `Production`).

   1. Seleccione la pestaña **Actividad de implementación** y compruebe que aparezca una implementación con el **estado** **CORRECTO**. Esto indica que un flujo de trabajo ejecutado implementó correctamente los recursos de la aplicación.

   1. Seleccione la pestaña **Destinos de implementación** y compruebe que aparecen los recursos de la aplicación.

# Asociación de una VPC a un entorno
<a name="deploy-environments-associate-vpc"></a>

Cuando se configura una acción con un entorno que tiene una conexión de VPC, la acción se ejecutará conectada a la VPC, respetando las reglas de red y los recursos de acceso especificados por la VPC asociada. Uno o varios entornos pueden utilizar la misma conexión de VPC.

Siga estas instrucciones para asociar una conexión de VPC a un entorno.

**Asociación de una conexión de VPC a un entorno**

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

1. Elija su entorno (por ejemplo, `Production`).

1. Elija la pestaña de **Propiedades del entorno**.

1. Elija **Administrar la conexión de VPC**, elija la conexión de VPC que desee y elija **Confirmar**. Esto asocia la conexión de VPC seleccionada a este entorno.
**nota**  
Si la conexión de VPC que quieres usar no aparece en la lista, puede que se deba a que incluye una Cuenta de AWS conexión que no está permitida en tu proyecto. Para obtener más información, consulte [Configuración de conexiones de cuentas restringidas por proyectos](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-accounts-restriction.html) en la Guía * CodeCatalystdel administrador de Amazon*.

Para obtener más información, consulte [Gestión de Amazon Virtual Private Clouds](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-vpcs.html) en la *Guía CodeCatalyst del administrador*.

# Asociar un hombre Cuenta de AWS con un entorno
<a name="deploy-environments-associate-account"></a>

Utilice las siguientes instrucciones para Cuenta de AWS asociar y a un entorno. Al Cuenta de AWS asociar un a un entorno, las acciones del flujo de trabajo que estén asignadas al entorno podrán conectarse al Cuenta de AWS.

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

**Antes de empezar**

Necesitará lo siguiente:
+ Una conexión de AWS cuenta que incluya las funciones de IAM a las que necesitará acceder AWS tu acción de flujo de trabajo. Para obtener más información sobre la creación de una conexión de cuenta, consulte [Permitir el acceso a AWS los recursos con conexión Cuentas de AWS](ipa-connect-account.md). Puede utilizar como máximo una conexión de cuenta por entorno.
+ Uno de los siguientes CodeCatalyst roles: **administrador del espacio o administrador** **del proyecto**. Para obtener más información, consulte [Concesión de permisos de proyecto a los usuarios](projects-members.md).

**Para asociar y Cuenta de AWS a un entorno**

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

1. Elija su entorno (por ejemplo, `Production`).

1. Elija **Editar entorno**.

1. En **Propiedades del entorno**, en la lista desplegable **Cuenta de AWS conexión (opcional)**, elija la Cuenta de AWS que desee.

   Si la Cuenta de AWS conexión que quieres usar no aparece en la lista, puede que se deba a que no está permitida en tu proyecto. Para obtener más información, consulte [Configuración de conexiones de cuentas restringidas por proyectos](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-accounts-restriction.html) en la Guía * CodeCatalyst del administrador de Amazon*.

1. En **Rol de IAM predeterminado**, elija el rol de IAM que desea asociar a este entorno. Las acciones de flujo de trabajo a las que se asigne este entorno heredarán esta función de IAM y podrán utilizarla para conectarse a los servicios y recursos de su entorno. Cuenta de AWS

   Si la función de IAM que desea usar como predeterminada no aparece en la lista, es posible que se deba a que aún no la ha agregado a su Cuenta de AWS conexión. Para añadir un rol de IAM a una conexión de cuenta, consulte [Adición de roles de IAM a las conexiones de cuentas](ipa-connect-account-addroles.md).

# Cambio del rol de IAM de una acción
<a name="deploy-environments-switch-role"></a>

De forma predeterminada, al asociar un [entorno](deploy-environments.md) a una acción de flujo de trabajo, la [acción](workflows-actions.md) hereda el rol de IAM predeterminado especificado en el entorno. Puede cambiar este comportamiento para que la acción utilice un rol diferente. Es posible que desee que una acción utilice un rol diferente si al rol de IAM predeterminado le faltan los permisos que la acción necesita para funcionar en la nube de AWS .

Para asignar un rol de IAM diferente a una acción, puede usar la opción **Cambiar rol** en el editor visual o la propiedad `Connections:` en el editor de YAML. El nuevo rol invalida el rol de IAM predeterminado especificado en el entorno, lo que le permite mantener el rol de IAM predeterminado tal como está. Es posible que desee mantener el rol de IAM predeterminado tal como está si hay otras acciones que lo utilizan.

Siga estas instrucciones para configurar una acción que utilice un rol de IAM diferente del especificado en su entorno.

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

**Asignación de un rol de IAM diferente a una acción (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. Seleccione la casilla que representa la acción cuyo rol de IAM desea actualizar.

1. Elija la pestaña **Configuración**.

1. En la **sección ¿Qué hay*my-environment*?** selecciona el icono de puntos suspensivos verticales (![\[Ellipsis.\]](http://docs.aws.amazon.com/es_es/codecatalyst/latest/userguide/images/flows/elipsis.png)).

1. Elija **Cambiar rol**.

1. En el cuadro de diálogo **Cambiar rol**, en la lista desplegable **Rol de IAM**, elija el rol de IAM que desee que utilice la acción. Este rol invalidará el rol de IAM predeterminado del entorno. Si el rol que quiere usar no está en la lista, asegúrese de haberlo añadido a su espacio. Para obtener más información, consulte [Adición de roles de IAM a las conexiones de cuentas](ipa-connect-account-addroles.md).

   El rol elegido aparece ahora en la sección **¿Qué hay? *my-environment*** cuadro junto con la insignia **Definido en el flujo de trabajo**. El rol también aparece en el archivo de definición del flujo de trabajo, en la sección `Connections:`.

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 ]

**Asignación de un rol de IAM diferente a una acción (editor de YAML)**

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

1. En la acción del flujo de trabajo en la que desee utilizar un rol de IAM diferente, añada una sección `Connections:` similar a la siguiente:

   ```
   action-name:
     Environment:
       Name: environment-name
       Connections: 
         - Name: account-connection-name
           Role: iam-role-name
   ```

   En el código anterior, *account-connection-name* sustitúyalo por el nombre de la [conexión de cuenta](ipa-connect-account.md) que contiene el rol de IAM y *iam-role-name* sustitúyelo por el nombre del rol de IAM que quieres que utilice la acción. Este rol invalidará el rol de IAM predeterminado del entorno. Asegúrese de haber añadido el rol a su espacio. Para obtener más información, consulte [Adición de roles de IAM a las conexiones de cuentas](ipa-connect-account-addroles.md).

   Para obtener más información, consulte el tema [Tipos de acción](workflows-actions.md#workflows-actions-types). Este tema contiene enlaces a la documentación de cada acción, incluida su referencia de YAML.

------

# Visualización de la URL de la aplicación en el diagrama de flujo de trabajo
<a name="deploy-app-url"></a>

Si tu flujo de trabajo implementa una aplicación, puedes configurar Amazon CodeCatalyst para que muestre la URL de la aplicación como un enlace en el que se puede hacer clic. Este enlace aparece en la CodeCatalyst consola, dentro de la acción que lo implementó. En el siguiente diagrama de flujo de trabajo se muestra la URL de **Ver aplicación** que aparece en la parte inferior de una acción.

![\[Visualización de la URL de la aplicación\]](http://docs.aws.amazon.com/es_es/codecatalyst/latest/userguide/images/deploy/view-app-url.png)


Al hacer clic en esta URL en la CodeCatalyst consola, puede verificar rápidamente la implementación de la aplicación.

**nota**  
La URL de la aplicación no se admite con la acción **Implementar en Amazon ECS**.

Para habilitar esta característica, añada una variable de salida a la acción con un nombre que contenga `appurl` o `endpointurl`. Puede usar un nombre con o sin un guion (`-`), un guión bajo (`_`) o un espacio (` `) que lo unan. La cadena no distingue entre mayúsculas y minúsculas. Establezca el valor de la variable en la URL `http` o `https` de la aplicación implementada.

**nota**  
Si está actualizando una variable de salida existente para incluir la cadena `app url` o `endpoint url`, actualice todas las referencias a esta variable para usar el nombre de la nueva variable.

Para ver los pasos detallados, consulte uno de los siguientes procedimientos:
+ [Para mostrar la URL de la aplicación en la acción «AWS CDK implementar»](#deploy-app-url-cdk)
+ [Para mostrar la URL de la aplicación en la acción «Implementar CloudFormation pila»](#deploy-app-url-cfn)
+ [Visualización de la URL de la aplicación en todas las demás acciones](#deploy-app-url-other)

Cuando haya terminado de configurar la URL, compruebe que aparece como se espera siguiendo estas instrucciones:
+ [Comprobación de que se añadió la URL de la aplicación](#deploy-app-url-verify)<a name="deploy-app-url-cdk"></a>

**Para mostrar la URL de la aplicación en la acción «AWS CDK implementar»**

1. Si utilizas la acción de **AWS CDK despliegue**, añade una `CfnOutput` construcción (que es un par clave-valor) en el código de tu AWS CDK aplicación:
   + El nombre de la clave debe contener `appurl` o `endpointurl`, con o sin un guion (`-`), un guión bajo (`_`) o un espacio (` `). La cadena no distingue entre mayúsculas y minúsculas.
   + El valor debe ser la URL `http` o `https` de la aplicación implementada.

   Por ejemplo, el AWS CDK código podría tener este aspecto:

   ```
   import { Duration, Stack, StackProps, CfnOutput, RemovalPolicy} from 'aws-cdk-lib';
   import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
   import * as s3 from 'aws-cdk-lib/aws-s3';
   import { Construct } from 'constructs';
   import * as cdk from 'aws-cdk-lib';
   export class HelloCdkStack extends Stack {
     constructor(scope: Construct, id: string, props?: StackProps) {
       super(scope, id, props);
       const bucket = new s3.Bucket(this, 'amzn-s3-demo-bucket', {
         removalPolicy: RemovalPolicy.DESTROY,
       });
       new CfnOutput(this, 'APP-URL', {
         value: https://mycompany.myapp.com,
         description: 'The URL of the deployed application',
         exportName: 'myApp',
       });
       ...
     }
   }
   ```

   Para obtener más información sobre la `CfnOutput` construcción, consulta la [interfaz CfnOutputProps](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.CfnOutputProps.html) en la *referencia de la AWS Cloud Development Kit (AWS CDK) API*.

1. Guarde y confirme el código.

1. Continúe en [Comprobación de que se añadió la URL de la aplicación](#deploy-app-url-verify).<a name="deploy-app-url-cfn"></a>

**Para mostrar la URL de la aplicación en la acción «Implementar CloudFormation pila»**

1. Si utilizas la acción **Implementar CloudFormation pila**, añade un resultado a la `Outputs` sección de tu CloudFormation plantilla o AWS SAM plantilla con estas características:
   + La clave (llamada también ID lógico) debe contener `appurl` o `endpointurl`, con o sin un guion (`-`), un guión bajo (`_`) o un espacio (` `). La cadena no distingue entre mayúsculas y minúsculas.
   + El valor debe ser la URL `http` o `https` de la aplicación implementada.

   Por ejemplo, la CloudFormation plantilla podría tener este aspecto:

   ```
   "Outputs" : {
     "APP-URL" : {
       "Description" : "The URL of the deployed app",
       "Value" : "https://mycompany.myapp.com",
       "Export" : {
         "Name" : "My App"
       }
     }
   }
   ```

   Para obtener más información sobre CloudFormation las salidas, consulte [las salidas](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/outputs-section-structure.html) en la *Guía del AWS CloudFormation usuario*.

1. Guarde y confirme el código.

1. Continúe en [Comprobación de que se añadió la URL de la aplicación](#deploy-app-url-verify).<a name="deploy-app-url-other"></a>

**Visualización de la URL de la aplicación en todas las demás acciones**

Si utilizas otra acción para implementar la aplicación, como la acción de creación o **GitHub las acciones**, haz lo siguiente para que se muestre la URL de la aplicación.

1. Defina una variable de entorno en la sección `Inputs` o `Steps` de la acción en el archivo de definición del flujo de trabajo. La entrada debe tener las características siguientes:
   + El `name` debe contener `appurl` o `endpointurl`, con o sin un guion (`-`), un guión bajo (`_`) o un espacio (` `). La cadena no distingue entre mayúsculas y minúsculas.
   + El valor debe ser la URL `http` o `https` de la aplicación implementada.

   Por ejemplo, una acción de compilación podría tener el siguiente aspecto:

   ```
   Build-action:
     Identifier: aws/build@v1
     Inputs:
       Variables:
         - Name: APP-URL
           Value: https://mycompany.myapp.com
   ```

   O este:

   ```
   Actions:
     Build:
       Identifier: aws/build@v1
       Configuration:    
         Steps:
           - Run: APP-URL=https://mycompany.myapp.com
   ```

   Para obtener más información sobre cómo definir variables de entorno, consulte [Definición de una variable](workflows-working-with-variables-define-input.md).

1. Exporte la variable.

   Por ejemplo, la acción de compilación podría tener el siguiente aspecto:

   ```
   Build-action:
     ...
     Outputs:
       Variables:
         - APP-URL
   ```

   Para obtener más información sobre cómo exportar variables, consulte [Exportación de una variable para que otras acciones puedan utilizarla](workflows-working-with-variables-export-input.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**.

1. Continúe en [Comprobación de que se añadió la URL de la aplicación](#deploy-app-url-verify).<a name="deploy-app-url-verify"></a>

**Comprobación de que se añadió la URL de la aplicación**
+ Inicie una ejecución de flujo de trabajo, si no se ha iniciado automáticamente. La nueva ejecución debe mostrar la URL de la aplicación como un enlace en el que se pueda hacer clic en el diagrama de flujo de trabajo. Para obtener más información sobre cómo iniciar ejecuciones, consulte [Inicio manual de la ejecución de un flujo de trabajo](workflows-manually-start.md). 

# Eliminación de un destino de implementación
<a name="deploy-remove-target"></a>

Puede eliminar un objetivo de despliegue, como un clúster o CloudFormation pila de Amazon ECS, de la página de **objetivos de despliegue** de la CodeCatalyst consola.

**importante**  
Al eliminar un objetivo de despliegue, se elimina de la CodeCatalyst consola, pero permanece disponible en el AWS servicio que lo aloja (si aún existe).

Considere la posibilidad de eliminar un objetivo de despliegue si el objetivo se ha quedado obsoleto. CodeCatalyst Los destinos de implementación pueden quedarse obsoletos si:
+ Ha eliminado el flujo de trabajo que se implementó en el destino.
+ Ha cambiado la pila o el clúster en el que se realiza la implementación. 
+ Eliminó la pila o el clúster del CloudFormation servicio Amazon ECS de la AWS consola.

**Eliminación de un destino de implementación**

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

1. Elija el nombre del entorno que contiene el destino de implementación que desea eliminar. Para obtener más información sobre los entornos, consulte [Implementación en Cuentas de AWS y VPCs](deploy-environments.md).

1. Elija la pestaña **Destinos de implementación**.

1. Seleccione el botón de opción situado junto al destino de implementación que desea quitar.

1. Elija **Eliminar **.

   El destino se elimina de la página.

# Seguimiento del estado de la implementación por confirmación
<a name="track-changes"></a>

En cualquier momento del ciclo de vida del desarrollo, es importante conocer el estado de implementación de determinadas confirmaciones, como las correcciones de errores, las nuevas características u otros cambios importantes. Tenga en cuenta los siguientes escenarios en los que la capacidad de seguimiento del estado de la implementación resulta útil para los equipos de desarrollo:
+ Como desarrollador, ha realizado una corrección para solventar un error y quiere informar del estado de su implementación en todos los entornos de implementación del equipo.
+ Como administrador de versiones, quiere ver una lista de las confirmaciones implementadas para hacer un seguimiento de su estado de implementación e informar al respecto.

CodeCatalyst proporciona una vista que puede utilizar para determinar de un vistazo dónde se han implementado las confirmaciones o los cambios individuales y en qué entorno. Esta vista incluye: 
+ Una lista de confirmaciones.
+ El estado de las implementaciones que incluyen las confirmaciones.
+ Los entornos en los que las confirmaciones se han implementado correctamente.
+ El estado de cualquier prueba que se ejecute en función de las confirmaciones de su CI/CD flujo de trabajo.

El siguiente procedimiento detalla cómo navegar hasta esta vista y utilizarla para realizar un seguimiento de los cambios en el proyecto.

**nota**  
El seguimiento del estado de la implementación por confirmación solo se admite en los [CodeCatalyst repositorios](source.md). No puedes usar esta función con un [GitHub repositorio, un repositorio de Bitbucket o un repositorio de GitLab proyectos](extensions.md).

**Seguimiento del estado de la implementación por confirmación**

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 **Control de cambios**.

1. En las dos listas desplegables de la parte superior del panel principal, seleccione el repositorio y la ramificación de origen que contengan las confirmaciones cuyo estado de publicación quiera ver.

1. Seleccione **Ver cambios**.

   Aparecerá una lista de confirmaciones.

   Para cada confirmación, puede ver lo siguiente:
   + Información de confirmación, como el ID, el autor, el mensaje y cuándo se confirmó. Para obtener más información, consulte [Almacene código y colabore en él con los repositorios de código fuente en CodeCatalystAlmacenamiento de código y colaboración con los repositorios de código fuente](source.md).
   + El estado de las implementaciones en cada entorno. Para obtener más información, consulte [Implementación en Cuentas de AWS y VPCs](deploy-environments.md).
   + Resultados de las pruebas y la cobertura del código. Para obtener más información, consulte [Pruebas con flujos de trabajoPruebas con flujos de trabajo](test-workflow-actions.md).
**nota**  
No se muestran los resultados de los análisis de composición del software (SCA).

1. (Opcional) Para ver más información sobre los cambios relacionados con una confirmación específica, incluida la última implementación y la información detallada de la cobertura de código y las pruebas unitarias, seleccione **Ver detalles** para esa confirmación.

# Visualización de los registros de implementación
<a name="deploy-deployment-logs"></a>

Puedes ver los registros relacionados con acciones de implementación específicas para solucionar problemas en Amazon CodeCatalyst.

Puede ver los registros de un [flujo de trabajo](workflow.md) o un [entorno](deploy-environments.md).

**Visualización de los registros de una acción de implementación de un flujo de trabajo**

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

1. Elija la ejecución del flujo de trabajo que implementó la aplicación.

1. En el diagrama de flujo de trabajo, elija la acción cuyos registros desea ver.

1. Seleccione la pestaña **Registros** y expanda las secciones para mostrar los mensajes de registro.

1. Para ver más registros, selecciona la pestaña **Resumen** y, a continuación, selecciona **Ver en CloudFormation** (si está disponible) para ver allí más registros. Es posible que tenga que iniciar sesión en AWS.

**Visualización de los registros de una acción de implementación de un entorno**

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

1. Elija el entorno en el que se implementó la aplicación.

1. En **Actividad de despliegue**, busque la columna **ID de ejecución de flujo de trabajo** y elija la ejecución del flujo de trabajo que implementó la pila.

1. En el diagrama de flujo de trabajo, elija la acción cuyos registros desea ver.

1. Seleccione la pestaña **Registros** y expanda las secciones para mostrar los mensajes de registro.

1. Para ver más registros, selecciona la pestaña **Resumen** y, a continuación, selecciona **Ver en CloudFormation** (si está disponible) para ver allí más registros. Es posible que tenga que iniciar sesión en AWS.

# Consulta de la información de implementación
<a name="deploy-view-deployment-info"></a>

Puedes ver la siguiente información sobre una implementación en Amazon CodeCatalyst:
+ La actividad de implementación, incluidos el estado de la implementación, la hora de inicio, la hora de finalización, el historial y la duración de los eventos.
+ Nombre de la pila Región de AWS, hora de la última actualización y flujos de trabajo asociados.
+ Solicitudes de confirmación y extracción.
+ Información específica sobre la acción, por ejemplo, CloudFormation eventos y resultados.

Puede ver la información de implementación desde un [flujo de trabajo](workflow.md), un [entorno](deploy-environments.md) o una [acción](workflows-concepts.md#workflows-concepts-actions) del flujo de trabajo.

**Consulta de la información de implementación desde un flujo de trabajo**
+ Elija la ejecución del flujo de trabajo que implementó la aplicación. Para obtener instrucciones, consulte [Visualización del estado y los detalles de la ejecución de un flujo de trabajo](workflows-view-run.md). 

**Consulta de la información de implementación desde un entorno**

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

1. Elija el entorno en el que se implementó la pila, por ejemplo, `Production`.

1. Seleccione **Actividad de implementación** para ver el historial de implementación de sus pilas, el estado de las implementaciones (por ejemplo, **CORRECTO** O **ERROR**) y otra información relacionada con la implementación.

1. Seleccione **Destino de implementación** para ver información sobre las pilas, los clústeres u otros destinos implementados en el entorno. Puede ver información como el nombre de la pila, la región, el proveedor y el identificador.

**Consulta de la información de implementación desde una acción**

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. En el diagrama de flujo de trabajo, elija la acción de flujo de trabajo que implementó la aplicación. Por ejemplo, puede elegir **DeployCloudFormationStack**.

1. Revise el contenido del panel derecho para obtener información sobre la implementación específica para cada acción.