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

Tratamento de erros nos fluxos de trabalho do Step Functions

Todos os estados, exceto Pass e Wait estados, podem encontrar erros de tempo de execução. Os erros podem ocorrer por vários motivos, como os seguintes:

Por padrão, quando um estado relata um erro, AWS Step Functions faz com que a execução falhe completamente.

Nomes de erro

O Step Functions identifica erros na Amazon States Language usando sequências de caracteres que diferenciam maiúsculas de minúsculas, conhecidas como nomes de erro. A Amazon States Language define um conjunto de sequências de caracteres incorporadas que nomeiam erros conhecidos, todos começando com o States. prefixo.

Os estados podem relatar erros com outros nomes. No entanto, esses nomes de erro não podem começar com o States. prefixo.

Como prática recomendada, garanta que o código de produção possa lidar com AWS Lambda exceções de serviço (Lambda.ServiceExceptioneLambda.SdkClientException). Para obter mais informações, consulte Lidar com exceções transitórias do serviço Lambda.

Tentando novamente após um erro

Task,Parallel, e Map os estados podem ter um campo chamadoRetry, cujo valor deve ser uma matriz de objetos conhecidos como retriers. Um retrier individual representa determinado número de novas tentativas, geralmente em intervalos de tempo crescentes.

Quando um desses estados relata um erro e há um Retry campo, o Step Functions examina os recuperadores na ordem listada na matriz. Quando o nome do erro aparece no valor do ErrorEquals campo de um recuperador, a máquina de estado faz novas tentativas conforme definido no Retry campo.

Se suas receitas redriven a execução executa novamente um estado Estado do fluxo de trabalho da tarefaEstado do fluxo de trabalho paralelo,, ou Inline Map, para o qual você definiu novas tentativas. A contagem de tentativas para esses estados é redefinida para 0 para permitir o número máximo de tentativas em redrive. Para um redriven execução, você pode rastrear tentativas individuais desses estados usando o console. Para obter mais informações, consulte Repetir o comportamento do redriven execuções em Reiniciando as execuções da máquina de estado com redrive em Step Functions.

Um retrier contém os seguintes campos:

Tente novamente exemplos de campo

Esta seção inclui os seguintes exemplos de Retry campo.

Exemplo 1 — Tente novamente com BackoffRate

O exemplo a seguir de a Retry faz duas tentativas de repetição, com a primeira tentativa ocorrendo depois de esperar por três segundos. Com base no BackoffRate que você especifica, o Step Functions aumenta o intervalo entre cada nova tentativa até que o número máximo de tentativas seja atingido. No exemplo a seguir, a segunda tentativa começa depois de esperar por três segundos após a primeira tentativa.

"Retry": [ {
   "ErrorEquals": [ "States.Timeout" ],
   "IntervalSeconds": 3,
   "MaxAttempts": 2,
   "BackoffRate": 1
} ]

Exemplo 2 — Tente novamente com MaxDelaySeconds

O exemplo a seguir faz três tentativas de repetição e limita o tempo de espera resultante BackoffRate em 5 segundos. A primeira tentativa ocorre depois de esperar por três segundos. A segunda e a terceira tentativas de repetição ocorrem após a espera de cinco segundos após a tentativa anterior, devido ao limite máximo de tempo de espera definido por. MaxDelaySeconds

"Retry": [ {
    "ErrorEquals": [ "States.Timeout" ],
    "IntervalSeconds": 3,
    "MaxAttempts": 3,
    "BackoffRate":2,
    "MaxDelaySeconds": 5,
    "JitterStrategy": "FULL"
} ]

Sem issoMaxDelaySeconds, a segunda tentativa ocorreria seis segundos após a primeira tentativa, e a terceira tentativa ocorreria 12 segundos após a segunda tentativa.

Exemplo 3 — Tente novamente todos os erros, exceto States.Timeout

O nome reservado States.ALL que aparece no campo ErrorEquals de um retrier é um curinga que corresponde a qualquer nome de erro. Ele deve aparecer sozinho na matriz ErrorEquals e também no último retrier na matriz Retry. O nome States.TaskFailed também atua como um curinga e corresponde a qualquer erro, exceto o. States.Timeout

O exemplo a seguir de um Retry campo repete qualquer erro, excetoStates.Timeout.

"Retry": [ {
   "ErrorEquals": [ "States.Timeout" ],
   "MaxAttempts": 0
}, {
   "ErrorEquals": [ "States.ALL" ]
} ]

