Für Version AWS SDK für Java 1.x wurde der Support am 31. Dezember 2025 eingestellt. Wir empfehlen Ihnen, auf den zu migrieren, [AWS SDK for Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/home.html)um weiterhin neue Funktionen, Verfügbarkeitsverbesserungen und Sicherheitsupdates zu erhalten.
Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Lambda Aufgaben
Als Alternative zu oder in Verbindung mit Amazon SWF Aktivitäten können Sie [Lambda-Funktionen](https://aws.amazon.com/lambda/) verwenden, um Arbeitseinheiten in Ihren Workflows darzustellen und sie ähnlich wie Aktivitäten zu planen.
Dieses Thema konzentriert sich auf die Implementierung von Amazon SWF Lambda Aufgaben mithilfe von. AWS SDK für Java Weitere Informationen zu Lambda Aufgaben im Allgemeinen finden Sie unter [AWS Lambda Aufgaben](https://docs.aws.amazon.com/amazonswf/latest/developerguide/lambda-task.html) im Amazon SWF Entwicklerhandbuch.
## Einrichten einer serviceübergreifenden IAM-Rolle zum Ausführen Ihrer Lambda-Funktion
Bevor Sie Ihre Lambda Funktion ausführen Amazon SWF können, müssen Sie eine IAM-Rolle einrichten, um die Amazon SWF Erlaubnis zu erteilen, Lambda Funktionen in Ihrem Namen auszuführen. Vollständige Informationen dazu finden Sie unter [AWS Lambda Aufgaben](https://docs.aws.amazon.com/amazonswf/latest/developerguide/lambda-task.html).
Sie benötigen den Amazon-Ressourcennamen (ARN) dieser IAM-Rolle, wenn Sie einen Workflow registrieren, der Lambda Aufgaben verwendet.
## Erstellen Sie eine Funktion Lambda
Sie können Lambda Funktionen in einer Reihe verschiedener Sprachen schreiben, einschließlich Java. Vollständige Informationen zum Erstellen, Bereitstellen und Verwenden von Lambda Funktionen finden Sie im [AWS Lambda Entwicklerhandbuch](https://docs.aws.amazon.com/lambda/latest/dg/).
**Anmerkung**
Es spielt keine Rolle, in welcher Sprache Sie Ihre Lambda Funktion schreiben, sie kann von *jedem* Amazon SWF Workflow geplant und ausgeführt werden, unabhängig von der Sprache, in der Ihr Workflow-Code geschrieben ist. Amazon SWF kümmert sich um die Einzelheiten der Ausführung der Funktion und der Weitergabe von Daten an und von ihr.
Hier ist eine einfache Lambda Funktion, die anstelle der Aktivität unter [Erstellen einer einfachen Amazon SWF Anwendung](swf-hello.md) verwendet werden könnte.
+ Diese Version ist geschrieben JavaScript und kann direkt mit dem folgenden Befehl eingegeben werden [AWS-Managementkonsole](https://console.aws.amazon.com/console/home):
```
exports.handler = function(event, context) {
context.succeed("Hello, " + event.who + "!");
};
```
+ Hier ist dieselbe in Java geschriebene Funktion, die Sie auch auf Lambda bereitstellen und ausführen könnten:
```
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 + "!");
}
}
```
**Anmerkung**
Weitere Informationen zur Bereitstellung von Java-Funktionen in Lambda finden Sie unter [Creating a Deployment Package (Java)](https://docs.aws.amazon.com/lambda/latest/dg/lambda-java-how-to-create-deployment-package.html) im AWS Lambda Developer Guide. Sie sollten sich auch den Abschnitt mit dem Titel [Programmiermodell für Lambda Autorenfunktionen in](https://docs.aws.amazon.com/lambda/latest/dg/java-programming-model.html) Java ansehen.
Lambda Funktionen verwenden ein *Ereignis* oder *Eingabeobjekt* als ersten Parameter und ein *Kontextobjekt* als zweiten, das Informationen über die Anforderung zur Ausführung der Lambda Funktion bereitstellt. Diese bestimmte Funktion erwartet die Parameter im JSON-Format, wobei das Feld `who` auf den Namen zum Zusammensetzen der Begrüßung gesetzt ist.
## Registrieren Sie einen Workflow zur Verwendung mit Lambda
Damit ein Workflow eine Lambda Funktion planen kann, müssen Sie den Namen der IAM-Rolle angeben, die die Berechtigung zum Aufrufen Lambda von Funktionen erteilt Amazon SWF . Sie können dies bei der Workflow-Registrierung festlegen, indem Sie die `setDefaultLambdaRole` Methoden `withDefaultLambdaRole` oder von verwenden. [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) {
```
## Planen Sie eine Lambda Aufgabe
Das Planen einer Lambda Aufgabe ähnelt dem Planen einer Aktivität. Sie geben eine [Entscheidung](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/Decision.html) mit einem ScheduleLambdaFunction `[DecisionType](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/DecisionType.html)und mit an [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(
```
In der `ScheduleLambdaFuntionDecisionAttributes` müssen Sie einen *Namen* angeben, der der ARN der aufzurufenden Lambda Funktion ist, und eine *ID*, mit der die Lambda Funktion in Verlaufsprotokollen identifiziert Amazon SWF wird.
Sie können auch optionale *Eingaben* für die Lambda Funktion angeben und ihren *Timeout-Wert für Start bis Ende* festlegen. Dabei handelt es sich um die Anzahl der Sekunden, die die Lambda Funktion ausführen darf, bevor ein `LambdaFunctionTimedOut` Ereignis generiert wird.
**Anmerkung**
Dieser Code verwendet den [AWSLambdaClient](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/AWSLambdaClient.html), um den ARN der Lambda Funktion anhand des Funktionsnamens abzurufen. Sie können diese Technik verwenden, um zu vermeiden, dass der vollständige ARN (einschließlich Ihrer AWS-Konto ID) in Ihrem Code fest codiert wird.
## Behandeln Sie Lambda-Funktionsereignisse in Ihrem Decider
Lambda Aufgaben generieren eine Reihe von Ereignissen, auf die Sie reagieren können, wenn Sie in Ihrem Workflow-Worker nach Entscheidungsaufgaben suchen, die dem Lebenszyklus Ihrer Lambda Aufgabe entsprechen, mit [EventType](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/EventType.html)Werten wie`LambdaFunctionScheduled`, `LambdaFunctionStarted` und. `LambdaFunctionCompleted` Wenn die Lambda Funktion fehlschlägt oder ihre Ausführung länger dauert als der eingestellte Timeout-Wert, erhalten Sie entweder einen Ereignistyp `LambdaFunctionFailed` oder einen `LambdaFunctionTimedOut` Ereignistyp.
```
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;
```
## Empfangen Sie die Ausgabe Ihrer Funktion Lambda
Wenn Sie einen Befehl `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` [HistoryEvent](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/HistoryEvent.html)zum Abrufen eines [LambdaFunctionCompletedEventAttributes](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/LambdaFunctionCompletedEventAttributes.html)Objekts erhalten und dann dessen `getResult` Methode aufrufen, um die Ausgabe der Lambda Funktion abzurufen:
```
LambdaFunctionCompleted:
running_functions--;
```
## Vollständiger Quellcode für dieses Beispiel
Sie können die *komplette Quellcode:github: `< awsdocs/aws-java-developer-guide/tree/master/doc\_source/snippets/helloswf \_lambda/>* nach diesem Beispiel auf Github im Repository durchsuchen. *aws-java-developer-guide*