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á.
# Estado de tarefa do fluxo de trabalho
**Gerenciar estados e transformar dados**
Saiba mais sobre como [transmitir dados entre estados com variáveis](workflow-variables.md) e [transformar dados com JSONata](transforming-data.md).
Um estado `Task` (`"Type": "Task"`) representa uma unidade de trabalho específica executada por uma máquina de estado. Uma tarefa executa o trabalho usando uma atividade ou AWS Lambda função, integrando-se a outras [suportadas Serviços da AWS](supported-services-awssdk.md#supported-services-awssdk-list) ou invocando uma API HTTPS, como o Stripe.
A [Amazon States Language](concepts-amazon-states-language.md) representa tarefas definindo o tipo de um estado como `Task` e fornecendo à tarefa o nome do recurso da Amazon (ARN) da atividade, a função do Lambda ou o endpoint da API HTTPS.
**Invocar uma função com argumentos JSONata **
A definição de estado da tarefa a seguir (JSONata) invoca uma função Lambda chamada. `priceWatcher`
Observe o uso de JSONata expressões para consultar dados de entrada para usar em Argumentos e o resultado da tarefa no campo de atribuição.
```
"Get Current Price": {
"Type": "Task",
"QueryLanguage" : "JSONata",
"Resource": "arn:aws:states:::lambda:invoke",
"Next": "Check Price",
"Arguments": {
"Payload": {
"product": "{% $states.context.Execution.Input.product %}"
},
"FunctionName": "arn:aws:lambda::account-id:function:priceWatcher:$LATEST"
},
"Assign": {
"currentPrice": "{% $states.result.Payload.current_price %}"
}
}
```
**Invocar uma função com parâmetros JSONPath **
A definição de estado da tarefa a seguir (JSONPath) invoca uma função Lambda chamada. `HelloFunction`
```
"Lambda Invoke": {
"Type": "Task",
"Resource": "arn:aws:states:::lambda:invoke",
"Parameters": {
"Payload.$": "$",
"FunctionName": "arn:aws:lambda:region:account-id:function:HelloFunction:$LATEST"
},
"End": true
}
```
## Tipos de tarefa
O Step Functions é compatível com os seguintes tipos de tarefa que você pode especificar em uma definição de estado Tarefa.
+ [Atividades](#state-task-activity)
+ [Funções do Lambda](#state-task-lambda)
+ [Um suportado AWS service (Serviço da AWS)](#state-task-connector)
+ [Uma tarefa HTTP](call-https-apis.md)
Você especifica um tipo de tarefa fornecendo seu ARN no campo `Resource` da definição do estado Tarefa. O exemplo a seguir mostra a sintaxe do campo `Resource`. Todos os tipos de tarefa, exceto o que invoca uma API HTTPS, usam a sintaxe a seguir. Para obter informações sobre a sintaxe da tarefa HTTP, consulte [Chame HTTPS APIs nos fluxos de trabalho do Step Functions](call-https-apis.md).
Na definição do estado da tarefa, substitua o texto em itálico na sintaxe a seguir pelas informações específicas do AWS recurso.
```
arn:partition:service:region:account:task_type:name
```
A lista a seguir explica os componentes individuais dessa sintaxe.
+ `partition`é a AWS Step Functions partição a ser usada, mais comumente`aws`.
+ `service`indica o AWS service (Serviço da AWS) usado para executar a tarefa e pode ser um dos seguintes valores:
+ `states` para uma [atividade](#state-task-activity).
+ `lambda` para uma [função do Lambda](#state-task-lambda). Se você se integrar com outros Serviços da AWS, por exemplo, Amazon SNS ou Amazon DynamoDB, use ou. `sns` `dynamodb`
+ `region`é o [código da AWS região](https://docs.aws.amazon.com/general/latest/gr/rande.html) em que a atividade Step Functions ou o tipo de máquina de estado, a função Lambda ou qualquer outro AWS recurso foi criado.
+ `account`é o Conta da AWS ID no qual você definiu o recurso.
+ `task_type` é o tipo de tarefa a ser executada. Pode ter um dos valores a seguir:
+ `activity` – Uma [atividade](#state-task-activity).
+ `function` – Uma [função do Lambda](#state-task-lambda).
+ `servicename` – O nome de um serviço conectado compatível (consulte [Integrar serviços ao Step Functions](integrate-optimized.md)).
+ `name` é o nome de recurso registrado (nome da atividade, nome da função do Lambda ou ação de API de serviço).
**nota**
O Step Functions não suporta referências ARNs entre partições ou regiões. Por exemplo, `aws-cn` não consegue invocar tarefas na partição da `aws` e vice-versa.
As seções a seguir oferecem mais detalhes sobre cada tipo de tarefa.
### Atividade
As atividades representam operadores (processos ou threads), implementados e hospedados por você, que executam uma tarefa específica. Eles oferecem suporte apenas de fluxos de trabalho padrão, não de expressos.
A atividade `Resource` ARNs usa a seguinte sintaxe.
```
arn:partition:states:region:account:activity:name
```
**nota**
Você deve criar atividades com Step Functions (usando uma [CreateActivity](https://docs.aws.amazon.com/step-functions/latest/apireference/API_CreateActivity.html)ação de API ou o [console Step Functions](https://console.aws.amazon.com/states/home?region=us-east-1#/)) antes de usá-las pela primeira vez.
Para obter mais informações sobre a criação de uma atividade e a implementação de operadores, consulte [Atividades](concepts-activities.md).
### funções do Lambda
As tarefas Lambda executam uma função usando o. AWS Lambda Para especificar uma função do Lambda, use o ARN da função do Lambda no campo `Resource`.
A forma do campo `Resource` da função do Lambda varia conforme o tipo de integração.
Para uma integração padrão do AWS SDK com uma função Lambda, `Resource` o campo conterá o seguinte valor:
```
"arn:aws:states:::aws-sdk:lambda:invoke"
```
**Recomendamos** usar a integração otimizada para suas funções do Lambda, usando o seguinte valor para o campo `Resource`:
```
"arn:aws:states:::lambda:invoke"
```
A definição de `Task` estado a seguir mostra um exemplo de uma integração otimizada com uma função Lambda chamada `HelloWorld` using. JSONata
```
"Optimized call to Lambda function (JSONata)": {
"Type": "Task",
"Resource": "arn:aws:states:::lambda:invoke",
"Output": "{% $states.result.Payload %}",
"Arguments": {
"FunctionName": "arn:aws:lambda:region:account-id:function:HelloWorld:$LATEST",
"Payload": {
"key": "{% $states.input.myKey %}"
}
},
"Next": "NextState"
}
```
### Um suportado AWS service (Serviço da AWS)
Ao fazer referência a um recurso conectado, o Step Functions chama diretamente as ações de API de um serviço compatível. Especifique o serviço e a ação no campo `Resource`.
O serviço conectado `Resource` ARNs usa a seguinte sintaxe.
```
arn:partition:states:region:account-id:servicename:APIname
```
**nota**
Para criar uma conexão síncrona com um recurso conectado, anexe `.sync` à *APIname* entrada no ARN. Para obter mais informações, consulte [Integração de produtos da ](integrate-services.md).
Por exemplo:
```
{
"StartAt": "BATCH_JOB",
"States": {
"BATCH_JOB": {
"Type": "Task",
"Resource": "arn:aws:states:::batch:submitJob.sync",
"Parameters": {
"JobDefinition": "preprocessing",
"JobName": "PreprocessingBatchJob",
"JobQueue": "SecondaryQueue",
"Parameters.$": "$.batchjob.parameters",
"RetryStrategy": {
"attempts": 5
}
},
"End": true
}
}
}
```
## Campos do estado Tarefa
Além dos [campos de estado comuns](statemachine-structure.md#amazon-states-language-common-fields), os estados `Task` têm os campos a seguir.
** `Resource` (Obrigatório)**
Um URI, especialmente um ARN que identifica exclusivamente a tarefa específica a ser executada.
**`Arguments`(Opcional, JSONata somente)**
Usado para passar informações para as ações de API de recursos conectados. Os valores podem incluir JSONata expressões. Para obter mais informações, consulte [Transformando dados com Step JSONata Functions](transforming-data.md).
**`Output`(Opcional, JSONata somente)**
Usado para especificar e transformar a saída do estado. Quando especificado, o valor substitui o padrão de saída de estado.
O campo de saída aceita qualquer valor JSON (objeto, matriz, string, número, booleano, nulo). Qualquer valor de string, incluindo aqueles dentro de objetos ou matrizes, será avaliado como JSONata se estivesse cercado por \$1%%\$1 caracteres.
A saída também aceita uma JSONata expressão diretamente, por exemplo: “Output”: “\$1% jsonata expression%\$1”
Para obter mais informações, consulte [Processamento de entrada e saída](concepts-input-output-filtering.md).
**`Parameters`(Opcional, JSONPath somente)**
Usado para passar informações para as ações de API de recursos conectados. Os parâmetros podem usar uma combinação de JSON estático e. [JsonPath](https://datatracker.ietf.org/wg/jsonpath/about/) Para obter mais informações, consulte [Transmitir parâmetros a uma API de serviço no Step Functions](connect-parameters.md).
**`Credentials` (Opcional)**
Especifica um perfil de destino que o perfil de execução da máquina de estado deve assumir antes de invocar o `Resource` especificado. Como alternativa, você também pode especificar um JSONPath valor ou uma [função intrínseca que seja resolvida em um ARN de função](intrinsic-functions.md) do IAM em tempo de execução com base na entrada de execução. Se você especificar um JSONPath valor, deverá prefixá-lo com a `$.` notação.
Para obter exemplos de uso desse campo no estado `Task`, consulte[Exemplos do campo Credenciais do estado Tarefa](#task-state-example-credentials). Para ver um exemplo de como usar esse campo para acessar um AWS recurso entre contas a partir de sua máquina de estado, consulte[Acessando AWS recursos entre contas em Step Functions](tutorial-access-cross-acct-resources.md).
Esse campo é suportado por aqueles [Tipos de tarefa](#task-types) que usam [funções Lambda](#state-task-lambda) e [um serviço compatível AWS](integrate-services.md).
** `ResultPath`(Opcional, JSONPath somente)**
Especifica onde (na entrada) inserir os resultados da execução da tarefa que é especificada em `Resource`. A entrada é então filtrada conforme especificado pelo campo `OutputPath` (se houver) antes de ser usada como a saída do estado. Para obter mais informações, consulte [Processamento de entrada e saída](concepts-input-output-filtering.md).
** `ResultSelector`(Opcional, JSONPath somente)**
Transmitir um conjunto de pares de valores-chave, em que os valores são estáticos ou selecionados a partir do resultado. Para obter mais informações, consulte [ResultSelector](input-output-inputpath-params.md#input-output-resultselector).
** `Retry` (Opcional)**
Uma matriz de objetos, chamados Retriers, que definem uma política de novas tentativas caso o estado encontre erros de tempo de execução. Para obter mais informações, consulte [Exemplos de máquina de estado usando repetição e captura](concepts-error-handling.md#error-handling-examples).
** `Catch` (Opcional)**
Uma matriz de objetos, chamados Catchers, que definem um estado de fallback. Esse estado é executado caso o estado encontre erros de tempo de execução e sua política de novas tentativas esteja esgotada ou não tenha sido definida. Para obter mais informações, consulte [Estados de fallback](concepts-error-handling.md#error-handling-fallback-states).
** `TimeoutSeconds` (Opcional)**
Especifica o tempo máximo que uma atividade ou tarefa pode ser executada antes que ela atinja o tempo limite com o erro [States.Timeout](concepts-error-handling.md#statestimeout) e falhe. O valor do tempo limite deve ser um número inteiro positivo e diferente de zero. O valor padrão é `99999999`.
A contagem do tempo limite começa quando o evento inicial é executado, como quando eventos `TaskStarted`, `ActivityStarted` ou `LambdaFunctionStarted` são registrados no histórico de eventos de execução. Para as atividades, a contagem começa quando `GetActivityTask` recebe um token e `ActivityStarted` é registrado no histórico de eventos de execução.
Quando uma tarefa é iniciada, o Step Functions espera por uma resposta de conclusão ou falha do operário da tarefa ou atividade dentro da duração de `TimeoutSeconds` especificada. Se o operário da tarefa ou da atividade não responder dentro desse período, o Step Functions marcará a execução do fluxo de trabalho como com falha.
O tempo limite da tarefa HTTP tem no máximo sessenta segundos, mesmo que `TimeoutSeconds` exceda esse limite. Consulte [Cotas relacionadas à tarefa HTTP](service-quotas.md#service-limits-http-task)
** `TimeoutSecondsPath`(Opcional, JSONPath somente)**
Para fornecer dinamicamente um valor de tempo limite a partir da entrada de estado usando um caminho de referência, use `TimeoutSecondsPath`. Quando resolvido, o caminho de referência deve selecionar campos cujos valores sejam números inteiros positivos.
Um estado `Task` não pode incluir `TimeoutSeconds` e `TimeoutSecondsPath`. O tempo limite da tarefa HTTP tem no máximo sessenta segundos, mesmo que o valor `TimeoutSecondsPath` exceda esse limite.
** `HeartbeatSeconds` (Opcional)**
Determina a frequência dos sinais de pulsação que um operário da atividade envia durante a execução de uma tarefa. As pulsações indicam que uma tarefa ainda está em execução e precisa de mais tempo para ser concluída. As pulsações evitam que uma atividade ou tarefa atinja o tempo limite durante o tempo de `TimeoutSeconds`.
`HeartbeatSeconds` deve ser um valor inteiro positivo, diferente de zero, menor que o valor do campo `TimeoutSeconds`. O valor padrão é `99999999`. Se decorrer um tempo maior do que os segundos especificados entre as pulsações da tarefa, o estado Tarefa apresentará uma falha com o erro [States.Timeout](concepts-error-handling.md#statestimeout).
Para as atividades, a contagem começa quando `GetActivityTask` recebe um token e `ActivityStarted` é registrado no histórico de eventos de execução.
** `HeartbeatSecondsPath`(Opcional, JSONPath somente)**
Para fornecer dinamicamente um valor de pulsação a partir da entrada de estado usando um caminho de referência, use `HeartbeatSecondsPath`. Quando resolvido, o caminho de referência deve selecionar campos cujos valores sejam números inteiros positivos.
Um estado `Task` não pode incluir `HeartbeatSeconds` e `HeartbeatSecondsPath`.
Um estado `Task` deverá definir o campo `End` como `true` se o estado encerrar a execução, ou deverá fornecer um estado no campo `Next` que será executado quando o estado `Task` for concluído.
## Exemplos de definição de estado Tarefa
Os exemplos a seguir mostram como especificar a definição do estado Tarefa com base na sua necessidade.
+ [Especificar tempos limite e intervalos de pulsação do estado Tarefa](#task-state-example-timeouts)
+ [Exemplo de tempo limite estático e notificação de pulsação](#task-state-example-static)
+ [Exemplo de tempo limite de tarefa dinâmica e notificação de pulsação](#task-state-example-dynamic)
+ [Usar o campo Credenciais](#task-state-example-credentials)
+ [Especificar o ARN do perfil do IAM com codificação rígida](#example-credentials-specify-role-arn)
+ [Especificando JSONPath como ARN da função do IAM](#example-credentials-specify-dynamic-jsonpath)
+ [Especificar uma função intrínseca como ARN do perfil do IAM](#example-credentials-specify-dynamic-intrinsic-function)
### Tempos limite e intervalos de pulsação do estado Tarefa
É recomendável definir um valor de tempo limite e um intervalo de pulsação para atividades de longa duração. Isso pode ser feito especificando os valores de tempo limite e pulsação ou definindo-os dinamicamente.
#### Exemplo de tempo limite estático e notificação de pulsação
Quando `HelloWorld` for concluída, o próximo estado (chamado aqui de `NextState`) será executado.
Se essa tarefa não for concluída em 300 segundos ou não enviar notificações de pulsação em intervalos de 60 segundos, ela será marcada como `failed`.
```
"ActivityState": {
"Type": "Task",
"Resource": "arn:aws:states:region:123456789012:activity:HelloWorld",
"TimeoutSeconds": 300,
"HeartbeatSeconds": 60,
"Next": "NextState"
}
```
#### Exemplo de tempo limite de tarefa dinâmica e notificação de pulsação
Neste exemplo, quando o AWS Glue trabalho for concluído, o próximo estado será executado.
Se essa tarefa não for concluída dentro do intervalo definido dinamicamente pelo trabalho AWS Glue , a tarefa será marcada como `failed`.
```
"GlueJobTask": {
"Type": "Task",
"Resource": "arn:aws:states:::glue:startJobRun.sync",
"Parameters": {
"JobName": "myGlueJob"
},
"TimeoutSecondsPath": "$.params.maxTime",
"Next": "NextState"
}
```
### Exemplos do campo Credenciais do estado Tarefa
#### Especificar o ARN do perfil do IAM com codificação rígida
O exemplo a seguir especifica um perfil do IAM de destino que o perfil do IAM de execução de uma máquina de estado deve assumir para acessar uma função do Lambda entre contas chamada `Echo`. Neste exemplo, o ARN do perfil de destino é especificado como um valor com codificação rígida.
```
{
"StartAt": "Cross-account call",
"States": {
"Cross-account call": {
"Type": "Task",
"Resource": "arn:aws:states:::lambda:invoke",
"Credentials": {
"RoleArn": "arn:aws:iam::111122223333:role/LambdaRole"
},
"Parameters": {
"FunctionName": "arn:aws:lambda:us-east-2:111122223333:function:Echo"
},
"End": true
}
}
}
```
#### Especificando JSONPath como ARN da função do IAM
O exemplo a seguir especifica um JSONPath valor, que será resolvido como um ARN de função do IAM em tempo de execução.
```
{
"StartAt": "Lambda",
"States": {
"Lambda": {
"Type": "Task",
"Resource": "arn:aws:states:::lambda:invoke",
"Credentials": {
"RoleArn.$": "$.roleArn"
},
...
}
}
}
```
#### Especificar uma função intrínseca como ARN do perfil do IAM
O exemplo a seguir usa a função intrínseca [`States.Format`](intrinsic-functions.md#asl-intrsc-func-generic), que será resolvida em um ARN do perfil do IAM em runtime.
```
{
"StartAt": "Lambda",
"States": {
"Lambda": {
"Type": "Task",
"Resource": "arn:aws:states:::lambda:invoke",
"Credentials": {
"RoleArn.$": "States.Format('arn:aws:iam::{}:role/ROLENAME', $.accountId)"
},
...
}
}
}
```