As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Gerenciar implantações contínuas com o recurso Versões e Aliases no Step Functions
Você pode usar o Step Functions para gerenciar implantações contínuas dos fluxos de trabalho por meio de *versões* e *aliases* de máquina de estado. Uma *versão* é um snapshot numerado e imutável de uma máquina de estado que você pode executar. Um *alias* é um ponteiro para até duas versões de uma máquina de estado.
Você pode manter várias versões das máquinas de estado e gerenciar sua implantação no fluxo de trabalho de produção. Com aliases, você pode rotear o tráfego entre diferentes versões dos fluxos de trabalho e implantá-los gradualmente no ambiente de produção.
Além disso, você pode iniciar execuções de máquinas de estado usando uma versão ou um alias. Se você não usa uma versão ou alias ao iniciar a execução de uma máquina de estado, o Step Functions usa a revisão mais recente da definição da máquina de estado.
**Revisão das máquinas de estado**
Uma máquina de estado pode ter uma ou mais revisões. Quando você atualiza uma máquina de estado usando a ação da [UpdateStateMachine](https://docs.aws.amazon.com/step-functions/latest/apireference/API_UpdateStateMachine.html)API, ela cria uma nova revisão da máquina de estado. Uma *revisão* é um snapshot imutável, somente para leitura, da definição e configuração de uma máquina de estado. Você não pode iniciar a execução de uma máquina de estado a partir de uma revisão, e as revisões não têm um ARN. As revisões têm um `revisionId`, que é um identificador universalmente exclusivo (UUID).
**Topics**
+ [Versões](concepts-state-machine-version.md)
+ [Aliases](concepts-state-machine-alias.md)
+ [Autorização de versões e de aliases](auth-version-alias.md)
+ [Como associar execuções de máquinas a uma versão ou alias](execution-alias-version-associate.md)
+ [Exemplo de implantação](example-alias-version-deployment.md)
+ [Implantação gradual de versões](version-rolling-deployment.md)
# Versões da máquina de estado nos fluxos de trabalho do Step Functions
Uma *versão* é um snapshot numerado e **imutável** de uma máquina de estado. Você publica versões da revisão mais recente feita nessa máquina de estado. Cada versão tem um nome do recurso da Amazon (ARN) exclusivo, que é uma combinação do ARN da máquina de estado e do número da versão separados por dois-pontos (:). O exemplo a seguir mostra o formato de um ARN da versão da máquina de estado.
```
arn:partition:states:region:account-id:stateMachine:myStateMachine:1
```
Para começar a usar versões de máquina de estado, você deve publicar a primeira versão. Depois de publicar uma versão, você pode invocar a ação da [StartExecution](https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html)API com o ARN da versão. Você não pode editar uma versão, mas pode atualizar uma máquina de estado e publicar uma nova versão. Você também pode publicar várias versões da máquina de estado.
![\[Diagrama ilustrativo difuso mostrando como as versões são snapshots imutáveis de máquinas de estado.\]](http://docs.aws.amazon.com/pt_br/step-functions/latest/dg/images/versioning-concept.png)
Ao publicar uma nova versão da máquina de estado, o Step Functions atribui a ela um número de versão. Os números das versões começam em 1 e aumentam monotonicamente para cada nova versão. Os números de versão não são reutilizados para uma máquina de estado. Se você excluir a versão 10 da máquina de estado e depois publicar uma nova versão, o Step Functions a publicará como versão 11.
As propriedades a seguir são as mesmas para todas as versões de uma máquina de estado:
+ Todas as versões de uma máquina de estado compartilham o mesmo tipo [(padrão ou expresso)](choosing-workflow-type.md).
+ Não é possível alterar o nome ou a data de criação de uma máquina de estado entre as versões.
+ As tags se aplicam globalmente às máquinas de estado. Você pode gerenciar tags para máquinas de estado usando as ações [TagResource](https://docs.aws.amazon.com/step-functions/latest/apireference/API_TagResource.html)e [UntagResource](https://docs.aws.amazon.com/step-functions/latest/apireference/API_UntagResource.html)da API.
As máquinas de estado também contêm propriedades que fazem parte de cada versão e [revision](concepts-cd-aliasing-versioning.md#statemachinerev), mas essas propriedades podem diferir entre duas versões ou revisões fornecidas. Essas propriedades incluem [Definição de máquina de estado](https://docs.aws.amazon.com/step-functions/latest/apireference/API_UpdateStateMachine.html#StepFunctions-UpdateStateMachine-request-definition), [Perfil do IAM](https://docs.aws.amazon.com/step-functions/latest/apireference/API_UpdateStateMachine.html#StepFunctions-UpdateStateMachine-request-roleArn), [Configuração de rastreamento](https://docs.aws.amazon.com/step-functions/latest/apireference/API_UpdateStateMachine.html#StepFunctions-UpdateStateMachine-request-tracingConfiguration) e [Configuração de registro](https://docs.aws.amazon.com/step-functions/latest/apireference/API_UpdateStateMachine.html#StepFunctions-UpdateStateMachine-request-loggingConfiguration).
## Como publicar uma versão de máquina de estado (Console)
Você pode publicar até mil versões de uma máquina de estado. Para solicitar um aumento desse limite flexível, use a página **Support Center** no [Console de gerenciamento da AWS](https://docs.aws.amazon.com/servicequotas/latest/userguide/request-quota-increase.html). Você pode excluir manualmente as versões não utilizadas do console ou invocando a ação da [DeleteStateMachineVersion](https://docs.aws.amazon.com/step-functions/latest/apireference/API_DeleteStateMachineVersion.html)API.
**Para publicar uma versão de máquina de estado:**
1. Abra o [console do Step Functions](https://console.aws.amazon.com/states/home?region=us-east-1#/) e escolha uma máquina de estado.
1. Na página **Detalhes da máquina de estado**, escolha **Editar**.
1. Edite a definição da máquina de estado conforme necessário e escolha **Salvar**.
1. Escolha **Publish version (Publicar versão)**.
1. (Opcional) No campo **Descrição** da caixa de diálogo exibida, digite uma breve descrição sobre a versão da máquina de estado.
1. Selecione **Publish**.
**nota**
Ao publicar uma nova versão da máquina de estado, o Step Functions atribui a ela um número de versão. Os números das versões começam em 1 e aumentam monotonicamente para cada nova versão. Os números de versão não são reutilizados para uma máquina de estado. Se você excluir a versão 10 da máquina de estado e depois publicar uma nova versão, o Step Functions a publicará como versão 11.
## Como gerenciar versões com operações da API do Step Functions
O Step Functions fornece as seguintes operações de API para publicar e gerenciar versões de máquinas de estado:
+ [PublishStateMachineVersion](https://docs.aws.amazon.com/step-functions/latest/apireference/API_PublishStateMachineVersion.html)— Publica uma versão da corrente [revision](concepts-cd-aliasing-versioning.md#statemachinerev) de uma máquina de estado.
+ [UpdateStateMachine](https://docs.aws.amazon.com/step-functions/latest/apireference/API_UpdateStateMachine.html)— Publica uma nova versão da máquina de estado se você atualizar uma máquina de estado e definir o `publish` parâmetro como `true` na mesma solicitação.
+ [CreateStateMachine](https://docs.aws.amazon.com/step-functions/latest/apireference/API_CreateStateMachine.html)— Publica a primeira revisão da máquina de estado se você definir o `publish` parâmetro como. `true`
+ [ListStateMachineVersions](https://docs.aws.amazon.com/step-functions/latest/apireference/API_ListStateMachineVersions.html)— Lista as versões do ARN da máquina de estado especificada.
+ [DescribeStateMachine](https://docs.aws.amazon.com/step-functions/latest/apireference/API_DescribeStateMachine.html)— Retorna os detalhes da versão da máquina de estado para uma versão ARN especificada em. `stateMachineArn`
+ [DeleteStateMachineVersion](https://docs.aws.amazon.com/step-functions/latest/apireference/API_DeleteStateMachineVersion.html)— Exclui uma versão da máquina de estado.
Para publicar uma nova versão da revisão atual de uma máquina de estado chamada `myStateMachine` usando o AWS Command Line Interface, use o `publish-state-machine-version` comando:
```
aws stepfunctions publish-state-machine-version --state-machine-arn arn:aws:states:region:account-id:stateMachine:myStateMachine
```
A resposta retorna o `stateMachineVersionArn`. Por exemplo, o comando anterior devolve uma resposta de `arn:aws:states:region:account-id:stateMachine:myStateMachine:1`.
**nota**
Ao publicar uma nova versão da máquina de estado, o Step Functions atribui a ela um número de versão. Os números das versões começam em 1 e aumentam monotonicamente para cada nova versão. Os números de versão não são reutilizados para uma máquina de estado. Se você excluir a versão 10 da máquina de estado e depois publicar uma nova versão, o Step Functions a publicará como versão 11.
## Como executar uma versão de máquina de estado do console
Para começar a usar versões de máquina de estado, você deve publicar primeiro uma versão da [revision](concepts-cd-aliasing-versioning.md#statemachinerev) da máquina de estado atual. Para publicar uma versão, use o console Step Functions ou invoque a ação da [PublishStateMachineVersion](https://docs.aws.amazon.com/step-functions/latest/apireference/API_PublishStateMachineVersion.html)API. Você também pode invocar a ação da [UpdateStateMachineAlias](https://docs.aws.amazon.com/step-functions/latest/apireference/API_UpdateStateMachineAlias.html)API com um parâmetro opcional chamado `publish` para atualizar uma máquina de estado e publicar sua versão.
Você pode iniciar as execuções de uma versão usando o console ou invocando a ação da [StartExecution](https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html)API e fornecendo o ARN da versão. Também é possível usar um [alias](concepts-state-machine-alias.md) para iniciar a execução de uma versão. Com base na [configuração de roteamento](concepts-state-machine-alias.md#alias-routing-config), um alias roteia o tráfego para uma versão específica.
Se você iniciar a execução de uma máquina de estado sem usar uma versão, o Step Functions usará a revisão mais recente da máquina de estado para a execução. Para obter informações sobre como o Step Functions associa uma execução a uma versão, consulte [Como associar execuções de máquinas a uma versão ou alias](execution-alias-version-associate.md).
**Para iniciar a execução usando uma versão da máquina de estado:**
1. Abra o [console do Step Functions](https://console.aws.amazon.com/states/home?region=us-east-1#/) e escolha uma máquina de estado para a qual você publicou uma ou mais versões. Para saber como publicar uma versão, consulte [Como publicar uma versão de máquina de estado (Console)](#procedure-create-versions).
1. Na página **Detalhes da máquina de estado**, escolha a guia **Versões**.
1. Na seção **Versões**, faça o seguinte:
1. Selecione a versão com a qual você quer iniciar a execução.
1. Selecione **Iniciar execução**.
1. (Opcional) Na caixa de diálogo **Iniciar execução**, digite um nome para a execução.
1. (Opcional) Digite os dados de entrada de execução e escolha **Iniciar execução**.
# Aliases de máquinas de estado nos fluxos de trabalho do Step Functions
Um *alias* é um ponteiro para até duas versões da mesma máquina de estado. Você pode criar vários aliases para as máquinas de estado. Cada alias tem um nome do recurso da Amazon (ARN) exclusivo. O ARN do alias é uma combinação do ARN da máquina de estado e do nome do alias, separados por dois pontos (:). O exemplo a seguir mostra o formato de um ARN do alias de uma máquina de estado.
```
arn:partition:states:region:account-id:stateMachine:myStateMachine:aliasName
```
Você pode usar um alias para [rotear o tráfego](#alias-routing-config) entre uma das duas versões da máquina de estado. Você também pode criar um alias que direcione para uma única versão. Os aliases só podem direcionar para versões de máquinas de estado. Você não pode usar um alias para direcionar para outro alias. O alias pode ser atualizado para direcionar para uma versão diferente da máquina de estado.
![\[Diagrama mostrando um alias que envia 80% das solicitações para a v1 e 20% para a v2.\]](http://docs.aws.amazon.com/pt_br/step-functions/latest/dg/images/aliases-concept.png)
**Topics**
+ [Como criar um alias de máquina de estado (Console)](#procedure-create-aliases)
+ [Gerenciando aliases com APIs](#manage-aliases-with-api)
+ [Configuração de roteamento de alias](#alias-routing-config)
+ [Como executar uma máquina de estado usando um alias (Console)](#procedure-run-exec-with-alias)
## Como criar um alias de máquina de estado (Console)
Você pode criar até 100 aliases para cada máquina de estado usando o console Step Functions ou invocando a ação da [CreateStateMachineAlias](https://docs.aws.amazon.com/step-functions/latest/apireference/API_CreateStateMachineAlias.html)API. Para solicitar um aumento desse limite flexível, use a página **Support Center** no [Console de gerenciamento da AWS](https://docs.aws.amazon.com/servicequotas/latest/userguide/request-quota-increase.html). Exclua aliases não utilizados do console ou invocando a ação da [DeleteStateMachineAlias](https://docs.aws.amazon.com/step-functions/latest/apireference/API_DeleteStateMachineAlias.html)API.
**Para criar um alias de máquina de estado:**
1. Abra o [console do Step Functions](https://console.aws.amazon.com/states/home?region=us-east-1#/) e escolha uma máquina de estado.
1. Na página **Detalhes da máquina de estado**, escolha a guia **Aliases**.
1. Escolha **Criar novo alias**.
1. Na página **Create alias (Criar alias)**, faça o seguinte:
1. Insira um **Nome do alias**.
1. (Opcional) Insira uma **Description (Descrição)** do alias.
1. Para configurar o roteamento no alias, consulte [Configuração de roteamento de alias](#alias-routing-config).
1. Escolha **Criar alias**.
## Como gerenciar aliases com operações da API do Step Functions
O Step Functions fornece as seguintes operações de API que você pode usar para criar e gerenciar aliases de máquinas de estado ou obter informações sobre os aliases:
+ [CreateStateMachineAlias](https://docs.aws.amazon.com/step-functions/latest/apireference/API_CreateStateMachineAlias.html)— Cria um alias para uma máquina de estado.
+ [DescribeStateMachineAlias](https://docs.aws.amazon.com/step-functions/latest/apireference/API_DescribeStateMachineAlias.html)— Retorna detalhes sobre um alias de máquina de estado.
+ [ListStateMachineAliases](https://docs.aws.amazon.com/step-functions/latest/apireference/API_ListStateMachineAliases.html)— Lista aliases para o ARN da máquina de estado especificada.
+ [UpdateStateMachineAlias](https://docs.aws.amazon.com/step-functions/latest/apireference/API_UpdateStateMachineAlias.html)— Atualiza a configuração de um alias de máquina de estado existente modificando seu `description` ou. `routingConfiguration`
+ [DeleteStateMachineAlias](https://docs.aws.amazon.com/step-functions/latest/apireference/API_DeleteStateMachineAlias.html)— Exclui um alias de máquina de estado.
Para criar um alias chamado `PROD` que aponte para a versão 1 de uma máquina de estado chamada `myStateMachine` usando o AWS Command Line Interface, use o `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}]"
```
## Configuração de roteamento de alias
Você pode usar um alias para rotear o tráfego entre duas versões de uma máquina de estado. Por exemplo, digamos que você queira lançar uma nova versão da sua máquina de estado. Você pode reduzir os riscos envolvidos na implantação da nova versão configurando o roteamento em um alias. Ao configurar o roteamento, você pode enviar a maior parte do tráfego para uma versão anterior e testada da sua máquina de estado. A nova versão pode então receber uma porcentagem menor, até que você possa confirmar que é seguro avançar com a nova versão.
Para definir a configuração de roteamento, verifique se publicou as duas versões da máquina de estado para as quais seu alias direciona. Ao iniciar uma execução a partir de um alias, o Step Functions escolhe aleatoriamente a versão da máquina de estado a ser executada a partir das versões especificadas na configuração de roteamento. Ele baseia essa escolha na porcentagem de tráfego que você atribui a cada versão na configuração de roteamento de alias.
**Para definir a configuração de roteamento em um alias:**
+ Na página **Criar alias**, em **Configuração de roteamento**, faça o seguinte:
1. Em **Versão**, escolha a primeira versão da máquina de estado para a qual o alias direciona.
1. Marque a caixa de seleção **Dividir tráfego entre duas versões**.
**dica**
Para direcionar para uma única versão, desmarque a caixa de seleção **Dividir tráfego entre duas versões**.
1. Em **Versão**, escolha a segunda versão para a qual o alias deve direcionar.
1. Nos campos **Porcentagem de tráfego**, especifique a porcentagem de tráfego a ser roteada para cada versão. Por exemplo, digite **60** e **40** para rotear 60% do tráfego de execução para a primeira versão e 40% do tráfego para a segunda versão.
As porcentagens de tráfego combinadas devem ser iguais a 100%.
## Como executar uma máquina de estado usando um alias (Console)
Você pode iniciar as execuções da máquina de estado com um alias do console ou invocando a ação da [StartExecution](https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html)API com o ARN do alias. O Step Functions então executa a versão especificada pelo alias. Por padrão, se você não especificar uma versão ou alias ao iniciar a execução de uma máquina de estado, o Step Functions usará a revisão mais recente.
**Para iniciar a execução de uma máquina de estado usando um alias:**
1. Abra o [console Step Functions](https://console.aws.amazon.com/states/home?region=us-east-1#/) e, em seguida, escolha uma máquina de estado existente para a qual você criou um alias. Para obter informações sobre como criar um alias, consulte [Como criar um alias de máquina de estado (Console)](#procedure-create-aliases).
1. Na página **Detalhes da máquina de estado**, escolha a guia **Aliases**.
1. Na seção **Aliases**, faça o seguinte:
1. Selecione o alias com o qual você deseja iniciar a execução.
1. Selecione **Iniciar execução**.
1. (Opcional) Na caixa de diálogo **Iniciar execução**, digite um nome para a execução.
1. Se necessário, digite a entrada de execução e escolha **Iniciar execução**.
# Autorização de versões e de aliases nos fluxos de trabalho do Step Functions
Para invocar ações da API do Step Functions com uma versão ou um alias, você precisa das permissões apropriadas. Para autorizar uma versão ou um alias a invocar uma ação de API, o Step Functions usa o ARN da máquina de estado em vez de usar o ARN da versão ou do alias. Você também pode definir o escopo das permissões de uma versão ou alias específico. Para obter mais informações, consulte [Definir o escopo das permissões](#auth-scope-permission-version-alias).
Você pode usar o seguinte exemplo de política do IAM de uma máquina de estado chamada `myStateMachine` para invocar a ação da [CreateStateMachineAlias](https://docs.aws.amazon.com/step-functions/latest/apireference/API_CreateStateMachineAlias.html)API para criar um 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"
}
]
}
```
Ao definir permissões para permitir ou negar acesso às ações da API usando versões ou aliases de máquina de estado, considere o seguinte:
+ Se você usar o `publish` parâmetro das ações [CreateStateMachine](https://docs.aws.amazon.com/step-functions/latest/apireference/API_CreateStateMachine.html)e da [UpdateStateMachine](https://docs.aws.amazon.com/step-functions/latest/apireference/API_UpdateStateMachine.html)API para publicar uma nova versão da máquina de estado, também precisará da `ALLOW` permissão na ação da [PublishStateMachineVersion](https://docs.aws.amazon.com/step-functions/latest/apireference/API_PublishStateMachineVersion.html)API.
+ A ação [DeleteStateMachine](https://docs.aws.amazon.com/step-functions/latest/apireference/API_DeleteStateMachine.html)da API exclui todas as versões e aliases associados a uma máquina de estado.
## Definir o escopo de permissões para uma versão ou alias
Você pode usar um qualificador para detalhar ainda mais a permissão de autorização necessária para uma versão ou um alias. Um qualificador se refere a um número de versão ou nome de alias. Você usa o qualificador para qualificar uma máquina de estado. O exemplo a seguir é um ARN de máquina de estado que usa um alias chamado `PROD` como o qualificador.
```
arn:aws:states:region:account-id:stateMachine:myStateMachine:PROD
```
Para obter mais informações sobre qualificados e não qualificados ARNs, consulte[Como associar execuções de máquinas a uma versão ou alias](execution-alias-version-associate.md).
Você define o escopo das permissões usando a chave de contexto opcional nomeada `states:StateMachineQualifier` em uma declaração `Condition` da política do IAM. Por exemplo, a política do IAM a seguir para uma máquina de estado chamada `myStateMachine` nega acesso para invocar a ação da [DescribeStateMachine](https://docs.aws.amazon.com/step-functions/latest/apireference/API_DescribeStateMachine.html)API com um alias chamado como `PROD` ou a versão. `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"
]
}
}
}
]
}
```
A lista a seguir especifica as ações da API nas quais você pode definir o escopo das permissões com a chave 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)
# Como o Step Functions associa as execuções a uma versão ou a um alias
O Step Functions associa uma execução a uma versão ou alias com base no nome do recurso da Amazon (ARN) que você usa para invocar a ação da API [StartExecution](https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html). O Step Functions executa essa ação no horário de início da execução.
É possível iniciar a execução de uma máquina de estado usando um ARN qualificado ou não qualificado.
+ **ARN qualificado** — Refere-se ao ARN de uma máquina de estado com o sufixo de um número de versão ou nome de alias.
O seguinte exemplo de ARN qualificado se refere à versão `3` de uma máquina de estado chamada `myStateMachine`.
```
arn:aws:states:region:account-id:stateMachine:myStateMachine:3
```
O seguinte exemplo de ARN qualificado se refere a um alias chamado `PROD` de uma máquina de estado chamada `myStateMachine`.
```
arn:aws:states:region:account-id:stateMachine:myStateMachine:PROD
```
+ **ARN não qualificado** — Refere-se ao ARN de uma máquina de estado sem o sufixo de um número de versão ou nome de alias.
```
arn:aws:states:region:account-id:stateMachine:myStateMachine
```
Por exemplo, se o ARN qualificado se referir à versão `3`, o Step Functions associará a execução a essa versão. Ele não associa a execução a nenhum alias que aponte para a versão `3`.
Se o ARN qualificado se referir a um alias, o Step Functions associará a execução a esse alias e à versão para a qual o alias aponta. Uma execução só pode ser associada a um alias.
**nota**
Se você iniciar uma execução com um ARN não qualificado, o Step Functions não associará essa execução a uma versão, mesmo que a versão use a mesma máquina de estado [revision](concepts-cd-aliasing-versioning.md#statemachinerev). Por exemplo, se a versão 3 usar a revisão mais recente, mas você iniciar uma execução com um ARN não qualificado, o Step Functions não associará essa execução à versão 3.
## Como visualizar execuções iniciadas com uma versão ou um alias
O Step Functions fornece as seguintes maneiras pelas quais você pode visualizar as execuções iniciadas com uma versão ou um alias:
### Como usar ações de API
Você pode visualizar todas as execuções associadas a uma versão ou a um alias invocando as ações da API [DescribeExecution](https://docs.aws.amazon.com/step-functions/latest/apireference/API_DescribeExecution.html) e [ListExecutions](https://docs.aws.amazon.com/step-functions/latest/apireference/API_ListExecutions.html). Essas ações de API retornam o ARN da versão ou alias usado para iniciar a execução. Essas ações também retornam outros detalhes, incluindo status e ARN da execução.
Você também pode fornecer um ARN ou ARN de versão do alias da máquina de estado para listar as execuções associadas a um alias ou versão específica.
O exemplo de resposta da ação da API [ListExecutions](https://docs.aws.amazon.com/step-functions/latest/apireference/API_ListExecutions.html) a seguir mostra o ARN do alias usado para iniciar a execução de uma máquina de estado denominada *myFirstExecution*.
O texto em *itálico* no trecho de código a seguir representa informações específicas do 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"
}
]
}
```
### Como usar o console do Step Functions
Você também pode ver as execuções iniciadas por uma versão ou um alias no [console do Step Functions](https://console.aws.amazon.com/states/home?region=us-east-1#/). O seguinte procedimento mostra como você pode visualizar as execuções iniciadas com uma versão específica:
1. Abra o [console do Step Functions](https://console.aws.amazon.com/states/home?region=us-east-1#/) e, em seguida, escolha uma máquina de estado existente para a qual você publicou uma [versão](concepts-state-machine-version.md#procedure-create-versions) ou criou um [alias](concepts-state-machine-alias.md#procedure-create-aliases). Este exemplo mostra como visualizar as execuções iniciadas com uma versão específica da máquina de estado.
1. Escolha a guia **Versões** e, em seguida, escolha uma versão na lista **Versões**.
**dica**
Filtre por propriedade ou caixa de valor para pesquisar uma versão específica.
1. Na *página de detalhes da versão*, você pode ver uma lista de todas as execuções de máquina de estado em andamento e anteriores iniciadas com a versão selecionada.
A seguinte imagem mostra a página do console *Detalhes da versão*. Essa página lista as execuções iniciadas pela versão *4* de uma máquina de estado chamada `MathAddDemo`. Essa lista também exibe uma execução que foi iniciada por um alias chamado `PROD`. Esse alias roteou o tráfego de execução para a versão *4*.
![\[Captura de tela ilustrativa da página do console de detalhes da versão da máquina de estado.\]](http://docs.aws.amazon.com/pt_br/step-functions/latest/dg/images/view-version-executions.png)
### Usar métricas do Amazon CloudWatch
Para cada execução de máquina de estado que você inicia com um [Qualified ARN](#qualifiedARN), o Step Functions emite métricas adicionais com o mesmo nome e valor das métricas emitidas atualmente. Essas métricas adicionais contêm dimensões para cada identificador de versão e nome de alias com os quais você inicia uma execução. Com essas métricas, você pode monitorar as execuções da máquina de estado no nível da versão e determinar quando um cenário de reversão pode ser necessário. Você também pode [criar alarmes do Amazon CloudWatch](procedure-cw-metrics.md#monitoring-using-cloudwatch-console-set-alarm) com base nessas métricas.
O Step Functions emite as seguintes métricas para execuções que você inicia com um alias ou uma versão:
+ `ExecutionTime`
+ `ExecutionsAborted`
+ `ExecutionsFailed`
+ `ExecutionsStarted`
+ `ExecutionsSucceeded`
+ `ExecutionsTimedOut `
Se você iniciou a execução com um ARN de versão, o Step Functions publica a métrica com o `StateMachineArn` e uma segunda métrica com dimensões `StateMachineArn` e `Version`.
Se você iniciou a execução com um ARN de alias, o Step Functions emite as seguintes métricas:
+ Duas métricas para o ARN não qualificado e a versão.
+ Uma métrica com as dimensões `StateMachineArn` e `Alias`.
# Exemplo: implantação de alias e de versões no Step Functions
O seguinte exemplo da técnica de implantação canário mostra como você pode implantar uma nova versão da máquina de estado com a AWS Command Line Interface. Neste exemplo, o alias que você cria direciona 20% do tráfego de execução para a nova versão. Em seguida, ele direciona os 80% restantes para a versão anterior. Para implantar uma nova [versão](concepts-state-machine-version.md) da máquina de estado e mudar o tráfego de execução com um [alias](concepts-state-machine-alias.md), conclua as seguintes etapas:
1.
**Publique uma versão a partir da revisão da máquina de estado atual.**
Use o comando **publish-state-machine-version** na AWS CLI para publicar uma versão da revisão atual de uma máquina de estado chamada `myStateMachine:`
```
aws stepfunctions publish-state-machine-version --state-machine-arn arn:aws:states:region:account-id:stateMachine:myStateMachine
```
A resposta retorna o `stateMachineVersionArn` da versão que você publicou. Por exemplo, .`arn:aws:states:region:account-id:stateMachine:myStateMachine:1`
1.
**Crie um alias que aponte para a versão da máquina de estado.**
Use o chamado **create-state-machine-alias** para criar um alias chamado `PROD` que aponta para a versão 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.
**Verifique se as execuções iniciadas pelo alias usam a versão publicada correta.**
Inicie uma nova execução de `myStateMachine` fornecendo o ARN do alias **PROD** no comando **start-execution**:
```
aws stepfunctions start-execution
--state-machine-arn arn:aws:states:region:account-id:stateMachineAlias:myStateMachine:PROD
--input "{}"
```
Se você fornecer o ARN da máquina de estado na [StartExecution](https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html)solicitação, ela usará a mais recente [revision](concepts-cd-aliasing-versioning.md#statemachinerev) da máquina de estado em vez da versão especificada em seu alias para iniciar a execução.
1.
**Atualize a definição da máquina de estado e publique uma nova versão.**
Atualize `myStateMachine` e publique a nova versão. Para fazer isso, use o parâmetro opcional `publish` do 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
```
A resposta retorna o `stateMachineVersionArn` para a nova versão. Por exemplo, .`arn:aws:states:region:account-id:stateMachine:myStateMachine:2`
1.
**Atualize o alias para apontar para as duas versões e defina a [configuração de roteamento](concepts-state-machine-alias.md#alias-routing-config) do alias.**
Use o comando **update-state-machine-alias** para atualizar a configuração de roteamento do alias `PROD`. Configure o alias para que 80% do tráfego de execução vá para a versão 1 e os 20% restantes para a versão 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.
**Substitua a versão 1 pela versão 2.**
Depois de verificar se a nova versão da máquina de estado funciona corretamente, você pode implantar a nova versão da máquina de estado. Para fazer isso, atualize o alias novamente para atribuir 100% do tráfego de execução à nova versão.
Use o comando **update-state-machine-alias** para definir a configuração de roteamento do alias `PROD` para 100% para a versão 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}]"
```
**dica**
Para reverter a implantação da versão 2, edite a configuração de roteamento do alias para transferir 100% do tráfego para a versão recém-implantada.
```
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}]"
```
Você pode usar versões e aliases para realizar outros tipos de implantações. Por exemplo, você pode realizar uma *implantação contínua* de uma nova versão da máquina de estado. Para fazer isso, aumente gradualmente a porcentagem ponderada na configuração de roteamento do alias que aponta para a nova versão.
Você também pode usar versões e aliases para realizar uma *implantação azul/verde*. Para fazer isso, crie um alias chamado `green` que execute a versão 1 atual da máquina de estado. Em seguida, crie outro alias chamado `blue` que execute a nova versão, por exemplo, `2`. Para testar a nova versão, envie o tráfego de execução para o alias `blue`. Quando tiver certeza de que a nova versão funciona corretamente, atualize o alias `green` para apontar para a nova versão.
# Realizar a implantação gradual de versões da máquina de estado no Step Functions
A implantação contínua é uma estratégia de implantação que substitui lentamente as versões anteriores de um aplicativo por novas versões. Para realizar a implantação contínua de uma versão da máquina de estado, envie gradualmente uma quantidade crescente de tráfego de execução para a nova versão. A quantidade de tráfego e a taxa de aumento são parâmetros que você configura.
Você pode realizar a implantação contínua de uma versão usando uma das opções a seguir.
+ [Console do Step Functions](https://console.aws.amazon.com/states/home?region=us-east-1#/): crie um alias que aponte para duas versões da mesma máquina de estado. Para esse alias, você define a configuração de roteamento para transferir o tráfego entre as duas versões. Para obter mais informações sobre como usar o console para implementar versões, consulte [Versões](concepts-state-machine-version.md) e [Aliases](concepts-state-machine-alias.md).
+ **Scripts para a AWS CLI e o SDK**: crie um script de shell usando a AWS CLI ou o AWS SDK. Para obter mais informações, consulte as seções a seguir sobre como usar a AWS CLI e o AWS SDK.
+ **Modelos do AWS CloudFormation**: use os recursos `[AWS::StepFunctions::StateMachineVersion](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-stepfunctions-statemachine.html)` e `[AWS::StepFunctions::StateMachineAlias](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-stepfunctions-statemachine.html)` para publicar várias versões de máquinas de estado e criar um alias para apontar para uma ou duas dessas versões.
## Usar a AWS CLI para implantar uma nova versão da máquina de estado
O script de exemplo nesta seção mostra como você pode usar a AWS CLI para transferir gradualmente o tráfego de uma versão anterior da máquina de estado para uma nova versão. Você pode usar esse script como exemplo ou atualizá-lo de conforme necessário.
O script mostra a implantação canário para implantar uma nova versão da máquina de estado usando um alias. As etapas a seguir descrevem as tarefas que o script executa:
1. Se o parâmetro `publish_revision` estiver definido como verdadeiro, publique a mais recente de [revision](concepts-cd-aliasing-versioning.md#statemachinerev) como a próxima versão da máquina de estado. Esta versão se tornará a nova versão ativa se a implantação for bem-sucedida.
Se você definir o parâmetro `publish_revision` como falso, o script implantará a última versão publicada da máquina de estado.
1. Crie um alias se ele ainda não existir. Se o alias não existir, direcione 100% do tráfego desse alias para a nova versão e saia do script.
1. Atualize a configuração de roteamento do alias para transferir uma pequena porcentagem do tráfego da versão anterior para a nova versão. Você define a porcentagem de canário no parâmetro `canary_percentage`.
1. Por padrão, monitore os alarmes configuráveis do CloudWatch a cada 60 segundos. Se algum desses alarmes for acionado, reverta a implantação imediatamente, apontando 100% do tráfego para a versão anterior.
Após cada intervalo de tempo, em segundos, definido em `alarm_polling_interval`, continue monitorando os alarmes. Continue monitorando até que o intervalo de tempo definido em `canary_interval_seconds` tenha passado.
1. Se nenhum alarme for acionado durante `canary_interval_seconds`, transfira 100% do tráfego para a nova versão.
1. Se a nova versão for implementada com êxito, exclua todas as versões anteriores ao número especificado no 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!
```
## Usar o AWS SDK para implantar uma nova versão da máquina de estado
O script de exemplo em [aws-stepfunctions-examples](https://github.com/aws-samples/aws-stepfunctions-examples/tree/main/gradual-deploy) mostra como usar o AWS SDK para Python para transferir gradualmente o tráfego de uma versão anterior para uma nova versão da máquina de estado. Você pode usar esse script como exemplo ou atualizá-lo de conforme necessário.
O script mostra as seguintes estratégias de implantação:
+ **Canário**: o tráfego é transferido em dois incrementos.
No primeiro incremento, uma pequena porcentagem do tráfego, por exemplo, 10% é transferida para a nova versão. No segundo incremento, antes do fim do intervalo de tempo especificado em segundos, o tráfego restante é transferido para a nova versão. A transferência do tráfego restante para a nova versão ocorre somente se nenhum alarme do CloudWatch for acionado durante o intervalo de tempo especificado.
+ **Linear ou contínuo**: transfere o tráfego para a nova versão em incrementos iguais com um número igual de segundos entre cada incremento.
Por exemplo, se você especificar a porcentagem de incremento como **20** com um `--interval` de **600** segundos, a implantação aumentará o tráfego em 20% a cada 600 segundos até que a nova versão receba 100% do tráfego.
Essa implantação reverte imediatamente a nova versão se algum alarme do CloudWatch for acionado.
+ **Tudo de uma vez ou azul/verde**: transfere imediatamente 100% do tráfego para a nova versão. Essa implantação monitora a nova versão e a reverte automaticamente para a versão anterior se algum alarme do CloudWatch for acionado.
## Usar o AWS CloudFormation para implantar uma nova versão da máquina de estado
O exemplo de modelo do CloudFormation a seguir publica duas versões da máquina de estado chamada `MyStateMachine`. Ele cria um alias chamado `PROD`, que aponta para essas duas versões e, em seguida, implanta a versão `2`.
Neste exemplo, 10% do tráfego é transferido para a versão a `2` cada cinco minutos até que essa versão receba 100% do tráfego. O exemplo também mostra como você pode configurar os alarmes do CloudWatch. Se algum dos alarmes configurados entrar no estado `ALARM`, a implantação falhará e será revertida imediatamente.
```
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
```