O AWS SDK para Java 1.x atingiu o fim do suporte em 31 de dezembro de 2025. Recomendamos que você migre para o [AWS SDK for Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/home.html) para continuar recebendo novos recursos, melhorias de disponibilidade e atualizações de segurança.
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á.
# LambdaTarefas do
Como alternativa às atividades do Amazon SWF ou em conjunto com elas, você pode usar funções [Lambda](https://aws.amazon.com/lambda/) para representar unidades de trabalho nos fluxos de trabalho e programá-las de maneira semelhante a atividades.
Este tópico descreve como implementar tarefas Lambda do Amazon SWF usando o AWS SDK para Java. Para obter mais informações sobre tarefas do Lambda em geral, consulte [Tarefas do AWS Lambda](https://docs.aws.amazon.com/amazonswf/latest/developerguide/lambda-task.html) em Guia do desenvolvedor do Amazon SWF.
## Configurar um perfil do IAM entre serviços para executar a função Lambda
Para o Amazon SWF executar a função do Lambda, você precisa configurar um perfil do IAM para dar ao Amazon SWF permissão para executar funções do Lambda em seu nome. Para obter informações completas sobre como fazer isso, consulte [Tarefas do AWS Lambda](https://docs.aws.amazon.com/amazonswf/latest/developerguide/lambda-task.html).
Será necessário o nome do recurso da Amazon (ARN) desse perfil do IAM ao registrar um fluxo de trabalho que usará tarefas do Lambda.
## Criar uma função do Lambda
Você pode escrever funções Lambda em várias linguagens diferentes, inclusive Java. Para obter informações completas sobre como criar, implantar e usar funções do Lambda, consulte o [Guia do desenvolvedor do AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/).
**nota**
Não importa a linguagem usada para escrever a função do Lambda, pois ela pode ser programada e executada por *qualquer* fluxo de trabalho do Amazon SWF, independentemente da linguagem na qual o código de fluxo de trabalho foi escrito. O Amazon SWF processa os detalhes de como executar a função e passar os dados de e para ele.
Veja a seguir uma função do Lambda simples que pode ser usada no lugar da atividade em [Criar um aplicativo do Amazon SWF simples](swf-hello.md).
+ Essa versão foi escrita em JavaScript, que pode ser inserido diretamente usando-se o [Console de gerenciamento da AWS](https://console.aws.amazon.com/console/home):
```
exports.handler = function(event, context) {
context.succeed("Hello, " + event.who + "!");
};
```
+ Aqui está a mesma função escrita em Java, que você também pode implantar e executar no Lambda:
```
package example.swf.hellolambda;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.util.json.JSONException;
import com.amazonaws.util.json.JSONObject;
public class SwfHelloLambdaFunction implements RequestHandler {
@Override
public Object handleRequest(Object input, Context context) {
String who = "{SWF}";
if (input != null) {
JSONObject jso = null;
try {
jso = new JSONObject(input.toString());
who = jso.getString("who");
} catch (JSONException e) {
e.printStackTrace();
}
}
return ("Hello, " + who + "!");
}
}
```
**nota**
Para saber mais sobre como implantar funções do Java no Lambda, consulte [Criar um pacote de implantação (Java)](https://docs.aws.amazon.com/lambda/latest/dg/lambda-java-how-to-create-deployment-package.html) no Guia do desenvolvedor do AWS Lambda. Você também deve observar a seção intitulada [Programar modelo para criar funções do Lambda no Java](https://docs.aws.amazon.com/lambda/latest/dg/java-programming-model.html).
As funções do Lambda utilizam um objeto *event* ou *input* como o primeiro parâmetro e um objeto *context* como o segundo, o que fornece informações sobre a solicitação para executar a função do Lambda. Essa função em especial espera que a entrada esteja em JSON, com um campo `who` definido como o nome usado para criar o cumprimento.
## Registrar um fluxo de trabalho a ser usado com o Lambda
Para um fluxo de trabalho programar uma função do Lambda, você deve fornecer o nome do perfil do IAM que dá ao Amazon SWF permissão para invocar funções Lambda. Você pode definir isso durante o registro do fluxo de trabalho usando os métodos `withDefaultLambdaRole` ou `setDefaultLambdaRole` de [RegisterWorkflowTypeRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/RegisterWorkflowTypeRequest.html).
```
System.out.println("** Registering the workflow type '" + WORKFLOW + "-" + WORKFLOW_VERSION
+ "'.");
try {
swf.registerWorkflowType(new RegisterWorkflowTypeRequest()
.withDomain(DOMAIN)
.withName(WORKFLOW)
.withDefaultLambdaRole(lambda_role_arn)
.withVersion(WORKFLOW_VERSION)
.withDefaultChildPolicy(ChildPolicy.TERMINATE)
.withDefaultTaskList(new TaskList().withName(TASKLIST))
.withDefaultTaskStartToCloseTimeout("30"));
}
catch (TypeAlreadyExistsException e) {
```
## Programar uma tarefa do Lambda
Programar uma tarefa do Lambda é semelhante a programar uma atividade. Você fornece uma [Decisão](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/Decision.html) com um [DecisionType](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/DecisionType.html) “ScheduleLambdaFunction” e com [ScheduleLambdaFunctionDecisionAttributes](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/ScheduleLambdaFunctionDecisionAttributes.html).
```
running_functions == 0 && scheduled_functions == 0) {
AWSLambda lam = AWSLambdaClientBuilder.defaultClient();
GetFunctionConfigurationResult function_config =
lam.getFunctionConfiguration(
new GetFunctionConfigurationRequest()
.withFunctionName("HelloFunction"));
String function_arn = function_config.getFunctionArn();
ScheduleLambdaFunctionDecisionAttributes attrs =
new ScheduleLambdaFunctionDecisionAttributes()
.withId("HelloFunction (Lambda task example)")
.withName(function_arn)
.withInput(workflow_input);
decisions.add(
```
Em `ScheduleLambdaFuntionDecisionAttributes`, você deve fornecer um *nome*, que é o ARN da função do Lambda a ser chamada, e um *id*, que é o nome que o Amazon SWF usará para identificar a função do Lambda em logs do histórico.
Você também pode fornecer *input* opcional para a função do Lambda e definir o valor *começar para encerrar tempo limte*, que é o número de segundos em que a função do Lambda tem permissão para ser executada antes de gerar um evento `LambdaFunctionTimedOut`.
**nota**
Esse código usa o [AWSLambdaClient](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/AWSLambdaClient.html) para recuperar o ARN da função do Lambda, dado o nome da função. Você pode usar essa técnica para evitar realizar a codificação rígida do ARN completo (o que inclui o ID de Conta da AWS) no código.
## Processar eventos de função do Lambda no administrador
As tarefas do Lambda vão gerar vários eventos em que você pode atuar ao fazer uma sondagem de tarefas de decisão no operador de fluxo de trabalho, correspondente ao ciclo de vida da tarefa do Lambda, com valores [EventType](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/EventType.html) como `LambdaFunctionScheduled`, `LambdaFunctionStarted` e `LambdaFunctionCompleted`. Se a função do Lambda falhar ou demorar mais do que o valor de tempo limite definido, você receberá um tipo de evento `LambdaFunctionFailed` ou `LambdaFunctionTimedOut`, respectivamente.
```
boolean function_completed = false;
String result = null;
System.out.println("Executing the decision task for the history events: [");
for (HistoryEvent event : events) {
System.out.println(" " + event);
EventType event_type = EventType.fromValue(event.getEventType());
switch(event_type) {
case WorkflowExecutionStarted:
workflow_input =
event.getWorkflowExecutionStartedEventAttributes()
.getInput();
break;
case LambdaFunctionScheduled:
scheduled_functions++;
break;
case ScheduleLambdaFunctionFailed:
scheduled_functions--;
break;
case LambdaFunctionStarted:
scheduled_functions--;
running_functions++;
break;
case LambdaFunctionCompleted:
running_functions--;
function_completed = true;
result = event.getLambdaFunctionCompletedEventAttributes()
.getResult();
break;
case LambdaFunctionFailed:
running_functions--;
break;
case LambdaFunctionTimedOut:
running_functions--;
break;
```
## Receber a saída da função do Lambda
Você pode receber um `LambdaFunctionCompleted`[EventType](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/EventType.html), you can retrieve your 0 function’s return value by first calling `getLambdaFunctionCompletedEventAttributes` no [HistoryEvent](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/HistoryEvent.html) para obter um objeto [LambdaFunctionCompletedEventAttributes](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/LambdaFunctionCompletedEventAttributes.html) e chamar o método `getResult` para recuperar a saída da função do Lambda:
```
LambdaFunctionCompleted:
running_functions--;
```
## Fonte completa deste exemplo
Você pode procurar a *origem completa :github:`* desse exemplo no Github no repositório *aws-java-developer-guide*.