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.
# Administración de implementaciones continuas con versiones y alias en Step Functions
Puede utilizar Step Functions para gestionar las implementaciones continuas de los flujos de trabajo mediante *versiones* y *alias* de máquina de estado. Una *versión* es una instantánea numerada e inmutable de una máquina de estado que se puede ejecutar. Un *alias* es un puntero para un máximo de dos versiones de una máquina de estado.
Puede mantener varias versiones de las máquinas de estado y gestionar su implementación en el flujo de trabajo de producción. Con alias, puede enrutar tráfico entre diferentes versiones del flujo de trabajo e implementar gradualmente esos flujos de trabajo en el entorno de producción.
Además, puede iniciar ejecuciones de máquinas de estado mediante una versión o un alias. Si no se utiliza una versión o un alias al iniciar la ejecución de una máquina de estado, Step Functions utiliza la última revisión de la definición de la máquina de estado.
**Revisión de máquina de estado**
Una máquina de estado puede tener una o más revisiones. Cuando actualizas una máquina de estados mediante la acción de la [UpdateStateMachine](https://docs.aws.amazon.com/step-functions/latest/apireference/API_UpdateStateMachine.html)API, se crea una nueva revisión de la máquina de estados. Una *revisión* es una instantánea inmutable y de solo lectura de la definición y configuración de una máquina de estado. No se puede iniciar la ejecución de una máquina de estado a partir de una revisión y las revisiones no tienen un ARN. Las revisiones tienen un `revisionId`, que es un identificador único universal (UUID).
**Topics**
+ [Versiones](concepts-state-machine-version.md)
+ [Alias](concepts-state-machine-alias.md)
+ [Autorización de versiones y alias](auth-version-alias.md)
+ [Asociar ejecuciones a una versión o alias](execution-alias-version-associate.md)
+ [Ejemplo de implementación](example-alias-version-deployment.md)
+ [Implementación gradual de versiones](version-rolling-deployment.md)
# Versiones de máquinas de estado en los flujos de trabajo de Step Functions
Una *versión* es una instantánea numerada e **inmutable** de una máquina de estado. Usted publica versiones de la revisión más reciente realizada en esa máquina de estado. Cada versión tiene un nombre de recurso de Amazon (ARN) único, que es una combinación del ARN de la máquina de estado y el número de versión separados por dos puntos (:). En el ejemplo siguiente se muestra el formato de un ARN de versión de máquina de estado.
```
arn:partition:states:region:account-id:stateMachine:myStateMachine:1
```
Para empezar a utilizar versiones de máquinas de estado, debe publicar la primera versión. Tras publicar una versión, puede invocar la acción de la [StartExecution](https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html)API con el ARN de la versión. No se puede editar una versión, pero es posible actualizar una máquina de estado y publicar una versión nueva. También se puede publicar varias versiones de la máquina de estado.
![\[Diagrama ilustrativo difuso que muestra cómo las versiones son instantáneas inmutables de máquinas de estado.\]](http://docs.aws.amazon.com/es_es/step-functions/latest/dg/images/versioning-concept.png)
Cuando se publica una nueva versión de la máquina de estado, Step Functions le asigna un número de versión. Los números de versión comienzan en 1 y aumentan de forma monótona para cada nueva versión. Los números de versión no se reutilizan para una máquina de estados dada. Si se elimina la versión 10 de la máquina de estado y, a continuación, se publica una nueva versión, Step Functions la publica como versión 11.
Las siguientes propiedades son las mismas para todas las versiones de una máquina de estado:
+ Todas las versiones de una máquina de estado comparten el mismo tipo [(estándar o rápido)](choosing-workflow-type.md).
+ No se puede cambiar el nombre o la fecha de creación de una máquina de estado de una versión a otra.
+ Las etiquetas se aplican globalmente a las máquinas de estado. Puede administrar las etiquetas de las máquinas de estado mediante las acciones [TagResource](https://docs.aws.amazon.com/step-functions/latest/apireference/API_TagResource.html)y de la [UntagResource](https://docs.aws.amazon.com/step-functions/latest/apireference/API_UntagResource.html)API.
Las máquinas de estado también contienen propiedades que forman parte de cada versión y [revision](concepts-cd-aliasing-versioning.md#statemachinerev), pero estas propiedades pueden diferir entre dos versiones o revisiones determinadas. Estas propiedades incluyen la [Definición de la máquina de estado](https://docs.aws.amazon.com/step-functions/latest/apireference/API_UpdateStateMachine.html#StepFunctions-UpdateStateMachine-request-definition), el [rol de IAM](https://docs.aws.amazon.com/step-functions/latest/apireference/API_UpdateStateMachine.html#StepFunctions-UpdateStateMachine-request-roleArn), [la configuración de seguimiento](https://docs.aws.amazon.com/step-functions/latest/apireference/API_UpdateStateMachine.html#StepFunctions-UpdateStateMachine-request-tracingConfiguration) y la [configuración de registro](https://docs.aws.amazon.com/step-functions/latest/apireference/API_UpdateStateMachine.html#StepFunctions-UpdateStateMachine-request-loggingConfiguration).
## Publicación de una versión de una máquina de estado (Consola)
Puede publicar hasta 1000 versiones de una máquina de estado. Para solicitar un aumento de este límite flexible, utilice la página **Centro de soporte** de [Consola de administración de AWS](https://docs.aws.amazon.com/servicequotas/latest/userguide/request-quota-increase.html). Puedes eliminar manualmente las versiones no utilizadas de la consola o invocando la acción de la [DeleteStateMachineVersion](https://docs.aws.amazon.com/step-functions/latest/apireference/API_DeleteStateMachineVersion.html)API.
**Para publicar una versión de una máquina de estado**
1. Abra la [consola de Step Functions](https://console.aws.amazon.com/states/home?region=us-east-1#/) y, a continuación, elija una máquina de estado existente.
1. En la página **Detalle de la máquina de estado**, elija **Editar**.
1. Edite la definición de la máquina de estados según sea necesario y, a continuación, elija **Guardar**.
1. Elija **Publicar versión**.
1. (Opcional) En el campo **Descripción** del cuadro de diálogo que aparece, escriba una breve descripción de la versión de la máquina de estado.
1. Elija **Publicar**.
**nota**
Cuando se publica una nueva versión de la máquina de estado, Step Functions le asigna un número de versión. Los números de versión comienzan en 1 y aumentan de forma monótona para cada nueva versión. Los números de versión no se reutilizan para una máquina de estados dada. Si se elimina la versión 10 de la máquina de estado y, a continuación, se publica una nueva versión, Step Functions la publica como versión 11.
## Gestión de versiones con operaciones de API de Step Functions
Step Functions proporciona las siguientes operaciones de API para publicar y gestionar versiones de máquinas de estado:
+ [PublishStateMachineVersion](https://docs.aws.amazon.com/step-functions/latest/apireference/API_PublishStateMachineVersion.html)— Publica una versión a partir de la versión actual [revision](concepts-cd-aliasing-versioning.md#statemachinerev) de una máquina de estados.
+ [UpdateStateMachine](https://docs.aws.amazon.com/step-functions/latest/apireference/API_UpdateStateMachine.html)— Publica una nueva versión de la máquina de estados si se actualiza una máquina de estados y se establece el `publish` parámetro `true` en la misma solicitud.
+ [CreateStateMachine](https://docs.aws.amazon.com/step-functions/latest/apireference/API_CreateStateMachine.html)— Publica la primera revisión de la máquina de estados si se establece el `publish` parámetro en`true`.
+ [ListStateMachineVersions](https://docs.aws.amazon.com/step-functions/latest/apireference/API_ListStateMachineVersions.html)— Muestra las versiones del ARN de la máquina de estado especificada.
+ [DescribeStateMachine](https://docs.aws.amazon.com/step-functions/latest/apireference/API_DescribeStateMachine.html)— Devuelve los detalles de la versión de la máquina de estados para una versión ARN especificada en. `stateMachineArn`
+ [DeleteStateMachineVersion](https://docs.aws.amazon.com/step-functions/latest/apireference/API_DeleteStateMachineVersion.html)— Elimina una versión de máquina de estados.
Para publicar una nueva versión de la revisión actual de una máquina de estados llamada `myStateMachine` mediante el AWS Command Line Interface, utilice el `publish-state-machine-version` comando:
```
aws stepfunctions publish-state-machine-version --state-machine-arn arn:aws:states:region:account-id:stateMachine:myStateMachine
```
La respuesta devuelve el `stateMachineVersionArn`. Por ejemplo, el comando anterior devuelve una respuesta de`arn:aws:states:region:account-id:stateMachine:myStateMachine:1`.
**nota**
Cuando se publica una nueva versión de la máquina de estado, Step Functions le asigna un número de versión. Los números de versión comienzan en 1 y aumentan de forma monótona para cada nueva versión. Los números de versión no se reutilizan para una máquina de estados dada. Si se elimina la versión 10 de la máquina de estado y, a continuación, se publica una nueva versión, Step Functions la publica como versión 11.
## Ejecución de una versión de una máquina de estado desde la consola
Para empezar a utilizar versiones de máquina de estado, primero debe publicar una versión de la máquina de estado actual [revision](concepts-cd-aliasing-versioning.md#statemachinerev). Para publicar una versión, utilice la consola Step Functions o invoque la acción de la [PublishStateMachineVersion](https://docs.aws.amazon.com/step-functions/latest/apireference/API_PublishStateMachineVersion.html)API. También puede invocar la acción de la [UpdateStateMachineAlias](https://docs.aws.amazon.com/step-functions/latest/apireference/API_UpdateStateMachineAlias.html)API con un parámetro opcional denominado `publish` para actualizar una máquina de estados y publicar su versión.
Puede iniciar las ejecuciones de una versión mediante la consola o invocando la acción de la [StartExecution](https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html)API y proporcionando el ARN de la versión. También puede usar un [alias](concepts-state-machine-alias.md) para iniciar las ejecuciones de una versión. Según su [configuración de direccionamiento](concepts-state-machine-alias.md#alias-routing-config), un alias dirige el tráfico a una versión específica.
Si inicia la ejecución de una máquina de estado sin usar una versión, Step Functions utilizará la revisión más reciente de la máquina de estado para la ejecución. Para obtener información sobre cómo Step Functions asocia una ejecución a una versión, consulte [Asociar ejecuciones a una versión o alias](execution-alias-version-associate.md).
**Para iniciar una ejecución utilizando una versión de una máquina de estado**
1. Abra la [consola de Step Functions](https://console.aws.amazon.com/states/home?region=us-east-1#/) y, a continuación, elija una máquina de estado existente de la que haya publicado una o más versiones. Para aprender a publicar una versión, consulte [Publicación de una versión de una máquina de estado (Consola)](#procedure-create-versions).
1. En la página **Detalle de la máquina de estado**, elija la pestaña **Versiones**.
1. En la sección **Versiones**, haga lo siguiente:
1. Seleccione la versión con la que desee iniciar la ejecución.
1. Seleccione **Iniciar ejecución**.
1. (Opcional) En el cuadro de diálogo **Iniciar ejecución**, escriba un nombre para la ejecución.
1. (Opcional) Introduzca la entrada de ejecución y, a continuación, seleccione **Iniciar ejecución**.
# Alias de máquinas de estado en los flujos de trabajo de Step Functions
Un *alias* es un puntero para un máximo de dos versiones de la misma máquina de estado. Puede crear varios alias para las máquinas de estado. Cada alias tiene un nombre de recurso de Amazon (ARN) único. El ARN de alias es una combinación del ARN de la máquina de estado y el nombre del alias, separados por dos puntos (:). En el ejemplo siguiente se muestra el formato de un alias de máquina de estado.
```
arn:partition:states:region:account-id:stateMachine:myStateMachine:aliasName
```
Puede usar un alias para [dirigir tráfico](#alias-routing-config) entre una de las dos versiones de la máquina de estado. También puede crear un alias que apunte a una única versión. Los alias solo pueden apuntar a versiones de máquinas de estado. No se puede usar un alias para apuntar a otro alias. También se puede actualizar un alias para que apunte a una nueva versión de la máquina de estado.
![\[Diagrama que muestra un alias que envía el 80 % de las solicitudes a la versión 1 y el 20 % a la versión 2.\]](http://docs.aws.amazon.com/es_es/step-functions/latest/dg/images/aliases-concept.png)
**Topics**
+ [Creación de un alias de máquina de estado (Consola)](#procedure-create-aliases)
+ [Administrar los alias con APIs](#manage-aliases-with-api)
+ [Configuración de direccionamiento de alias](#alias-routing-config)
+ [Ejecución de una máquina de estado con un alias (Consola)](#procedure-run-exec-with-alias)
## Creación de un alias de máquina de estado (Consola)
Puede crear hasta 100 alias para cada máquina de estado mediante la consola Step Functions o invocando la acción de la [CreateStateMachineAlias](https://docs.aws.amazon.com/step-functions/latest/apireference/API_CreateStateMachineAlias.html)API. Para solicitar un aumento de este límite flexible, utilice la página **Centro de soporte** de [Consola de administración de AWS](https://docs.aws.amazon.com/servicequotas/latest/userguide/request-quota-increase.html). Elimine los alias no utilizados de la consola o invoque la acción de la API. [DeleteStateMachineAlias](https://docs.aws.amazon.com/step-functions/latest/apireference/API_DeleteStateMachineAlias.html)
**Para crear un alias de máquina de estado**
1. Abra la [consola de Step Functions](https://console.aws.amazon.com/states/home?region=us-east-1#/) y, a continuación, elija una máquina de estado existente.
1. En la página **Detalle de la máquina de estado**, elija la pestaña **Alias**.
1. Elija **Crear nuevo alias**.
1. En la página **Crear alias**, haga lo siguiente:
1. Escriba un **Nombre de alias**.
1. (Opcional) En **Descripción**, escriba una descripción del alias.
1. Para configurar el direccionamiento en el alias, consulte [Configuración de direccionamiento de alias](#alias-routing-config).
1. Elija **Crear alias**.
## Gestión de alias con las operaciones de la API de Step Functions
Step Functions proporciona las siguientes operaciones de API que puede utilizar para crear y gestionar alias de máquinas de estado u obtener información sobre los alias:
+ [CreateStateMachineAlias](https://docs.aws.amazon.com/step-functions/latest/apireference/API_CreateStateMachineAlias.html)— Crea un alias para una máquina de estados.
+ [DescribeStateMachineAlias](https://docs.aws.amazon.com/step-functions/latest/apireference/API_DescribeStateMachineAlias.html)— Devuelve detalles sobre el alias de una máquina de estados.
+ [ListStateMachineAliases](https://docs.aws.amazon.com/step-functions/latest/apireference/API_ListStateMachineAliases.html)— Muestra los alias del ARN de la máquina de estado especificada.
+ [UpdateStateMachineAlias](https://docs.aws.amazon.com/step-functions/latest/apireference/API_UpdateStateMachineAlias.html)— Actualiza la configuración de un alias de máquina de estado existente modificando su `description` o. `routingConfiguration`
+ [DeleteStateMachineAlias](https://docs.aws.amazon.com/step-functions/latest/apireference/API_DeleteStateMachineAlias.html)— Elimina un alias de máquina de estados.
Para crear un alias con un nombre `PROD` que apunte a la versión 1 de una máquina de estados denominada `myStateMachine` mediante el AWS Command Line Interface, utilice el `create-state-machine-alias` comando.
```
aws stepfunctions create-state-machine-alias --name PROD --routing-configuration "[{\"stateMachineVersionArn\":\"arn:aws:states:region:account-id:stateMachine:myStateMachine:1\",\"weight\":100}]"
```
## Configuración de direccionamiento de alias
Puede usar un alias para dirigir tráfico de ejecución entre dos versiones de una máquina de estado. Por ejemplo, supongamos que desea lanzar una nueva versión de la máquina de estado. Puede reducir los riesgos que implica la implementación de la nueva versión configurando el direccionamiento en un alias. Al configurar el direccionamiento puede enviar la mayor parte del tráfico a una versión anterior y probada de la máquina de estado. De este modo, la nueva versión puede recibir un porcentaje menor, hasta que se confirme que es seguro lanzar la nueva versión.
Para definir la configuración de direccionamiento, publique las dos versiones de la máquina de estado a las que apunta el alias. Al iniciar una ejecución desde un alias, Step Functions elige aleatoriamente la versión de la máquina de estado que se va a ejecutar a partir de las versiones especificadas en la configuración de direccionamiento. Basa esta elección en el porcentaje de tráfico que se asigna a cada versión en la configuración de direccionamiento de alias.
**Para configurar la configuración de direccionamiento en un alias**
+ En la página **Crear alias**, en **Configuración de direccionamiento**, haga lo siguiente:
1. En **Versión**, elija la primera versión de la máquina de estado a la que apunte el alias.
1. Active la casilla de verificación **Dividir el tráfico entre dos versiones**.
**sugerencia**
Para seleccionar una sola versión, desactive la casilla de verificación **Dividir el tráfico entre dos versiones**.
1. En **Versión**, elija la segunda versión a la que debe apuntar el alias.
1. En los campos de **Porcentaje de tráfico**, especifique el porcentaje de tráfico que se direccionará a cada versión. Por ejemplo, introduzca **60** y **40** para direccionar el 60 por ciento del tráfico de ejecución a la primera versión y el 40 por ciento del tráfico a la segunda versión.
Los porcentajes de tráfico combinados deben ser iguales al 100 por ciento.
## Ejecución de una máquina de estado con un alias (Consola)
Puede iniciar las ejecuciones de máquinas de estado con un alias desde la consola o invocando la acción de la [StartExecution](https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html)API con el ARN del alias. A continuación, Step Functions ejecuta la versión especificada por el alias. De forma predeterminada, si no especifica una versión o un alias al iniciar la ejecución de una máquina de estado, Step Functions utilizará la revisión más reciente.
**Para iniciar la ejecución de una máquina de estado utilizando un alias**
1. Abra la [consola de Step Functions](https://console.aws.amazon.com/states/home?region=us-east-1#/) y, a continuación, seleccione una máquina de estado existente para la que haya creado un alias. Para obtener información acerca de la creación de un alias, consulte [Creación de un alias de máquina de estado (Consola)](#procedure-create-aliases).
1. En la página **Detalle de la máquina de estado**, elija la pestaña **Alias**.
1. En la sección **Alias**, haga lo siguiente:
1. Seleccione el alias con el que desee comenzar la ejecución.
1. Seleccione **Iniciar ejecución**.
1. (Opcional) En el cuadro de diálogo **Iniciar ejecución**, escriba un nombre para la ejecución.
1. Si es necesario, introduzca la entrada de ejecución y, a continuación, seleccione **Iniciar ejecución**.
# Autorización para versiones y alias en los flujos de trabajo de Step Functions
Para invocar las acciones de la API de Step Functions con una versión o un alias, necesita los permisos adecuados. Para autorizar una versión o un alias a invocar una acción de API, Step Functions usa el ARN de la máquina de estado en lugar de usar el ARN de la versión o el ARN del alias. También puede restringir los permisos para una versión o un alias específicos. Para obtener más información, consulte [Reducir el alcance de los permisos](#auth-scope-permission-version-alias).
Puede utilizar el siguiente ejemplo de política de IAM de una máquina de estado denominada `myStateMachine` para invocar la acción de la [CreateStateMachineAlias](https://docs.aws.amazon.com/step-functions/latest/apireference/API_CreateStateMachineAlias.html)API destinada a crear un alias de máquina de estado.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "states:CreateStateMachineAlias",
"Resource": "arn:aws:states:us-east-1:123456789012:stateMachine:myStateMachine"
}
]
}
```
Cuando configure permisos para permitir o denegar el acceso a acciones de la API mediante versiones o alias de máquinas de estado, tenga en cuenta lo siguiente:
+ Si utilizas el `publish` parámetro de las acciones [CreateStateMachine](https://docs.aws.amazon.com/step-functions/latest/apireference/API_CreateStateMachine.html)y de la [UpdateStateMachine](https://docs.aws.amazon.com/step-functions/latest/apireference/API_UpdateStateMachine.html)API para publicar una nueva versión de la máquina de estados, también necesitarás el `ALLOW` permiso para la acción de la [PublishStateMachineVersion](https://docs.aws.amazon.com/step-functions/latest/apireference/API_PublishStateMachineVersion.html)API.
+ La acción de la [DeleteStateMachine](https://docs.aws.amazon.com/step-functions/latest/apireference/API_DeleteStateMachine.html)API elimina todas las versiones y los alias asociados a una máquina de estados.
## Reducir el alcance de los permisos de una versión o un alias
Puede usar un calificador para reducir más el permiso de autorización que necesita una versión o un alias. Un calificador hace referencia a un número de versión o a un nombre de alias. El calificador se utiliza para calificar una máquina de estado. El siguiente ejemplo es un ARN de máquina de estado que usa un alias denominado `PROD` como calificador.
```
arn:aws:states:region:account-id:stateMachine:myStateMachine:PROD
```
Para obtener más información sobre las cualificadas y las no ARNs cualificadas, consulte. [Asociar ejecuciones a una versión o alias](execution-alias-version-associate.md)
Para reducir el alcance de los permisos, utilice la clave de contexto opcional llamada `states:StateMachineQualifier` en la instrucción `Condition` de una política de IAM. Por ejemplo, la siguiente política de IAM para una máquina de estado denominada `myStateMachine` deniega el acceso a la acción de la [DescribeStateMachine](https://docs.aws.amazon.com/step-functions/latest/apireference/API_DescribeStateMachine.html)API con un alias denominado como `PROD` o la versión. `1`
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": "states:DescribeStateMachine",
"Resource": "arn:aws:states:us-east-1:123456789012:stateMachine:myStateMachine",
"Condition": {
"ForAnyValue:StringEquals": {
"states:StateMachineQualifier": [
"PROD",
"1"
]
}
}
}
]
}
```
En la siguiente lista se especifican las acciones de la API que se pueden utilizar para limitar los permisos con la clave de contexto `StateMachineQualifier`.
+ [CreateStateMachineAlias](https://docs.aws.amazon.com/step-functions/latest/apireference/API_CreateStateMachineAlias.html)
+ [DeleteStateMachineAlias](https://docs.aws.amazon.com/step-functions/latest/apireference/API_DeleteStateMachineAlias.html)
+ [DeleteStateMachineVersion](https://docs.aws.amazon.com/step-functions/latest/apireference/API_DeleteStateMachineVersion.html)
+ [DescribeStateMachine](https://docs.aws.amazon.com/step-functions/latest/apireference/API_DescribeStateMachine.html)
+ [DescribeStateMachineAlias](https://docs.aws.amazon.com/step-functions/latest/apireference/API_DescribeStateMachineAlias.html)
+ [ListExecutions](https://docs.aws.amazon.com/step-functions/latest/apireference/API_ListExecutions.html)
+ [ListStateMachineAliases](https://docs.aws.amazon.com/step-functions/latest/apireference/API_ListStateMachineAliases.html)
+ [StartExecution](https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html)
+ [StartSyncExecution](https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartSyncExecution.html)
+ [UpdateStateMachineAlias](https://docs.aws.amazon.com/step-functions/latest/apireference/API_UpdateStateMachineAlias.html)
# Cómo Step Functions asocia las ejecuciones con una versión o un alias
Step Functions asocia una ejecución a una versión o alias según el nombre de recurso de Amazon (ARN) que se utiliza para invocar la acción de la API [StartExecution](https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html). Step Functions realiza esta acción en el momento en que comienza la ejecución.
Puede iniciar la ejecución de una máquina de estado mediante un ARN completo o incompleto.
+ **ARN completo**: hace referencia al ARN de una máquina de estado que tiene sufijo con un número de versión o un nombre de alias.
El siguiente ejemplo de ARN completo hace referencia a la versión `3` de una máquina de estado denominada `myStateMachine`.
```
arn:aws:states:region:account-id:stateMachine:myStateMachine:3
```
El siguiente ejemplo de ARN completo hace referencia a un alias denominado `PROD` de una máquina de estado llamada `myStateMachine`.
```
arn:aws:states:region:account-id:stateMachine:myStateMachine:PROD
```
+ **ARN incompleto**: hace referencia al ARN de una máquina de estado sin número de versión ni sufijo de nombre de alias.
```
arn:aws:states:region:account-id:stateMachine:myStateMachine
```
Por ejemplo, si su ARN incompleto hace referencia a la versión `3`, Step Functions asocia la ejecución a esta versión. No asocia la ejecución a ningún alias que apunte a la versión `3`.
Si su ARN completo hace referencia a un alias, Step Functions asocia la ejecución a ese alias y a la versión a la que apunta el alias. Una ejecución solo puede asociarse a un alias.
**nota**
Si inicia una ejecución con un ARN incompleto, Step Functions no asocia esa ejecución a una versión aunque la versión utilice la misma [revision](concepts-cd-aliasing-versioning.md#statemachinerev) de la máquina de estado. Por ejemplo, si la versión 3 utiliza la última revisión, pero inicia una ejecución con un ARN incompleto, Step Functions no asocia esa ejecución a la versión 3.
## Ver las ejecuciones iniciadas con una versión o un alias
Step Functions ofrece las siguientes formas de ver las ejecuciones iniciadas con una versión o un alias:
### Uso de acciones de la API
Puede ver todas las ejecuciones asociadas a una versión o un alias invocando las acciones de la API [DescribeExecution](https://docs.aws.amazon.com/step-functions/latest/apireference/API_DescribeExecution.html) y [ListExecutions](https://docs.aws.amazon.com/step-functions/latest/apireference/API_ListExecutions.html). Estas acciones de la API devuelven el ARN de la versión o el alias que se utilizó para iniciar la ejecución. Estas acciones también devuelven otros detalles, como el estado y el ARN de la ejecución.
También puede proporcionar un ARN de alias de máquina de estado o un ARN de versión para enumerar las ejecuciones asociadas a un alias o una versión específicos.
En el siguiente ejemplo de respuesta de la acción de la API [ListExecutions](https://docs.aws.amazon.com/step-functions/latest/apireference/API_ListExecutions.html) se muestra el ARN del alias que se utiliza para iniciar la ejecución de una máquina de estado llamada *myFirstExecution*.
El texto en *cursiva* del siguiente fragmento de código representa información específica del recurso.
```
{
"executions": [
{
"executionArn": "arn:aws:states:region:account-id:execution:myStateMachine:myFirstExecution",
"stateMachineArn": "arn:aws:states:region:account-id:stateMachine:myStateMachine",
"stateMachineAliasArn": "arn:aws:states:region:account-id:stateMachine:myStateMachine:PROD",
"name": "myFirstExecution",
"status": "SUCCEEDED",
"startDate": "2023-04-20T23:07:09.477000+00:00",
"stopDate": "2023-04-20T23:07:09.732000+00:00"
}
]
}
```
### Uso de la consola de Step Functions
También puede ver las ejecuciones iniciadas por una versión o un alias desde la [consola de Step Functions](https://console.aws.amazon.com/states/home?region=us-east-1#/). En el siguiente procedimiento se muestra cómo ver las ejecuciones iniciadas con una versión específica:
1. Abra la [consola de Step Functions](https://console.aws.amazon.com/states/home?region=us-east-1#/) y, a continuación, seleccione una máquina de estado existente para la que haya publicado una [versión](concepts-state-machine-version.md#procedure-create-versions) o creado un [alias](concepts-state-machine-alias.md#procedure-create-aliases). En este ejemplo se muestra cómo ver las ejecuciones iniciadas con una versión específica de la máquina de estado.
1. Seleccione la pestaña **Versiones** y, a continuación, elija una versión de la lista de **versiones**.
**sugerencia**
Filtre por propiedad o cuadro de valores para buscar una versión específica.
1. En la *página Detalles de la versión*, puede ver una lista de todas las ejecuciones de máquinas de estado en curso y pasadas que se hayan iniciado con la versión seleccionada.
En la siguiente imagen se muestra la página *Detalles de la versión* de la consola. Esta página muestra las ejecuciones iniciadas por la versión *4* de una máquina de estado denominada `MathAddDemo`. Esta lista también muestra una ejecución que se inició con un alias denominado `PROD`. Este alias enrutaba el tráfico de ejecución a la versión *4*.
![\[Captura de pantalla ilustrativa de la página de la consola de detalles de la versión de máquina de estado.\]](http://docs.aws.amazon.com/es_es/step-functions/latest/dg/images/view-version-executions.png)
### Uso de métricas de CloudWatch
Para cada ejecución de una máquina de estado que se inicie con un [Qualified ARN](#qualifiedARN), Step Functions emite métricas adicionales con el mismo nombre y valor que las métricas emitidas actualmente. Estas métricas adicionales contienen dimensiones para cada identificador de la versión y nombre de alias con los que se inicia una ejecución. Con estas métricas, puede supervisar las ejecuciones de la máquinas de estado en el nivel de versión y determinar cuándo podría ser necesaria una reversión. También puede [crear alarmas de Amazon CloudWatch](procedure-cw-metrics.md#monitoring-using-cloudwatch-console-set-alarm) en función de estas métricas.
Step Functions emite las siguientes métricas para las ejecuciones que se inician con un alias o una versión:
+ `ExecutionTime`
+ `ExecutionsAborted`
+ `ExecutionsFailed`
+ `ExecutionsStarted`
+ `ExecutionsSucceeded`
+ `ExecutionsTimedOut `
Si ha iniciado la ejecución con un ARN de versión, Step Functions publica la métrica con `StateMachineArn` y una segunda métrica con las dimensiones `StateMachineArn` y`Version`.
Si ha iniciado la ejecución con un ARN de alias, Step Functions emite las siguientes métricas:
+ Dos métricas para el ARN incompleto y la versión.
+ Una métrica con las dimensiones `StateMachineArn` y `Alias`.
# Ejemplo: implementación de alias y versiones en Step Functions
En el siguiente ejemplo de la técnica de implementación de valores controlados se muestra cómo se puede implementar una nueva versión de la máquina de estado con la AWS Command Line Interface. En este ejemplo, el alias que cree enruta el 20 por ciento del tráfico de ejecución a la nueva versión. A continuación, enruta el 80 por ciento restante a la versión anterior. Para implementar una nueva [versión](concepts-state-machine-version.md) de la máquina de estados y cambiar el tráfico de ejecución a un [alias](concepts-state-machine-alias.md), complete los siguientes pasos:
1.
**Publique una versión de la revisión actual de la máquina de estado.**
Utilice el comando **publish-state-machine-version** en la AWS CLI para publicar una versión de la revisión actual de una máquina de estado llamada `myStateMachine:`
```
aws stepfunctions publish-state-machine-version --state-machine-arn arn:aws:states:region:account-id:stateMachine:myStateMachine
```
La respuesta devuelve `stateMachineVersionArn` de la versión que ha publicado. Por ejemplo, `arn:aws:states:region:account-id:stateMachine:myStateMachine:1`.
1.
**Cree un alias que apunte a la nueva versión de la máquina de estado.**
Utilice el comando **create-state-machine-alias** para crear un nombre de alias `PROD` que apunte a la versión 1 de `myStateMachine`:
```
aws stepfunctions create-state-machine-alias --name PROD --routing-configuration "[{\"stateMachineVersionArn\":\"arn:aws:states:region:account-id:stateMachine:myStateMachine:1\",\"weight\":100}]"
```
1.
**Compruebe que las ejecuciones iniciadas con el alias utilizan la versión publicada correcta.**
Inicie una nueva ejecución de `myStateMachine` proporcionando el ARN del alias **PROD** en el comando **start-execution**:
```
aws stepfunctions start-execution
--state-machine-arn arn:aws:states:region:account-id:stateMachineAlias:myStateMachine:PROD
--input "{}"
```
Si proporciona el ARN de la máquina de estado en la [StartExecution](https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html)solicitud, utilizará la más reciente [revision](concepts-cd-aliasing-versioning.md#statemachinerev) de la máquina de estado en lugar de la versión especificada en su alias para iniciar la ejecución.
1.
**Actualice la definición de la máquina de estado y publique una nueva versión.**
Actualice `myStateMachine` y publique su nueva versión. Para ello, utilice el parámetro `publish` opcional del comando **update-state-machine**:
```
aws stepfunctions update-state-machine
--state-machine-arn arn:aws:states:region:account-id:stateMachine:myStateMachine
--definition $UPDATED_STATE_MACHINE_DEFINITION
--publish
```
La respuesta devuelve `stateMachineVersionArn` para la nueva versión. Por ejemplo, `arn:aws:states:region:account-id:stateMachine:myStateMachine:2`.
1.
**Actualice el alias para que apunte a ambas versiones y establezca la [configuración de enrutamiento](concepts-state-machine-alias.md#alias-routing-config) del alias.**
Utilice el comando **update-state-machine-alias** para actualizar la configuración de enrutamiento del alias `PROD`. Configure el alias para que el 80 por ciento del tráfico de ejecución vaya a la versión 1 y el 20 por ciento restante a la versión 2:
```
aws stepfunctions update-state-machine-alias --state-machine-alias-arn arn:aws:states:region:account-id:stateMachineAlias:myStateMachine:PROD --routing-configuration "[{\"stateMachineVersionArn\":\"arn:aws:states:region:account-id:stateMachine:myStateMachine:1\",\"weight\":80}, {\"stateMachineVersionArn\":\"arn:aws:states:region:account-id:stateMachine:myStateMachine:2\",\"weight\":20}]"
```
1.
**Reemplace la versión 1 por la versión 2.**
Tras comprobar que la nueva versión de la máquina de estado funciona correctamente, puede implementar la nueva versión de esta. Para ello, vuelva a actualizar el alias para asignar el 100 por ciento del tráfico de ejecución a la nueva versión.
Use el comando **update-state-machine-alias** para establecer la configuración de enrutamiento del alias `PROD` en el 100 por ciento para la versión 2:
```
aws stepfunctions update-state-machine-alias --state-machine-alias-arn arn:aws:states:region:account-id:stateMachineAlias:myStateMachine:PROD --routing-configuration "[{\"stateMachineVersionArn\":\"arn:aws:states:region:account-id:stateMachine:myStateMachine:2\",\"weight\":100}]"
```
**sugerencia**
Para revertir la implementación de la versión 2, edite la configuración de enrutamiento del alias para transferir el 100 por ciento del tráfico a la versión recién implementada.
```
aws stepfunctions update-state-machine-alias
--state-machine-alias-arn arn:aws:states:region:account-id:stateMachineAlias:myStateMachine:PROD
--routing-configuration "[{\"stateMachineVersionArn\":\"arn:aws:states:region:account-id:stateMachine:myStateMachine:1\",\"weight\":100}]"
```
Puede usar versiones y alias para realizar otros tipos de implementaciones. Por ejemplo, puede realizar una *implementación continua* de una nueva versión de su máquina de estado. Para ello, aumente gradualmente el porcentaje ponderado en la configuración de enrutamiento del alias que apunta a la nueva versión.
También puede usar versiones y alias para realizar una *implementación azul/verde*. Para ello, cree un alias denominado `green` que ejecute la versión 1 actual de su máquina de estado. A continuación, cree otro alias denominado `blue` que ejecute la nueva versión, por ejemplo, `2`. Para probar la nueva versión, envíe el tráfico de ejecución al alias `blue`. Cuando esté seguro de que la nueva versión funciona correctamente, actualice el alias `green` para que apunte a la nueva versión.
# Realiza una implementación gradual de las versiones de las máquinas de estado en Step Functions
Una implementación continua es una estrategia de implementación que reemplaza lentamente las versiones anteriores de una aplicación por versiones nuevas de la misma. Para realizar una implementación continua de una versión de máquina de estado, envíe gradualmente una cantidad creciente de tráfico de ejecución a la nueva versión. La cantidad de tráfico y la tasa de aumento son parámetros que configura.
Puede realizar la implementación continua de una versión si opta por una de las opciones siguientes:
+ [Consola de Step Functions](https://console.aws.amazon.com/states/home?region=us-east-1#/): cree un alias que apunte a dos versiones de la misma máquina de estado. Para este alias, debe configurar la configuración de enrutamiento para transferir el tráfico entre las dos versiones. Para más información acerca de cómo utilizar la consola para desplegar versiones, consulte [Versiones](concepts-state-machine-version.md) y [Alias](concepts-state-machine-alias.md).
+ **Scripts para AWS CLI y SDK**: cree un script de intérprete de comandos con el AWS CLI o el SDK de AWS. Para obtener más información, consulte las siguientes secciones para utilizar AWS CLI y el SDK de AWS.
+ **Plantillas de AWS CloudFormation**: utilice los recursos `[AWS::StepFunctions::StateMachineVersion](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-stepfunctions-statemachine.html)` y `[AWS::StepFunctions::StateMachineAlias](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-stepfunctions-statemachine.html)` para publicar varias versiones de máquinas de estado y crear un alias que apunte a una o dos de estas versiones.
## Utilizar la AWS CLI para implementar una nueva versión de la máquina de estado
El script de ejemplo de esta sección muestra cómo se puede utilizar la AWS CLI para cambiar gradualmente el tráfico de una versión anterior de una máquina de estado a una nueva versión de máquina de estado. Puede utilizar este script de ejemplo o actualizarlo según sus necesidades.
Este script muestra una implementación de valores controlados para implementar una nueva versión de máquina de estado mediante un alias. En los siguientes pasos se describen las tareas que realiza el script:
1. Si el parámetro `publish_revision` está establecido en true, publique la versión más reciente [revision](concepts-cd-aliasing-versioning.md#statemachinerev) como la siguiente de la máquina de estado. Si la implementación se realiza correctamente, esta versión se convierte en la nueva versión activa.
Si establece el parámetro `publish_revision` en false, el script implementa la última versión publicada de la máquina de estado.
1. Cree un alias si todavía no existe. Si el alias no existe, dirija el 100 por ciento del tráfico de este alias a la nueva versión y, a continuación, salga del script.
1. Actualice la configuración de enrutamiento del alias para cambiar un pequeño porcentaje del tráfico de la versión anterior a la nueva. Este porcentaje de valor controlado se establece con el parámetro `canary_percentage`.
1. De forma predeterminada, supervise las alarmas configurables de CloudWatch cada 60 segundos. Si se activa alguna de estas alarmas, revierta la implementación inmediatamente dirigiendo el 100 por ciento del tráfico a la versión anterior.
Después de cada intervalo de tiempo, en segundos, definido en `alarm_polling_interval`, continúe supervisando las alarmas. Continúe la supervisión hasta que haya transcurrido el intervalo de tiempo definido en `canary_interval_seconds`.
1. Si no se activó ninguna alarma durante el proceso `canary_interval_seconds`, transfiera el 100 por ciento del tráfico a la nueva versión.
1. Si la nueva versión se implementa correctamente, elimine las versiones anteriores al número especificado en el parámetro `history_max`.
```
#!/bin/bash
#
# AWS StepFunctions example showing how to create a canary deployment with a
# State Machine Alias and versions.
#
# Requirements: AWS CLI installed and credentials configured.
#
# A canary deployment deploys the new version alongside the old version, while
# routing only a small fraction of the overall traffic to the new version to
# see if there are any errors. Only once the new version has cleared a testing
# period will it start receiving 100% of traffic.
#
# For a Blue/Green or All at Once style deployment, you can set the
# canary_percentage to 100. The script will immediately shift 100% of traffic
# to the new version, but keep on monitoring the alarms (if any) during the
# canary_interval_seconds time interval. If any alarms raise during this period,
# the script will automatically rollback to the previous version.
#
# Step Functions allows you to keep a maximum of 1000 versions in version history
# for a state machine. This script has a version history deletion mechanism at
# the end, where it will delete any versions older than the limit specified.
#
# For an example that also demonstrates linear (or rolling) deployments, see the following:
# https://github.com/aws-samples/aws-stepfunctions-examples/blob/main/gradual-deploy/sfndeploy.py
set -euo pipefail
# ******************************************************************************
# you can safely change the variables in this block to your values
state_machine_name="my-state-machine"
alias_name="alias-1"
region="us-east-1"
# array of cloudwatch alarms to poll during the test period.
# to disable alarm checking, set alarm_names=()
alarm_names=("alarm1" "alarm name with a space")
# true to publish the current revision as the next version before deploy.
# false to deploy the latest version from the state machine's version history.
publish_revision=true
# true to force routing configuration update even if the current routing
# for the alias does not have a 100% routing config.
# false will abandon deploy attempt if current routing config not 100% to a
# single version.
# Be careful when you combine this flag with publish_revision - if you just
# rerun the script you might deploy the newly published revision from the
# previous run.
force=false
# percentage of traffic to route to the new version during the test period
canary_percentage=10
# how many seconds the canary deployment lasts before full deploy to 100%
canary_interval_seconds=300
# how often to poll the alarms
alarm_polling_interval=60
# how many versions to keep in history. delete versions prior to this.
# set to 0 to disable old version history deletion.
history_max=0
# ******************************************************************************
#######################################
# Update alias routing configuration.
#
# If you don't specify version 2 details, will only create 1 routing entry. In
# this case the routing entry weight must be 100.
#
# Globals:
# alias_arn
# Arguments:
# 1. version 1 arn
# 2. version 1 weight
# 3. version 2 arn (optional)
# 4. version 2 weight (optional)
#######################################
function update_routing() {
if [[ $# -eq 2 ]]; then
local routing_config="[{\"stateMachineVersionArn\": \"$1\", \"weight\":$2}]"
elif [[ $# -eq 4 ]]; then
local routing_config="[{\"stateMachineVersionArn\": \"$1\", \"weight\":$2}, {\"stateMachineVersionArn\": \"$3\", \"weight\":$4}]"
else
echo "You have to call update_routing with either 2 or 4 input arguments." >&2
exit 1
fi
${aws} update-state-machine-alias --state-machine-alias-arn ${alias_arn} --routing-configuration "${routing_config}"
}
# ******************************************************************************
# pre-run validation
if [[ (("${#alarm_names[@]}" -gt 0)) ]]; then
alarm_exists_count=$(aws cloudwatch describe-alarms --alarm-names "${alarm_names[@]}" --alarm-types "CompositeAlarm" "MetricAlarm" --query "length([MetricAlarms, CompositeAlarms][])" --output text)
if [[ (("${#alarm_names[@]}" -ne "${alarm_exists_count}")) ]]; then
echo All of the alarms to monitor do not exist in CloudWatch: $(IFS=,; echo "${alarm_names[*]}") >&2
echo Only the following alarm names exist in CloudWatch:
aws cloudwatch describe-alarms --alarm-names "${alarm_names[@]}" --alarm-types "CompositeAlarm" "MetricAlarm" --query "join(', ', [MetricAlarms, CompositeAlarms][].AlarmName)" --output text
exit 1
fi
fi
if [[ (("${history_max}" -gt 0)) && (("${history_max}" -lt 2)) ]]; then
echo The minimum value for history_max is 2. This is the minimum number of older state machine versions to be able to rollback in the future. >&2
exit 1
fi
# ******************************************************************************
# main block follows
account_id=$(aws sts get-caller-identity --query Account --output text)
sm_arn="arn:aws:states:${region}:${account_id}:stateMachine:${state_machine_name}"
# the aws command we'll be invoking a lot throughout.
aws="aws stepfunctions"
# promote the latest revision to the next version
if [[ "${publish_revision}" = true ]]; then
new_version=$(${aws} publish-state-machine-version --state-machine-arn=$sm_arn --query stateMachineVersionArn --output text)
echo Published the current revision of state machine as the next version with arn: ${new_version}
else
new_version=$(${aws} list-state-machine-versions --state-machine-arn ${sm_arn} --max-results 1 --query "stateMachineVersions[0].stateMachineVersionArn" --output text)
echo "Since publish_revision is false, using the latest version from the state machine's version history: ${new_version}"
fi
# find the alias if it exists
alias_arn_expected="${sm_arn}:${alias_name}"
alias_arn=$(${aws} list-state-machine-aliases --state-machine-arn ${sm_arn} --query "stateMachineAliases[?stateMachineAliasArn==\`${alias_arn_expected}\`].stateMachineAliasArn" --output text)
if [[ "${alias_arn_expected}" == "${alias_arn}" ]]; then
echo Found alias ${alias_arn}
echo Current routing configuration is:
${aws} describe-state-machine-alias --state-machine-alias-arn "${alias_arn}" --query routingConfiguration
else
echo Alias does not exist. Creating alias ${alias_arn_expected} and routing 100% traffic to new version ${new_version}
${aws} create-state-machine-alias --name "${alias_name}" --routing-configuration "[{\"stateMachineVersionArn\": \"${new_version}\", \"weight\":100}]"
echo Done!
exit 0
fi
# find the version to which the alias currently points (the current live version)
old_version=$(${aws} describe-state-machine-alias --state-machine-alias-arn $alias_arn --query "routingConfiguration[?weight==\`100\`].stateMachineVersionArn" --output text)
if [[ -z "${old_version}" ]]; then
if [[ "${force}" = true ]]; then
echo Force setting is true. Will force update to routing config for alias to point 100% to new version.
update_routing "${new_version}" 100
echo Alias ${alias_arn} now pointing 100% to ${new_version}.
echo Done!
exit 0
else
echo Alias ${alias_arn} does not have a routing config entry with 100% of the traffic. This means there might be a deploy in progress, so not starting another deploy at this time. >&2
exit 1
fi
fi
if [[ "${old_version}" == "${new_version}" ]]; then
echo The alias already points to this version. No update necessary.
exit 0
fi
echo Switching ${canary_percentage}% to new version ${new_version}
(( old_weight = 100 - ${canary_percentage} ))
update_routing "${new_version}" ${canary_percentage} "${old_version}" ${old_weight}
echo New version receiving ${canary_percentage}% of traffic.
echo Old version ${old_version} is still receiving ${old_weight}%.
if [[ ${#alarm_names[@]} -eq 0 ]]; then
echo No alarm_names set. Skipping cloudwatch monitoring.
echo Will sleep for ${canary_interval_seconds} seconds before routing 100% to new version.
sleep ${canary_interval_seconds}
echo Canary period complete. Switching 100% of traffic to new version...
else
echo Checking if alarms fire for the next ${canary_interval_seconds} seconds.
(( total_wait = canary_interval_seconds + $(date +%s) ))
now=$(date +%s)
while [[ ((${now} -lt ${total_wait})) ]]; do
alarm_result=$(aws cloudwatch describe-alarms --alarm-names "${alarm_names[@]}" --state-value ALARM --alarm-types "CompositeAlarm" "MetricAlarm" --query "join(', ', [MetricAlarms, CompositeAlarms][].AlarmName)" --output text)
if [[ ! -z "${alarm_result}" ]]; then
echo The following alarms are in ALARM state: ${alarm_result}. Rolling back deploy. >&2
update_routing "${old_version}" 100
echo Rolled back to ${old_version}
exit 1
fi
echo Monitoring alarms...no alarms have triggered.
sleep ${alarm_polling_interval}
now=$(date +%s)
done
echo No alarms detected during canary period. Switching 100% of traffic to new version...
fi
update_routing "${new_version}" 100
echo Version ${new_version} is now receiving 100% of traffic.
if [[ (("${history_max}" -eq 0 ))]]; then
echo Version History deletion is disabled. Remember to prune your history, the default limit is 1000 versions.
echo Done!
exit 0
fi
echo Keep the last ${history_max} versions. Deleting any versions older than that...
# the results are sorted in descending order of the version creation time
version_history=$(${aws} list-state-machine-versions --state-machine-arn ${sm_arn} --max-results 1000 --query "join(\`\"\\n\"\`, stateMachineVersions[].stateMachineVersionArn)" --output text)
counter=0
while read line; do
((counter=${counter} + 1))
if [[ (( ${counter} -gt ${history_max})) ]]; then
echo Deleting old version ${line}
${aws} delete-state-machine-version --state-machine-version-arn ${line}
fi
done <<< "${version_history}"
echo Done!
```
## Utilizar el SDK de AWS para implementar una nueva versión de la máquina de estado
El script de ejemplo que se encuentra en [aws-stepfunctions-examples](https://github.com/aws-samples/aws-stepfunctions-examples/tree/main/gradual-deploy) muestra cómo usar el SDK de AWS para Python para cambiar gradualmente el tráfico de una versión anterior a una nueva versión de una máquina de estado. Puede utilizar este script de ejemplo o actualizarlo según sus necesidades.
El script muestra las siguientes estrategias de implementación:
+ **Valores controlados**: desvía el tráfico en dos incrementos.
En el primer incremento, un pequeño porcentaje del tráfico, por ejemplo, el 10 por ciento, se desvía a la nueva versión. En el segundo incremento, antes de que supere un intervalo de tiempo específico en segundos, el tráfico restante se desvía a la nueva versión. El cambio a la nueva versión para el tráfico restante solo se produce si no se activa ninguna alarma de CloudWatch durante el intervalo de tiempo especificado.
+ **Lineal o continuo**: desplaza el tráfico a la nueva versión en incrementos iguales, con el mismo número de segundos entre cada incremento.
Por ejemplo, si especifica el porcentaje de incremento como **20** con un `--interval` de **600** segundos, esta implementación aumenta el tráfico un 20 por ciento cada 600 segundos hasta que la nueva versión reciba el 100 por ciento del tráfico.
Esta implementación revierte inmediatamente la nueva versión si se activa alguna alarma de CloudWatch.
+ **Todo a la vez o azul/verde**: transfiere el 100 por ciento del tráfico a la nueva versión de forma inmediata. Esta implementación supervisa la nueva versión y la revierte automáticamente a la versión anterior si se activa alguna alarma de CloudWatch.
## Utilizar AWS CloudFormation para implementar una nueva versión de la máquina de estado
En el siguiente ejemplo de plantilla de CloudFormation se publican dos versiones de una máquina de estado denominada `MyStateMachine`. Crea un alias denominado `PROD`, que apunta a ambas versiones, y luego implementa la versión `2`.
En este ejemplo, el 10 por ciento del tráfico se transfiere a la versión `2` cada cinco minutos hasta que esta versión recibe el 100 por ciento del tráfico. Este ejemplo muestra también cómo puede configurar las alarmas de CloudWatch. Si alguna de las alarmas que configuró pasa a ese estado `ALARM`, la implementación fallará y se revertirá inmediatamente.
```
MyStateMachine:
Type: AWS::StepFunctions::StateMachine
Properties:
Type: STANDARD
StateMachineName: MyStateMachine
RoleArn: arn:aws:iam::account-id:role/myIamRole
Definition:
StartAt: PassState
States:
PassState:
Type: Pass
Result: Result
End: true
MyStateMachineVersionA:
Type: AWS::StepFunctions::StateMachineVersion
Properties:
Description: Version 1
StateMachineArn: !Ref MyStateMachine
MyStateMachineVersionB:
Type: AWS::StepFunctions::StateMachineVersion
Properties:
Description: Version 2
StateMachineArn: !Ref MyStateMachine
PROD:
Type: AWS::StepFunctions::StateMachineAlias
Properties:
Name: PROD
Description: The PROD state machine alias taking production traffic.
DeploymentPreference:
StateMachineVersionArn: !Ref MyStateMachineVersionB
Type: LINEAR
Percentage: 10
Interval: 5
Alarms:
# A list of alarms that you want to monitor. If any of these alarms trigger, rollback the deployment immediately by pointing 100 percent of traffic to the previous version.
- !Ref CloudWatchAlarm1
- !Ref CloudWatchAlarm2
```