Exemplo 4 — Cenário complexo de nova tentativa

Parâmetros de um retrier em todas as visitas ao retrier no contexto de uma única execução de estado.

Considere o seguinte estado Task.

"X": {
   "Type": "Task",
   "Resource": "arn:aws:states:us-east-1:123456789012:task:X",
   "Next": "Y",
   "Retry": [ {
      "ErrorEquals": [ "ErrorA", "ErrorB" ],
      "IntervalSeconds": 1,
      "BackoffRate": 2.0,
      "MaxAttempts": 2
   }, {
      "ErrorEquals": [ "ErrorC" ],
      "IntervalSeconds": 5
   } ],
   "Catch": [ {
      "ErrorEquals": [ "States.ALL" ],
      "Next": "Z"
   } ]
}

Essa tarefa falha quatro vezes consecutivas, gerando os seguintes nomes de erro:ErrorA,, ErrorBErrorC, e. ErrorB O seguinte ocorre em consequência disso:

Estados alternativos

Task, Map e cada Parallel estado pode ter um campo chamadoCatch. O valor desse campo deve ser uma matriz de objetos, conhecidos como catchers.

Um catcher contém os campos a seguir.

Quando um estado relata um erro e não há Retry campo ou se as novas tentativas falham em resolver o erro, o Step Functions examina os coletores na ordem listada na matriz. Quando o nome do erro é exibido no valor do campo ErrorEquals de um catcher, a máquina de estado muda para o estado denominado no campo Next.

O nome reservado States.ALL que aparece em um campo ErrorEquals do catcher é um curinga que corresponde a qualquer nome de erro. Ele deve aparecer sozinho na matriz ErrorEquals e também no último catcher na matriz Catch. O nome States.TaskFailed também atua como um curinga e corresponde a qualquer erro, exceto o. States.Timeout

O exemplo a seguir de um Catch campo faz a transição para o estado nomeado RecoveryState quando uma função Lambda gera uma exceção Java não tratada. Do contrário, o campo muda para o estado EndState.

"Catch": [ {
   "ErrorEquals": [ "java.lang.Exception" ],
   "ResultPath": "$.error-info",
   "Next": "RecoveryState"
}, {
   "ErrorEquals": [ "States.ALL" ],
   "Next": "EndState"
} ]

Error output (Saída de erro)

Quando Step Functions faz a transição para o estado especificado em um nome catch, o objeto geralmente contém o campoCause. O valor desse campo é uma descrição de erro humanamente. Esse objeto é conhecido como saída de erro.

Neste exemplo, o primeiro catcher contém um campo ResultPath. Ele funciona de modo semelhante a um campo ResultPath em um nível superior do estado, o que resulta em duas possibilidades:

Assim, para o primeiro coletor no exemplo, o coletor adiciona a saída de erro à entrada como um campo nomeado error-info se ainda não houver um campo com esse nome na entrada. Em seguida, o coletor envia toda a entrada paraRecoveryState. Para o segundo coletor, a saída de erro sobrescreve a entrada e o coletor envia apenas a saída de erro para. EndState

Quando um estado tem Catch campos Retry e, o Step Functions usa primeiro qualquer recuperador apropriado. Se a política de repetição não solucionar o erro, o Step Functions aplicará a transição correspondente do coletor.

Cause cargas úteis e integrações de serviços

Um coletor retorna uma carga de string como saída. Ao trabalhar com integrações de serviços, como Amazon Athena ou AWS CodeBuild, talvez você queira converter a Cause string emJSON. O exemplo a seguir de um Pass estado com funções intrínsecas mostra como converter uma Cause string em. JSON

"Handle escaped JSON with JSONtoString": {
  "Type": "Pass",
  "Parameters": {
    "Cause.$": "States.StringToJson($.Cause)"
  },
  "Next": "Pass State with Pass Processing"
},

Exemplos de máquinas de estado usando Retry e usando Catch

As máquinas de estado definidas nos exemplos a seguir pressupõem a existência de duas funções Lambda: uma que sempre falha e outra que espera o tempo limite definido na máquina de estado.

Essa é uma definição de função do Lambda Node.js que sempre falha, retornando a mensagem error. Nos exemplos de máquina de estado a seguir, essa função Lambda é nomeada. FailFunction Para obter informações sobre a criação de uma função Lambda, consulte Etapa 1: criar uma função do Lambda a seção.

exports.handler = (event, context, callback) => {
    callback("error");
};

