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 de una CloudFormation pila
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
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
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
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
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
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.
**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
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
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
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
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
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
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
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
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
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
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
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
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»
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
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»
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
**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
(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
(*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
(*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
(*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
(*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
(*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
(*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
(*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
(*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
(*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
(*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
(*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
(*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
(*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
(*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
(*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
(*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
(*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
(*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
(*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
(*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
(*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
(*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
(*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
(*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
(*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
(*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
(*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
(*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
(*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
(*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**