Essa é uma definição de uma função Lambda do Node.js que dorme por 10 segundos. Nos exemplos de máquina de estado a seguir, essa função Lambda é nomeada. sleep10

exports.handler = (event, context, callback) => {
    setTimeout(function(){
    }, 11000);
};

Lidando com uma falha usando Retry

Essa máquina de estado usa um campo Retry para tentar novamente uma função que falha e gera o nome de erro HandledError. Ele repete essa função duas vezes com um recuo exponencial entre as novas tentativas.

{
   "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda function",
   "StartAt": "HelloWorld",
   "States": {
      "HelloWorld": {
         "Type": "Task",
         "Resource": "arn:aws:lambda:us-east-1:123456789012:function:FailFunction",
         "Retry": [ {
            "ErrorEquals": ["HandledError"],
            "IntervalSeconds": 1,
            "MaxAttempts": 2,
            "BackoffRate": 2.0
         } ],
      "End": true
      }
   }
}

Essa variante usa o código de erro predefinidoStates.TaskFailed, que corresponde a qualquer erro gerado por uma função Lambda.

{
   "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda function",
   "StartAt": "HelloWorld",
   "States": {
      "HelloWorld": {
         "Type": "Task",
         "Resource": "arn:aws:lambda:us-east-1:123456789012:function:FailFunction",
         "Retry": [ {
            "ErrorEquals": ["States.TaskFailed"],
            "IntervalSeconds": 1,
            "MaxAttempts": 2,
            "BackoffRate": 2.0
         } ],
         "End": true
      }
   }
}

Lidando com uma falha usando Catch

Este exemplo usa um campo Catch. Quando uma função Lambda gera um erro, ela detecta o erro e a máquina de estado faz a transição para o estado. fallback

{
   "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda function",
   "StartAt": "HelloWorld",
   "States": {
      "HelloWorld": {
         "Type": "Task",
         "Resource": "arn:aws:lambda:us-east-1:123456789012:function:FailFunction",
         "Catch": [ {
            "ErrorEquals": ["HandledError"],
            "Next": "fallback"
         } ],
         "End": true
      },
      "fallback": {
         "Type": "Pass",
         "Result": "Hello, AWS Step Functions!",
         "End": true
      }
   }
}

Essa variante usa o código de erro predefinidoStates.TaskFailed, que corresponde a qualquer erro gerado por uma função Lambda.

{
   "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda function",
   "StartAt": "HelloWorld",
   "States": {
      "HelloWorld": {
         "Type": "Task",
         "Resource": "arn:aws:lambda:us-east-1:123456789012:function:FailFunction",
         "Catch": [ {
            "ErrorEquals": ["States.TaskFailed"],
            "Next": "fallback"
         } ],
      "End": true
      },
      "fallback": {
         "Type": "Pass",
         "Result": "Hello, AWS Step Functions!",
         "End": true
      }
   }
}

Lidando com um tempo limite usando Retry

Essa máquina de estado usa um Retry campo para repetir um Task estado que atinge o tempo limite, com base no valor de tempo limite especificado em. TimeoutSeconds Step Functions tenta novamente a invocação da função Lambda Task nesse estado duas vezes, com um recuo exponencial entre as novas tentativas.

{
   "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda function",
   "StartAt": "HelloWorld",
   "States": {
      "HelloWorld": {
         "Type": "Task",
         "Resource": "arn:aws:lambda:us-east-1:123456789012:function:sleep10",
         "TimeoutSeconds": 2,
         "Retry": [ {
            "ErrorEquals": ["States.Timeout"],
            "IntervalSeconds": 1,
            "MaxAttempts": 2,
            "BackoffRate": 2.0
         } ],
         "End": true
      }
   }
}

Lidando com um tempo limite usando Catch

Este exemplo usa um campo Catch. Quando ocorre um tempo limite, a máquina de estado muda para o estado fallback.

{
   "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda function",
   "StartAt": "HelloWorld",
   "States": {
      "HelloWorld": {
         "Type": "Task",
         "Resource": "arn:aws:lambda:us-east-1:123456789012:function:sleep10",
         "TimeoutSeconds": 2,
         "Catch": [ {
            "ErrorEquals": ["States.Timeout"],
            "Next": "fallback"
         } ],
         "End": true
      },
      "fallback": {
         "Type": "Pass",
         "Result": "Hello, AWS Step Functions!",
         "End": true
      }
   }
}