Die Version AWS SDK für Java 1.x wurde end-of-support am 31. Dezember 2025 erreicht. 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.
# AWS SDK für Java Codebeispiele
Dieser Abschnitt enthält Tutorials und Beispiele für die Verwendung von AWS SDK für Java Version 1 zum Programmieren von AWS Diensten.
Den Quellcode für diese und andere Beispiele finden Sie im [Repository für AWS Dokumentationscodebeispiele unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples).
Um dem AWS Dokumentationsteam ein neues Codebeispiel vorzuschlagen, das es erstellen könnte, erstellen Sie eine neue Anfrage. Das Team möchte Codebeispiele erstellen, die breitere Szenarien und Anwendungsfälle abdecken, im Vergleich zu einfachen Codeausschnitten, die nur einzelne API-Aufrufe abdecken. Anweisungen finden Sie in den [Richtlinien](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/CONTRIBUTING.md) für Beiträge im Codebeispiel-Repository auf.. GitHub
## AWS SDK für Java 2.x
Im Jahr 2018 AWS veröffentlichte das [AWS SDK for Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/home.html). Dieses Handbuch enthält Anweisungen zur Verwendung des neuesten Java-SDK sowie Beispielcode.
**Anmerkung**
Weitere Beispiele [und zusätzliche Ressourcen für AWS SDK für Java Entwickler finden Sie unter Zusätzliche Dokumentation](welcome.md#additional-resources) und Ressourcen\$1
**Topics**
# CloudWatch Beispiele für die Verwendung der AWS SDK für Java
Dieser Abschnitt bietet Beispiele für die Programmierung von [CloudWatch](https://aws.amazon.com/cloudwatch/) mithilfe des [AWS SDK für Java](https://aws.amazon.com/sdk-for-java/).
Amazon CloudWatch überwacht Ihre Amazon Web Services (AWS) Ressourcen und die Anwendungen, auf denen Sie laufen, AWS in Echtzeit. Sie können CloudWatch damit Metriken sammeln und verfolgen. Dabei handelt es sich um Variablen, die Sie für Ihre Ressourcen und Anwendungen messen können. CloudWatch Alarme senden Benachrichtigungen oder nehmen auf der Grundlage von von Ihnen festgelegter Regeln automatisch Änderungen an den Ressourcen vor, die Sie überwachen.
Weitere Informationen dazu CloudWatch finden Sie im [Amazon CloudWatch Benutzerhandbuch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/).
**Anmerkung**
Die Beispiele enthalten nur den Code, der zur Demonstration jeder Technik nötig ist. Der [vollständige Beispielcode ist verfügbar unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/java). Von dort aus können Sie eine einzelne Quelldatei herunterladen oder das Repository klonen, um alle Beispiele lokal zu erstellen und auszuführen.
**Topics**
+ [Metriken abrufen von CloudWatch](examples-cloudwatch-get-metrics.md)
+ [Veröffentlichen benutzerdefinierter Metrikdaten](examples-cloudwatch-publish-custom-metrics.md)
+ [Mit CloudWatch Alarmen arbeiten](examples-cloudwatch-create-alarms.md)
+ [Verwenden von Alarmaktionen in CloudWatch](examples-cloudwatch-use-alarm-actions.md)
+ [Ereignisse senden an CloudWatch](examples-cloudwatch-send-events.md)
# Metriken abrufen von CloudWatch
## Auflisten von Metriken
Um CloudWatch Metriken aufzulisten, erstellen Sie eine `listMetrics` Methode [ListMetricsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/ListMetricsRequest.html)und rufen sie auf. AmazonCloudWatchClient Sie können `ListMetricsRequest` zum Filtern der zurückgegebenen Metriken nach Namespace, Metrikname oder Dimensionen verwenden.
**Anmerkung**
Eine Liste der Metriken und Dimensionen, die von AWS Services veröffentlicht werden, finden Sie im \$1https---docs-aws-amazon-com- AmazonCloudWatch -Latest-Monitoring-cw-support-for-AWS-html\$1 [Amazon Metrics and Dimensions Reference] im Benutzerhandbuch. CloudWatch Amazon CloudWatch
**Importe**
```
import com.amazonaws.services.cloudwatch.AmazonCloudWatch;
import com.amazonaws.services.cloudwatch.AmazonCloudWatchClientBuilder;
import com.amazonaws.services.cloudwatch.model.ListMetricsRequest;
import com.amazonaws.services.cloudwatch.model.ListMetricsResult;
import com.amazonaws.services.cloudwatch.model.Metric;
```
**Code**
```
final AmazonCloudWatch cw =
AmazonCloudWatchClientBuilder.defaultClient();
ListMetricsRequest request = new ListMetricsRequest()
.withMetricName(name)
.withNamespace(namespace);
boolean done = false;
while(!done) {
ListMetricsResult response = cw.listMetrics(request);
for(Metric metric : response.getMetrics()) {
System.out.printf(
"Retrieved metric %s", metric.getMetricName());
}
request.setNextToken(response.getNextToken());
if(response.getNextToken() == null) {
done = true;
}
}
```
Die Metriken werden in a zurückgegeben, indem die zugehörige Methode aufgerufen wird. [ListMetricsResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/ListMetricsResult.html)`getMetrics` Eventuell werden die Ergebnisse *seitenweise* zurückgegeben. Um den nächsten Stapel Ergebnisse abzurufen, rufen Sie `setNextToken` beim Original-Anforderungsobjekt mit dem Rückgabewert der `getNextToken`-Methode des `ListMetricsResult`-Objekts auf. Übergeben Sie das geänderte Anforderungsobjekt dann an einen weiteren Aufruf von `listMetrics`.
## Weitere Informationen
+ [ListMetrics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_ListMetrics.html)in der Amazon CloudWatch API-Referenz.
# Veröffentlichen benutzerdefinierter Metrikdaten
Eine Reihe von AWS Diensten veröffentlichen [ihre eigenen Metriken](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/aws-namespaces.html) in Namespaces, die mit "`AWS`" beginnen. Sie können benutzerdefinierte Metrikdaten auch mit Ihrem eigenen Namespace veröffentlichen (sofern dieser nicht mit "" beginnt). `AWS`
## Veröffentlichen benutzerdefinierter Metrikdaten
Um Ihre eigenen Metrikdaten zu veröffentlichen, rufen Sie die Methode AmazonCloudWatchClient's `putMetricData` mit einem auf. [PutMetricDataRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/PutMetricDataRequest.html) Die `PutMetricDataRequest` muss den benutzerdefinierten Namespace enthalten, der für die Daten verwendet werden soll, und Informationen über den Datenpunkt selbst in einem [MetricDatum](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/MetricDatum.html)Objekt.
**Anmerkung**
Sie können keinen Namespace angeben, der mit "" `AWS` beginnt. Namespaces, die mit "`AWS`" beginnen, sind für die Verwendung durch Produkte reserviert. Amazon Web Services
**Importe**
```
import com.amazonaws.services.cloudwatch.AmazonCloudWatch;
import com.amazonaws.services.cloudwatch.AmazonCloudWatchClientBuilder;
import com.amazonaws.services.cloudwatch.model.Dimension;
import com.amazonaws.services.cloudwatch.model.MetricDatum;
import com.amazonaws.services.cloudwatch.model.PutMetricDataRequest;
import com.amazonaws.services.cloudwatch.model.PutMetricDataResult;
import com.amazonaws.services.cloudwatch.model.StandardUnit;
```
**Code**
```
final AmazonCloudWatch cw =
AmazonCloudWatchClientBuilder.defaultClient();
Dimension dimension = new Dimension()
.withName("UNIQUE_PAGES")
.withValue("URLS");
MetricDatum datum = new MetricDatum()
.withMetricName("PAGES_VISITED")
.withUnit(StandardUnit.None)
.withValue(data_point)
.withDimensions(dimension);
PutMetricDataRequest request = new PutMetricDataRequest()
.withNamespace("SITE/TRAFFIC")
.withMetricData(datum);
PutMetricDataResult response = cw.putMetricData(request);
```
## Weitere Informationen
+ [Verwenden von Amazon CloudWatch Metriken](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/working_with_metrics.html) im Amazon CloudWatch Benutzerhandbuch.
+ [AWS Namespaces](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/aws-namespaces.html) im Amazon CloudWatch Benutzerhandbuch.
+ [PutMetricData](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_PutMetricData.html)in der API-Referenz Amazon CloudWatch .
# Mit CloudWatch Alarmen arbeiten
## Einrichten eines Alarms
Um einen Alarm auf der Grundlage einer CloudWatch Metrik zu erstellen, rufen Sie die AmazonCloudWatchClient `putMetricAlarm` Methode 'mit [PutMetricAlarmRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/PutMetricAlarmRequest.html)einer Angabe der Alarmbedingungen auf.
**Importe**
```
import com.amazonaws.services.cloudwatch.AmazonCloudWatch;
import com.amazonaws.services.cloudwatch.AmazonCloudWatchClientBuilder;
import com.amazonaws.services.cloudwatch.model.ComparisonOperator;
import com.amazonaws.services.cloudwatch.model.Dimension;
import com.amazonaws.services.cloudwatch.model.PutMetricAlarmRequest;
import com.amazonaws.services.cloudwatch.model.PutMetricAlarmResult;
import com.amazonaws.services.cloudwatch.model.StandardUnit;
import com.amazonaws.services.cloudwatch.model.Statistic;
```
**Code**
```
final AmazonCloudWatch cw =
AmazonCloudWatchClientBuilder.defaultClient();
Dimension dimension = new Dimension()
.withName("InstanceId")
.withValue(instanceId);
PutMetricAlarmRequest request = new PutMetricAlarmRequest()
.withAlarmName(alarmName)
.withComparisonOperator(
ComparisonOperator.GreaterThanThreshold)
.withEvaluationPeriods(1)
.withMetricName("CPUUtilization")
.withNamespace("{AWS}/EC2")
.withPeriod(60)
.withStatistic(Statistic.Average)
.withThreshold(70.0)
.withActionsEnabled(false)
.withAlarmDescription(
"Alarm when server CPU utilization exceeds 70%")
.withUnit(StandardUnit.Seconds)
.withDimensions(dimension);
PutMetricAlarmResult response = cw.putMetricAlarm(request);
```
## Auflisten von Alarmen
Um die CloudWatch Alarme aufzulisten, die Sie erstellt haben, rufen Sie die `describeAlarms` Methode AmazonCloudWatchClient's mit einer auf [DescribeAlarmsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/DescribeAlarmsRequest.html), mit der Sie Optionen für das Ergebnis festlegen können.
**Importe**
```
import com.amazonaws.services.cloudwatch.AmazonCloudWatch;
import com.amazonaws.services.cloudwatch.AmazonCloudWatchClientBuilder;
import com.amazonaws.services.cloudwatch.model.DescribeAlarmsRequest;
import com.amazonaws.services.cloudwatch.model.DescribeAlarmsResult;
import com.amazonaws.services.cloudwatch.model.MetricAlarm;
```
**Code**
```
final AmazonCloudWatch cw =
AmazonCloudWatchClientBuilder.defaultClient();
boolean done = false;
DescribeAlarmsRequest request = new DescribeAlarmsRequest();
while(!done) {
DescribeAlarmsResult response = cw.describeAlarms(request);
for(MetricAlarm alarm : response.getMetricAlarms()) {
System.out.printf("Retrieved alarm %s", alarm.getAlarmName());
}
request.setNextToken(response.getNextToken());
if(response.getNextToken() == null) {
done = true;
}
}
```
Die Liste der Alarme kann abgerufen werden, indem Sie die `getMetricAlarms` Funktion aufrufen [DescribeAlarmsResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/DescribeAlarmsResult.html), die von zurückgegeben wird`describeAlarms`.
Eventuell werden die Ergebnisse *seitenweise* zurückgegeben. Um den nächsten Stapel Ergebnisse abzurufen, rufen Sie `setNextToken` beim Original-Anforderungsobjekt mit dem Rückgabewert der `getNextToken`-Methode des `DescribeAlarmsResult`-Objekts auf. Übergeben Sie das geänderte Anforderungsobjekt dann an einen weiteren Aufruf von `describeAlarms`.
**Anmerkung**
Sie können auch Alarme für eine bestimmte Metrik abrufen, indem Sie die `describeAlarmsForMetric` Methode AmazonCloudWatchClient's verwenden. Sie lässt sich ähnlich wie `describeAlarms` nutzen.
## Löschen von Alarmen
Um CloudWatch Alarme zu löschen, rufen Sie die AmazonCloudWatchClient `deleteAlarms` Methode mit einer auf, [DeleteAlarmsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/DeleteAlarmsRequest.html)die einen oder mehrere Namen von Alarmen enthält, die Sie löschen möchten.
**Importe**
```
import com.amazonaws.services.cloudwatch.AmazonCloudWatch;
import com.amazonaws.services.cloudwatch.AmazonCloudWatchClientBuilder;
import com.amazonaws.services.cloudwatch.model.DeleteAlarmsRequest;
import com.amazonaws.services.cloudwatch.model.DeleteAlarmsResult;
```
**Code**
```
final AmazonCloudWatch cw =
AmazonCloudWatchClientBuilder.defaultClient();
DeleteAlarmsRequest request = new DeleteAlarmsRequest()
.withAlarmNames(alarm_name);
DeleteAlarmsResult response = cw.deleteAlarms(request);
```
## Weitere Informationen
+ [Amazon CloudWatch Alarme erstellen](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html) im Amazon CloudWatch Benutzerhandbuch
+ [PutMetricAlarm](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_PutMetricAlarm.html)in der Amazon CloudWatch API-Referenz
+ [DescribeAlarms](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_DescribeAlarms.html)in der Amazon CloudWatch API-Referenz
+ [DeleteAlarms](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_DeleteAlarms.html)in der Amazon CloudWatch API-Referenz
# Verwenden von Alarmaktionen in CloudWatch
Mithilfe von CloudWatch Alarmaktionen können Sie Alarme erstellen, die Aktionen wie das automatische Stoppen, Beenden, Neustarten oder Wiederherstellen von Instanzen ausführen. Amazon EC2
**Anmerkung**
Alarmaktionen können einem Alarm hinzugefügt werden, indem Sie bei der [PutMetricAlarmRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/PutMetricAlarmRequest.html)[Erstellung eines](examples-cloudwatch-create-alarms.md) Alarms die `setAlarmActions` Methode verwenden.
## Aktivieren von Alarmaktionen
Um Alarmaktionen für einen CloudWatch Alarm zu aktivieren, rufen Sie den AmazonCloudWatchClient `enableAlarmActions` Befehl mit einem auf, der einen oder mehrere Namen von Alarmen [EnableAlarmActionsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/EnableAlarmActionsRequest.html)enthält, deren Aktionen Sie aktivieren möchten.
**Importe**
```
import com.amazonaws.services.cloudwatch.AmazonCloudWatch;
import com.amazonaws.services.cloudwatch.AmazonCloudWatchClientBuilder;
import com.amazonaws.services.cloudwatch.model.EnableAlarmActionsRequest;
import com.amazonaws.services.cloudwatch.model.EnableAlarmActionsResult;
```
**Code**
```
final AmazonCloudWatch cw =
AmazonCloudWatchClientBuilder.defaultClient();
EnableAlarmActionsRequest request = new EnableAlarmActionsRequest()
.withAlarmNames(alarm);
EnableAlarmActionsResult response = cw.enableAlarmActions(request);
```
## Deaktivieren von Alarmaktionen
Um Alarmaktionen für einen CloudWatch Alarm zu deaktivieren, rufen Sie die AmazonCloudWatchClient s `disableAlarmActions` mit einem auf, das einen oder mehrere Namen von Alarmen [DisableAlarmActionsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/DisableAlarmActionsRequest.html)enthält, deren Aktionen Sie deaktivieren möchten.
**Importe**
```
import com.amazonaws.services.cloudwatch.AmazonCloudWatch;
import com.amazonaws.services.cloudwatch.AmazonCloudWatchClientBuilder;
import com.amazonaws.services.cloudwatch.model.DisableAlarmActionsRequest;
import com.amazonaws.services.cloudwatch.model.DisableAlarmActionsResult;
```
**Code**
```
final AmazonCloudWatch cw =
AmazonCloudWatchClientBuilder.defaultClient();
DisableAlarmActionsRequest request = new DisableAlarmActionsRequest()
.withAlarmNames(alarmName);
DisableAlarmActionsResult response = cw.disableAlarmActions(request);
```
## Weitere Informationen
+ [Erstellen Sie im Amazon CloudWatch Benutzerhandbuch Alarme zum Stoppen, Beenden, Neustarten oder Wiederherstellen einer Instanz](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/UsingAlarmActions.html)
+ [PutMetricAlarm](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_PutMetricAlarm.html)in der Amazon CloudWatch API-Referenz
+ [EnableAlarmActions](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_EnableAlarmActions.html)in der Amazon CloudWatch API-Referenz
+ [DisableAlarmActions](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_DisableAlarmActions.html)in der Amazon CloudWatch API-Referenz
# Ereignisse senden an CloudWatch
CloudWatch Events liefert nahezu in Echtzeit einen Stream von Systemereignissen, die Änderungen an AWS Ressourcen für Amazon EC2 Instanzen, Lambda Funktionen, Kinesis Streams, Amazon ECS Aufgaben, Schrittfunktionen Zustandsmaschinen, Amazon SNS Themen, Amazon SQS Warteschlangen oder integrierte Ziele beschreiben. Sie können Ereignisse zuordnen und sie zu einer oder mehreren Zielfunktionen oder Streams umleiten, indem Sie einfache Regeln nutzen.
## Hinzufügen von Ereignissen
Um benutzerdefinierte CloudWatch Ereignisse hinzuzufügen, rufen Sie die AmazonCloudWatchEventsClient `putEvents` 's-Methode mit einem [PutEventsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatchevents/model/PutEventsRequest.html)Objekt auf, das ein oder mehrere [PutEventsRequestEntry](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatchevents/model/PutEventsRequestEntry.html)Objekte enthält, die Details zu jedem Ereignis bereitstellen. Sie können mehrere Parameter für den Eintrag angeben, wie z. B. die Quelle und den Typ des Ereignisses, mit dem Ereignis verknüpfte Ressourcen usw.
**Anmerkung**
Sie können maximal 10 Ereignisse pro Aufruf von `putEvents` angeben.
**Importe**
```
import com.amazonaws.services.cloudwatchevents.AmazonCloudWatchEvents;
import com.amazonaws.services.cloudwatchevents.AmazonCloudWatchEventsClientBuilder;
import com.amazonaws.services.cloudwatchevents.model.PutEventsRequest;
import com.amazonaws.services.cloudwatchevents.model.PutEventsRequestEntry;
import com.amazonaws.services.cloudwatchevents.model.PutEventsResult;
```
**Code**
```
final AmazonCloudWatchEvents cwe =
AmazonCloudWatchEventsClientBuilder.defaultClient();
final String EVENT_DETAILS =
"{ \"key1\": \"value1\", \"key2\": \"value2\" }";
PutEventsRequestEntry request_entry = new PutEventsRequestEntry()
.withDetail(EVENT_DETAILS)
.withDetailType("sampleSubmitted")
.withResources(resource_arn)
.withSource("aws-sdk-java-cloudwatch-example");
PutEventsRequest request = new PutEventsRequest()
.withEntries(request_entry);
PutEventsResult response = cwe.putEvents(request);
```
## Hinzufügen von Regeln
Um eine Regel zu erstellen oder zu aktualisieren, rufen Sie die AmazonCloudWatchEventsClient `putRule` Methode '[PutRuleRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatchevents/model/PutRuleRequest.html)mit dem Namen der Regel und optionalen Parametern wie dem [Ereignismuster](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/CloudWatchEventsandEventPatterns.html), der IAM Rolle, die der Regel zugeordnet werden soll, und einem [Planungsausdruck](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html) auf, der beschreibt, wie oft die Regel ausgeführt wird.
**Importe**
```
import com.amazonaws.services.cloudwatchevents.AmazonCloudWatchEvents;
import com.amazonaws.services.cloudwatchevents.AmazonCloudWatchEventsClientBuilder;
import com.amazonaws.services.cloudwatchevents.model.PutRuleRequest;
import com.amazonaws.services.cloudwatchevents.model.PutRuleResult;
import com.amazonaws.services.cloudwatchevents.model.RuleState;
```
**Code**
```
final AmazonCloudWatchEvents cwe =
AmazonCloudWatchEventsClientBuilder.defaultClient();
PutRuleRequest request = new PutRuleRequest()
.withName(rule_name)
.withRoleArn(role_arn)
.withScheduleExpression("rate(5 minutes)")
.withState(RuleState.ENABLED);
PutRuleResult response = cwe.putRule(request);
```
## Hinzufügen von Zielen
Ziele sind die Ressourcen, die beim Auslösen einer Regel aufgerufen werden. Zu den Beispielzielen gehören Amazon EC2 Instanzen, Lambda Funktionen, Kinesis Streams, Amazon ECS Aufgaben, Schrittfunktionen Zustandsmaschinen und integrierte Ziele.
Um einer Regel ein Ziel hinzuzufügen, rufen Sie die AmazonCloudWatchEventsClient `putTargets` 's-Methode mit einer auf, die die zu aktualisierende Regel und eine Liste von Zielen [PutTargetsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatchevents/model/PutTargetsRequest.html)enthält, die der Regel hinzugefügt werden sollen.
**Importe**
```
import com.amazonaws.services.cloudwatchevents.AmazonCloudWatchEvents;
import com.amazonaws.services.cloudwatchevents.AmazonCloudWatchEventsClientBuilder;
import com.amazonaws.services.cloudwatchevents.model.PutTargetsRequest;
import com.amazonaws.services.cloudwatchevents.model.PutTargetsResult;
import com.amazonaws.services.cloudwatchevents.model.Target;
```
**Code**
```
final AmazonCloudWatchEvents cwe =
AmazonCloudWatchEventsClientBuilder.defaultClient();
Target target = new Target()
.withArn(function_arn)
.withId(target_id);
PutTargetsRequest request = new PutTargetsRequest()
.withTargets(target)
.withRule(rule_name);
PutTargetsResult response = cwe.putTargets(request);
```
## Weitere Informationen
+ [Hinzufügen von Ereignissen mit PutEvents](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/AddEventsPutEvents.html) im Amazon CloudWatch Events Benutzerhandbuch
+ [Planen Sie Ausdrücke für Regeln](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html) im Amazon CloudWatch Events Benutzerhandbuch
+ [Ereignistypen für CloudWatch Ereignisse](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html) im Amazon CloudWatch Events Benutzerhandbuch
+ [Ereignisse und Ereignismuster](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/CloudWatchEventsandEventPatterns.html) im Amazon CloudWatch Events Benutzerhandbuch
+ [PutEvents](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/API_PutEvents.html)in der Amazon CloudWatch Events API-Referenz
+ [PutTargets](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/API_PutTargets.html)in der Amazon CloudWatch Events API-Referenz
+ [PutRule](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/API_PutRule.html)in der Amazon CloudWatch Events API-Referenz
# DynamoDB Beispiele für die Verwendung der AWS SDK für Java
Dieser Abschnitt bietet Beispiele für die Programmierung von [DynamoDB](https://aws.amazon.com/dynamodb/) mithilfe des [AWS SDK für Java](https://aws.amazon.com/sdk-for-java/).
**Anmerkung**
Die Beispiele enthalten nur den Code, der zur Demonstration jeder Technik nötig ist. Der [vollständige Beispielcode ist verfügbar unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/java). Von dort aus können Sie eine einzelne Quelldatei herunterladen oder das Repository klonen, um alle Beispiele lokal zu erstellen und auszuführen.
**Topics**
+ [Verwenden Sie AWS kontobasierte Endpunkte](#account-based-endpoint-routing)
+ [Arbeiten mit Tabellen in DynamoDB](examples-dynamodb-tables.md)
+ [Arbeiten mit Elementen in DynamoDB](examples-dynamodb-items.md)
## Verwenden Sie AWS kontobasierte Endpunkte
DynamoDB bietet [AWS kontobasierte Endpunkte](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.SDKOverview.html#Programming.SDKs.endpoints), die die Leistung verbessern können, indem sie Ihre AWS Konto-ID verwenden, um die Anforderungsweiterleitung zu optimieren.
Um diese Funktion nutzen zu können, müssen Sie Version 1.12.771 oder höher von Version 1 von verwenden. AWS SDK für Java Sie finden die neueste Version des SDK im zentralen [Maven-Repository](https://central.sonatype.com/artifact/com.amazonaws/aws-java-sdk-bom). Sobald eine unterstützte Version des SDK aktiv ist, verwendet sie automatisch die neuen Endpunkte.
Wenn Sie das kontobasierte Routing deaktivieren möchten, haben Sie vier Möglichkeiten:
+ Konfigurieren Sie einen DynamoDB-Dienstclient mit der `AccountIdEndpointMode` Einstellung auf. `DISABLED`
+ Legen Sie eine Umgebungsvariable fest.
+ Legen Sie eine JVM-Systemeigenschaft fest.
+ Aktualisieren Sie die Einstellung für die gemeinsam genutzte AWS Konfigurationsdatei.
Der folgende Ausschnitt ist ein Beispiel dafür, wie Sie das kontobasierte Routing deaktivieren können, indem Sie einen DynamoDB-Dienstclient konfigurieren:
```
ClientConfiguration config = new ClientConfiguration()
.withAccountIdEndpointMode(AccountIdEndpointMode.DISABLED);
AWSCredentialsProvider credentialsProvider = new EnvironmentVariableCredentialsProvider();
AmazonDynamoDB dynamodb = AmazonDynamoDBClientBuilder.standard()
.withClientConfiguration(config)
.withCredentials(credentialsProvider)
.withRegion(Regions.US_WEST_2)
.build();
```
[Das AWS SDKs Referenzhandbuch zu Tools enthält weitere Informationen zu den letzten drei Konfigurationsoptionen.](https://docs.aws.amazon.com/sdkref/latest/guide/feature-account-endpoints.html)
# Arbeiten mit Tabellen in DynamoDB
Tabellen sind die Container für alle Elemente in einer DynamoDB Datenbank. Bevor Sie Daten hinzufügen oder daraus entfernen können DynamoDB, müssen Sie eine Tabelle erstellen.
Für jede Tabelle definieren Sie:
+ Einen Tabellen*namen*, der eindeutig für Ihr Konto und Ihre Region ist.
+ Einen *Primärschlüssel,* für den jeder Wert eindeutig sein muss. Ihre Tabelle kann keine zwei Elemente mit demselben Primärschlüsselwert enthalten.
Ein Primärschlüssel kann *einfach* sein, also aus einem Schlüssel mit einer einzigen Partition (HASH) bestehen, oder *zusammengesetzt*, also aus einer Partition und einem Sortierschlüssel (RANGE).
Jedem Schlüsselwert ist ein *Datentyp* zugeordnet, der nach der [ScalarAttributeType](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/ScalarAttributeType.html)Klasse aufgezählt wird. Der Schlüsselwert kann binär (B), numerisch (n) oder eine Zeichenfolge (S) sein. Weitere Informationen finden Sie unter [Benennungsregeln und Datentypen](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html) im Amazon DynamoDB Entwicklerhandbuch.
+ Werte zum *bereitgestellten Durchsatz*, die die Anzahl der reservierten Lese-Schreib-Kapazitätseinheiten für die Tabelle angeben.
**Anmerkung**
Amazon DynamoDB Die [Preisgestaltung](https://aws.amazon.com/dynamodb/pricing/) basiert auf den bereitgestellten Durchsatzwerten, die Sie für Ihre Tabellen festlegen. Reservieren Sie daher nur so viel Kapazität, wie Sie für Ihre Tabelle voraussichtlich benötigen.
Der bereitgestellte Durchsatz für eine Tabelle kann jederzeit geändert werden. So können Sie die Kapazität anpassen, wenn sich Ihre Anforderungen ändern.
## Erstellen einer Tabelle
Verwenden Sie die `createTable` Methode des [DynamoDB Kunden](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/AmazonDynamoDB.html), um eine neue DynamoDB Tabelle zu erstellen. Sie müssen Tabellenattribute und ein Tabellenschema erstellen. Beide Komponenten fließen in den Primärschlüssel der Tabelle ein. Sie müssen auch anfänglich bereitgestellte Durchsatzwerte und einen Tabellennamen angeben. Definieren Sie nur wichtige Tabellenattribute, wenn Sie Ihre DynamoDB Tabelle erstellen.
**Anmerkung**
Wenn eine Tabelle mit dem von Ihnen gewählten Namen bereits existiert, [AmazonServiceException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/AmazonServiceException.html)wird eine ausgelöst.
**Importe**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.model.AttributeDefinition;
import com.amazonaws.services.dynamodbv2.model.CreateTableRequest;
import com.amazonaws.services.dynamodbv2.model.CreateTableResult;
import com.amazonaws.services.dynamodbv2.model.KeySchemaElement;
import com.amazonaws.services.dynamodbv2.model.KeyType;
import com.amazonaws.services.dynamodbv2.model.ProvisionedThroughput;
import com.amazonaws.services.dynamodbv2.model.ScalarAttributeType;
```
### Erstellen einer Tabelle mit einem einfachen Primärschlüssel
Dieser Code erstellt eine Tabelle mit einem einfachen Primärschlüssel ("Name").
**Code**
```
CreateTableRequest request = new CreateTableRequest()
.withAttributeDefinitions(new AttributeDefinition(
"Name", ScalarAttributeType.S))
.withKeySchema(new KeySchemaElement("Name", KeyType.HASH))
.withProvisionedThroughput(new ProvisionedThroughput(
new Long(10), new Long(10)))
.withTableName(table_name);
final AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
try {
CreateTableResult result = ddb.createTable(request);
System.out.println(result.getTableDescription().getTableName());
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/CreateTable.java) finden Sie unter GitHub.
### Erstellen einer Tabelle mit einem zusammengesetzten Primärschlüssel
Füge ein weiteres hinzu [AttributeDefinition](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/AttributeDefinition.html)und [KeySchemaElement](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/KeySchemaElement.html)zu [CreateTableRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/CreateTableRequest.html).
**Code**
```
CreateTableRequest request = new CreateTableRequest()
.withAttributeDefinitions(
new AttributeDefinition("Language", ScalarAttributeType.S),
new AttributeDefinition("Greeting", ScalarAttributeType.S))
.withKeySchema(
new KeySchemaElement("Language", KeyType.HASH),
new KeySchemaElement("Greeting", KeyType.RANGE))
.withProvisionedThroughput(
new ProvisionedThroughput(new Long(10), new Long(10)))
.withTableName(table_name);
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/CreateTableCompositeKey.java) finden Sie unter GitHub.
## Auflisten von Tabellen
Sie können die Tabellen in einer bestimmten Region auflisten, indem Sie die `listTables` Methode des [DynamoDB Clients](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/AmazonDynamoDB.html) aufrufen.
**Anmerkung**
Wenn die benannte Tabelle für Ihr Konto und Ihre Region nicht existiert, [ResourceNotFoundException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/ResourceNotFoundException.html)wird a ausgelöst.
**Importe**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.model.ListTablesRequest;
import com.amazonaws.services.dynamodbv2.model.ListTablesResult;
```
**Code**
```
final AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
ListTablesRequest request;
boolean more_tables = true;
String last_name = null;
while(more_tables) {
try {
if (last_name == null) {
request = new ListTablesRequest().withLimit(10);
}
else {
request = new ListTablesRequest()
.withLimit(10)
.withExclusiveStartTableName(last_name);
}
ListTablesResult table_list = ddb.listTables(request);
List table_names = table_list.getTableNames();
if (table_names.size() > 0) {
for (String cur_name : table_names) {
System.out.format("* %s\n", cur_name);
}
} else {
System.out.println("No tables found!");
System.exit(0);
}
last_name = table_list.getLastEvaluatedTableName();
if (last_name == null) {
more_tables = false;
}
```
Standardmäßig werden bis zu 100 Tabellen pro Aufruf zurückgegeben. Verwenden Sie diese `getLastEvaluatedTableName` Option für das zurückgegebene [ListTablesResult](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/model/ListTablesResult.html)Objekt, um die zuletzt ausgewertete Tabelle abzurufen. Mit diesem Wert können Sie die Auflistung nach dem zuletzt zurückgegebenen Wert der vorherigen Auflistung beginnen.
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/ListTables.java) finden Sie unter. GitHub
## Beschreiben (Abrufen von Informationen zu) einer Tabelle
Rufen Sie die `describeTable` Methode des [DynamoDB Clients](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/AmazonDynamoDB.html) auf.
**Anmerkung**
Wenn die benannte Tabelle für Ihr Konto und Ihre Region nicht existiert, [ResourceNotFoundException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/ResourceNotFoundException.html)wird a ausgelöst.
**Importe**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.model.AttributeDefinition;
import com.amazonaws.services.dynamodbv2.model.ProvisionedThroughputDescription;
import com.amazonaws.services.dynamodbv2.model.TableDescription;
```
**Code**
```
final AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
try {
TableDescription table_info =
ddb.describeTable(table_name).getTable();
if (table_info != null) {
System.out.format("Table name : %s\n",
table_info.getTableName());
System.out.format("Table ARN : %s\n",
table_info.getTableArn());
System.out.format("Status : %s\n",
table_info.getTableStatus());
System.out.format("Item count : %d\n",
table_info.getItemCount().longValue());
System.out.format("Size (bytes): %d\n",
table_info.getTableSizeBytes().longValue());
ProvisionedThroughputDescription throughput_info =
table_info.getProvisionedThroughput();
System.out.println("Throughput");
System.out.format(" Read Capacity : %d\n",
throughput_info.getReadCapacityUnits().longValue());
System.out.format(" Write Capacity: %d\n",
throughput_info.getWriteCapacityUnits().longValue());
List attributes =
table_info.getAttributeDefinitions();
System.out.println("Attributes");
for (AttributeDefinition a : attributes) {
System.out.format(" %s (%s)\n",
a.getAttributeName(), a.getAttributeType());
}
}
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/DescribeTable.java) finden Sie unter GitHub.
## Ändern (Aktualisieren) einer Tabelle
Sie können die bereitgestellten Durchsatzwerte Ihrer Tabelle jederzeit ändern, indem Sie die `updateTable` Methode des [DynamoDB Clients](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/AmazonDynamoDB.html) aufrufen.
**Anmerkung**
Wenn die benannte Tabelle für Ihr Konto und Ihre Region nicht existiert, [ResourceNotFoundException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/ResourceNotFoundException.html)wird a ausgelöst.
**Importe**
```
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.model.ProvisionedThroughput;
import com.amazonaws.AmazonServiceException;
```
**Code**
```
ProvisionedThroughput table_throughput = new ProvisionedThroughput(
read_capacity, write_capacity);
final AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
try {
ddb.updateTable(table_name, table_throughput);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/UpdateTable.java) finden Sie unter GitHub.
## Löschen einer Tabelle
Rufen Sie die `deleteTable` Methode des [DynamoDB Clients](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/AmazonDynamoDB.html) auf und übergeben Sie ihr den Namen der Tabelle.
**Anmerkung**
Wenn die benannte Tabelle für Ihr Konto und Ihre Region nicht existiert, [ResourceNotFoundException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/ResourceNotFoundException.html)wird a ausgelöst.
**Importe**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
```
**Code**
```
final AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
try {
ddb.deleteTable(table_name);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/DeleteTable.java) finden Sie unter GitHub.
## Weitere Infos
+ [Richtlinien für die Arbeit mit Tabellen finden](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GuidelinesForTables.html) Sie im Amazon DynamoDB Entwicklerhandbuch
+ [Arbeiten mit Tabellen finden Sie DynamoDB im](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.html) Amazon DynamoDB Entwicklerhandbuch
# Arbeiten mit Elementen in DynamoDB
DynamoDB In ist ein Element eine Sammlung von *Attributen*, von denen jedes einen *Namen* und einen *Wert* hat. Ein Attributwert kann eine Skalarfunktion, eine Gruppe oder ein Dokumenttyp sein. Weitere Informationen finden Sie unter [Benennungsregeln und Datentypen](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html) im Amazon DynamoDB Entwicklerhandbuch.
## Abrufen (empfangen) eines Elements aus einer Tabelle
Rufen Sie die AmazonDynamo `getItem` DB-Methode auf und übergeben Sie ihr ein [GetItemRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/GetItemRequest.html)Objekt mit dem Tabellennamen und dem Primärschlüsselwert des gewünschten Elements. Sie gibt ein [GetItemResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/GetItemResult.html)Objekt zurück.
Sie können die `getItem()` Methode des zurückgegebenen `GetItemResult` Objekts verwenden, um eine [Map](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/Map.html) von Schlüsselpaaren (String) und Wertpaaren ([AttributeValue](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/AttributeValue.html)) abzurufen, die dem Element zugeordnet sind.
**Importe**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.model.AttributeValue;
import com.amazonaws.services.dynamodbv2.model.GetItemRequest;
import java.util.HashMap;
import java.util.Map;
```
**Code**
```
HashMap key_to_get =
new HashMap();
key_to_get.put("DATABASE_NAME", new AttributeValue(name));
GetItemRequest request = null;
if (projection_expression != null) {
request = new GetItemRequest()
.withKey(key_to_get)
.withTableName(table_name)
.withProjectionExpression(projection_expression);
} else {
request = new GetItemRequest()
.withKey(key_to_get)
.withTableName(table_name);
}
final AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
try {
Map returned_item =
ddb.getItem(request).getItem();
if (returned_item != null) {
Set keys = returned_item.keySet();
for (String key : keys) {
System.out.format("%s: %s\n",
key, returned_item.get(key).toString());
}
} else {
System.out.format("No item found with the key %s!\n", name);
}
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/GetItem.java) finden Sie unter GitHub.
## Hinzufügen eines neuen Elements zu einer Tabelle
Erstellen Sie eine [Map](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/Map.html) mit Schlüssel-Wert-Paaren, die die Attribute des Elements darstellen. Diese müssen Werte für die Primärschlüsselfelder der Tabelle enthalten. Wenn das Element mit dem Primärschlüssel bereits vorhanden ist, werden dessen Felder durch die Anforderung *aktualisiert*.
**Anmerkung**
Wenn die benannte Tabelle für Ihr Konto und Ihre Region nicht existiert, [ResourceNotFoundException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/ResourceNotFoundException.html)wird a ausgelöst.
**Importe**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.model.AttributeValue;
import com.amazonaws.services.dynamodbv2.model.ResourceNotFoundException;
import java.util.ArrayList;
```
**Code**
```
HashMap item_values =
new HashMap();
item_values.put("Name", new AttributeValue(name));
for (String[] field : extra_fields) {
item_values.put(field[0], new AttributeValue(field[1]));
}
final AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
try {
ddb.putItem(table_name, item_values);
} catch (ResourceNotFoundException e) {
System.err.format("Error: The table \"%s\" can't be found.\n", table_name);
System.err.println("Be sure that it exists and that you've typed its name correctly!");
System.exit(1);
} catch (AmazonServiceException e) {
System.err.println(e.getMessage());
System.exit(1);
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/PutItem.java) finden Sie unter GitHub.
## Aktualisieren eines vorhandenen Elements in einer Tabelle
Sie können ein Attribut für ein Element aktualisieren, das bereits in einer Tabelle vorhanden ist, indem Sie die `updateItem` Methode der AmazonDynamo Datenbank verwenden und dabei einen Tabellennamen, einen Primärschlüsselwert und eine Zuordnung der zu aktualisierenden Felder angeben.
**Anmerkung**
Wenn die benannte Tabelle für Ihr Konto und Ihre Region nicht existiert oder wenn das Element, das durch den von Ihnen übergebenen Primärschlüssel identifiziert wurde, nicht existiert, [ResourceNotFoundException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/ResourceNotFoundException.html)wird a ausgelöst.
**Importe**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.model.AttributeAction;
import com.amazonaws.services.dynamodbv2.model.AttributeValue;
import com.amazonaws.services.dynamodbv2.model.AttributeValueUpdate;
import com.amazonaws.services.dynamodbv2.model.ResourceNotFoundException;
import java.util.ArrayList;
```
**Code**
```
HashMap item_key =
new HashMap();
item_key.put("Name", new AttributeValue(name));
HashMap updated_values =
new HashMap();
for (String[] field : extra_fields) {
updated_values.put(field[0], new AttributeValueUpdate(
new AttributeValue(field[1]), AttributeAction.PUT));
}
final AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
try {
ddb.updateItem(table_name, item_key, updated_values);
} catch (ResourceNotFoundException e) {
System.err.println(e.getMessage());
System.exit(1);
} catch (AmazonServiceException e) {
System.err.println(e.getMessage());
System.exit(1);
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/UpdateItem.java) finden Sie unter GitHub.
## Verwenden Sie die Dynamo-Klasse DBMapper
Die [AWS SDK für Java](https://aws.amazon.com/sdk-for-java/)stellt eine [DBMapperDynamo-Klasse](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapper.html) bereit, mit der Sie Ihre clientseitigen Klassen Tabellen zuordnen können. Amazon DynamoDB Um die [DBMapperDynamo-Klasse](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapper.html) zu verwenden, definieren Sie die Beziehung zwischen Elementen in einer DynamoDB Tabelle und ihren entsprechenden Objektinstanzen in Ihrem Code mithilfe von Anmerkungen (wie im folgenden Codebeispiel gezeigt). Mit der [DBMapperDynamo-Klasse](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapper.html) können Sie auf Ihre Tabellen zugreifen, verschiedene Erstellungs-, Lese-, Aktualisierungs- und Löschvorgänge (CRUD) ausführen und Abfragen ausführen.
**Anmerkung**
Mit der [DBMapperDynamo-Klasse](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapper.html) können Sie keine Tabellen erstellen, aktualisieren oder löschen.
**Importe**
```
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBAttribute;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBHashKey;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBMapper;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBTable;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBRangeKey;
import com.amazonaws.services.dynamodbv2.model.AmazonDynamoDBException;
```
**Code**
Das folgende Java-Codebeispiel zeigt Ihnen, wie Sie mithilfe der [DBMapperDynamo-Klasse](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapper.html) Inhalte zur *Music-Tabelle* hinzufügen. Nachdem der Inhalt der Tabelle hinzugefügt wurde, beachten Sie, dass ein Element mithilfe der Schlüssel *Partition* und *Sortieren* geladen wird. Anschließend wird das Element *Auszeichnungen* aktualisiert. Informationen zum Erstellen der *Music-Tabelle* finden Sie unter [Create a Table](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/getting-started-step-1.html) im Amazon DynamoDB Developer Guide.
```
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
MusicItems items = new MusicItems();
try{
// Add new content to the Music table
items.setArtist(artist);
items.setSongTitle(songTitle);
items.setAlbumTitle(albumTitle);
items.setAwards(Integer.parseInt(awards)); //convert to an int
// Save the item
DynamoDBMapper mapper = new DynamoDBMapper(client);
mapper.save(items);
// Load an item based on the Partition Key and Sort Key
// Both values need to be passed to the mapper.load method
String artistName = artist;
String songQueryTitle = songTitle;
// Retrieve the item
MusicItems itemRetrieved = mapper.load(MusicItems.class, artistName, songQueryTitle);
System.out.println("Item retrieved:");
System.out.println(itemRetrieved);
// Modify the Award value
itemRetrieved.setAwards(2);
mapper.save(itemRetrieved);
System.out.println("Item updated:");
System.out.println(itemRetrieved);
System.out.print("Done");
} catch (AmazonDynamoDBException e) {
e.getStackTrace();
}
}
@DynamoDBTable(tableName="Music")
public static class MusicItems {
//Set up Data Members that correspond to columns in the Music table
private String artist;
private String songTitle;
private String albumTitle;
private int awards;
@DynamoDBHashKey(attributeName="Artist")
public String getArtist() {
return this.artist;
}
public void setArtist(String artist) {
this.artist = artist;
}
@DynamoDBRangeKey(attributeName="SongTitle")
public String getSongTitle() {
return this.songTitle;
}
public void setSongTitle(String title) {
this.songTitle = title;
}
@DynamoDBAttribute(attributeName="AlbumTitle")
public String getAlbumTitle() {
return this.albumTitle;
}
public void setAlbumTitle(String title) {
this.albumTitle = title;
}
@DynamoDBAttribute(attributeName="Awards")
public int getAwards() {
return this.awards;
}
public void setAwards(int awards) {
this.awards = awards;
}
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/UseDynamoMapping.java) finden Sie unter GitHub.
## Weitere Infos
+ [Richtlinien für die Arbeit mit Elementen](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GuidelinesForItems.html) im Amazon DynamoDB Entwicklerhandbuch
+ [Arbeiten mit Elementen aus DynamoDB dem](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html) Amazon DynamoDB Entwicklerhandbuch
# Amazon EC2 Beispiele für die Verwendung der AWS SDK für Java
Dieser Abschnitt enthält Beispiele für die Programmierung [Amazon EC2](https://aws.amazon.com/ec2/)mit dem AWS SDK für Java.
**Topics**
+ [Tutorial: Eine EC2 Instanz starten](how-to-ec2.md)
+ [Verwenden von IAM-Rollen, um Zugriff auf AWS Ressourcen zu gewähren für Amazon EC2](java-dg-roles.md)
+ [Tutorial: Amazon EC2 Spot-Instances](tutorial-spot-instances-java.md)
+ [Tutorial: Erweitertes Amazon EC2 Spot-Anforderungsmanagement](tutorial-spot-adv-java.md)
+ [Amazon EC2 Instanzen verwalten](examples-ec2-instances.md)
+ [Verwendung von Elastic IP-Adressen in Amazon EC2](examples-ec2-elastic-ip.md)
+ [Regionen und Verfügbarkeitszonen verwenden](examples-ec2-regions-zones.md)
+ [Mit Amazon EC2 Schlüsselpaaren arbeiten](examples-ec2-key-pairs.md)
+ [Arbeiten mit Sicherheitsgruppen in Amazon EC2](examples-ec2-security-groups.md)
# Tutorial: Eine EC2 Instanz starten
Dieses Tutorial zeigt, wie Sie mit AWS SDK für Java dem eine EC2 Instanz starten können.
**Topics**
+ [Voraussetzungen](#prerequisitesec2)
+ [Eine Amazon EC2 Sicherheitsgruppe erstellen](create-security-group.md)
+ [Erstellen eines Schlüsselpaares](create-key-pair.md)
+ [Eine Amazon EC2 Instanz ausführen](run-instance.md)
## Voraussetzungen
Bevor Sie beginnen, stellen Sie sicher, dass Sie eine erstellt AWS-Konto und Ihre AWS Anmeldeinformationen eingerichtet haben. Weitere Informationen finden Sie unter [Erste Schritte mit ](getting-started.md).
# Eine Amazon EC2 Sicherheitsgruppe erstellen
## EC2-Classic geht in den Ruhestand
**Warnung**
Wir gehen in den Ruhestand EC2 -Classic am 15. August 2022. Wir empfehlen Ihnen, von EC2 -Classic zu einer VPC zu migrieren. Weitere Informationen finden Sie im Blogbeitrag [EC2-Classic-Classic-Classic Networking is Retiring —](https://aws.amazon.com/blogs/aws/ec2-classic-is-retiring-heres-how-to-prepare/) So bereiten Sie sich vor.
Erstellen Sie eine *Sicherheitsgruppe*, die als virtuelle Firewall fungiert und den Netzwerkverkehr für eine oder mehrere Instanzen kontrolliert. EC2 Ordnet Ihre Amazon EC2 Instances standardmäßig einer Sicherheitsgruppe zu, die keinen eingehenden Datenverkehr zulässt. Sie können eine Sicherheitsgruppe erstellen, die es Ihren EC2 Instances ermöglicht, bestimmten Datenverkehr zu akzeptieren. Wenn Sie beispielsweise eine Verbindung zu einer Linux-Instance herstellen müssen, muss die Sicherheitsgruppe so konfiguriert werden, dass SSH-Datenverkehr möglich ist. Sie können eine Sicherheitsgruppe mithilfe der Amazon EC2 Konsole oder der erstellen AWS SDK für Java.
Sie erstellen eine Sicherheitsgruppe für die Verwendung in EC2 -Classic oder VPC EC2. Weitere Informationen zu EC2 -Classic und EC2 VPC finden Sie unter [Unterstützte Plattformen](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-supported-platforms.html) im Amazon EC2 Benutzerhandbuch für Linux-Instances.
Weitere Informationen zum Erstellen einer Sicherheitsgruppe mithilfe der Amazon EC2 Konsole finden Sie unter [Amazon EC2 Sicherheitsgruppen](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html) im Amazon EC2 Benutzerhandbuch für Linux-Instances.
1. Erstellen und initialisieren Sie eine [CreateSecurityGroupRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateSecurityGroupRequest.html)Instanz. Verwenden Sie die [withGroupName](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateSecurityGroupRequest.html#withGroupName-java.lang.String-)Methode, um den Namen der Sicherheitsgruppe festzulegen, und die Methode [withDescription](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateSecurityGroupRequest.html#withDescription-java.lang.String-), um die Beschreibung der Sicherheitsgruppe wie folgt festzulegen:
```
CreateSecurityGroupRequest csgr = new CreateSecurityGroupRequest();
csgr.withGroupName("JavaSecurityGroup").withDescription("My security group");
```
Der Name der Sicherheitsgruppe muss in der AWS Region, in der Sie Ihren Amazon EC2 Client initialisieren, eindeutig sein. Sie müssen US-ASCII-Zeichen für den Namen und die Beschreibung der Sicherheitsgruppe verwenden.
1. Übergeben Sie das Anforderungsobjekt als Parameter an die [createSecurityGroup](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/AmazonEC2.html#createSecurityGroup-com.amazonaws.services.ec2.model.CreateSecurityGroupRequest-)Methode. Die Methode gibt ein [CreateSecurityGroupResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateSecurityGroupResult.html)Objekt wie folgt zurück:
```
CreateSecurityGroupResult createSecurityGroupResult =
amazonEC2Client.createSecurityGroup(csgr);
```
Wenn Sie versuchen, eine Sicherheitsgruppe mit dem gleichen Namen wie dem einer bereits vorhandenen Sicherheitsgruppe zu erstellen, gibt `createSecurityGroup` eine Ausnahme aus.
Standardmäßig lässt eine neue Sicherheitsgruppe keinen eingehenden Datenverkehr zu Ihrer Amazon EC2 Instance zu. Um eingehenden Datenverkehr zu erlauben, müssen Sie ausdrücklich eingehende Daten für die Sicherheitsgruppe autorisieren. Sie können eingehende Daten für einzelne IP-Adressen, für einen IP-Adressbereich, ein bestimmtes Protokoll sowie für TCP-/UDP-Ports autorisieren.
1. Erstellen und initialisieren Sie eine Instanz [IpPermission](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/IpPermission.html). Verwenden Sie die Methode [withIPv4Ranges](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/IpPermission.html#withIpv4Ranges-java.util.Collection-), um den Bereich der IP-Adressen festzulegen, für den der Zugriff autorisiert werden soll, und verwenden Sie die Methode, um das [withIpProtocol](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/IpPermission.html#withIpProtocol-java.lang.String-)IP-Protokoll festzulegen. Verwenden Sie die [withToPort](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/IpPermission.html#withToPort-java.lang.Integer-)Methoden [withFromPort](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/IpPermission.html#withFromPort-java.lang.Integer-)und, um den Portbereich anzugeben, für den der eingehende Datenverkehr autorisiert werden soll, wie folgt:
```
IpPermission ipPermission =
new IpPermission();
IpRange ipRange1 = new IpRange().withCidrIp("111.111.111.111/32");
IpRange ipRange2 = new IpRange().withCidrIp("150.150.150.150/32");
ipPermission.withIpv4Ranges(Arrays.asList(new IpRange[] {ipRange1, ipRange2}))
.withIpProtocol("tcp")
.withFromPort(22)
.withToPort(22);
```
Alle im `IpPermission`-Objekt angegebenen Bedingungen müssen erfüllt sein, damit eingehende Daten zugelassen werden.
Geben Sie die IP-Adresse über CIDR-Notation an. Wenn Sie das Protokoll als TCP/UDP angeben, müssen Sie einen Quell- und Ziel-Port festlegen. Sie können Ports nur bei Angabe von TCP oder UDP autorisieren.
1. Erstellen und initialisieren Sie eine Instanz. [AuthorizeSecurityGroupIngressRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AuthorizeSecurityGroupEgressRequest.html) Verwenden Sie die `withGroupName` Methode, um den Namen der Sicherheitsgruppe anzugeben, und übergeben Sie das `IpPermission` Objekt, das Sie zuvor initialisiert haben, wie folgt an die [withIpPermissions](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AuthorizeSecurityGroupEgressRequest.html#withIpPermissions-com.amazonaws.services.ec2.model.IpPermission…-)Methode:
```
AuthorizeSecurityGroupIngressRequest authorizeSecurityGroupIngressRequest =
new AuthorizeSecurityGroupIngressRequest();
authorizeSecurityGroupIngressRequest.withGroupName("JavaSecurityGroup")
.withIpPermissions(ipPermission);
```
1. Übergeben Sie das Anforderungsobjekt wie folgt an die [authorizeSecurityGroupIngress-Methode](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/AmazonEC2Client.html#authorizeSecurityGroupIngress-com.amazonaws.services.ec2.model.AuthorizeSecurityGroupIngressRequest-):
```
amazonEC2Client.authorizeSecurityGroupIngress(authorizeSecurityGroupIngressRequest);
```
Wenn Sie `authorizeSecurityGroupIngress` mit IP-Adressen aufrufen, für die eingehende Daten bereits autorisiert sind, gibt diese Methode eine Ausnahme aus. Erstellen und initialisieren Sie vor dem Aufruf ein neues `IpPermission` Objekt, um den Zugriff für verschiedene Ports und IPs Protokolle zu autorisieren. `AuthorizeSecurityGroupIngress`
Immer wenn Sie die Methoden [authorizeSecurityGroupIngress](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/AmazonEC2Client.html#authorizeSecurityGroupIngress-com.amazonaws.services.ec2.model.AuthorizeSecurityGroupIngressRequest-) oder [authorizeSecurityGroupEgress](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/AmazonEC2Client.html#authorizeSecurityGroupEgress-com.amazonaws.services.ec2.model.AuthorizeSecurityGroupEgressRequest-) aufrufen, wird Ihrer Sicherheitsgruppe eine Regel hinzugefügt.
# Erstellen eines Schlüsselpaares
Sie müssen ein key pair angeben, wenn Sie eine EC2 Instance starten, und dann den privaten Schlüssel des key pair angeben, wenn Sie eine Verbindung mit der Instance herstellen. Sie können ein Schlüsselpaar erstellen oder ein vorhandenes Schlüsselpaar verwenden, das Sie beim Start anderer Instances genutzt haben. Weitere Informationen finden Sie unter [Amazon EC2 Schlüsselpaare](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) im Amazon EC2 Benutzerhandbuch für Linux-Instances.
1. Erstellen und initialisieren Sie eine [CreateKeyPairRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateKeyPairRequest.html)Instanz. Verwenden Sie die [withKeyName](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateKeyPairRequest.html#withKeyName-java.lang.String-)Methode, um den Namen des key pair wie folgt festzulegen:
```
CreateKeyPairRequest createKeyPairRequest = new CreateKeyPairRequest();
createKeyPairRequest.withKeyName(keyName);
```
**Wichtig**
Namen von Schlüsselpaaren müssen eindeutig sein. Wenn Sie versuchen, ein Schlüsselpaar mit dem gleichen Namen wie dem eines bereits vorhandenen Schlüsselpaars zu erstellen, wird eine Ausnahme ausgelöst.
1. Übergeben Sie das Anforderungsobjekt an die [createKeyPair](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/AmazonEC2.html#createKeyPair-com.amazonaws.services.ec2.model.CreateKeyPairRequest--)Methode. Die Methode gibt wie folgt eine [CreateKeyPairResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateKeyPairResult.html)Instanz zurück:
```
CreateKeyPairResult createKeyPairResult =
amazonEC2Client.createKeyPair(createKeyPairRequest);
```
1. Rufen Sie die [getKeyPair](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateKeyPairResult.html#getKeyPair--)Methode des Ergebnisobjekts auf, um ein [KeyPair](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/KeyPair.html)Objekt zu erhalten. Rufen Sie die [getKeyMaterial](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/KeyPair.html#getKeyMaterial--)Methode des `KeyPair` Objekts wie folgt auf, um den unverschlüsselten PEM-codierten privaten Schlüssel abzurufen:
```
KeyPair keyPair = new KeyPair();
keyPair = createKeyPairResult.getKeyPair();
String privateKey = keyPair.getKeyMaterial();
```
# Eine Amazon EC2 Instanz ausführen
Gehen Sie wie folgt vor, um eine oder mehrere identisch konfigurierte EC2 Instances von demselben Amazon Machine Image (AMI) aus zu starten. Nachdem Sie Ihre EC2 Instances erstellt haben, können Sie deren Status überprüfen. Nachdem Ihre EC2 Instances ausgeführt wurden, können Sie eine Verbindung zu ihnen herstellen.
1. Erstellen und initialisieren Sie eine [RunInstancesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RunInstancesRequest.html)Instanz. Stellen Sie sicher, dass das AMI, das Schlüsselpaar und die Sicherheitsgruppe, die Sie angeben, in der beim Erstellen des Client-Objekts angegebenen Region vorhanden sind.
```
RunInstancesRequest runInstancesRequest =
new RunInstancesRequest();
runInstancesRequest.withImageId("ami-a9d09ed1")
.withInstanceType(InstanceType.T1Micro)
.withMinCount(1)
.withMaxCount(1)
.withKeyName("my-key-pair")
.withSecurityGroups("my-security-group");
```
[withImageId](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RunInstancesRequest.html#withImageId-java.lang.String-)
+ Die ID des AMI. Unter Amazon [Machine Image (AMI) erfahren Sie, wie Sie die von Amazon AMIs bereitgestellten Inhalte](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html) finden oder Ihre eigenen erstellen können.
[withInstanceType](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RunInstancesRequest.html#withInstanceType-java.lang.String-)
+ Ein Instance-Typ, der kompatibel mit dem angegebenen AMI ist. Weitere Informationen finden Sie unter [Instance-Typen](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html) im Amazon EC2 Benutzerhandbuch für Linux-Instances.
[withMinCount](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RunInstancesRequest.html#withMinCount-java.lang.Integer-)
+ Die Mindestanzahl der zu startenden EC2 Instances. Wenn es sich dabei um mehr Instances handelt, als in der Ziel-Availability Zone gestartet werden Amazon EC2 können, werden keine Instances Amazon EC2 gestartet.
[withMaxCount](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RunInstancesRequest.html#withMaxCount-java.lang.Integer-)
+ Die maximale Anzahl der zu startenden EC2 Instances. Wenn es sich dabei um mehr Instances handelt, als in der Ziel-Availability Zone Amazon EC2 gestartet werden Amazon EC2 können, wird die größtmögliche Anzahl von oben genannten Instances gestartet`MinCount`. Sie können zwischen 1 und der maximalen Anzahl der Instances starten, die für Sie beim jeweiligen Instance-Typ zulässig sind. Weitere Informationen finden Sie unter Wie viele Instances kann ich ausführen? Amazon EC2 in den Amazon EC2 allgemeinen FAQs.
[withKeyName](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RunInstancesRequest.html#withKeyName-java.lang.String-)
+ Der Name des EC2 key pair. Wenn Sie eine Instance ohne Angabe eines Schlüsselpaars starten, können Sie sich nicht mit ihr verbinden. Weitere Informationen finden Sie unter [Erstellen eines Schlüsselpaars](create-key-pair.md).
[withSecurityGroups](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RunInstancesRequest.html#withSecurityGroups-java.util.Collection-)
+ Eine oder mehrere Sicherheitsgruppen. Weitere Informationen finden Sie unter [Amazon EC2 Sicherheitsgruppe erstellen](create-security-group.md).
1. Starten Sie die Instances, indem Sie das Anforderungsobjekt an die [runInstances](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/AmazonEC2Client.html#runInstances-com.amazonaws.services.ec2.model.RunInstancesRequest-)-Methode übergeben. Die Methode gibt ein [RunInstancesResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RunInstancesResult.html)Objekt wie folgt zurück:
```
RunInstancesResult result = amazonEC2Client.runInstances(
runInstancesRequest);
```
Sobald die Instance ausgeführt wird, können Sie sich mit dem Schlüsselpaar mit ihr verbinden. Weitere Informationen finden Sie unter [Connect to Your Linux Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstances.html). im Amazon EC2 Benutzerhandbuch für Linux-Instances.
# Verwenden von IAM-Rollen, um Zugriff auf AWS Ressourcen zu gewähren für Amazon EC2
Alle Anfragen an Amazon Web Services (AWS) müssen kryptografisch signiert werden, wobei die Anmeldeinformationen verwendet werden müssen, die von ausgestellt wurden. AWS Sie können *IAM-Rollen* verwenden, um bequem sicheren Zugriff auf AWS Ressourcen von Ihren Instances aus zu gewähren. Amazon EC2
Dieses Thema enthält Informationen zur Verwendung von IAM-Rollen mit Java SDK-Anwendungen, die auf ausgeführt werden. Amazon EC2 Weitere Informationen zu IAM-Instanzen finden Sie unter [IAM-Rollen für Amazon EC2 im Amazon EC2 Benutzerhandbuch für](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html) Linux-Instances.
## Die Standardanbieterketten und Instanzprofile EC2
Wenn Ihre Anwendung mithilfe des Standardkonstruktors einen AWS Client erstellt, sucht der Client mithilfe der *standardmäßigen Anbieterkette für Anmeldeinformationen* in der folgenden Reihenfolge nach Anmeldeinformationen:
1. in den Java-Systemeigenschaften: `aws.accessKeyId` und `aws.secretKey`
1. in System-Umgebungsvariablen: `AWS_ACCESS_KEY_ID` und `AWS_SECRET_ACCESS_KEY`
1. in der Standarddatei für Anmeldeinformationen (der Speicherort dieser Datei hängt von der jeweiligen Plattform ab)
1. Anmeldeinformationen, die über den Amazon EC2 Container-Service bereitgestellt werden, wenn die `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI` Umgebungsvariable gesetzt ist und der Sicherheitsmanager über die Zugriffsberechtigung für die Variable verfügt.
1. In den *Instanzprofil-Anmeldeinformationen*, die in den Instanz-Metadaten enthalten sind, die der IAM-Rolle für die EC2 Instanz zugeordnet sind.
1. Web-Identitätstoken-Anmeldeinformationen aus der Umgebung oder dem Container.
Der Schritt mit den *Anmeldeinformationen für das Instanzprofil* in der Standardanbieterkette ist nur verfügbar, wenn Sie Ihre Anwendung auf einer Amazon EC2 Instance ausführen, bietet jedoch die größte Benutzerfreundlichkeit und die beste Sicherheit bei der Arbeit mit Amazon EC2 Instances. Sie können eine [InstanceProfileCredentialsProvider](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/InstanceProfileCredentialsProvider.html)Instanz auch direkt an den Client-Konstruktor übergeben, um die Anmeldeinformationen für das Instanzprofil abzurufen, ohne die gesamte Standardanbieterkette durchlaufen zu müssen.
Zum Beispiel:
```
AmazonS3 s3 = AmazonS3ClientBuilder.standard()
.withCredentials(new InstanceProfileCredentialsProvider(false))
.build();
```
Bei diesem Ansatz ruft das SDK temporäre AWS Anmeldeinformationen ab, die dieselben Berechtigungen haben wie die, die der IAM-Rolle zugeordnet sind, die der Amazon EC2 Instanz in ihrem Instanzprofil zugeordnet ist. Diese Anmeldeinformationen sind zwar temporär und würden irgendwann ablaufen, aktualisiert sie jedoch `InstanceProfileCredentialsProvider` regelmäßig für Sie, sodass die abgerufenen Anmeldeinformationen weiterhin Zugriff auf ermöglichen. AWS
**Wichtig**
Die Anmeldeinformationen werden *nur dann* automatisch aktualisiert, wenn Sie den standardmäßigen Client-Konstruktor verwenden, der seinen eigenen `InstanceProfileCredentialsProvider` als Teil der standardmäßigen Anbieterkette erstellt, oder wenn Sie eine `InstanceProfileCredentialsProvider`-Instance direkt an den Client-Konstruktor übergeben. Wenn Sie Anmeldeinformationen des Instance-Profils auf andere Weise abrufen oder übergeben, sind Sie selbst für die Überprüfung und ggf. für die Aktualisierung abgelaufener Anmeldeinformationen zuständig.
Wenn der Client-Konstruktor mithilfe der Anmeldeinformationsanbieterkette keine Anmeldeinformationen finden kann, gibt er eine aus. [AmazonClientException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/AmazonClientException.html)
## Exemplarische Vorgehensweise: Verwenden von IAM-Rollen für Instanzen EC2
In der folgenden exemplarischen Vorgehensweise wird gezeigt, wie Sie Amazon S3 mithilfe einer IAM-Rolle ein Objekt abrufen können, um den Zugriff zu verwalten.
### Erstellen einer IAM-Rolle
Erstellen Sie eine IAM-Rolle, die nur Lesezugriff auf gewährt. Amazon S3
1. Öffnen Sie die [IAM-Konsole](https://console.aws.amazon.com/iam/home).
1. Wechseln Sie im Navigationsbereich zu **Roles (Rollen)** und klicken Sie auf **Create New Role (Neue Rolle erstellen)**.
1. Geben Sie einen Namen für die Rolle ein und klicken Sie dann auf **Next Step**. Merken Sie sich diesen Namen, da Sie ihn benötigen, wenn Sie Ihre Instance starten. Amazon EC2
1. **Wählen Sie auf der Seite „Rollentyp** auswählen“ unter ** AWS-Service Rollen** die Option aus ** Amazon EC2 **.
1. Wählen Sie auf der Seite „**Berechtigungen festlegen****“ unter Richtlinienvorlage** auswählen die Option ** Amazon S3 Schreibgeschützter Zugriff** und dann **Nächster Schritt** aus.
1. Wählen Sie auf der Seite **Review (Prüfen)** **Create Role (Rolle erstellen)** aus.
### Starten Sie eine EC2 Instance und geben Sie Ihre IAM-Rolle an
Sie können eine Amazon EC2 Instance mit einer IAM-Rolle über die Amazon EC2 Konsole oder die starten. AWS SDK für Java
+ Um eine Amazon EC2 Instance über die Konsole zu starten, folgen Sie den Anweisungen unter [Erste Schritte mit Amazon EC2 Linux-Instances](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html) im Amazon EC2 Benutzerhandbuch für Linux-Instances.
Wenn Sie die Seite **Review Instance Launch** erreichen, klicken Sie auf **Edit instance details**. Wählen Sie unter **IAM-Rolle** die IAM-Rolle aus, die Sie zuvor erstellt haben. Befolgen Sie die Anweisungen und schließen Sie den Vorgang ab.
**Anmerkung**
Zum Herstellen einer Verbindung mit der Instance müssen Sie eine Sicherheitsgruppe und ein Schlüsselpaar neu erstellen oder vorhandene Anmeldeinformationen auswählen.
+ Informationen zum Starten einer Amazon EC2 Instance mit einer IAM-Rolle mithilfe von finden Sie unter Instanz [ausführen](run-instance.md). AWS SDK für Java Amazon EC2
### Erstellen Ihrer Anwendung
Lassen Sie uns die Beispielanwendung erstellen, die auf der EC2 Instance ausgeführt werden soll. Zuerst erstellen Sie ein Verzeichnis, in dem Sie die Tutorial-Dateien abspeichern können (z. B. `GetS3ObjectApp`).
Kopieren Sie als Nächstes die AWS SDK für Java Bibliotheken in Ihr neu erstelltes Verzeichnis. Wenn Sie die AWS SDK für Java in Ihr `~/Downloads` Verzeichnis heruntergeladen haben, können Sie sie mit den folgenden Befehlen kopieren:
```
cp -r ~/Downloads/aws-java-sdk-{1.7.5}/lib .
cp -r ~/Downloads/aws-java-sdk-{1.7.5}/third-party .
```
Legen Sie eine neue Datei namens `GetS3Object.java` an und fügen Sie den folgenden Code ein:
```
import java.io.*;
import com.amazonaws.auth.*;
import com.amazonaws.services.s3.*;
import com.amazonaws.services.s3.model.*;
import com.amazonaws.AmazonClientException;
import com.amazonaws.AmazonServiceException;
public class GetS3Object {
private static final String bucketName = "text-content";
private static final String key = "text-object.txt";
public static void main(String[] args) throws IOException
{
AmazonS3 s3Client = AmazonS3ClientBuilder.defaultClient();
try {
System.out.println("Downloading an object");
S3Object s3object = s3Client.getObject(
new GetObjectRequest(bucketName, key));
displayTextInputStream(s3object.getObjectContent());
}
catch(AmazonServiceException ase) {
System.err.println("Exception was thrown by the service");
}
catch(AmazonClientException ace) {
System.err.println("Exception was thrown by the client");
}
}
private static void displayTextInputStream(InputStream input) throws IOException
{
// Read one text line at a time and display.
BufferedReader reader = new BufferedReader(new InputStreamReader(input));
while(true)
{
String line = reader.readLine();
if(line == null) break;
System.out.println( " " + line );
}
System.out.println();
}
}
```
Legen Sie eine weitere neue Datei namens `build.xml` an und fügen Sie folgende Zeilen ein:
```
```
Erstellen und starten Sie das geänderte Programm. Beachten Sie, dass keine Anmeldeinformationen im Programm gespeichert werden. Daher wird der Code ausgelöst, sofern Sie Ihre AWS Anmeldeinformationen nicht bereits angegeben haben`AmazonServiceException`. Zum Beispiel:
```
$ ant
Buildfile: /path/to/my/GetS3ObjectApp/build.xml
build:
[javac] Compiling 1 source file to /path/to/my/GetS3ObjectApp
run:
[java] Downloading an object
[java] AmazonServiceException
BUILD SUCCESSFUL
```
### Übertragen Sie das kompilierte Programm auf Ihre EC2 Instance
Übertragen Sie das Programm zusammen mit den AWS SDK für Java Bibliotheken mithilfe von Secure Copy (**``**) auf Ihre Amazon EC2 Instanz. Die Reihenfolge der Befehle sieht in etwa wie folgt aus:
```
scp -p -i {my-key-pair}.pem GetS3Object.class ec2-user@{public_dns}:GetS3Object.class
scp -p -i {my-key-pair}.pem build.xml ec2-user@{public_dns}:build.xml
scp -r -p -i {my-key-pair}.pem lib ec2-user@{public_dns}:lib
scp -r -p -i {my-key-pair}.pem third-party ec2-user@{public_dns}:third-party
```
**Anmerkung**
Abhängig von der verwendeten Linux-Distribution lautet der *user name (Benutzername)* "ec2-user", "root" oder "ubuntu". Um den öffentlichen DNS-Namen Ihrer Instance abzurufen, öffnen Sie die [EC2 Konsole](https://console.aws.amazon.com/ec2/home) und suchen Sie auf der Registerkarte **Beschreibung** nach dem Wert **Public DNS** (z. B.`ec2-198-51-100-1.compute-1.amazonaws.com`).
Bei den vorhergehenden Befehlen:
+ ist `GetS3Object.class` Ihr kompiliertes Programm,
+ `build.xml` ist die Ant-Datei zum Erstellen und Ausführen Ihres Programms und
+ die Verzeichnisse `lib` und `third-party` sind die entsprechenden Bibliotheksordner aus dem AWS SDK für Java.
+ Der `-r` Schalter gibt an, dass eine rekursive Kopie des gesamten Inhalts der `third-party` Verzeichnisse `library` und in der AWS SDK für Java Distribution erstellt werden `scp` soll.
+ Der Schalter `-p` sorgt dafür, dass `scp` die Berechtigungen der Quelldateien beibehalten soll, während diese zum Ziel kopiert werden.
**Anmerkung**
Der `-p` Switch funktioniert nur unter Linux, macOS oder Unix. Wenn Sie Dateien von Windows kopieren, müssen Sie die Dateiberechtigungen auf Ihrer Instance mit dem folgenden Befehl korrigieren:
```
chmod -R u+rwx GetS3Object.class build.xml lib third-party
```
### Führen Sie das Beispielprogramm auf der EC2 Instanz aus
Um das Programm auszuführen, stellen Sie eine Verbindung zu Ihrer Amazon EC2 Instance her. Weitere Informationen finden Sie unter [Connect to Your Linux Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstances.html) im Amazon EC2 Benutzerhandbuch für Linux-Instances.
Wenn ** ` ant ` ** auf Ihrer Instance nicht verfügbar ist, installieren Sie es mit folgendem Befehl:
```
sudo yum install ant
```
Führen Sie das Programm dann mithilfe von `ant` wie folgt aus:
```
ant run
```
Das Programm schreibt den Inhalt Ihres Amazon S3 Objekts in Ihr Befehlsfenster.
# Tutorial: Amazon EC2 Spot-Instances
## Übersicht
Spot-Instances ermöglichen es Ihnen, auf ungenutzte Amazon Elastic Compute Cloud (Amazon EC2) Kapazität bis zu 90% gegenüber dem Preis für On-Demand-Instances zu bieten und die erworbenen Instances so lange laufen zu lassen, wie Ihr Gebot den aktuellen *Spot-Preis* übersteigt. Amazon EC2 ändert den Spot-Preis in regelmäßigen Abständen auf der Grundlage von Angebot und Nachfrage, und Kunden, deren Gebote dem Preis entsprechen oder ihn übertreffen, erhalten Zugriff auf die verfügbaren Spot-Instances. Wie mit On-Demand-Instances und Reserved Instances erhalten Sie mit Spot-Instances eine weitere Möglichkeit, mehr Rechenkapazität zu erhalten.
Spot-Instances können Ihre Amazon EC2 Kosten für Stapelverarbeitung, wissenschaftliche Forschung, Bildverarbeitung, Videokodierung, Daten- und Webcrawling, Finanzanalysen und Tests erheblich senken. Darüber hinaus ermöglichen Spot-Instances Zugriff auf große Mengen an zusätzlicher Kapazität in Situationen, in denen diese Kapazität nicht dringend benötigt wird.
Senden Sie zur Nutzung von Spot-Instances eine Spot-Instance-Anforderung und geben Sie den Höchstpreis an, den Sie pro Instance-Stunde zu zahlen bereit sind; dies ist Ihr Gebot. Wenn Ihr Höchstgebot den aktuellen Spot-Preis übersteigt, wird Ihrer Anforderung stattgegeben. Ihre Instances werden so lange ausgeführt, bis Sie sie entweder beenden oder bis der Spot-Preis Ihr Höchstgebot übersteigt.
Wichtiger Hinweis:
+ Sie zahlen oft weniger pro Stunde als Sie geboten haben. Amazon EC2 passt den Spotpreis regelmäßig an, wenn Anfragen eingehen und sich das verfügbare Angebot ändert. Alle Benutzer bezahlen für diesen Zeitraum denselben Spot-Preis, unabhängig davon, ob ihr Gebot höher lag. Daher zahlen Sie möglicherweise weniger als Ihr Gebot, aber Sie zahlen nie mehr als das Gebot.
+ Wenn Sie Spot-Instances ausführen und Ihr Gebot nicht mehr mindestens dem aktuellen Spot-Preis entspricht, werden Ihre Instances beendet. Daher sollten Sie sicherstellen, dass Ihre Workloads und Anwendungen flexibel genug sind, um aus dieser gelegentlichen Kapazität Nutzen zu ziehen.
Spot-Instances verhalten sich während der Ausführung genau wie andere Amazon EC2 Instances, und wie andere Amazon EC2 Instances können Spot-Instances beendet werden, wenn Sie sie nicht mehr benötigen. Beim Beenden einer Instance zahlen Sie für die angefangene Stunde (wie bei On-Demand- und Reserved Instances). Wenn der Spot-Preis jedoch über Ihrem Gebot liegt und Ihre Instance bis gekündigt wird Amazon EC2, wird Ihnen keine Teilstunde der Nutzung in Rechnung gestellt.
In diesem Tutorial wird gezeigt, wie AWS SDK für Java Sie Folgendes tun können.
+ Senden einer Spot-Anfrage
+ Ermitteln, wann die Spot-Anfrage erfüllt wird
+ Abbrechen der Spot-Anfrage
+ Beenden von dazugehörigen Instances
## Voraussetzungen
Um dieses Tutorial verwenden zu können, müssen Sie das AWS SDK für Java installiert haben und die grundlegenden Installationsvoraussetzungen erfüllen. Weitere Informationen finden [Sie unter Einrichten](setup-install.md) von. AWS SDK für Java
## Schritt 1: Einrichten Ihrer Anmeldeinformationen
Um mit der Verwendung dieses Codebeispiels zu beginnen, müssen Sie AWS Anmeldeinformationen einrichten. Anweisungen dazu finden Sie unter [AWS Zugangsdaten und Region für die Entwicklung einrichten](setup-credentials.md).
**Anmerkung**
Wir empfehlen, dass Sie die Anmeldeinformationen eines IAM-Benutzers für diese Werte nutzen. Weitere Informationen finden Sie unter [Registrierung für einen IAM-Benutzer AWS und Erstellen eines IAM-Benutzers](signup-create-iam-user.md).
Nachdem Sie Ihre Einstellungen eingerichtet haben, können Sie mit dem Beispiel-Code loslegen.
## Schritt 2: Einrichten einer Sicherheitsgruppe
Eine *Sicherheitsgruppe* agiert als Firewall, die den zulässigen Verkehr zu und von einer Gruppe Instances steuert. Standardmäßig wird eine Instance ohne eine Sicherheitsgruppe gestartet. Sämtlicher eingehender IP-Datenverkehr auf allen TCP-Ports wird daher verweigert. Vor dem Absenden unserer Spot-Anforderung richten wir also eine Sicherheitsgruppe ein, die den nötigen Netzwerkverkehr zulässt. Für die Zwecke dieses Tutorials erstellen wir eine neue Sicherheitsgruppe mit dem Namen "GettingStarted", die Secure Shell (SSH) -Verkehr von der IP-Adresse aus ermöglicht, von der aus Sie Ihre Anwendung ausführen. Zur Einrichtung einer neuen Sicherheitsgruppe sollten Sie das folgende Codebeispiel einschließen oder ausführen. Dadurch wird die Sicherheitsgruppe per Programm eingerichtet.
Nachdem wir ein `AmazonEC2` Client-Objekt erstellt haben, erstellen wir ein `CreateSecurityGroupRequest` Objekt mit dem Namen "GettingStarted" und einer Beschreibung für die Sicherheitsgruppe. Anschließend wird die `ec2.createSecurityGroup`-API zum Erstellen der Gruppe aufgerufen.
Zum Aktivieren des Zugriffs auf die Gruppe erstellen wir ein `ipPermission`-Objekt, bei dem der IP-Adressbereich des Subnetzes auf die CIDR-Darstellung des Subnetzes des lokalen Computers festgelegt ist. Das Suffix "/10" bei der IP-Adresse zeigt das Subnetz für die angegebene IP-Adresse an. Anschließend konfigurieren wir auch das `ipPermission`-Objekt mit dem TCP-Protokoll und dem Port 22 (SSH). Im letzten Schritt wird `ec2.authorizeSecurityGroupIngress` mit dem Namen der Sicherheitsgruppe und dem `ipPermission`-Objekt aufgerufen.
```
// Create the AmazonEC2 client so we can call various APIs.
AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
// Create a new security group.
try {
CreateSecurityGroupRequest securityGroupRequest = new CreateSecurityGroupRequest("GettingStartedGroup", "Getting Started Security Group");
ec2.createSecurityGroup(securityGroupRequest);
} catch (AmazonServiceException ase) {
// Likely this means that the group is already created, so ignore.
System.out.println(ase.getMessage());
}
String ipAddr = "0.0.0.0/0";
// Get the IP of the current host, so that we can limit the Security
// Group by default to the ip range associated with your subnet.
try {
InetAddress addr = InetAddress.getLocalHost();
// Get IP Address
ipAddr = addr.getHostAddress()+"/10";
} catch (UnknownHostException e) {
}
// Create a range that you would like to populate.
ArrayList ipRanges = new ArrayList();
ipRanges.add(ipAddr);
// Open up port 22 for TCP traffic to the associated IP
// from above (e.g. ssh traffic).
ArrayList ipPermissions = new ArrayList ();
IpPermission ipPermission = new IpPermission();
ipPermission.setIpProtocol("tcp");
ipPermission.setFromPort(new Integer(22));
ipPermission.setToPort(new Integer(22));
ipPermission.setIpRanges(ipRanges);
ipPermissions.add(ipPermission);
try {
// Authorize the ports to the used.
AuthorizeSecurityGroupIngressRequest ingressRequest =
new AuthorizeSecurityGroupIngressRequest("GettingStartedGroup",ipPermissions);
ec2.authorizeSecurityGroupIngress(ingressRequest);
} catch (AmazonServiceException ase) {
// Ignore because this likely means the zone has
// already been authorized.
System.out.println(ase.getMessage());
}
```
Hinweis: Sie müssen diese Anwendung nur einmal ausführen, um eine neue Sicherheitsgruppe zu erstellen.
Sie können die Sicherheitsgruppe auch mithilfe von AWS Toolkit for Eclipse erstellen. Weitere Informationen finden Sie unter [Sicherheitsgruppen verwalten von AWS Cost Explorer](https://docs.aws.amazon.com/toolkit-for-eclipse/v1/user-guide/tke-sg.html).
## Schritt 3: Senden Ihrer Spot-Instance-Anforderung
Zum Senden einer Spot-Anforderung sollten Sie zuerst den Instance-Typ, das Amazon Machine Image (AMI) und den Höchstpreis für Ihr Gebot festlegen. Sie müssen auch die zuvor konfigurierte Sicherheitsgruppe aufnehmen, damit Sie sich bei Bedarf bei der Instance anmelden können.
Es stehen mehrere Instanztypen zur Auswahl. Eine vollständige Liste finden Sie unter Amazon EC2 Instanztypen. Für diese Anleitung verwenden wir t1.micro, den günstigsten verfügbaren Instance-Typ. Als Nächstes bestimmen wir, welches AMI wir nutzen möchten. Wir werden ami-a9d09ed1 verwenden, das up-to-date Amazon Linux-AMI, das am meisten verfügbar war, als wir dieses Tutorial geschrieben haben. Von Zeit zu Zeit kann es neuere AMIs geben. Die jeweils neueste AMI-Version lässt sich mit folgenden Schritten ermitteln:
1. Öffnen Sie die [Amazon EC2 -Konsole](https://console.aws.amazon.com/ec2/home).
1. Wählen Sie die Schaltfläche **Launch Instance (Instance starten)**.
1. Im ersten Fenster werden die verfügbaren angezeigt. AMIs Die AMI-ID ist neben dem jeweiligen AMI-Titel aufgelistet. Alternativ können Sie die `DescribeImages`-API nutzen. Die Nutzung dieses Befehls wird in dieser Anleitung allerdings nicht behandelt.
Es gibt viele Wege zur Gebotsgestaltung für Spot-Instances. Eine gute Übersicht der unterschiedlichen Ansätze finden Sie im Video [Bieten für Spot-Instances](https://www.youtube.com/watch?v=WD9N73F3Fao&feature=player_embedded). Allerdings beschreiben wir drei allgemeine Strategien für den Einstieg: Gebote, um sicherzustellen, dass die Kosten geringer sind als bei On-Demand-Preisen; Gebote basierend auf dem Wert der resultierenden Berechnung; Gebote, um Rechenkapazität so schnell wie möglich zu erwerben.
+ *Senkung der Kosten unter On-Demand* Sie haben eine Stapelverarbeitungsaufgabe, die einige Stunden oder Tage laufen wird. Allerdings sind Sie flexibel, was den Start und Abschluss angeht. Sie möchten die Aufgabe nach Möglichkeit günstiger als mit On-Demand-Instances abschließen. Sie untersuchen den Spot-Price-Verlauf für Instance-Typen, indem Sie entweder die AWS-Managementkonsole oder die Amazon EC2 API verwenden. Weitere Informationen finden Sie unter [Anzeigen des Spot-Preisverlaufs](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-spot-instances-history.html). Nachdem Sie den Preisverlauf für Ihren gewünschten Instance-Typ in einer bestimmten Availability Zone analysiert haben, gibt es zwei alternative Ansätze für Ihr Gebot:
+ Sie könnten ein Gebot am oberen Ende der Skala für Spot-Preise abgeben (aber immer noch unter dem On-Demand-Preis) und voraussehen, dass Ihre einmalige Spot-Anforderung sehr wahrscheinlich erfüllt wird und die Instance lange genug aktiv bleibt, um die Aufgabe abzuschließen.
+ Oder Sie können den Betrag, den Sie für Spot-Instances zu zahlen bereit sind, als % des On-Demand-Instance-Preises angeben und planen, viele Instances zu kombinieren, die im Laufe der Zeit über eine persistente Anforderungen gestartet wurden. Wenn der angegebene Preis überschritten wird, wird die Spot-Instance beendet. (Später in dieser Anleitung zeigen wir Ihnen, wie Sie diese Aufgabe automatisieren können.)
+ *Nicht mehr zahlen, als das Ergebnis einbringt* Sie haben eine Aufgabe zur Datenverarbeitung, die ausgeführt werden soll. Sie kennen den Wert der Ergebnisse des Auftrags gut genug, um zu wissen, wie sich der Wert als Rechenkosten darstellen lässt. Sie analysieren den Spot-Preisverlauf Ihres Instance-Typs und entscheiden sich dann für einen Gebotspreis, der sicherstellt, dass die Kosten der Rechenzeit geringer sind als der Wert der Auftragsergebnisse. Sie erstellen ein persistentes Gebot und lassen es zwischenzeitlich laufen, sobald der Spot-Preis Ihr Gebot erreicht oder darunter sinkt.
+ *Schneller Erwerb von Rechenkapazität* Sie haben einen plötzlichen, kurzfristigen Bedarf an zusätzlicher Kapazität, die von On-Demand-Instances nicht bereitgestellt werden kann. Sie analysieren den Spot-Preisverlauf Ihres Instance-Typs und bieten dann über dem höchsten bisherigen Preis. So sorgen Sie dafür, dass Ihre Anforderung mit hoher Wahrscheinlichkeit schnell erfüllt wird und bis zum Abschluss der Aufgabe läuft.
Nachdem Sie den Gebotspreis ausgewählt haben, können Sie eine Spot-Instance anfordern. Für diese Anleitung bieten wir den On-Demand-Preis (0,03 USD) und maximieren so die Chancen, dass das Gebot erfüllt wird. Sie können die Typen der verfügbaren Instances und die On-Demand-Preise für Instances auf der Seite mit den Amazon EC2 Preisen ermitteln. Für die Dauer der Ausführung der Instances zahlen Sie bei Spot-Instances den bei der Anforderung angegebenen Stundensatz. Die Spot-Instance-Preise werden festgelegt Amazon EC2 und auf der Grundlage langfristiger Trends bei Angebot und Nachfrage nach Spot-Instance-Kapazität schrittweise angepasst. Sie können auch den Betrag, den Sie für eine Spot-Instance zu zahlen bereit sind, als % des On-Demand-Instance-Preises angeben. Um eine Spot-Instance anzufordern, müssen Sie Ihre Anfrage einfach mit den zuvor ausgewählten Parametern erstellen. Als Erstes erstellen wir ein `RequestSpotInstanceRequest`-Objekt. Für das Anforderungsobjekt sind die Anzahl der zu startenden Instances sowie der Gebotspreis nötig. Außerdem müssen Sie die `LaunchSpecification` für die Anforderung festlegen. Sie umfasst den Instance-Typ, die AMI-ID sowie die Sicherheitsgruppe, die Sie verwenden möchten. Sobald die Anforderung vorbereitet ist, rufen Sie die Methode `requestSpotInstances` des Objekts `AmazonEC2Client` auf. Das folgende Beispiel zeigt, wie Sie eine Spot-Instance anfordern.
```
// Create the AmazonEC2 client so we can call various APIs.
AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
// Initializes a Spot Instance Request
RequestSpotInstancesRequest requestRequest = new RequestSpotInstancesRequest();
// Request 1 x t1.micro instance with a bid price of $0.03.
requestRequest.setSpotPrice("0.03");
requestRequest.setInstanceCount(Integer.valueOf(1));
// Setup the specifications of the launch. This includes the
// instance type (e.g. t1.micro) and the latest Amazon Linux
// AMI id available. Note, you should always use the latest
// Amazon Linux AMI id or another of your choosing.
LaunchSpecification launchSpecification = new LaunchSpecification();
launchSpecification.setImageId("ami-a9d09ed1");
launchSpecification.setInstanceType(InstanceType.T1Micro);
// Add the security group to the request.
ArrayList securityGroups = new ArrayList();
securityGroups.add("GettingStartedGroup");
launchSpecification.setSecurityGroups(securityGroups);
// Add the launch specifications to the request.
requestRequest.setLaunchSpecification(launchSpecification);
// Call the RequestSpotInstance API.
RequestSpotInstancesResult requestResult = ec2.requestSpotInstances(requestRequest);
```
Beim Ausführen dieses Codes wird eine neue Spot-Instance-Anforderung ausgeführt. Mit weiteren Optionen können Sie Spot-Anforderungen konfigurieren. Weitere Informationen finden Sie unter [Tutorial: Advanced Amazon EC2 Spot Request Management](tutorial-spot-adv-java.md) oder im [RequestSpotInstances](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RequestSpotInstancesRequest.html)Kurs in der AWS SDK für Java API-Referenz.
**Anmerkung**
Sie zahlen für Spot-Instances, die tatsächlich gestartet werden. Achten Sie also darauf, getätigte Anforderungen zu stornieren und gestartete Instances zu beenden, damit Ihnen keine unnötigen Kosten entstehen.
## Schritt 4: Ermitteln des Status Ihrer Spot-Instance-Anforderung
Als Nächstes erstellen wir einen Code, der darauf wartet, dass die Spot-Anforderung den Status "active" erreicht, bevor wir zum letzten Schritt wechseln. Um den Status unserer Spot-Anfrage zu ermitteln, fragen wir die Methode [describeSpotInstanceRequests](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/AmazonEC2Client.html#describeSpotInstanceRequests) nach dem Status der Spot-Request-ID ab, die wir überwachen möchten.
Die in Schritt 2 erstellte Anforderungs-ID ist in der Antwort auf unsere `requestSpotInstances`-Anforderung enthalten. Der folgende Beispielcode zeigt, wie Sie Anfragen IDs aus der `requestSpotInstances` Antwort sammeln und sie verwenden, um eine `ArrayList` zu füllen.
```
// Call the RequestSpotInstance API.
RequestSpotInstancesResult requestResult = ec2.requestSpotInstances(requestRequest);
List requestResponses = requestResult.getSpotInstanceRequests();
// Setup an arraylist to collect all of the request ids we want to
// watch hit the running state.
ArrayList spotInstanceRequestIds = new ArrayList();
// Add all of the request ids to the hashset, so we can determine when they hit the
// active state.
for (SpotInstanceRequest requestResponse : requestResponses) {
System.out.println("Created Spot Request: "+requestResponse.getSpotInstanceRequestId());
spotInstanceRequestIds.add(requestResponse.getSpotInstanceRequestId());
}
```
Rufen Sie zur Überwachung Ihrer Anforderungs-ID die Methode `describeSpotInstanceRequests` auf und ermitteln Sie so den Status der Anforderung. Warten Sie dann in einer Schleife, bis die Anforderung nicht mehr den Zustand "open" aufweist. Hinweis: Wir überprüfen hier, ob der Zustand ungleich "open" ist, anstatt etwa auf "active" zu überprüfen. Der Grund ist, dass die Anforderung direkt zu "closed" übergehen kann, wenn ein Problem mit den Argumenten der Anforderung vorliegt. Im folgenden Codebeispiel sehen Sie im Detail, wie diese Aufgabe umgesetzt wird.
```
// Create a variable that will track whether there are any
// requests still in the open state.
boolean anyOpen;
do {
// Create the describeRequest object with all of the request ids
// to monitor (e.g. that we started).
DescribeSpotInstanceRequestsRequest describeRequest = new DescribeSpotInstanceRequestsRequest();
describeRequest.setSpotInstanceRequestIds(spotInstanceRequestIds);
// Initialize the anyOpen variable to false - which assumes there
// are no requests open unless we find one that is still open.
anyOpen=false;
try {
// Retrieve all of the requests we want to monitor.
DescribeSpotInstanceRequestsResult describeResult = ec2.describeSpotInstanceRequests(describeRequest);
List describeResponses = describeResult.getSpotInstanceRequests();
// Look through each request and determine if they are all in
// the active state.
for (SpotInstanceRequest describeResponse : describeResponses) {
// If the state is open, it hasn't changed since we attempted
// to request it. There is the potential for it to transition
// almost immediately to closed or cancelled so we compare
// against open instead of active.
if (describeResponse.getState().equals("open")) {
anyOpen = true;
break;
}
}
} catch (AmazonServiceException e) {
// If we have an exception, ensure we don't break out of
// the loop. This prevents the scenario where there was
// blip on the wire.
anyOpen = true;
}
try {
// Sleep for 60 seconds.
Thread.sleep(60*1000);
} catch (Exception e) {
// Do nothing because it woke up early.
}
} while (anyOpen);
```
Nachdem dieser Code ausgeführt wird, ist Ihre Spot-Instance-Anforderung entweder abgeschlossen oder mit einem Fehler gescheitert, der auf dem Bildschirm angezeigt wird. In beiden Fällen können wir mit dem nächsten Schritt fortfahren, alle aktiven Anforderungen bereinigen und alle laufenden Instances beenden.
## Schritt 5: Bereinigen der Spot-Anforderungen und ‑Instances
Schließlich müssen wir unsere Anforderungen und Instances bereinigen. Es ist wichtig, sowohl ausstehende Anforderungen zu stornieren *als auch* etwaige Instances zu beenden. Wenn Sie nur die Anforderungen stornieren, werden Ihre Instances nicht beendet und Sie müssen weiter für sie zahlen. Wenn Sie die Instances beenden, können Ihre Spot-Anforderungen storniert werden. In einigen Fällen – etwa dann, wenn Sie persistente Gebote nutzen –, reicht das Beenden Ihrer Instances nicht aus, damit Ihre Anforderung nicht erneut erfüllt wird. Daher ist es eine bewährte Methode, sowohl die aktiven Gebote zu stornieren als auch alle laufenden Instances zu beenden.
Im folgenden Beispiel wird gezeigt, wie Sie Ihre Anforderungen stornieren.
```
try {
// Cancel requests.
CancelSpotInstanceRequestsRequest cancelRequest =
new CancelSpotInstanceRequestsRequest(spotInstanceRequestIds);
ec2.cancelSpotInstanceRequests(cancelRequest);
} catch (AmazonServiceException e) {
// Write out any exceptions that may have occurred.
System.out.println("Error cancelling instances");
System.out.println("Caught Exception: " + e.getMessage());
System.out.println("Reponse Status Code: " + e.getStatusCode());
System.out.println("Error Code: " + e.getErrorCode());
System.out.println("Request ID: " + e.getRequestId());
}
```
Zum Stornieren ausstehender Anforderungen brauchen Sie die jeweilige Instance-ID. Sie ist mit der Anforderung verknüpft, die sie gestartet hat. Im folgenden Codebeispiel ergänzen wir unseren Originalcode zur Überwachung der Instances um eine `ArrayList`. Darin speichern wir die Instance-ID aus der `describeInstance`-Antwort.
```
// Create a variable that will track whether there are any requests
// still in the open state.
boolean anyOpen;
// Initialize variables.
ArrayList instanceIds = new ArrayList();
do {
// Create the describeRequest with all of the request ids to
// monitor (e.g. that we started).
DescribeSpotInstanceRequestsRequest describeRequest = new DescribeSpotInstanceRequestsRequest();
describeRequest.setSpotInstanceRequestIds(spotInstanceRequestIds);
// Initialize the anyOpen variable to false, which assumes there
// are no requests open unless we find one that is still open.
anyOpen = false;
try {
// Retrieve all of the requests we want to monitor.
DescribeSpotInstanceRequestsResult describeResult =
ec2.describeSpotInstanceRequests(describeRequest);
List describeResponses =
describeResult.getSpotInstanceRequests();
// Look through each request and determine if they are all
// in the active state.
for (SpotInstanceRequest describeResponse : describeResponses) {
// If the state is open, it hasn't changed since we
// attempted to request it. There is the potential for
// it to transition almost immediately to closed or
// cancelled so we compare against open instead of active.
if (describeResponse.getState().equals("open")) {
anyOpen = true; break;
}
// Add the instance id to the list we will
// eventually terminate.
instanceIds.add(describeResponse.getInstanceId());
}
} catch (AmazonServiceException e) {
// If we have an exception, ensure we don't break out
// of the loop. This prevents the scenario where there
// was blip on the wire.
anyOpen = true;
}
try {
// Sleep for 60 seconds.
Thread.sleep(60*1000);
} catch (Exception e) {
// Do nothing because it woke up early.
}
} while (anyOpen);
```
Beenden Sie mithilfe der Instance IDs, die in gespeichert ist`ArrayList`, alle laufenden Instances mithilfe des folgenden Codeausschnitts.
```
try {
// Terminate instances.
TerminateInstancesRequest terminateRequest = new TerminateInstancesRequest(instanceIds);
ec2.terminateInstances(terminateRequest);
} catch (AmazonServiceException e) {
// Write out any exceptions that may have occurred.
System.out.println("Error terminating instances");
System.out.println("Caught Exception: " + e.getMessage());
System.out.println("Reponse Status Code: " + e.getStatusCode());
System.out.println("Error Code: " + e.getErrorCode());
System.out.println("Request ID: " + e.getRequestId());
}
```
## Zusammenfassung
Um all das zusammenzubringen, bieten wir einen objektorientierteren Ansatz, der die oben beschriebenen Schritte kombiniert: Initialisierung des EC2 Clients, Senden der Spot-Anfrage, Feststellung, wann sich die Spot-Anfragen nicht mehr im offenen Zustand befinden, und Bereinigen aller verbliebenen Spot-Anfragen und der zugehörigen Instances. Wir erstellen eine Klasse namens `Requests`, die diese Aktionen ausführt.
Zudem legen wir eine Klasse `GettingStartedApp` mit einer main-Methode an, in der wir die High-Level-Funktionsaufrufe durchführen. Insbesondere initialisieren wir das zuvor beschriebene `Requests`-Objekt. Wir senden die Spot-Instance-Anforderung. Anschließend warten wir, bis die Spot-Anforderung den Zustand "active" erreicht. Schließlich bereinigen wir die Anforderungen und Instances.
Der vollständige Quellcode für dieses Beispiel kann unter eingesehen oder heruntergeladen werden. [GitHub](https://github.com/aws/aws-sdk-java/tree/master/src/samples/AmazonEC2SpotInstances-GettingStarted)
Herzlichen Glückwunsch\$1 Sie haben jetzt die Erste-Schritte-Anleitung zur Entwicklung von Spot-Instance-Software mit dem AWS SDK für Java abgeschlossen.
## Nächste Schritte
Fahren Sie mit [Tutorial: Erweitertes Amazon EC2 Spot-Anforderungsmanagement](tutorial-spot-adv-java.md) fort.
# Tutorial: Erweitertes Amazon EC2 Spot-Anforderungsmanagement
Amazon EC2 Spot-Instances ermöglichen es Ihnen, Gebote für ungenutzte Amazon EC2 Kapazität abzugeben und diese Instances so lange laufen zu lassen, wie Ihr Gebot den aktuellen *Spot-Preis* übersteigt. Amazon EC2 ändert den Spot-Preis regelmäßig auf der Grundlage von Angebot und Nachfrage. Weitere Informationen zu Spot-Instances finden Sie unter [Spot-Instances](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-spot-instances.html) im Amazon EC2 Benutzerhandbuch für Linux-Instances.
## Voraussetzungen
Um dieses Tutorial verwenden zu können, müssen Sie das AWS SDK für Java installiert haben und die grundlegenden Installationsvoraussetzungen erfüllen. Weitere Informationen finden [Sie unter Einrichten](setup-install.md) von. AWS SDK für Java
## Einrichten Ihrer Anmeldeinformationen
Um mit der Verwendung dieses Codebeispiels zu beginnen, müssen Sie AWS Anmeldeinformationen einrichten. Anweisungen dazu finden Sie unter [AWS Zugangsdaten und Region für die Entwicklung einrichten](setup-credentials.md).
**Anmerkung**
Wir empfehlen, dass Sie die Anmeldeinformationen eines IAM Benutzers verwenden, um diese Werte anzugeben. Weitere Informationen finden Sie unter [Registrieren für AWS und Erstellen eines IAM Benutzers](signup-create-iam-user.md).
Nachdem Sie Ihre Einstellungen eingerichtet haben, können Sie mit dem Beispiel-Code loslegen.
## Einrichten einer Sicherheitsgruppe
Eine Sicherheitsgruppe agiert als Firewall, die den zulässigen Verkehr zu und von einer Gruppe Instances steuert. Standardmäßig wird eine Instance ohne eine Sicherheitsgruppe gestartet. Sämtlicher eingehender IP-Datenverkehr auf allen TCP-Ports wird daher verweigert. Vor dem Absenden unserer Spot-Anforderung richten wir also eine Sicherheitsgruppe ein, die den nötigen Netzwerkverkehr zulässt. Für die Zwecke dieses Tutorials erstellen wir eine neue Sicherheitsgruppe namens "GettingStarted", die Secure Shell (SSH) -Verkehr von der IP-Adresse aus ermöglicht, von der aus Sie Ihre Anwendung ausführen. Zur Einrichtung einer neuen Sicherheitsgruppe sollten Sie das folgende Codebeispiel einschließen oder ausführen. Dadurch wird die Sicherheitsgruppe per Programm eingerichtet.
Nachdem wir ein `AmazonEC2` Client-Objekt erstellt haben, erstellen wir ein `CreateSecurityGroupRequest` Objekt mit dem Namen "GettingStarted" und einer Beschreibung für die Sicherheitsgruppe. Anschließend wird die `ec2.createSecurityGroup`-API zum Erstellen der Gruppe aufgerufen.
Zum Aktivieren des Zugriffs auf die Gruppe erstellen wir ein `ipPermission`-Objekt, bei dem der IP-Adressbereich des Subnetzes auf die CIDR-Darstellung des Subnetzes des lokalen Computers festgelegt ist. Das Suffix "/10" bei der IP-Adresse zeigt das Subnetz für die angegebene IP-Adresse an. Anschließend konfigurieren wir auch das `ipPermission`-Objekt mit dem TCP-Protokoll und dem Port 22 (SSH). Im letzten Schritt wird `ec2 .authorizeSecurityGroupIngress` mit dem Namen der Sicherheitsgruppe und dem `ipPermission`-Objekt aufgerufen.
(Der folgende Code entspricht unserem Code aus der ersten Anleitung.)
```
// Create the AmazonEC2Client object so we can call various APIs.
AmazonEC2 ec2 = AmazonEC2ClientBuilder.standard()
.withCredentials(credentials)
.build();
// Create a new security group.
try {
CreateSecurityGroupRequest securityGroupRequest =
new CreateSecurityGroupRequest("GettingStartedGroup",
"Getting Started Security Group");
ec2.createSecurityGroup(securityGroupRequest);
} catch (AmazonServiceException ase) {
// Likely this means that the group is already created, so ignore.
System.out.println(ase.getMessage());
}
String ipAddr = "0.0.0.0/0";
// Get the IP of the current host, so that we can limit the Security Group
// by default to the ip range associated with your subnet.
try {
// Get IP Address
InetAddress addr = InetAddress.getLocalHost();
ipAddr = addr.getHostAddress()+"/10";
}
catch (UnknownHostException e) {
// Fail here...
}
// Create a range that you would like to populate.
ArrayList ipRanges = new ArrayList();
ipRanges.add(ipAddr);
// Open up port 22 for TCP traffic to the associated IP from
// above (e.g. ssh traffic).
ArrayList ipPermissions = new ArrayList ();
IpPermission ipPermission = new IpPermission();
ipPermission.setIpProtocol("tcp");
ipPermission.setFromPort(new Integer(22));
ipPermission.setToPort(new Integer(22));
ipPermission.setIpRanges(ipRanges);
ipPermissions.add(ipPermission);
try {
// Authorize the ports to the used.
AuthorizeSecurityGroupIngressRequest ingressRequest =
new AuthorizeSecurityGroupIngressRequest(
"GettingStartedGroup",ipPermissions);
ec2.authorizeSecurityGroupIngress(ingressRequest);
}
catch (AmazonServiceException ase) {
// Ignore because this likely means the zone has already
// been authorized.
System.out.println(ase.getMessage());
}
```
Sie können das gesamte Codebeispiel im `advanced.CreateSecurityGroupApp.java`-Codebeispiel einsehen. Hinweis: Sie müssen diese Anwendung nur einmal ausführen, um eine neue Sicherheitsgruppe zu erstellen.
**Anmerkung**
Sie können die Sicherheitsgruppe auch mithilfe von AWS Toolkit for Eclipse erstellen. Weitere Informationen finden Sie AWS Cost Explorer im AWS Toolkit for Eclipse Benutzerhandbuch unter [Sicherheitsgruppen verwalten](https://docs.aws.amazon.com/toolkit-for-eclipse/v1/user-guide/tke-sg.html).
## Detaillierte Optionen für die Erstellung von Spot-Instance-Anforderungen
Wie wir im [Tutorial: Amazon EC2 Spot-Instances](tutorial-spot-instances-java.md) erklärt haben, müssen Sie Ihre Anfrage mit einem Instance-Typ, einem Amazon Machine Image (AMI) und einem Höchstgebotspreis erstellen.
Als Erstes erstellen wir ein `RequestSpotInstanceRequest`-Objekt. Für das Anforderungsobjekt sind die Anzahl der gewünschten Instances sowie der Gebotspreis nötig. Außerdem müssen wir die `LaunchSpecification` für die Anforderung festlegen. Sie umfasst den Instance-Typ, die AMI-ID sowie die Sicherheitsgruppe, die Sie verwenden möchten. Nachdem die Anforderung vorbereitet ist, rufen wir die Methode `requestSpotInstances` des Objekts `AmazonEC2Client` auf. Es folgt ein Beispiel für die Anforderung einer Spot-Instance.
(Der folgende Code entspricht unserem Code aus der ersten Anleitung.)
```
// Create the AmazonEC2 client so we can call various APIs.
AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
// Initializes a Spot Instance Request
RequestSpotInstancesRequest requestRequest = new RequestSpotInstancesRequest();
// Request 1 x t1.micro instance with a bid price of $0.03.
requestRequest.setSpotPrice("0.03");
requestRequest.setInstanceCount(Integer.valueOf(1));
// Set up the specifications of the launch. This includes the
// instance type (e.g. t1.micro) and the latest Amazon Linux
// AMI id available. Note, you should always use the latest
// Amazon Linux AMI id or another of your choosing.
LaunchSpecification launchSpecification = new LaunchSpecification();
launchSpecification.setImageId("ami-a9d09ed1");
launchSpecification.setInstanceType(InstanceType.T1Micro);
// Add the security group to the request.
ArrayList securityGroups = new ArrayList();
securityGroups.add("GettingStartedGroup");
launchSpecification.setSecurityGroups(securityGroups);
// Add the launch specification.
requestRequest.setLaunchSpecification(launchSpecification);
// Call the RequestSpotInstance API.
RequestSpotInstancesResult requestResult =
ec2.requestSpotInstances(requestRequest);
```
## Persistente im Vergleich zu einmaligen Anforderungen
Beim Erstellen einer Spot-Instance-Anforderung können Sie mehrere optionale Parameter angeben. Die erste Option gibt an, ob Ihre Anforderung von einmaliger oder persistenter Natur sein soll. Standardmäßig handelt es sich um eine einmalige Anforderung. Eine einmalige Anforderung kann nur einmal erfüllt werden. Sind die angeforderten Instances beendet, wird die Anforderung geschlossen. Eine persistente Anforderung wird zur Erfüllung immer dann herangezogen, wenn für die gleiche Anforderung keine Spot-Instance ausgeführt wird. Geben Sie den Typ der Anforderung an, indem Sie einfach den "Type" auf der Spot-Anforderung festlegen. Dies lässt sich mit folgendem Code erreichen:
```
// Retrieves the credentials from an AWSCredentials.properties file.
AWSCredentials credentials = null;
try {
credentials = new PropertiesCredentials(
GettingStartedApp.class.getResourceAsStream("AwsCredentials.properties"));
}
catch (IOException e1) {
System.out.println(
"Credentials were not properly entered into AwsCredentials.properties.");
System.out.println(e1.getMessage());
System.exit(-1);
}
// Create the AmazonEC2 client so we can call various APIs.
AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
// Initializes a Spot Instance Request
RequestSpotInstancesRequest requestRequest =
new RequestSpotInstancesRequest();
// Request 1 x t1.micro instance with a bid price of $0.03.
requestRequest.setSpotPrice("0.03");
requestRequest.setInstanceCount(Integer.valueOf(1));
// Set the type of the bid to persistent.
requestRequest.setType("persistent");
// Set up the specifications of the launch. This includes the
// instance type (e.g. t1.micro) and the latest Amazon Linux
// AMI id available. Note, you should always use the latest
// Amazon Linux AMI id or another of your choosing.
LaunchSpecification launchSpecification = new LaunchSpecification();
launchSpecification.setImageId("ami-a9d09ed1");
launchSpecification.setInstanceType(InstanceType.T1Micro);
// Add the security group to the request.
ArrayList securityGroups = new ArrayList();
securityGroups.add("GettingStartedGroup");
launchSpecification.setSecurityGroups(securityGroups);
// Add the launch specification.
requestRequest.setLaunchSpecification(launchSpecification);
// Call the RequestSpotInstance API.
RequestSpotInstancesResult requestResult =
ec2.requestSpotInstances(requestRequest);
```
## Einschränken der Dauer einer Anforderung
Außerdem können Sie optional festlegen, wie lange Ihre Anforderung gültig bleibt. Sie können für diesen Zeitraum eine Start- und Endzeit festlegen. Standardmäßig wird eine Spot-Anforderung zur Erfüllung von dem Augenblick ihrer Erstellung bis zu dem Zeitpunkt herangezogen, an dem sie entweder erfüllt oder von Ihnen storniert wird. Allerdings können Sie die Gültigkeitsdauer bei Bedarf einschränken. Ein Beispiel dafür, wie Sie diesen Zeitraum angeben, wird im folgenden Code gezeigt:
```
// Create the AmazonEC2 client so we can call various APIs.
AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
// Initializes a Spot Instance Request
RequestSpotInstancesRequest requestRequest = new RequestSpotInstancesRequest();
// Request 1 x t1.micro instance with a bid price of $0.03.
requestRequest.setSpotPrice("0.03");
requestRequest.setInstanceCount(Integer.valueOf(1));
// Set the valid start time to be two minutes from now.
Calendar cal = Calendar.getInstance();
cal.add(Calendar.MINUTE, 2);
requestRequest.setValidFrom(cal.getTime());
// Set the valid end time to be two minutes and two hours from now.
cal.add(Calendar.HOUR, 2);
requestRequest.setValidUntil(cal.getTime());
// Set up the specifications of the launch. This includes
// the instance type (e.g. t1.micro)
// and the latest Amazon Linux AMI id available.
// Note, you should always use the latest Amazon
// Linux AMI id or another of your choosing.
LaunchSpecification launchSpecification = new LaunchSpecification();
launchSpecification.setImageId("ami-a9d09ed1");
launchSpecification.setInstanceType("t1.micro");
// Add the security group to the request.
ArrayList securityGroups = new ArrayList();
securityGroups.add("GettingStartedGroup");
launchSpecification.setSecurityGroups(securityGroups);
// Add the launch specification.
requestRequest.setLaunchSpecification(launchSpecification);
// Call the RequestSpotInstance API.
RequestSpotInstancesResult requestResult = ec2.requestSpotInstances(requestRequest);
```
## Gruppieren Sie Ihre Amazon EC2 Spot-Instance-Anfragen
Auf Wunsch können Sie Spot-Instance-Anforderungen auf verschiedene Weise gruppieren. Beachten Sie die Vorteile der Nutzung von Start-, Availability Zone- und Platzierungsgruppen.
Wenn Sie sichergehen möchten, dass Ihre Spot-Instances gleichzeitig gestartet und beendet werden, können Sie eine Startgruppe nutzen. Eine Startgruppe ist eine Bezeichnung, die einige Gebote gruppiert. Alle Instances in einer Startgruppe werden zusammen gestartet und beendet. Hinweis: Wurden Instances in einer Startgruppe bereits erfüllt, gibt es keine Garantie dafür, dass neu in der gleichen Startgruppe gestarteten Instances ebenfalls erfüllt werden. Ein Beispiel dafür, wie Sie eine Startgruppe festlegen können, wird im folgenden Code gezeigt:
```
// Create the AmazonEC2 client so we can call various APIs.
AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
// Initializes a Spot Instance Request
RequestSpotInstancesRequest requestRequest = new RequestSpotInstancesRequest();
// Request 5 x t1.micro instance with a bid price of $0.03.
requestRequest.setSpotPrice("0.03");
requestRequest.setInstanceCount(Integer.valueOf(5));
// Set the launch group.
requestRequest.setLaunchGroup("ADVANCED-DEMO-LAUNCH-GROUP");
// Set up the specifications of the launch. This includes
// the instance type (e.g. t1.micro) and the latest Amazon Linux
// AMI id available. Note, you should always use the latest
// Amazon Linux AMI id or another of your choosing.
LaunchSpecification launchSpecification = new LaunchSpecification();
launchSpecification.setImageId("ami-a9d09ed1");
launchSpecification.setInstanceType(InstanceType.T1Micro);
// Add the security group to the request.
ArrayList securityGroups = new ArrayList();
securityGroups.add("GettingStartedGroup");
launchSpecification.setSecurityGroups(securityGroups);
// Add the launch specification.
requestRequest.setLaunchSpecification(launchSpecification);
// Call the RequestSpotInstance API.
RequestSpotInstancesResult requestResult =
ec2.requestSpotInstances(requestRequest);
```
Wenn Sie sicherstellen möchten, dass alle Instances in einer Anforderung in derselben Availability Zone gestartet werden, und es nicht relevant ist, in welcher Zone, können Sie Availability Zone-Gruppen nutzen. Eine Availability Zone-Gruppe ist eine Bezeichnung, die eine Gruppe von Instances in derselben Availability Zone gruppiert. Alle Instances mit der gleichen Availability Zone-Gruppe, die gleichzeitig erfüllt werden, starten in derselben Availability Zone. Ein Beispiel für die Einrichtung einer Availability Zone-Gruppe finden Sie hier:
```
// Create the AmazonEC2 client so we can call various APIs.
AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
// Initializes a Spot Instance Request
RequestSpotInstancesRequest requestRequest = new RequestSpotInstancesRequest();
// Request 5 x t1.micro instance with a bid price of $0.03.
requestRequest.setSpotPrice("0.03");
requestRequest.setInstanceCount(Integer.valueOf(5));
// Set the availability zone group.
requestRequest.setAvailabilityZoneGroup("ADVANCED-DEMO-AZ-GROUP");
// Set up the specifications of the launch. This includes the instance
// type (e.g. t1.micro) and the latest Amazon Linux AMI id available.
// Note, you should always use the latest Amazon Linux AMI id or another
// of your choosing.
LaunchSpecification launchSpecification = new LaunchSpecification();
launchSpecification.setImageId("ami-a9d09ed1");
launchSpecification.setInstanceType(InstanceType.T1Micro);
// Add the security group to the request.
ArrayList securityGroups = new ArrayList();
securityGroups.add("GettingStartedGroup");
launchSpecification.setSecurityGroups(securityGroups);
// Add the launch specification.
requestRequest.setLaunchSpecification(launchSpecification);
// Call the RequestSpotInstance API.
RequestSpotInstancesResult requestResult =
ec2.requestSpotInstances(requestRequest);
```
Sie können eine Availability Zone angeben, die Sie für Ihre Spot-Instances nutzen möchten. Das folgende Codebeispiel zeigt, wie Sie eine Availability Zone festlegen.
```
// Create the AmazonEC2 client so we can call various APIs.
AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
// Initializes a Spot Instance Request
RequestSpotInstancesRequest requestRequest = new RequestSpotInstancesRequest();
// Request 1 x t1.micro instance with a bid price of $0.03.
requestRequest.setSpotPrice("0.03");
requestRequest.setInstanceCount(Integer.valueOf(1));
// Set up the specifications of the launch. This includes the instance
// type (e.g. t1.micro) and the latest Amazon Linux AMI id available.
// Note, you should always use the latest Amazon Linux AMI id or another
// of your choosing.
LaunchSpecification launchSpecification = new LaunchSpecification();
launchSpecification.setImageId("ami-a9d09ed1");
launchSpecification.setInstanceType(InstanceType.T1Micro);
// Add the security group to the request.
ArrayList securityGroups = new ArrayList();
securityGroups.add("GettingStartedGroup");
launchSpecification.setSecurityGroups(securityGroups);
// Set up the availability zone to use. Note we could retrieve the
// availability zones using the ec2.describeAvailabilityZones() API. For
// this demo we will just use us-east-1a.
SpotPlacement placement = new SpotPlacement("us-east-1b");
launchSpecification.setPlacement(placement);
// Add the launch specification.
requestRequest.setLaunchSpecification(launchSpecification);
// Call the RequestSpotInstance API.
RequestSpotInstancesResult requestResult =
ec2.requestSpotInstances(requestRequest);
```
Schließlich können Sie eine *Platzierungsgruppe* angeben, wenn Sie High Performance Computing (HPC)-Spot-Instances nutzen, etwa Cluster Compute-Instances oder Cluster-GPU-Instances. Platzierungsgruppen sorgen für eine niedrigere Latenz und eine hohe Bandbreitenkonnektivität zwischen den Instances. Ein Beispiel für die Einrichtung einer Platzierungsgruppe finden Sie hier:
```
// Create the AmazonEC2 client so we can call various APIs.
AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
// Initializes a Spot Instance Request
RequestSpotInstancesRequest requestRequest = new RequestSpotInstancesRequest();
// Request 1 x t1.micro instance with a bid price of $0.03.
requestRequest.setSpotPrice("0.03");
requestRequest.setInstanceCount(Integer.valueOf(1));
// Set up the specifications of the launch. This includes the instance
// type (e.g. t1.micro) and the latest Amazon Linux AMI id available.
// Note, you should always use the latest Amazon Linux AMI id or another
// of your choosing.
LaunchSpecification launchSpecification = new LaunchSpecification();
launchSpecification.setImageId("ami-a9d09ed1");
launchSpecification.setInstanceType(InstanceType.T1Micro);
// Add the security group to the request.
ArrayList securityGroups = new ArrayList();
securityGroups.add("GettingStartedGroup");
launchSpecification.setSecurityGroups(securityGroups);
// Set up the placement group to use with whatever name you desire.
// For this demo we will just use "ADVANCED-DEMO-PLACEMENT-GROUP".
SpotPlacement placement = new SpotPlacement();
placement.setGroupName("ADVANCED-DEMO-PLACEMENT-GROUP");
launchSpecification.setPlacement(placement);
// Add the launch specification.
requestRequest.setLaunchSpecification(launchSpecification);
// Call the RequestSpotInstance API.
RequestSpotInstancesResult requestResult =
ec2.requestSpotInstances(requestRequest);
```
Alle Parameter in diesem Abschnitt sind optional. Es ist auch wichtig zu wissen, dass die meisten dieser Parameter — mit Ausnahme der Tatsache, ob es sich bei Ihrem Gebot um ein einmaliges oder ein dauerhaftes Gebot handelt — die Wahrscheinlichkeit verringern können, dass das Gebot erfüllt wird. Daher ist es wichtig, diese Optionen nur bei Bedarf zu nutzen. Alle obigen Codebeispiele sind in einem langen Codebeispiel kombiniert, das in der `com.amazonaws.codesamples.advanced.InlineGettingStartedCodeSampleApp.java`-Klasse zu finden ist.
## So bleibt eine Stammpartition nach einer Unterbrechung oder Beendigung erhalten
Eine der einfachsten Möglichkeiten, mit Unterbrechungen Ihrer Spot-Instances umzugehen, besteht darin, sicherzustellen, dass Ihre Daten regelmäßig auf ein Amazon Elastic Block Store (Amazon Amazon EBS) -Volume (Amazon) überprüft werden. Durch das Setzen von Prüfpunkten in regelmäßigen Abständen verlieren Sie im Falle einer Unterbrechung nur die seit dem letzten Prüfpunkt erstellten Daten (angenommen, zwischenzeitlich wurden keine anderen idempotenten Aktionen ausgeführt). Um diesen Prozess zu vereinfachen, können Sie Ihre Spot-Anforderung so konfigurieren, dass Ihre Stammpartition bei Unterbrechungen oder Beendigungen nicht gelöscht wird. Im folgenden Beispiel haben wir neuen Code eingefügt, der zeigt, wie sich dieses Szenario umsetzen lässt.
Im hinzugefügten Code erstellen wir ein `BlockDeviceMapping` Objekt und setzen es mit einem Amazon EBS Objekt verknüpft Amazon Elastic Block Store (Amazon EBS), das wir so konfiguriert haben, dass es gelöscht `not` wird, wenn die Spot-Instance beendet wird. Wir fügen dies dann `BlockDeviceMapping` zu den ArrayList Mappings hinzu, die wir in die Startspezifikation aufnehmen.
```
// Retrieves the credentials from an AWSCredentials.properties file.
AWSCredentials credentials = null;
try {
credentials = new PropertiesCredentials(
GettingStartedApp.class.getResourceAsStream("AwsCredentials.properties"));
}
catch (IOException e1) {
System.out.println(
"Credentials were not properly entered into AwsCredentials.properties.");
System.out.println(e1.getMessage());
System.exit(-1);
}
// Create the AmazonEC2 client so we can call various APIs.
AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
// Initializes a Spot Instance Request
RequestSpotInstancesRequest requestRequest = new RequestSpotInstancesRequest();
// Request 1 x t1.micro instance with a bid price of $0.03.
requestRequest.setSpotPrice("0.03");
requestRequest.setInstanceCount(Integer.valueOf(1));
// Set up the specifications of the launch. This includes the instance
// type (e.g. t1.micro) and the latest Amazon Linux AMI id available.
// Note, you should always use the latest Amazon Linux AMI id or another
// of your choosing.
LaunchSpecification launchSpecification = new LaunchSpecification();
launchSpecification.setImageId("ami-a9d09ed1");
launchSpecification.setInstanceType(InstanceType.T1Micro);
// Add the security group to the request.
ArrayList securityGroups = new ArrayList();
securityGroups.add("GettingStartedGroup");
launchSpecification.setSecurityGroups(securityGroups);
// Create the block device mapping to describe the root partition.
BlockDeviceMapping blockDeviceMapping = new BlockDeviceMapping();
blockDeviceMapping.setDeviceName("/dev/sda1");
// Set the delete on termination flag to false.
EbsBlockDevice ebs = new EbsBlockDevice();
ebs.setDeleteOnTermination(Boolean.FALSE);
blockDeviceMapping.setEbs(ebs);
// Add the block device mapping to the block list.
ArrayList blockList = new ArrayList();
blockList.add(blockDeviceMapping);
// Set the block device mapping configuration in the launch specifications.
launchSpecification.setBlockDeviceMappings(blockList);
// Add the launch specification.
requestRequest.setLaunchSpecification(launchSpecification);
// Call the RequestSpotInstance API.
RequestSpotInstancesResult requestResult =
ec2.requestSpotInstances(requestRequest);
```
Wenn Sie dieses Volume beim Startup erneut an Ihre Instance anfügen möchten, können Sie auch die Einstellungen für Blockgerät-Zuweisung verwenden. Wenn Sie eine Nicht-Root-Partition angehängt haben, können Sie alternativ die Amazon EBS Amazon-Volumes angeben, die Sie an Ihre Spot-Instance anhängen möchten, nachdem sie wieder aufgenommen wurde. Geben Sie dazu einfach eine Snapshot-ID in Ihrem `EbsBlockDevice` und einen alternativen Gerätenamen in Ihren `BlockDeviceMapping`-Objekten an. Durch die Nutzung von Blockgerät-Zuweisungen lässt sich die Instance einfacher starten.
Wenn Sie die Stammpartition verwenden, um Prüfpunkte für Ihre wichtigen Daten anzulegen, können Sie auf diese Weise die Wahrscheinlichkeit der Unterbrechung Ihrer Instances im Griff behalten. Weitere Methoden zum Umgang mit der Wahrscheinlichkeit von Unterbrechungen finden Sie im Video [Managing Interruption](https://www.youtube.com/watch?feature=player_embedded&v=wcPNnUo60pc).
## So markieren Sie Spot-Anforderungen und ‑Instances
Das Hinzufügen von Tags zu Amazon EC2 Ressourcen kann die Verwaltung Ihrer Cloud-Infrastruktur vereinfachen. Tags sind ein Typ von Metadaten, der verwendet werden kann, um benutzerfreundliche Namen zu erstellen, die Durchsuchbarkeit zu optimieren und die Koordination zwischen mehreren Benutzern zu verbessern. Sie können Tags auch zur Automatisierung von Skripts und Teilen Ihrer Prozesse nutzen. Weitere Informationen zum Taggen von Amazon EC2 Ressourcen finden Sie [unter Verwenden von Tags](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html) im Amazon EC2 Benutzerhandbuch für Linux-Instances.
### Markieren von -Anforderungen
Zum Hinzufügen von Tags zu Ihren Spot-Anforderungen müssen Sie sie markieren, *nachdem* sie angefordert wurden. Der Rückgabewert von `requestSpotInstances()` stellt Ihnen ein [RequestSpotInstancesResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RequestSpotInstancesResult.html)Objekt zur Verfügung, mit dem Sie die Spot-Anfrage IDs für das Tagging abrufen können:
```
// Call the RequestSpotInstance API.
RequestSpotInstancesResult requestResult = ec2.requestSpotInstances(requestRequest);
List requestResponses = requestResult.getSpotInstanceRequests();
// A list of request IDs to tag
ArrayList spotInstanceRequestIds = new ArrayList();
// Add the request ids to the hashset, so we can determine when they hit the
// active state.
for (SpotInstanceRequest requestResponse : requestResponses) {
System.out.println("Created Spot Request: "+requestResponse.getSpotInstanceRequestId());
spotInstanceRequestIds.add(requestResponse.getSpotInstanceRequestId());
}
```
Sobald Sie die haben IDs, können Sie die Anfragen taggen, indem Sie sie IDs zu einer hinzufügen [CreateTagsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateTagsRequest.html)und die `createTags()` Methode des Amazon EC2 Clients aufrufen:
```
// The list of tags to create
ArrayList requestTags = new ArrayList();
requestTags.add(new Tag("keyname1","value1"));
// Create the tag request
CreateTagsRequest createTagsRequest_requests = new CreateTagsRequest();
createTagsRequest_requests.setResources(spotInstanceRequestIds);
createTagsRequest_requests.setTags(requestTags);
// Tag the spot request
try {
ec2.createTags(createTagsRequest_requests);
}
catch (AmazonServiceException e) {
System.out.println("Error terminating instances");
System.out.println("Caught Exception: " + e.getMessage());
System.out.println("Reponse Status Code: " + e.getStatusCode());
System.out.println("Error Code: " + e.getErrorCode());
System.out.println("Request ID: " + e.getRequestId());
}
```
### Markieren von Instances
Ähnlich wie bei Spot-Anforderungen selbst können Sie eine Instance erst nach ihrer Erstellung markieren. Instances werden erstellt, sobald die Spot-Anforderung erfüllt wurde (d. h., wenn sie nicht mehr den Status *offen* hat).
Sie können den Status Ihrer Anfragen überprüfen, indem Sie die `describeSpotInstanceRequests()` Methode des Amazon EC2 Clients mit einem [DescribeSpotInstanceRequestsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeSpotInstanceRequestsRequest.html)Objekt aufrufen. Das zurückgegebene [DescribeSpotInstanceRequestsResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeSpotInstanceRequestsResult.html)Objekt enthält eine Liste von [SpotInstanceRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/SpotInstanceRequest.html)Objekten, mit denen Sie den Status Ihrer Spot-Anfragen abfragen und deren Instanz abrufen können, IDs sobald sie sich nicht mehr im *geöffneten* Zustand befinden.
Sobald die Spot-Anforderung nicht mehr offen ist, können Sie ihre Instance-ID vom `SpotInstanceRequest`-Objekt erhalten, indem Sie dessen `getInstanceId()`-Methode aufrufen.
```
boolean anyOpen; // tracks whether any requests are still open
// a list of instances to tag.
ArrayList instanceIds = new ArrayList();
do {
DescribeSpotInstanceRequestsRequest describeRequest =
new DescribeSpotInstanceRequestsRequest();
describeRequest.setSpotInstanceRequestIds(spotInstanceRequestIds);
anyOpen=false; // assume no requests are still open
try {
// Get the requests to monitor
DescribeSpotInstanceRequestsResult describeResult =
ec2.describeSpotInstanceRequests(describeRequest);
List describeResponses =
describeResult.getSpotInstanceRequests();
// are any requests open?
for (SpotInstanceRequest describeResponse : describeResponses) {
if (describeResponse.getState().equals("open")) {
anyOpen = true;
break;
}
// get the corresponding instance ID of the spot request
instanceIds.add(describeResponse.getInstanceId());
}
}
catch (AmazonServiceException e) {
// Don't break the loop due to an exception (it may be a temporary issue)
anyOpen = true;
}
try {
Thread.sleep(60*1000); // sleep 60s.
}
catch (Exception e) {
// Do nothing if the thread woke up early.
}
} while (anyOpen);
```
Jetzt können Sie die zurückgegebenen Instances markieren:
```
// Create a list of tags to create
ArrayList instanceTags = new ArrayList();
instanceTags.add(new Tag("keyname1","value1"));
// Create the tag request
CreateTagsRequest createTagsRequest_instances = new CreateTagsRequest();
createTagsRequest_instances.setResources(instanceIds);
createTagsRequest_instances.setTags(instanceTags);
// Tag the instance
try {
ec2.createTags(createTagsRequest_instances);
}
catch (AmazonServiceException e) {
// Write out any exceptions that may have occurred.
System.out.println("Error terminating instances");
System.out.println("Caught Exception: " + e.getMessage());
System.out.println("Reponse Status Code: " + e.getStatusCode());
System.out.println("Error Code: " + e.getErrorCode());
System.out.println("Request ID: " + e.getRequestId());
}
```
## Stornieren von Spot-Anforderungen und Beenden von Instances
### Stornieren einer Spot-Anforderung
Um eine Spot-Instance-Anfrage zu stornieren, rufen Sie den Amazon EC2 Client mit einem [CancelSpotInstanceRequestsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CancelSpotInstanceRequestsRequest.html)Objekt `cancelSpotInstanceRequests` auf.
```
try {
CancelSpotInstanceRequestsRequest cancelRequest = new CancelSpotInstanceRequestsRequest(spotInstanceRequestIds);
ec2.cancelSpotInstanceRequests(cancelRequest);
} catch (AmazonServiceException e) {
System.out.println("Error cancelling instances");
System.out.println("Caught Exception: " + e.getMessage());
System.out.println("Reponse Status Code: " + e.getStatusCode());
System.out.println("Error Code: " + e.getErrorCode());
System.out.println("Request ID: " + e.getRequestId());
}
```
### Beenden von Spot-Instances
Sie können alle laufenden Spot-Instances beenden, indem Sie sie IDs an die `terminateInstances()` Methode des Amazon EC2 Clients übergeben.
```
try {
TerminateInstancesRequest terminateRequest = new TerminateInstancesRequest(instanceIds);
ec2.terminateInstances(terminateRequest);
} catch (AmazonServiceException e) {
System.out.println("Error terminating instances");
System.out.println("Caught Exception: " + e.getMessage());
System.out.println("Reponse Status Code: " + e.getStatusCode());
System.out.println("Error Code: " + e.getErrorCode());
System.out.println("Request ID: " + e.getRequestId());
}
```
## Zusammenfassung
Fassen wir zusammen: Wir bieten einen eher objektorientierten Ansatz, der die in dieser Anleitung gezeigten Schritte in einer einfach einsetzbaren Klasse kombiniert. Wir instanziieren eine Klasse namens `Requests`, die diese Aktionen ausführt. Zudem legen wir eine Klasse `GettingStartedApp` mit einer main-Methode an, in der wir die High-Level-Funktionsaufrufe durchführen.
Der vollständige Quellcode für dieses Beispiel kann unter eingesehen oder heruntergeladen werden [GitHub](https://github.com/aws/aws-sdk-java/tree/master/src/samples/AmazonEC2SpotInstances-Advanced).
Herzlichen Glückwunsch\$1 Sie haben jetzt die Anleitung "Erweiterte Anforderungsfunktionen" zur Entwicklung von Spot-Instance-Software mit dem AWS SDK für Java abgeschlossen.
# Amazon EC2 Instanzen verwalten
## Erstellen einer Instance
Erstellen Sie eine neue Amazon EC2 Instance, indem Sie die `runInstances` Methode des EC2 Amazon-Clients aufrufen und ihr ein [RunInstancesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RunInstancesRequest.html)zu verwendendes [Amazon Machine Image (AMI)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html) und einen [Instance-Typ](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html) zur Verfügung stellen.
**Importe**
```
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.InstanceType;
import com.amazonaws.services.ec2.model.RunInstancesRequest;
import com.amazonaws.services.ec2.model.RunInstancesResult;
import com.amazonaws.services.ec2.model.Tag;
```
**Code**
```
RunInstancesRequest run_request = new RunInstancesRequest()
.withImageId(ami_id)
.withInstanceType(InstanceType.T1Micro)
.withMaxCount(1)
.withMinCount(1);
RunInstancesResult run_response = ec2.runInstances(run_request);
String reservation_id = run_response.getReservation().getInstances().get(0).getInstanceId();
```
Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/CreateInstance.java).
## Starten einer Instance
Um eine Amazon EC2 Instance zu starten, rufen Sie die `startInstances` Methode des EC2 Amazon-Clients auf und geben ihr eine, die die ID der zu startenden Instance [StartInstancesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/StartInstancesRequest.html)enthält.
**Importe**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.StartInstancesRequest;
```
**Code**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
StartInstancesRequest request = new StartInstancesRequest()
.withInstanceIds(instance_id);
ec2.startInstances(request);
```
Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/StartStopInstance.java).
## Anhalten einer Instance
Um eine Amazon EC2 Instance zu stoppen, rufen Sie die `stopInstances` Methode des EC2 Amazon-Clients auf und geben ihr eine, die die ID der zu stoppenden Instance [StopInstancesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/StopInstancesRequest.html)enthält.
**Importe**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.StopInstancesRequest;
```
**Code**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
StopInstancesRequest request = new StopInstancesRequest()
.withInstanceIds(instance_id);
ec2.stopInstances(request);
```
Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/StartStopInstance.java).
## Neustarten einer Instance
Um eine Amazon EC2 Instance neu zu starten, rufen Sie die `rebootInstances` Methode des EC2 Amazon-Clients auf und geben ihr eine, die die ID der Instance [RebootInstancesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RebootInstancesRequest.html)enthält, die neu gestartet werden soll.
**Importe**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.RebootInstancesRequest;
import com.amazonaws.services.ec2.model.RebootInstancesResult;
```
**Code**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
RebootInstancesRequest request = new RebootInstancesRequest()
.withInstanceIds(instance_id);
RebootInstancesResult response = ec2.rebootInstances(request);
```
Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/RebootInstance.java).
## Beschreiben von Instances
Um Ihre Instances aufzulisten, erstellen Sie eine `describeInstances` Methode des EC2 Amazon-Clients [DescribeInstancesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeInstancesRequest.html)und rufen Sie sie auf. Es wird ein [DescribeInstancesResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeInstancesResult.html)Objekt zurückgegeben, mit dem Sie die Amazon EC2 Instances für Ihr Konto und Ihre Region auflisten können.
Instances werden nach *Reservierung* gruppiert. Jede Reservierung entspricht dem Aufruf von `startInstances`, durch den die Instance gestartet wurde. Um Ihre Instances aufzulisten, sollten Sie zuerst die `getReservations' method, and then call `getInstances`-Methode der `DescribeInstancesResult`-Klasse für jedes zurückgegebene [Reservation](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/Reservation.html)-Objekt aufrufen.
**Importe**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.DescribeInstancesRequest;
import com.amazonaws.services.ec2.model.DescribeInstancesResult;
import com.amazonaws.services.ec2.model.Instance;
import com.amazonaws.services.ec2.model.Reservation;
```
**Code**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
boolean done = false;
DescribeInstancesRequest request = new DescribeInstancesRequest();
while(!done) {
DescribeInstancesResult response = ec2.describeInstances(request);
for(Reservation reservation : response.getReservations()) {
for(Instance instance : reservation.getInstances()) {
System.out.printf(
"Found instance with id %s, " +
"AMI %s, " +
"type %s, " +
"state %s " +
"and monitoring state %s",
instance.getInstanceId(),
instance.getImageId(),
instance.getInstanceType(),
instance.getState().getName(),
instance.getMonitoring().getState());
}
}
request.setNextToken(response.getNextToken());
if(response.getNextToken() == null) {
done = true;
}
}
```
Die Ergebnisse werden seitenweise zurückgegeben. Sie können die weiteren Ergebnisse abrufen, indem Sie den von der `getNextToken`-Methode des Rückgabeobjekts zurückgegebenen Wert an die `setNextToken`-Methode des Original-Anforderungsobjekts übergeben. Verwenden Sie dann das gleiche Anforderungsobjekt für den nächsten Aufruf von `describeInstances`.
Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DescribeInstances.java).
## Überwachung einer Instance
Sie können verschiedene Aspekte Ihrer Amazon EC2 Instances überwachen, z. B. die CPU- und Netzwerkauslastung, den verfügbaren Arbeitsspeicher und den verbleibenden Festplattenspeicher. Weitere Informationen zur Instanzüberwachung finden Sie unter [Überwachung Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring_ec2.html) im Amazon EC2 Benutzerhandbuch für Linux-Instances.
Um mit der Überwachung einer Instance zu beginnen, müssen Sie eine [MonitorInstancesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/MonitorInstancesRequest.html)mit der ID der zu überwachenden Instance erstellen und sie an die `monitorInstances` Methode des EC2 Amazon-Clients übergeben.
**Importe**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.MonitorInstancesRequest;
```
**Code**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
MonitorInstancesRequest request = new MonitorInstancesRequest()
.withInstanceIds(instance_id);
ec2.monitorInstances(request);
```
Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/MonitorInstance.java).
## Anhalten der Instance-Überwachung
Um die Überwachung einer Instance zu beenden, erstellen Sie eine [UnmonitorInstancesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/UnmonitorInstancesRequest.html)mit der ID der Instance, deren Überwachung beendet werden soll, und übergeben Sie sie an die `unmonitorInstances` Methode des EC2 Amazon-Clients.
**Importe**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.UnmonitorInstancesRequest;
```
**Code**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
UnmonitorInstancesRequest request = new UnmonitorInstancesRequest()
.withInstanceIds(instance_id);
ec2.unmonitorInstances(request);
```
Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/MonitorInstance.java).
## Weitere Informationen
+ [RunInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html)in der Amazon EC2 API-Referenz
+ [DescribeInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeInstances.html)in der Amazon EC2 API-Referenz
+ [StartInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_StartInstances.html)in der Amazon EC2 API-Referenz
+ [StopInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_StopInstances.html)in der Amazon EC2 API-Referenz
+ [RebootInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RebootInstances.html)in der Amazon EC2 API-Referenz
+ [MonitorInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_MonitorInstances.html)in der Amazon EC2 API-Referenz
+ [UnmonitorInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_UnmonitorInstances.html)in der Amazon EC2 API-Referenz
# Verwendung von Elastic IP-Adressen in Amazon EC2
## EC2-Classic geht in den Ruhestand
**Warnung**
Wir gehen in den Ruhestand EC2 -Classic am 15. August 2022. Wir empfehlen Ihnen, von EC2 -Classic zu einer VPC zu migrieren. Weitere Informationen finden Sie im Blogbeitrag [EC2-Classic-Classic-Classic Networking is Retiring —](https://aws.amazon.com/blogs/aws/ec2-classic-is-retiring-heres-how-to-prepare/) So bereiten Sie sich vor.
## Zuweisen einer Elastic IP-Adresse
Um eine Elastic IP-Adresse zu verwenden, verknüpfen Sie sie zuerst mit Ihrem Konto und anschließend mit Ihrer Instance oder Netzwerkschnittstelle.
Um eine Elastic IP-Adresse zuzuweisen, rufen Sie die `allocateAddress` Methode des EC2 Amazon-Clients mit einem [AllocateAddressRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AllocateAddressRequest.html)Objekt auf, das den Netzwerktyp (klassisch EC2 oder VPC) enthält.
Die zurückgegebene Datei [AllocateAddressResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AllocateAddressResult.html)enthält eine Zuweisungs-ID, mit der Sie die Adresse einer Instance zuordnen können, indem Sie die Zuweisungs-ID und die Instance-ID in a [AssociateAddressRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AssociateAddressRequest.html)an die `associateAddress` Methode des EC2 Amazon-Clients übergeben.
**Importe**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.AllocateAddressRequest;
import com.amazonaws.services.ec2.model.AllocateAddressResult;
import com.amazonaws.services.ec2.model.AssociateAddressRequest;
import com.amazonaws.services.ec2.model.AssociateAddressResult;
import com.amazonaws.services.ec2.model.DomainType;
```
**Code**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
AllocateAddressRequest allocate_request = new AllocateAddressRequest()
.withDomain(DomainType.Vpc);
AllocateAddressResult allocate_response =
ec2.allocateAddress(allocate_request);
String allocation_id = allocate_response.getAllocationId();
AssociateAddressRequest associate_request =
new AssociateAddressRequest()
.withInstanceId(instance_id)
.withAllocationId(allocation_id);
AssociateAddressResult associate_response =
ec2.associateAddress(associate_request);
```
Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/AllocateAddress.java).
## Beschreiben von Elastic IP-Adressen
Um die Elastic IP-Adressen aufzulisten, die Ihrem Konto zugewiesen sind, rufen Sie die `describeAddresses` Methode des EC2 Amazon-Clients auf. Sie gibt eine zurück [DescribeAddressesResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeAddressesResult.html), mit der Sie eine Liste von [Address-Objekten](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/Address.html) abrufen können, die die Elastic IP-Adressen in Ihrem Konto repräsentieren.
**Importe**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.Address;
import com.amazonaws.services.ec2.model.DescribeAddressesResult;
```
**Code**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
DescribeAddressesResult response = ec2.describeAddresses();
for(Address address : response.getAddresses()) {
System.out.printf(
"Found address with public IP %s, " +
"domain %s, " +
"allocation id %s " +
"and NIC id %s",
address.getPublicIp(),
address.getDomain(),
address.getAllocationId(),
address.getNetworkInterfaceId());
}
```
Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DescribeAddresses.java).
## Freigeben einer Elastic IP-Adresse
Um eine Elastic IP-Adresse freizugeben, rufen Sie die `releaseAddress` Methode des EC2 Amazon-Clients auf und übergeben Sie ihr eine, die die Zuweisungs-ID der Elastic IP-Adresse [ReleaseAddressRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/ReleaseAddressRequest.html)enthält, die Sie freigeben möchten.
**Importe**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.ReleaseAddressRequest;
import com.amazonaws.services.ec2.model.ReleaseAddressResult;
```
**Code**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
ReleaseAddressRequest request = new ReleaseAddressRequest()
.withAllocationId(alloc_id);
ReleaseAddressResult response = ec2.releaseAddress(request);
```
Nachdem Sie eine Elastic IP-Adresse freigegeben haben, wird sie für den AWS IP-Adresspool freigegeben und steht Ihnen danach möglicherweise nicht mehr zur Verfügung. Achten Sie darauf, die DNS-Datensätze sowie alle Server und Geräte zu aktualisieren, die mit der Adresse kommunizieren. Wenn Sie versuchen, eine Elastic IP-Adresse freizugeben, die Sie bereits veröffentlicht haben, erhalten Sie eine *AuthFailure*Fehlermeldung, wenn die Adresse bereits einer anderen AWS-Konto zugewiesen ist.
Wenn Sie *EC2-Classic* oder eine *Standard-VPC* verwenden, wird durch die Freigabe einer Elastic IP-Adresse diese automatisch von allen Instances getrennt, mit der sie verknüpft ist. Verwenden Sie die `disassociateAddress` Methode des EC2 Amazon-Clients, um die Zuordnung einer Elastic IP-Adresse zu trennen, ohne sie freizugeben.
Wenn Sie einen Nicht-Standard-VPC verwenden, *müssen* Sie die Verknüpfung der Elastic IP-Adresse mit `disassociateAddress` aufheben, bevor Sie versuchen, sie freizugeben. Andernfalls wird ein Fehler Amazon EC2 zurückgegeben (*UngültigIPAddress). InUse*).
Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/ReleaseAddress.java).
## Weitere Informationen
+ [Elastische IP-Adressen](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) im Amazon EC2 Benutzerhandbuch für Linux-Instances
+ [AllocateAddress](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AllocateAddress.html)in der Amazon EC2 API-Referenz
+ [DescribeAddresses](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAddresses.html)in der Amazon EC2 API-Referenz
+ [ReleaseAddress](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ReleaseAddress.html)in der Amazon EC2 API-Referenz
# Regionen und Verfügbarkeitszonen verwenden
## Beschreiben von Regionen
Rufen Sie die EC2 `describeRegions` Amazon-Client-Methode auf, um die für Ihr Konto verfügbaren Regionen aufzulisten. Sie gibt [DescribeRegionsResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeRegionsResult.html) zurück. Rufen Sie die `getRegions`-Methode des zurückgegebenen Objekts auf und Sie erhalten eine Liste mit [Region](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/Region.html)-Objekten, von denen jedes für eine Region steht.
**Importe**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.DescribeRegionsResult;
import com.amazonaws.services.ec2.model.Region;
import com.amazonaws.services.ec2.model.AvailabilityZone;
import com.amazonaws.services.ec2.model.DescribeAvailabilityZonesResult;
```
**Code**
```
DescribeRegionsResult regions_response = ec2.describeRegions();
for(Region region : regions_response.getRegions()) {
System.out.printf(
"Found region %s " +
"with endpoint %s",
region.getRegionName(),
region.getEndpoint());
}
```
Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DescribeRegionsAndZones.java).
## Beschreiben von Availability Zones
Rufen Sie die EC2 `describeAvailabilityZones` Amazon-Client-Methode auf, um jede Availability Zone aufzulisten, die für Ihr Konto verfügbar sind. Sie gibt [DescribeAvailabilityZonesResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeAvailabilityZonesResult.html) zurück. Rufen Sie die `getAvailabilityZones` Methode auf, um eine Liste von [AvailabilityZone](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AvailabilityZone.html)Objekten zu erhalten, die jede Availability Zone repräsentieren.
**Importe**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.DescribeRegionsResult;
import com.amazonaws.services.ec2.model.Region;
import com.amazonaws.services.ec2.model.AvailabilityZone;
import com.amazonaws.services.ec2.model.DescribeAvailabilityZonesResult;
```
**Code**
```
DescribeAvailabilityZonesResult zones_response =
ec2.describeAvailabilityZones();
for(AvailabilityZone zone : zones_response.getAvailabilityZones()) {
System.out.printf(
"Found availability zone %s " +
"with status %s " +
"in region %s",
zone.getZoneName(),
zone.getState(),
zone.getRegionName());
}
```
Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DescribeRegionsAndZones.java).
## Beschreiben von Konten
Um Ihr Konto zu beschreiben, rufen Sie die `describeAccountAttributes` Methode des EC2 Amazon-Clients auf. Diese Methode gibt ein [DescribeAccountAttributesResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeAccountAttributesResult.html)Objekt zurück. Rufen Sie die `getAccountAttributes` Methode dieses Objekts auf, um eine Liste von [AccountAttribute](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AccountAttribute.html)Objekten zu erhalten. Sie können die Liste durchgehen, um ein [AccountAttribute](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AccountAttribute.html)Objekt abzurufen.
Sie können die Attributwerte Ihres Kontos abrufen, indem Sie die Methode des [AccountAttribute](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AccountAttribute.html)`getAttributeValues`Objekts aufrufen. Diese Methode gibt eine Liste von [AccountAttributeValue](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AccountAttributeValue.html)Objekten zurück. Sie können diese zweite Liste durchlaufen, um den Wert von Attributen anzuzeigen (siehe das folgende Codebeispiel).
**Importe**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.AccountAttributeValue;
import com.amazonaws.services.ec2.model.DescribeAccountAttributesResult;
import com.amazonaws.services.ec2.model.AccountAttribute;
import java.util.List;
import java.util.ListIterator;
```
**Code**
```
AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
try{
DescribeAccountAttributesResult accountResults = ec2.describeAccountAttributes();
List accountList = accountResults.getAccountAttributes();
for (ListIterator iter = accountList.listIterator(); iter.hasNext(); ) {
AccountAttribute attribute = (AccountAttribute) iter.next();
System.out.print("\n The name of the attribute is "+attribute.getAttributeName());
List values = attribute.getAttributeValues();
//iterate through the attribute values
for (ListIterator iterVals = values.listIterator(); iterVals.hasNext(); ) {
AccountAttributeValue myValue = (AccountAttributeValue) iterVals.next();
System.out.print("\n The value of the attribute is "+myValue.getAttributeValue());
}
}
System.out.print("Done");
}
catch (Exception e)
{
e.getStackTrace();
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DescribeAccount.java) finden Sie unter GitHub.
## Weitere Informationen
+ [Regionen und Availability Zones](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html) im Amazon EC2 Benutzerhandbuch für Linux-Instances
+ [DescribeRegions](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeRegions.html)in der Amazon EC2 API-Referenz
+ [DescribeAvailabilityZones](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAvailabilityZones.html)in der Amazon EC2 API-Referenz
# Mit Amazon EC2 Schlüsselpaaren arbeiten
## Erstellen eines Schlüsselpaars
Um ein key pair zu erstellen, rufen Sie die `createKeyPair` Methode des EC2 Amazon-Clients mit einer auf [CreateKeyPairRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateKeyPairRequest.html), die den Namen des Schlüssels enthält.
**Importe**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.CreateKeyPairRequest;
import com.amazonaws.services.ec2.model.CreateKeyPairResult;
```
**Code**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
CreateKeyPairRequest request = new CreateKeyPairRequest()
.withKeyName(key_name);
CreateKeyPairResult response = ec2.createKeyPair(request);
```
Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/CreateKeyPair.java).
## Beschreiben von Schlüsselpaaren
Rufen Sie die EC2 `describeKeyPairs` Amazon-Client-Methode auf, um Ihre Schlüsselpaare aufzulisten oder Informationen über sie zu erhalten. Sie gibt eine zurück [DescribeKeyPairsResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeKeyPairsResult.html), mit der Sie auf die Liste der Schlüsselpaare zugreifen können, indem Sie ihre `getKeyPairs` Methode aufrufen, die eine Liste von [KeyPairInfo](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/KeyPairInfo.html)Objekten zurückgibt.
**Importe**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.DescribeKeyPairsResult;
import com.amazonaws.services.ec2.model.KeyPairInfo;
```
**Code**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
DescribeKeyPairsResult response = ec2.describeKeyPairs();
for(KeyPairInfo key_pair : response.getKeyPairs()) {
System.out.printf(
"Found key pair with name %s " +
"and fingerprint %s",
key_pair.getKeyName(),
key_pair.getKeyFingerprint());
}
```
Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DescribeKeyPairs.java).
## Löschen eines Schlüsselpaars
Um ein key pair zu löschen, rufen Sie die `deleteKeyPair` Methode des EC2 Amazon-Clients auf und übergeben Sie ihr eine [DeleteKeyPairRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DeleteKeyPairRequest.html), die den Namen des zu löschenden key pair enthält.
**Importe**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.DeleteKeyPairRequest;
import com.amazonaws.services.ec2.model.DeleteKeyPairResult;
```
**Code**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
DeleteKeyPairRequest request = new DeleteKeyPairRequest()
.withKeyName(key_name);
DeleteKeyPairResult response = ec2.deleteKeyPair(request);
```
Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DeleteKeyPair.java).
## Weitere Informationen
+ [Amazon EC2 Schlüsselpaare](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) im Amazon EC2 Benutzerhandbuch für Linux-Instances
+ [CreateKeyPair](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateKeyPair.html)in der Amazon EC2 API-Referenz
+ [DescribeKeyPairs](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeKeyPairs.html)in der Amazon EC2 API-Referenz
+ [DeleteKeyPair](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeleteKeyPair.html)in der Amazon EC2 API-Referenz
# Arbeiten mit Sicherheitsgruppen in Amazon EC2
## Erstellen einer Sicherheitsgruppe
Um eine Sicherheitsgruppe zu erstellen, rufen Sie die `createSecurityGroup` Methode des EC2 Amazon-Clients mit einer auf [CreateSecurityGroupRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateSecurityGroupRequest.html), die den Namen des Schlüssels enthält.
**Importe**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.CreateSecurityGroupRequest;
import com.amazonaws.services.ec2.model.CreateSecurityGroupResult;
```
**Code**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
CreateSecurityGroupRequest create_request = new
CreateSecurityGroupRequest()
.withGroupName(group_name)
.withDescription(group_desc)
.withVpcId(vpc_id);
CreateSecurityGroupResult create_response =
ec2.createSecurityGroup(create_request);
```
Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/CreateSecurityGroup.java).
## Konfigurieren einer Sicherheitsgruppe
Eine Sicherheitsgruppe kann sowohl den eingehenden (eingehenden) als auch den ausgehenden (ausgehenden) Datenverkehr zu Ihren Instances kontrollieren. Amazon EC2
Um Ihrer Sicherheitsgruppe Eingangsregeln hinzuzufügen, verwenden Sie die `authorizeSecurityGroupIngress` Methode des EC2 Amazon-Clients und geben Sie den Namen der Sicherheitsgruppe und die Zugriffsregeln ([IpPermission](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/IpPermission.html)) an, die Sie ihr innerhalb eines [AuthorizeSecurityGroupIngressRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AuthorizeSecurityGroupIngressRequest.html)Objekts zuweisen möchten. Im folgenden Beispiel wird gezeigt, wie Sie einer Sicherheitsgruppe IP-Berechtigungen hinzufügen.
**Importe**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.CreateSecurityGroupRequest;
import com.amazonaws.services.ec2.model.CreateSecurityGroupResult;
```
**Code**
```
IpRange ip_range = new IpRange()
.withCidrIp("0.0.0.0/0");
IpPermission ip_perm = new IpPermission()
.withIpProtocol("tcp")
.withToPort(80)
.withFromPort(80)
.withIpv4Ranges(ip_range);
IpPermission ip_perm2 = new IpPermission()
.withIpProtocol("tcp")
.withToPort(22)
.withFromPort(22)
.withIpv4Ranges(ip_range);
AuthorizeSecurityGroupIngressRequest auth_request = new
AuthorizeSecurityGroupIngressRequest()
.withGroupName(group_name)
.withIpPermissions(ip_perm, ip_perm2);
AuthorizeSecurityGroupIngressResult auth_response =
ec2.authorizeSecurityGroupIngress(auth_request);
```
Um der Sicherheitsgruppe eine Ausgangsregel hinzuzufügen, geben Sie ähnliche Daten in einer der `authorizeSecurityGroupEgress` Methoden des EC2 Amazon-Clients [AuthorizeSecurityGroupEgressRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AuthorizeSecurityGroupEgressRequest.html)an.
Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/CreateSecurityGroup.java).
## Beschreiben von Sicherheitsgruppen
Rufen Sie die `describeSecurityGroups` Methode des EC2 Amazon-Clients auf, um Ihre Sicherheitsgruppen zu beschreiben oder Informationen über sie zu erhalten. Sie gibt eine zurück [DescribeSecurityGroupsResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeSecurityGroupsResult.html), mit der Sie auf die Liste der Sicherheitsgruppen zugreifen können, indem Sie ihre `getSecurityGroups` Methode aufrufen, die eine Liste von [SecurityGroup](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/ec2/model/SecurityGroup.html)Objekten zurückgibt.
**Importe**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.DescribeSecurityGroupsRequest;
import com.amazonaws.services.ec2.model.DescribeSecurityGroupsResult;
```
**Code**
```
final String USAGE =
"To run this example, supply a group id\n" +
"Ex: DescribeSecurityGroups \n";
if (args.length != 1) {
System.out.println(USAGE);
System.exit(1);
}
String group_id = args[0];
```
Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DescribeSecurityGroups.java).
## Löschen einer Sicherheitsgruppe
Um eine Sicherheitsgruppe zu löschen, rufen Sie die `deleteSecurityGroup` Methode des EC2 Amazon-Clients auf und übergeben Sie ihr eine [DeleteSecurityGroupRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DeleteSecurityGroupRequest.html), die die ID der zu löschenden Sicherheitsgruppe enthält.
**Importe**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.DeleteSecurityGroupRequest;
import com.amazonaws.services.ec2.model.DeleteSecurityGroupResult;
```
**Code**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
DeleteSecurityGroupRequest request = new DeleteSecurityGroupRequest()
.withGroupId(group_id);
DeleteSecurityGroupResult response = ec2.deleteSecurityGroup(request);
```
Siehe [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DeleteSecurityGroup.java).
## Weitere Informationen
+ [Amazon EC2 Sicherheitsgruppen](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) im Amazon EC2 Benutzerhandbuch für Linux-Instances
+ [Autorisieren von eingehendem Traffic für Ihre Linux-Instances](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/authorizing-access-to-an-instance.html) im Amazon EC2 Benutzerhandbuch für Linux-Instances
+ [CreateSecurityGroup](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateSecurityGroup.html)in der API-Referenz Amazon EC2
+ [DescribeSecurityGroups](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeSecurityGroups.html)in der Amazon EC2 API-Referenz
+ [DeleteSecurityGroup](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeleteSecurityGroup.html)in der Amazon EC2 API-Referenz
+ [AuthorizeSecurityGroupIngress](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AuthorizeSecurityGroupIngress.html)in der Amazon EC2 API-Referenz
# IAM-Beispiele mit dem AWS SDK für Java
Dieser Abschnitt enthält Beispiele für die Programmierung von [IAM](https://aws.amazon.com/iam/) mit dem [AWS SDK für Java](https://aws.amazon.com/sdk-for-java/).
AWS Identity and Access Management (IAM) ermöglicht es Ihnen, den Zugriff Ihrer Benutzer auf AWS Dienste und Ressourcen sicher zu kontrollieren. Mit IAM können Sie AWS Benutzer und Gruppen erstellen und verwalten und ihnen mithilfe von Berechtigungen den Zugriff auf Ressourcen gewähren oder verweigern. AWS Eine vollständige Anleitung zu IAM finden Sie im [IAM Benutzerhandbuch](https://docs.aws.amazon.com/IAM/latest/UserGuide/).
**Anmerkung**
Die Beispiele enthalten nur den Code, der zur Demonstration jeder Technik nötig ist. Der [vollständige Beispielcode ist verfügbar unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/java). Von dort aus können Sie eine einzelne Quelldatei herunterladen oder das Repository klonen, um alle Beispiele lokal zu erstellen und auszuführen.
**Topics**
+ [Verwalten von IAM-Zugriffsschlüsseln](examples-iam-access-keys.md)
+ [Verwalten von IAM-Benutzern](examples-iam-users.md)
+ [Verwenden von IAM-Konto-Aliasen](examples-iam-account-aliases.md)
+ [Arbeiten mit IAM-Richtlinien](examples-iam-policies.md)
+ [Arbeiten mit IAM-Serverzertifikaten](examples-iam-server-certificates.md)
# Verwalten von IAM-Zugriffsschlüsseln
## Erstellen eines Zugriffsschlüssels
Um einen IAM-Zugriffsschlüssel zu erstellen, rufen Sie die AmazonIdentityManagementClient `createAccessKey` Methode mit einem [CreateAccessKeyRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/CreateAccessKeyRequest.html)Objekt auf.
`CreateAccessKeyRequest`hat zwei Konstruktoren — einen für einen Benutzernamen und einen ohne Parameter. Wenn Sie die Version nutzen, die keine Parameter entgegen nimmt, müssen Sie den Benutzernamen mithilfe der `withUserName`-Setter-Methode festlegen, bevor Sie das Element an die `createAccessKey`-Methode übergeben.
**Importe**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.CreateAccessKeyRequest;
import com.amazonaws.services.identitymanagement.model.CreateAccessKeyResult;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
CreateAccessKeyRequest request = new CreateAccessKeyRequest()
.withUserName(user);
CreateAccessKeyResult response = iam.createAccessKey(request);
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/CreateAccessKey.java) finden Sie unter. GitHub
## Auflisten von Zugriffsschlüsseln
Um die Zugriffsschlüssel für einen bestimmten Benutzer aufzulisten, erstellen Sie ein [ListAccessKeysRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/ListAccessKeysRequest.html)Objekt, das den Benutzernamen enthält, für den die Schlüssel aufgelistet werden sollen, und übergeben Sie ihn an die AmazonIdentityManagementClient `listAccessKeys` Methode.
**Anmerkung**
Wenn Sie keinen Benutzernamen angeben, wird versucht`listAccessKeys`, die Zugriffsschlüssel aufzulisten, die dem Benutzer zugeordnet sind AWS-Konto , der die Anfrage signiert hat.
**Importe**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.AccessKeyMetadata;
import com.amazonaws.services.identitymanagement.model.ListAccessKeysRequest;
import com.amazonaws.services.identitymanagement.model.ListAccessKeysResult;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
boolean done = false;
ListAccessKeysRequest request = new ListAccessKeysRequest()
.withUserName(username);
while (!done) {
ListAccessKeysResult response = iam.listAccessKeys(request);
for (AccessKeyMetadata metadata :
response.getAccessKeyMetadata()) {
System.out.format("Retrieved access key %s",
metadata.getAccessKeyId());
}
request.setMarker(response.getMarker());
if (!response.getIsTruncated()) {
done = true;
}
}
```
Die Ergebnisse von `listAccessKeys` sind seitenweise angeordnet (mit einem Standardhöchstwert von 100 Datensätzen pro Aufruf). Sie können das zurückgegebene [ListAccessKeysResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/ListAccessKeysResult.html)Objekt aufrufen`getIsTruncated`, um zu überprüfen, ob die Abfrage weniger Ergebnisse geliefert hat, als verfügbar sind. Falls ja, rufen Sie `setMarker` für den `ListAccessKeysRequest` auf und übergeben Sie ihn beim nächsten Aufruf von `listAccessKeys`.
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/ListAccessKeys.java) finden Sie unter GitHub.
## Abrufen der letzten Nutzungszeit eines Zugriffsschlüssels
Um die Uhrzeit zu ermitteln, zu der ein Zugriffsschlüssel zuletzt verwendet wurde, rufen Sie die AmazonIdentityManagementClient `getAccessKeyLastUsed` 's-Methode mit der ID des Zugriffsschlüssels auf (die mithilfe eines [GetAccessKeyLastUsedRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/GetAccessKeyLastUsedRequest.html)Objekts übergeben werden kann), oder direkt an die Overload, die die Zugriffsschlüssel-ID direkt übernimmt.
Sie können dann das zurückgegebene [GetAccessKeyLastUsedResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/GetAccessKeyLastUsedResult.html)Objekt verwenden, um die Uhrzeit der letzten Verwendung des Schlüssels abzurufen.
**Importe**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.GetAccessKeyLastUsedRequest;
import com.amazonaws.services.identitymanagement.model.GetAccessKeyLastUsedResult;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
GetAccessKeyLastUsedRequest request = new GetAccessKeyLastUsedRequest()
.withAccessKeyId(access_id);
GetAccessKeyLastUsedResult response = iam.getAccessKeyLastUsed(request);
System.out.println("Access key was last used at: " +
response.getAccessKeyLastUsed().getLastUsedDate());
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/AccessKeyLastUsed.java) finden Sie unter GitHub.
## Aktivieren oder Deaktivieren von Zugriffsschlüsseln
Sie können einen Zugriffsschlüssel aktivieren oder deaktivieren, indem Sie ein [UpdateAccessKeyRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/UpdateAccessKeyRequest.html)Objekt erstellen, die Zugriffsschlüssel-ID, optional den Benutzernamen und den gewünschten [Status](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/StatusType.html) angeben und dann das Anforderungsobjekt an die AmazonIdentityManagementClient `updateAccessKey` -Methode übergeben.
**Importe**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.UpdateAccessKeyRequest;
import com.amazonaws.services.identitymanagement.model.UpdateAccessKeyResult;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
UpdateAccessKeyRequest request = new UpdateAccessKeyRequest()
.withAccessKeyId(access_id)
.withUserName(username)
.withStatus(status);
UpdateAccessKeyResult response = iam.updateAccessKey(request);
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/UpdateAccessKey.java) finden Sie unter GitHub.
## Löschen eines Zugriffsschlüssels
Um einen Zugriffsschlüssel dauerhaft zu löschen, rufen Sie die `deleteKey` Methode AmazonIdentityManagementClient 'auf und geben ihr eine, die die ID und den Benutzernamen des Zugriffsschlüssels [DeleteAccessKeyRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/DeleteAccessKeyRequest.html)enthält.
**Anmerkung**
Nach dem Löschen können Schlüssel nicht mehr abgerufen oder verwendet werden. Um einen Schlüssel vorübergehend zu deaktivieren, sodass er später wieder aktiviert werden kann, verwenden Sie stattdessen [updateAccessKey](#iam-access-keys-update)method.
**Importe**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.DeleteAccessKeyRequest;
import com.amazonaws.services.identitymanagement.model.DeleteAccessKeyResult;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
DeleteAccessKeyRequest request = new DeleteAccessKeyRequest()
.withAccessKeyId(access_key)
.withUserName(username);
DeleteAccessKeyResult response = iam.deleteAccessKey(request);
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/DeleteAccessKey.java) finden Sie unter GitHub.
## Weitere Informationen
+ [CreateAccessKey](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateAccessKey.html)in der IAM-API-Referenz
+ [ListAccessKeys](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListAccessKeys.html)in der IAM-API-Referenz
+ [GetAccessKeyLastUsed](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetAccessKeyLastUsed.html)in der IAM-API-Referenz
+ [UpdateAccessKey](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateAccessKey.html)in der IAM-API-Referenz
+ [DeleteAccessKey](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteAccessKey.html)in der IAM-API-Referenz
# Verwalten von IAM-Benutzern
## Erstellen eines Benutzers
Erstellen Sie einen neuen IAM-Benutzer, indem Sie den Benutzernamen für die `createUser` Methode AmazonIdentityManagementClient angeben, entweder direkt oder mithilfe eines [CreateUserRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/CreateUserRequest.html)Objekts, das den Benutzernamen enthält.
**Importe**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.CreateUserRequest;
import com.amazonaws.services.identitymanagement.model.CreateUserResult;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
CreateUserRequest request = new CreateUserRequest()
.withUserName(username);
CreateUserResult response = iam.createUser(request);
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/CreateUser.java) finden Sie unter. GitHub
## Auflisten von Benutzern
Um die IAM-Benutzer für Ihr Konto aufzulisten, erstellen Sie ein neues [ListUsersRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/ListUsersRequest.html)und übergeben Sie es an die AmazonIdentityManagementClient `listUsers` Methode. Sie können die Benutzerliste abrufen, indem Sie das zurückgegebene [ListUsersResult](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/identitymanagement/model/ListUsersResult.html)Objekt aufrufen`getUsers`.
Die von `listUsers` zurückgegebene Benutzerliste ist segmentiert. Sie können prüfen, ob weitere Ergebnisse bereitliegen, indem Sie die `getIsTruncated`-Methode des Antwortobjekts aufrufen. Gibt sie `true` zurück, rufen Sie die `setMarker()`-Methode des Anfrageobjekts auf und übergeben ihr den Rückgabewert der `getMarker()`-Methode des Antwortobjekts.
**Importe**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.ListUsersRequest;
import com.amazonaws.services.identitymanagement.model.ListUsersResult;
import com.amazonaws.services.identitymanagement.model.User;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
boolean done = false;
ListUsersRequest request = new ListUsersRequest();
while(!done) {
ListUsersResult response = iam.listUsers(request);
for(User user : response.getUsers()) {
System.out.format("Retrieved user %s", user.getUserName());
}
request.setMarker(response.getMarker());
if(!response.getIsTruncated()) {
done = true;
}
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/ListUsers.java) finden Sie unter GitHub.
## Aktualisieren eines Benutzers
Um einen Benutzer zu aktualisieren, rufen Sie die `updateUser` Methode des AmazonIdentityManagementClient Objekts auf, die ein [UpdateUserRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/UpdateUserRequest.html)Objekt verwendet, mit dem Sie den *Namen* oder *Pfad* des Benutzers ändern können.
**Importe**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.UpdateUserRequest;
import com.amazonaws.services.identitymanagement.model.UpdateUserResult;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
UpdateUserRequest request = new UpdateUserRequest()
.withUserName(cur_name)
.withNewUserName(new_name);
UpdateUserResult response = iam.updateUser(request);
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/UpdateUser.java) finden Sie unter GitHub.
## Löschen eines Benutzers
Um einen Benutzer zu löschen, rufen Sie die AmazonIdentityManagementClient `deleteUser` Anfrage mit einem [UpdateUserRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/UpdateUserRequest.html)Objektsatz mit dem zu löschenden Benutzernamen auf.
**Importe**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.DeleteConflictException;
import com.amazonaws.services.identitymanagement.model.DeleteUserRequest;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
DeleteUserRequest request = new DeleteUserRequest()
.withUserName(username);
try {
iam.deleteUser(request);
} catch (DeleteConflictException e) {
System.out.println("Unable to delete user. Verify user is not" +
" associated with any resources");
throw e;
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/DeleteUser.java) finden Sie unter GitHub.
## Weitere Informationen
+ [IAM-Benutzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html) im IAM Benutzerhandbuch
+ [Verwaltung von IAM-Benutzern](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_manage.html) im Benutzerhandbuch IAM
+ [CreateUser](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateUser.html)in der IAM-API-Referenz
+ [ListUsers](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListUsers.html)in der IAM-API-Referenz
+ [UpdateUser](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateUser.html)in der IAM-API-Referenz
+ [DeleteUser](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteUser.html)in der IAM-API-Referenz
# Verwenden von IAM-Konto-Aliasen
Wenn Sie möchten, dass die URL für Ihre Anmeldeseite Ihren Firmennamen oder eine andere benutzerfreundliche Kennung anstelle Ihrer AWS-Konto ID enthält, können Sie einen Alias für Ihre AWS-Konto.
**Anmerkung**
AWS unterstützt genau einen Kontoalias pro Konto.
## Erstellen eines Konto-Alias
Um einen Kontoalias zu erstellen, rufen Sie die `createAccountAlias` Methode AmazonIdentityManagementClient's mit einem [CreateAccountAliasRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/CreateAccountAliasRequest.html)Objekt auf, das den Aliasnamen enthält.
**Importe**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.CreateAccountAliasRequest;
import com.amazonaws.services.identitymanagement.model.CreateAccountAliasResult;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
CreateAccountAliasRequest request = new CreateAccountAliasRequest()
.withAccountAlias(alias);
CreateAccountAliasResult response = iam.createAccountAlias(request);
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/CreateAccountAlias.java) finden Sie unter GitHub.
## Auflisten von Konto-Aliassen
Rufen Sie die `listAccountAliases` Methode s auf, um den AmazonIdentityManagementClient Alias Ihres Kontos aufzulisten, falls vorhanden.
**Anmerkung**
Die zurückgegebene Methode [ListAccountAliasesResult](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/identitymanagement/model/ListAccountAliasesResult.html)unterstützt dieselben `getMarker` Methoden `getIsTruncated` und wie andere AWS SDK für Java *Listenmethoden*, AWS-Konto kann jedoch nur *einen* Kontoalias haben.
**Importe**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.ListAccountAliasesResult;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
ListAccountAliasesResult response = iam.listAccountAliases();
for (String alias : response.getAccountAliases()) {
System.out.printf("Retrieved account alias %s", alias);
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/ListAccountAliases.java) finden Sie unter GitHub.
## Löschen eines Konto-Alias
Um den Alias Ihres Kontos zu löschen, rufen Sie AmazonIdentityManagementClient die `deleteAccountAlias` Methode auf. Wenn Sie einen Kontoalias löschen, müssen Sie seinen Namen mithilfe eines [DeleteAccountAliasRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/DeleteAccountAliasRequest.html)Objekts angeben.
**Importe**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.DeleteAccountAliasRequest;
import com.amazonaws.services.identitymanagement.model.DeleteAccountAliasResult;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
DeleteAccountAliasRequest request = new DeleteAccountAliasRequest()
.withAccountAlias(alias);
DeleteAccountAliasResult response = iam.deleteAccountAlias(request);
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/DeleteAccountAlias.java) finden Sie unter GitHub.
## Weitere Informationen
+ [Ihre AWS Konto-ID und ihr Alias](https://docs.aws.amazon.com/IAM/latest/UserGuide/console_account-alias.html) finden Sie im IAM Benutzerhandbuch
+ [CreateAccountAlias](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateAccountAlias.html)in der IAM-API-Referenz
+ [ListAccountAliases](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListAccountAliases.html)in der IAM-API-Referenz
+ [DeleteAccountAlias](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteAccountAlias.html)in der IAM-API-Referenz
# Arbeiten mit IAM-Richtlinien
## Erstellen einer Richtlinie
Um eine neue Richtlinie zu erstellen, geben Sie den Namen der Richtlinie und ein Richtliniendokument im JSON-Format in einer Methode [CreatePolicyRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/CreatePolicyRequest.html)an AmazonIdentityManagementClient. `createPolicy`
**Importe**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.CreatePolicyRequest;
import com.amazonaws.services.identitymanagement.model.CreatePolicyResult;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
CreatePolicyRequest request = new CreatePolicyRequest()
.withPolicyName(policy_name)
.withPolicyDocument(POLICY_DOCUMENT);
CreatePolicyResult response = iam.createPolicy(request);
```
[IAM-Richtliniendokumente sind JSON-Zeichenfolgen mit einer gut dokumentierten Syntax.](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_grammar.html) Hier finden Sie ein Beispiel, das den Zugriff für bestimmte Anfragen an DynamoDB gewährt.
```
public static final String POLICY_DOCUMENT =
"{" +
" \"Version\": \"2012-10-17\", " +
" \"Statement\": [" +
" {" +
" \"Effect\": \"Allow\"," +
" \"Action\": \"logs:CreateLogGroup\"," +
" \"Resource\": \"%s\"" +
" }," +
" {" +
" \"Effect\": \"Allow\"," +
" \"Action\": [" +
" \"dynamodb:DeleteItem\"," +
" \"dynamodb:GetItem\"," +
" \"dynamodb:PutItem\"," +
" \"dynamodb:Scan\"," +
" \"dynamodb:UpdateItem\"" +
" ]," +
" \"Resource\": \"RESOURCE_ARN\"" +
" }" +
" ]" +
"}";
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/CreatePolicy.java) finden Sie unter. GitHub
## Abrufen einer Richtlinie
Um eine bestehende Richtlinie abzurufen, rufen Sie die AmazonIdentityManagementClient `getPolicy` Methode auf und geben den ARN der Richtlinie in einem [GetPolicyRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/GetPolicyRequest.html)Objekt an.
**Importe**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.GetPolicyRequest;
import com.amazonaws.services.identitymanagement.model.GetPolicyResult;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
GetPolicyRequest request = new GetPolicyRequest()
.withPolicyArn(policy_arn);
GetPolicyResult response = iam.getPolicy(request);
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/GetPolicy.java) finden Sie unter GitHub.
## Anfügen einer Rollenrichtlinie
Sie können eine Richtlinie an IAMhttp: //docs.aws.amazon anhängen. com/IAM/latest/UserGuide/id\$1roles.html [role], indem Sie die `attachRolePolicy` Methode AmazonIdentityManagementClient's aufrufen und ihr den Rollennamen und den Richtlinien-ARN in einem zur Verfügung stellen [AttachRolePolicyRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/AttachRolePolicyRequest.html).
**Importe**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.AttachRolePolicyRequest;
import com.amazonaws.services.identitymanagement.model.AttachedPolicy;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
AttachRolePolicyRequest attach_request =
new AttachRolePolicyRequest()
.withRoleName(role_name)
.withPolicyArn(POLICY_ARN);
iam.attachRolePolicy(attach_request);
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/AttachRolePolicy.java) finden Sie unter GitHub.
## Auflisten angefügter Rollenrichtlinien
Listet die angehängten Richtlinien für eine Rolle auf, indem Sie die `listAttachedRolePolicies` Methode AmazonIdentityManagementClient's aufrufen. Es wird ein [ListAttachedRolePoliciesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/ListAttachedRolePoliciesRequest.html)Objekt benötigt, das den Rollennamen enthält, um die Richtlinien aufzulisten.
Rufen Sie das zurückgegebene [ListAttachedRolePoliciesResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/ListAttachedRolePoliciesResult.html)Objekt `getAttachedPolicies` auf, um die Liste der angehängten Richtlinien abzurufen. Die Ergebnisse sind evtl. gekürzt. Gibt die `ListAttachedRolePoliciesResult`-Methode des `getIsTruncated`-Objekts `true` zurück, rufen Sie die `ListAttachedRolePoliciesRequest`-Methode des `setMarker`-Objekts auf. Verwenden Sie das Ergebnis dann in einem weiteren Aufruf von `listAttachedRolePolicies`, um das nächste Teilergebnis abzurufen.
**Importe**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.ListAttachedRolePoliciesRequest;
import com.amazonaws.services.identitymanagement.model.ListAttachedRolePoliciesResult;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
ListAttachedRolePoliciesRequest request =
new ListAttachedRolePoliciesRequest()
.withRoleName(role_name);
List matching_policies = new ArrayList<>();
boolean done = false;
while(!done) {
ListAttachedRolePoliciesResult response =
iam.listAttachedRolePolicies(request);
matching_policies.addAll(
response.getAttachedPolicies()
.stream()
.filter(p -> p.getPolicyName().equals(role_name))
.collect(Collectors.toList()));
if(!response.getIsTruncated()) {
done = true;
}
request.setMarker(response.getMarker());
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/AttachRolePolicy.java) finden Sie unter GitHub.
## Trennen einer Rollenrichtlinie
Um eine Richtlinie von einer Rolle zu trennen, rufen Sie die `detachRolePolicy` Methode AmazonIdentityManagementClient's auf und geben Sie ihr den Rollennamen und den Richtlinien-ARN in a [DetachRolePolicyRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/DetachRolePolicyRequest.html)an.
**Importe**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.DetachRolePolicyRequest;
import com.amazonaws.services.identitymanagement.model.DetachRolePolicyResult;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
DetachRolePolicyRequest request = new DetachRolePolicyRequest()
.withRoleName(role_name)
.withPolicyArn(policy_arn);
DetachRolePolicyResult response = iam.detachRolePolicy(request);
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/DetachRolePolicy.java) finden Sie unter. GitHub
## Weitere Informationen
+ [Überblick über die IAM-Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html) im IAM Benutzerhandbuch.
+ [AWS Referenz zu den IAM-Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies.html) im IAM Benutzerhandbuch.
+ [CreatePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreatePolicy.html)in der IAM-API-Referenz
+ [GetPolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetPolicy.html)in der IAM-API-Referenz
+ [AttachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachRolePolicy.html)in der IAM-API-Referenz
+ [ListAttachedRolePolicies](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListAttachedRolePolicies.html)in der IAM-API-Referenz
+ [DetachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DetachRolePolicy.html)in der IAM-API-Referenz
# Arbeiten mit IAM-Serverzertifikaten
Um HTTPS-Verbindungen zu Ihrer Website oder Anwendung zu aktivieren AWS, benötigen Sie ein *SSL/TLS-Serverzertifikat*. Sie können ein Serverzertifikat verwenden, das von AWS Certificate Manager bereitgestellt wird, oder eines, das Sie von einem externen Anbieter bezogen haben.
Wir empfehlen, dass Sie ACM für die Bereitstellung, Verwaltung und Bereitstellung Ihrer Serverzertifikate verwenden. Mit ACM können Sie ein Zertifikat anfordern, es für Ihre AWS Ressourcen bereitstellen und ACM die Zertifikatserneuerung für Sie durchführen lassen. Zertifikate von ACM sind kostenlos. [Weitere Informationen zu ACM finden Sie im ACM-Benutzerhandbuch.](https://docs.aws.amazon.com/acm/latest/userguide/)
## Abrufen eines Serverzertifikats
Sie können ein Serverzertifikat abrufen, indem Sie die `getServerCertificate` Methode AmazonIdentityManagementClient 'aufrufen und ihr eine [GetServerCertificateRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/GetServerCertificateRequest.html)mit dem Namen des Zertifikats übergeben.
**Importe**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.GetServerCertificateRequest;
import com.amazonaws.services.identitymanagement.model.GetServerCertificateResult;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
GetServerCertificateRequest request = new GetServerCertificateRequest()
.withServerCertificateName(cert_name);
GetServerCertificateResult response = iam.getServerCertificate(request);
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/GetServerCertificate.java) finden Sie unter GitHub.
## Auflisten von Serverzertifikaten
Um Ihre Serverzertifikate aufzulisten, rufen Sie die `listServerCertificates` Methode AmazonIdentityManagementClient's mit einem auf [ListServerCertificatesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/ListServerCertificatesRequest.html). Sie gibt [ListServerCertificatesResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/ListServerCertificatesResult.html) zurück.
Rufen Sie die `getServerCertificateMetadataList` Methode des zurückgegebenen `ListServerCertificateResult` Objekts auf, um eine Liste von [ServerCertificateMetadata](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/ServerCertificateMetadata.html)Objekten abzurufen, mit denen Sie Informationen zu den einzelnen Zertifikaten abrufen können.
Die Ergebnisse sind evtl. gekürzt. Gibt die `ListServerCertificateResult`-Methode des `getIsTruncated`-Objekts `true` zurück, rufen Sie die `ListServerCertificatesRequest`-Methode des `setMarker`-Objekts auf. Verwenden Sie das Ergebnis dann in einem weiteren Aufruf von `listServerCertificates`, um das nächste Teilergebnis abzurufen.
**Importe**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.ListServerCertificatesRequest;
import com.amazonaws.services.identitymanagement.model.ListServerCertificatesResult;
import com.amazonaws.services.identitymanagement.model.ServerCertificateMetadata;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
boolean done = false;
ListServerCertificatesRequest request =
new ListServerCertificatesRequest();
while(!done) {
ListServerCertificatesResult response =
iam.listServerCertificates(request);
for(ServerCertificateMetadata metadata :
response.getServerCertificateMetadataList()) {
System.out.printf("Retrieved server certificate %s",
metadata.getServerCertificateName());
}
request.setMarker(response.getMarker());
if(!response.getIsTruncated()) {
done = true;
}
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/ListServerCertificates.java) finden Sie unter GitHub.
## Aktualisieren eines Serverzertifikats
Sie können den Namen oder Pfad eines Serverzertifikats aktualisieren, indem Sie die `updateServerCertificate` Methode AmazonIdentityManagementClient's aufrufen. Sie benötigt eine [UpdateServerCertificateRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/UpdateServerCertificateRequest.html)Objektgruppe mit dem aktuellen Namen des Serverzertifikats und entweder einem neuen Namen oder einem neuen Pfad zur Verwendung.
**Importe**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.UpdateServerCertificateRequest;
import com.amazonaws.services.identitymanagement.model.UpdateServerCertificateResult;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
UpdateServerCertificateRequest request =
new UpdateServerCertificateRequest()
.withServerCertificateName(cur_name)
.withNewServerCertificateName(new_name);
UpdateServerCertificateResult response =
iam.updateServerCertificate(request);
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/UpdateServerCertificate.java) finden Sie unter GitHub.
## Löschen eines Serverzertifikats
Um ein Serverzertifikat zu löschen, rufen Sie die `deleteServerCertificate` Methode AmazonIdentityManagementClient 'mit einem auf, das den Namen des Zertifikats [DeleteServerCertificateRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/DeleteServerCertificateRequest.html)enthält.
**Importe**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.DeleteServerCertificateRequest;
import com.amazonaws.services.identitymanagement.model.DeleteServerCertificateResult;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
DeleteServerCertificateRequest request =
new DeleteServerCertificateRequest()
.withServerCertificateName(cert_name);
DeleteServerCertificateResult response =
iam.deleteServerCertificate(request);
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/DeleteServerCertificate.java) finden Sie unter GitHub.
## Weitere Informationen
+ [Arbeiten mit Serverzertifikaten](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_server-certs.html) im IAM Benutzerhandbuch
+ [GetServerCertificate](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetServerCertificate.html)in der IAM-API-Referenz
+ [ListServerCertificates](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListServerCertificates.html)in der IAM-API-Referenz
+ [UpdateServerCertificate](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateServerCertificate.html)in der IAM-API-Referenz
+ [DeleteServerCertificate](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteServerCertificate.html)in der IAM-API-Referenz
+ [ACM-Benutzerhandbuch](https://docs.aws.amazon.com/acm/latest/userguide/)
# Lambda Beispiele für die Verwendung der AWS SDK für Java
Dieser Abschnitt enthält Beispiele für die Programmierung Lambda mit dem AWS SDK für Java.
**Anmerkung**
Die Beispiele enthalten nur den Code, der zur Demonstration jeder Technik nötig ist. Der [vollständige Beispielcode ist verfügbar unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/java). Von dort aus können Sie eine einzelne Quelldatei herunterladen oder das Repository klonen, um alle Beispiele lokal zu erstellen und auszuführen.
**Topics**
+ [Serviceoperationen](examples-lambda.md)
# Funktionen aufrufen, auflisten und löschen Lambda
Dieser Abschnitt enthält Beispiele für die Programmierung mit dem Lambda Service-Client unter Verwendung von. AWS SDK für Java Informationen zum Erstellen einer Lambda Funktion finden Sie unter [So erstellen Sie AWS Lambda Funktionen](https://docs.aws.amazon.com/toolkit-for-eclipse/v1/user-guide/lambda-tutorial.html).
**Topics**
+ [Aufruf einer -Funktion](#invoke-function)
+ [Listenfunktionen](#list-function)
+ [Löschen einer -Funktion](#delete-function)
## Aufruf einer -Funktion
Sie können eine Lambda Funktion aufrufen, indem Sie ein [AWSLambda](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/AWSLambda.html)Objekt erstellen und dessen `invoke` Methode aufrufen. Erstellen Sie ein [InvokeRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/model/InvokeRequest.html)Objekt, um zusätzliche Informationen wie den Funktionsnamen und die Nutzlast anzugeben, die an die Funktion übergeben werden sollen. Lambda Funktionsnamen werden als *arn:aws:lambda:us-east* - 1:555556330391:function: angezeigt. HelloFunction Sie können den Wert abrufen, indem Sie sich die Funktion in der ansehen. AWS-Managementkonsole
Um Nutzdaten an eine Funktion zu übergeben, rufen Sie die `withPayload` Methode des [InvokeRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/model/InvokeRequest.html)Objekts auf und geben Sie eine Zeichenfolge im JSON-Format an, wie im folgenden Codebeispiel gezeigt.
**Importe**
```
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.lambda.AWSLambda;
import com.amazonaws.services.lambda.AWSLambdaClientBuilder;
import com.amazonaws.services.lambda.model.InvokeRequest;
import com.amazonaws.services.lambda.model.InvokeResult;
import com.amazonaws.services.lambda.model.ServiceException;
import java.nio.charset.StandardCharsets;
```
**Code**
Das folgende Codebeispiel zeigt, wie eine Funktion aufgerufen wird. Lambda
```
String functionName = args[0];
InvokeRequest invokeRequest = new InvokeRequest()
.withFunctionName(functionName)
.withPayload("{\n" +
" \"Hello \": \"Paris\",\n" +
" \"countryCode\": \"FR\"\n" +
"}");
InvokeResult invokeResult = null;
try {
AWSLambda awsLambda = AWSLambdaClientBuilder.standard()
.withCredentials(new ProfileCredentialsProvider())
.withRegion(Regions.US_WEST_2).build();
invokeResult = awsLambda.invoke(invokeRequest);
String ans = new String(invokeResult.getPayload().array(), StandardCharsets.UTF_8);
//write out the return value
System.out.println(ans);
} catch (ServiceException e) {
System.out.println(e);
}
System.out.println(invokeResult.getStatusCode());
```
Auf GitHub finden Sie ein [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/lambda/src/main/java/com/example/lambda/LambdaInvokeFunction.java).
## Listenfunktionen
Erstellen Sie ein [AWSLambda](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/AWSLambda.html)Objekt und rufen Sie seine `listFunctions` Methode auf. Diese Methode gibt ein [ListFunctionsResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/model/ListFunctionsResult.html)Objekt zurück. Sie können die `getFunctions` Methode dieses Objekts aufrufen, um eine Liste von [FunctionConfiguration](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/model/FunctionConfiguration.html)Objekten zurückzugeben. Sie können die Liste durchlaufen, um Informationen über die Funktionen abzurufen. Das folgende Java-Codebeispiel zeigt beispielsweise, wie die einzelnen Funktionsnamen abgerufen werden.
**Importe**
```
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.lambda.AWSLambda;
import com.amazonaws.services.lambda.AWSLambdaClientBuilder;
import com.amazonaws.services.lambda.model.FunctionConfiguration;
import com.amazonaws.services.lambda.model.ListFunctionsResult;
import com.amazonaws.services.lambda.model.ServiceException;
import java.util.Iterator;
import java.util.List;
```
**Code**
Das folgende Java-Codebeispiel zeigt, wie eine Liste von Lambda Funktionsnamen abgerufen wird.
```
ListFunctionsResult functionResult = null;
try {
AWSLambda awsLambda = AWSLambdaClientBuilder.standard()
.withCredentials(new ProfileCredentialsProvider())
.withRegion(Regions.US_WEST_2).build();
functionResult = awsLambda.listFunctions();
List list = functionResult.getFunctions();
for (Iterator iter = list.iterator(); iter.hasNext(); ) {
FunctionConfiguration config = (FunctionConfiguration)iter.next();
System.out.println("The function name is "+config.getFunctionName());
}
} catch (ServiceException e) {
System.out.println(e);
}
```
Auf GitHub finden Sie ein [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/lambda/src/main/java/com/example/lambda/ListFunctions.java).
## Löschen einer -Funktion
Erstellen Sie ein [AWSLambda](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/AWSLambda.html)Objekt und rufen Sie seine `deleteFunction` Methode auf. Erstellen Sie ein [DeleteFunctionRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/model/DeleteFunctionRequest.html)Objekt und übergeben Sie es an die `deleteFunction` Methode. Dieses Objekt enthält Informationen wie den Namen der zu löschenden Funktion. Funktionsnamen werden als *arn:aws:lambda:us-east* - 1:555556330391:function: angezeigt. HelloFunction Sie können den Wert abrufen, indem Sie sich die Funktion in der ansehen. AWS-Managementkonsole
**Importe**
```
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.lambda.AWSLambda;
import com.amazonaws.services.lambda.AWSLambdaClientBuilder;
import com.amazonaws.services.lambda.model.ServiceException;
import com.amazonaws.services.lambda.model.DeleteFunctionRequest;
```
**Code**
Der folgende Java-Code zeigt, wie eine Lambda Funktion gelöscht wird.
```
String functionName = args[0];
try {
AWSLambda awsLambda = AWSLambdaClientBuilder.standard()
.withCredentials(new ProfileCredentialsProvider())
.withRegion(Regions.US_WEST_2).build();
DeleteFunctionRequest delFunc = new DeleteFunctionRequest();
delFunc.withFunctionName(functionName);
//Delete the function
awsLambda.deleteFunction(delFunc);
System.out.println("The function is deleted");
} catch (ServiceException e) {
System.out.println(e);
}
```
Auf GitHub finden Sie ein [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/lambda/src/main/java/com/example/lambda/DeleteFunction.java).
# Amazon Pinpoint Beispiele für die Verwendung der AWS SDK für Java
Dieser Abschnitt bietet Beispiele für die Programmierung von [Amazon Pinpoint](https://aws.amazon.com/pinpoint/) mithilfe des [AWS SDK für Java](https://aws.amazon.com/sdk-for-java/).
**Anmerkung**
Die Beispiele enthalten nur den Code, der zur Demonstration jeder Technik nötig ist. Der [vollständige Beispielcode ist verfügbar unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/java). Von dort aus können Sie eine einzelne Quelldatei herunterladen oder das Repository klonen, um alle Beispiele lokal zu erstellen und auszuführen.
**Topics**
+ [Apps erstellen und löschen in Amazon Pinpoint](examples-pinpoint-create-app.md)
+ [Endpunkte erstellen in Amazon Pinpoint](examples-pinpoint-create-endpoint.md)
+ [Segmente erstellen in Amazon Pinpoint](examples-pinpoint-create-segment.md)
+ [Kampagnen erstellen in Amazon Pinpoint](examples-pinpoint-create-campaign.md)
+ [Kanäle aktualisieren in Amazon Pinpoint](examples-pinpoint-update-channel.md)
# Apps erstellen und löschen in Amazon Pinpoint
Eine App ist ein Amazon Pinpoint Projekt, in dem Sie die Zielgruppe für eine bestimmte Anwendung definieren und diese Zielgruppe mit maßgeschneiderten Nachrichten ansprechen. Die Beispiele auf dieser Seite zeigen, wie Sie eine neue App erstellen oder eine bestehende löschen.
## Erstellen einer Anwendung
Erstellen Sie eine neue App, Amazon Pinpoint indem Sie dem [CreateAppRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/CreateAppRequest.html)Objekt einen App-Namen geben und dieses Objekt dann an die AmazonPinpointClient `createApp` -Methode übergeben.
**Importe**
```
import com.amazonaws.services.pinpoint.AmazonPinpoint;
import com.amazonaws.services.pinpoint.AmazonPinpointClientBuilder;
import com.amazonaws.services.pinpoint.model.CreateAppRequest;
import com.amazonaws.services.pinpoint.model.CreateAppResult;
import com.amazonaws.services.pinpoint.model.CreateApplicationRequest;
```
**Code**
```
CreateApplicationRequest appRequest = new CreateApplicationRequest()
.withName(appName);
CreateAppRequest request = new CreateAppRequest();
request.withCreateApplicationRequest(appRequest);
CreateAppResult result = pinpoint.createApp(request);
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/pinpoint/src/main/java/com/example/pinpoint/CreateApp.java) finden Sie unter GitHub.
## Löschen einer APP
Um eine App zu löschen, rufen Sie die AmazonPinpointClient `deleteApp` Anfrage mit einem [DeleteAppRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/DeleteAppRequest.html)Objekt auf, für das der zu löschende App-Name festgelegt ist.
**Importe**
```
import com.amazonaws.services.pinpoint.AmazonPinpoint;
import com.amazonaws.services.pinpoint.AmazonPinpointClientBuilder;
```
**Code**
```
DeleteAppRequest deleteRequest = new DeleteAppRequest()
.withApplicationId(appID);
pinpoint.deleteApp(deleteRequest);
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/pinpoint/src/main/java/com/example/pinpoint/DeleteApp.java) finden Sie unter GitHub.
## Weitere Informationen
+ [Apps](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-apps.html) in der Amazon Pinpoint API-Referenz
+ [App](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-app.html) in der Amazon Pinpoint API-Referenz
# Endpunkte erstellen in Amazon Pinpoint
Ein Endpunkt kennzeichnet auf eindeutige Weise ein Benutzergerät, an das Sie mit Amazon Pinpoint Push-Benachrichtigungen senden können. Wenn für Ihre App Amazon Pinpoint Support aktiviert ist, registriert Ihre App automatisch einen Endpunkt, Amazon Pinpoint wenn ein neuer Benutzer Ihre App öffnet. Das folgende Beispiel zeigt, wie Sie programmgesteuert einen neuen Endpunkt hinzufügen.
## Erstellen eines Endpunkts
Erstellen Sie einen neuen Endpunkt, Amazon Pinpoint indem Sie die Endpunktdaten in einem [EndpointRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/EndpointRequest.html)Objekt angeben.
**Importe**
```
import com.amazonaws.services.pinpoint.AmazonPinpoint;
import com.amazonaws.services.pinpoint.AmazonPinpointClientBuilder;
import com.amazonaws.services.pinpoint.model.UpdateEndpointRequest;
import com.amazonaws.services.pinpoint.model.UpdateEndpointResult;
import com.amazonaws.services.pinpoint.model.EndpointDemographic;
import com.amazonaws.services.pinpoint.model.EndpointLocation;
import com.amazonaws.services.pinpoint.model.EndpointRequest;
import com.amazonaws.services.pinpoint.model.EndpointResponse;
import com.amazonaws.services.pinpoint.model.EndpointUser;
import com.amazonaws.services.pinpoint.model.GetEndpointRequest;
import com.amazonaws.services.pinpoint.model.GetEndpointResult;
```
**Code**
```
HashMap> customAttributes = new HashMap<>();
List favoriteTeams = new ArrayList<>();
favoriteTeams.add("Lakers");
favoriteTeams.add("Warriors");
customAttributes.put("team", favoriteTeams);
EndpointDemographic demographic = new EndpointDemographic()
.withAppVersion("1.0")
.withMake("apple")
.withModel("iPhone")
.withModelVersion("7")
.withPlatform("ios")
.withPlatformVersion("10.1.1")
.withTimezone("America/Los_Angeles");
EndpointLocation location = new EndpointLocation()
.withCity("Los Angeles")
.withCountry("US")
.withLatitude(34.0)
.withLongitude(-118.2)
.withPostalCode("90068")
.withRegion("CA");
Map metrics = new HashMap<>();
metrics.put("health", 100.00);
metrics.put("luck", 75.00);
EndpointUser user = new EndpointUser()
.withUserId(UUID.randomUUID().toString());
DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm'Z'"); // Quoted "Z" to indicate UTC, no timezone offset
String nowAsISO = df.format(new Date());
EndpointRequest endpointRequest = new EndpointRequest()
.withAddress(UUID.randomUUID().toString())
.withAttributes(customAttributes)
.withChannelType("APNS")
.withDemographic(demographic)
.withEffectiveDate(nowAsISO)
.withLocation(location)
.withMetrics(metrics)
.withOptOut("NONE")
.withRequestId(UUID.randomUUID().toString())
.withUser(user);
```
Erstellen Sie dann ein [UpdateEndpointRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/UpdateEndpointRequest.html)Objekt mit diesem EndpointRequest Objekt. Schließlich übergeben Sie das UpdateEndpointRequest Objekt an AmazonPinpointClient die `updateEndpoint` Methode.
**Code**
```
UpdateEndpointRequest updateEndpointRequest = new UpdateEndpointRequest()
.withApplicationId(appId)
.withEndpointId(endpointId)
.withEndpointRequest(endpointRequest);
UpdateEndpointResult updateEndpointResponse = client.updateEndpoint(updateEndpointRequest);
System.out.println("Update Endpoint Response: " + updateEndpointResponse.getMessageBody());
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/pinpoint/src/main/java/com/example/pinpoint/CreateEndpoint.java) finden Sie unter GitHub.
## Weitere Informationen
+ [Hinzufügen von Endpunkten](https://docs.aws.amazon.com/pinpoint/latest/developerguide/endpoints.html) im Amazon Pinpoint Entwicklerhandbuch
+ [Endpunkt](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-endpoint.html) in der Amazon Pinpoint API-Referenz
# Segmente erstellen in Amazon Pinpoint
Ein Benutzersegment stellt einen Teil Ihrer Benutzer basierend auf gemeinsamen Merkmalen dar, z. B. Zeitpunkt der letzten App-Öffnung durch einen Benutzer oder verwendetes Gerät. Das folgende Beispiel zeigt, wie ein Benutzersegment definiert wird.
## Erstellen eines Segments
Erstellen Sie ein neues Segment in, Amazon Pinpoint indem Sie die Abmessungen des Segments in einem [SegmentDimensions](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/SegmentDimensions.html)Objekt definieren.
**Importe**
```
import com.amazonaws.services.pinpoint.AmazonPinpoint;
import com.amazonaws.services.pinpoint.AmazonPinpointClientBuilder;
import com.amazonaws.services.pinpoint.model.CreateSegmentRequest;
import com.amazonaws.services.pinpoint.model.CreateSegmentResult;
import com.amazonaws.services.pinpoint.model.AttributeDimension;
import com.amazonaws.services.pinpoint.model.AttributeType;
import com.amazonaws.services.pinpoint.model.RecencyDimension;
import com.amazonaws.services.pinpoint.model.SegmentBehaviors;
import com.amazonaws.services.pinpoint.model.SegmentDemographics;
import com.amazonaws.services.pinpoint.model.SegmentDimensions;
import com.amazonaws.services.pinpoint.model.SegmentLocation;
import com.amazonaws.services.pinpoint.model.SegmentResponse;
import com.amazonaws.services.pinpoint.model.WriteSegmentRequest;
```
**Code**
```
Pinpoint pinpoint = AmazonPinpointClientBuilder.standard().withRegion(Regions.US_EAST_1).build();
Map segmentAttributes = new HashMap<>();
segmentAttributes.put("Team", new AttributeDimension().withAttributeType(AttributeType.INCLUSIVE).withValues("Lakers"));
SegmentBehaviors segmentBehaviors = new SegmentBehaviors();
SegmentDemographics segmentDemographics = new SegmentDemographics();
SegmentLocation segmentLocation = new SegmentLocation();
RecencyDimension recencyDimension = new RecencyDimension();
recencyDimension.withDuration("DAY_30").withRecencyType("ACTIVE");
segmentBehaviors.setRecency(recencyDimension);
SegmentDimensions dimensions = new SegmentDimensions()
.withAttributes(segmentAttributes)
.withBehavior(segmentBehaviors)
.withDemographic(segmentDemographics)
.withLocation(segmentLocation);
```
Als Nächstes setzen Sie das [SegmentDimensions](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/SegmentDimensions.html)Objekt in ein [WriteSegmentRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/WriteSegmentRequest.html), das wiederum verwendet wird, um ein [CreateSegmentRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/CreateSegmentRequest.html)Objekt zu erstellen. Übergeben Sie dann das CreateSegmentRequest Objekt an AmazonPinpointClient die `createSegment` Methode.
**Code**
```
WriteSegmentRequest writeSegmentRequest = new WriteSegmentRequest()
.withName("MySegment").withDimensions(dimensions);
CreateSegmentRequest createSegmentRequest = new CreateSegmentRequest()
.withApplicationId(appId).withWriteSegmentRequest(writeSegmentRequest);
CreateSegmentResult createSegmentResult = client.createSegment(createSegmentRequest);
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/pinpoint/src/main/java/com/example/pinpoint/CreateSegment.java) finden Sie unter GitHub.
## Weitere Informationen
+ [Amazon Pinpoint Segmente](https://docs.aws.amazon.com/pinpoint/latest/userguide/segments.html) im Amazon Pinpoint Benutzerhandbuch
+ [Segmente im Amazon Pinpoint Entwicklerhandbuch erstellen](https://docs.aws.amazon.com/pinpoint/latest/developerguide/segments.html)
+ [Segmente](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-segments.html) in der Amazon Pinpoint API-Referenz
+ [Segment](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-segment.html) in der Amazon Pinpoint API-Referenz
# Kampagnen erstellen in Amazon Pinpoint
Mit diesen Kampagnen können Sie die Bindung zwischen Ihrer App und den Benutzern erhöhen. Sie können eine Kampagne erstellen, um für ein bestimmtes Benutzersegment maßgeschneiderte Nachrichten oder besondere Werbeaktionen bereitzustellen. In diesem Beispiel wird gezeigt, wie eine neue Standard-Kampagne erstellt wird, bei der eine benutzerdefinierte Push-Benachrichtigung an ein bestimmtes Benutzersegment gesendet wird.
## Erstellen einer Kampagne
Bevor Sie eine neue Kampagne erstellen, müssen Sie einen [Zeitplan](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/Schedule.html) und eine [Nachricht](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/Message.html) definieren und diese Werte in einem [WriteCampaignRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/WriteCampaignRequest.html)Objekt festlegen.
**Importe**
```
import com.amazonaws.services.pinpoint.AmazonPinpoint;
import com.amazonaws.services.pinpoint.AmazonPinpointClientBuilder;
import com.amazonaws.services.pinpoint.model.CreateCampaignRequest;
import com.amazonaws.services.pinpoint.model.CreateCampaignResult;
import com.amazonaws.services.pinpoint.model.Action;
import com.amazonaws.services.pinpoint.model.CampaignResponse;
import com.amazonaws.services.pinpoint.model.Message;
import com.amazonaws.services.pinpoint.model.MessageConfiguration;
import com.amazonaws.services.pinpoint.model.Schedule;
import com.amazonaws.services.pinpoint.model.WriteCampaignRequest;
```
**Code**
```
Schedule schedule = new Schedule()
.withStartTime("IMMEDIATE");
Message defaultMessage = new Message()
.withAction(Action.OPEN_APP)
.withBody("My message body.")
.withTitle("My message title.");
MessageConfiguration messageConfiguration = new MessageConfiguration()
.withDefaultMessage(defaultMessage);
WriteCampaignRequest request = new WriteCampaignRequest()
.withDescription("My description.")
.withSchedule(schedule)
.withSegmentId(segmentId)
.withName("MyCampaign")
.withMessageConfiguration(messageConfiguration);
```
Erstellen Sie dann eine neue Kampagne, Amazon Pinpoint indem Sie die [WriteCampaignRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/WriteCampaignRequest.html)Kampagnenkonfiguration für ein [CreateCampaignRequest](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/pinpoint/model/CreateCampaignRequest.html)Objekt angeben. Schließlich übergeben Sie das CreateCampaignRequest Objekt an AmazonPinpointClient die `createCampaign` Methode.
**Code**
```
CreateCampaignRequest createCampaignRequest = new CreateCampaignRequest()
.withApplicationId(appId).withWriteCampaignRequest(request);
CreateCampaignResult result = client.createCampaign(createCampaignRequest);
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/pinpoint/src/main/java/com/example/pinpoint/CreateApp.java) finden Sie unter GitHub.
## Weitere Informationen
+ [Amazon Pinpoint Kampagnen](https://docs.aws.amazon.com/pinpoint/latest/userguide/campaigns.html) im Amazon Pinpoint Benutzerhandbuch
+ [Kampagnen im Amazon Pinpoint Entwicklerhandbuch erstellen](https://docs.aws.amazon.com/pinpoint/latest/developerguide/campaigns.html)
+ [Kampagnen](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-campaigns.html) in der Amazon Pinpoint API-Referenz
+ [Kampagne](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-campaign.html) in der Amazon Pinpoint API-Referenz
+ [Kampagnenaktivitäten](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-campaign-activities.html) in der Amazon Pinpoint API-Referenz
+ [Kampagnenversionen](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-campaign-versions.html) in der Amazon Pinpoint API-Referenz
+ [Kampagnenversion](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-campaign-version.html) in der Amazon Pinpoint API-Referenz
# Kanäle aktualisieren in Amazon Pinpoint
Ein Channel definiert die Arten von Plattformen, an die Sie Nachrichten übermitteln können. Dieses Beispiel zeigt, wie der APNs Kanal zum Senden einer Nachricht verwendet wird.
## Aktualisieren eines Channels
Aktivieren Sie einen Kanal, Amazon Pinpoint indem Sie eine App-ID und ein Anforderungsobjekt des Kanaltyps angeben, den Sie aktualisieren möchten. In diesem Beispiel wird der APNs Kanal aktualisiert, wofür das [APNSChannelRequest-Objekt](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/APNSChannelRequest.html) erforderlich ist. Legen Sie diese in der Methode fest [UpdateApnsChannelRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/UpdateApnsChannelRequest.html)und übergeben Sie das Objekt an AmazonPinpointClient die `updateApnsChannel` Methode.
**Importe**
```
import com.amazonaws.services.pinpoint.AmazonPinpoint;
import com.amazonaws.services.pinpoint.AmazonPinpointClientBuilder;
import com.amazonaws.services.pinpoint.model.APNSChannelRequest;
import com.amazonaws.services.pinpoint.model.APNSChannelResponse;
import com.amazonaws.services.pinpoint.model.GetApnsChannelRequest;
import com.amazonaws.services.pinpoint.model.GetApnsChannelResult;
import com.amazonaws.services.pinpoint.model.UpdateApnsChannelRequest;
import com.amazonaws.services.pinpoint.model.UpdateApnsChannelResult;
```
**Code**
```
APNSChannelRequest request = new APNSChannelRequest()
.withEnabled(enabled);
UpdateApnsChannelRequest updateRequest = new UpdateApnsChannelRequest()
.withAPNSChannelRequest(request)
.withApplicationId(appId);
UpdateApnsChannelResult result = client.updateApnsChannel(updateRequest);
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/pinpoint/src/main/java/com/example/pinpoint/UpdateChannel.java) finden Sie unter GitHub.
## Weitere Informationen
+ [Amazon Pinpoint Kanäle](https://docs.aws.amazon.com/pinpoint/latest/userguide/channels.html) im Amazon Pinpoint Benutzerhandbuch
+ [ADM-Kanal](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-adm-channel.html) in der Amazon Pinpoint API-Referenz
+ [APNs Kanal](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-apns-channel.html) in der Amazon Pinpoint API-Referenz
+ [APNs Sandbox-Kanal](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-apns-sandbox-channel.html) in der Amazon Pinpoint API-Referenz
+ [APNs VoIP-Kanal](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-apns-voip-channel.html) in der Amazon Pinpoint API-Referenz
+ [APNs VoIP-Sandbox-Kanal](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-apns-voip-sandbox-channel.html) in der Amazon Pinpoint API-Referenz
+ Der [Baidu-Kanal](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-baidu-channel.html) in der API-Referenz Amazon Pinpoint
+ [E-Mail-Kanal](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-email-channel.html) in der Amazon Pinpoint API-Referenz
+ [GCM-Kanal](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-gcm-channel.html) in der Amazon Pinpoint API-Referenz
+ [SMS-Kanal](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-sms-channel.html) in der Amazon Pinpoint API-Referenz
# Amazon S3 Beispiele für die Verwendung der AWS SDK für Java
Dieser Abschnitt bietet Beispiele für die Programmierung von [Amazon S3](https://aws.amazon.com/s3/) mithilfe des [AWS SDK für Java](https://aws.amazon.com/sdk-for-java/).
**Anmerkung**
Die Beispiele enthalten nur den Code, der zur Demonstration jeder Technik nötig ist. Der [vollständige Beispielcode ist verfügbar unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/java). Von dort aus können Sie eine einzelne Quelldatei herunterladen oder das Repository klonen, um alle Beispiele lokal zu erstellen und auszuführen.
**Topics**
+ [Amazon S3 Buckets erstellen, auflisten und löschen](examples-s3-buckets.md)
+ [Operationen an Amazon S3 Objekten ausführen](examples-s3-objects.md)
+ [Amazon S3 Zugriffsberechtigungen für Buckets und Objekte verwalten](examples-s3-access-permissions.md)
+ [Verwaltung des Zugriffs auf Amazon S3 Buckets mithilfe von Bucket-Richtlinien](examples-s3-bucket-policies.md)
+ [TransferManager Für Amazon S3 Operationen verwenden](examples-s3-transfermanager.md)
+ [Einen Amazon S3 Bucket als Website konfigurieren](examples-s3-website-configuration.md)
+ [Amazon S3 Clientseitige Verschlüsselung verwenden](examples-crypto.md)
# Amazon S3 Buckets erstellen, auflisten und löschen
Jedes Objekt (Datei) Amazon S3 muss sich in einem *Bucket* befinden, der eine Sammlung (Container) von Objekten darstellt. Jeder Bucket ist mit einem *Schlüssel* (Namen) bekannt, der eindeutig sein muss. Ausführliche Informationen zu Buckets und ihrer Konfiguration finden Sie unter [Arbeiten mit Amazon S3 Buckets](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingBucket.html) im Amazon Simple Storage Service Benutzerhandbuch.
**Anmerkung**
Bewährte Methode
Wir empfehlen, dass Sie die [AbortIncompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTlifecycle.html)Lebenszyklusregel für Ihre Amazon S3 Buckets aktivieren.
Diese Regel weist darauf Amazon S3 hin, dass mehrteilige Uploads abgebrochen werden, die nicht innerhalb einer bestimmten Anzahl von Tagen nach der Initiierung abgeschlossen werden. Wenn das festgelegte Zeitlimit überschritten wird, wird der Upload Amazon S3 abgebrochen und anschließend die unvollständigen Upload-Daten gelöscht.
Weitere Informationen finden Sie unter [Lebenszykluskonfiguration für einen Bucket mit Versionierung](https://docs.aws.amazon.com/AmazonS3/latest/userguide/lifecycle-configuration-bucket-with-versioning.html) im Amazon S3 Benutzerhandbuch.
**Anmerkung**
Bei diesen Codebeispielen wird vorausgesetzt, dass Sie die Informationen [unter Verwenden von](basics.md) verstehen AWS SDK für Java und AWS Standardanmeldedaten anhand der Informationen unter [AWS Anmeldeinformationen einrichten und Region für die Entwicklung](setup-credentials.md) konfiguriert haben.
## Bucket erstellen
Verwenden Sie die Methode des AmazonS3-Clients. `createBucket` Der neue [Bucket](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/Bucket.html) wird zurückgegeben. Die `createBucket`-Methode löst eine Ausnahme aus, falls der Bucket bereits vorhanden ist.
**Anmerkung**
Bevor Sie versuchen, einen Bucket zu erstellen, sollten Sie die `doesBucketExist`-Methode aufrufen, um zu prüfen, ob ein gleichnamiger Bucket bereits existiert. Falls ja, wird `true` zurückgegeben, andernfalls `false`.
**Importe**
```
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.AmazonS3Exception;
import com.amazonaws.services.s3.model.Bucket;
import java.util.List;
```
**Code**
```
if (s3.doesBucketExistV2(bucket_name)) {
System.out.format("Bucket %s already exists.\n", bucket_name);
b = getBucket(bucket_name);
} else {
try {
b = s3.createBucket(bucket_name);
} catch (AmazonS3Exception e) {
System.err.println(e.getErrorMessage());
}
}
return b;
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/CreateBucket.java) finden Sie unter. GitHub
## Auflisten von Buckets
Verwenden Sie die Methode des AmazonS3-Clients. `listBucket` Wenn diese Aktion erfolgreich ist, wird eine Liste mit [Bucket](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/Bucket.html)-Objekten zurückgegeben.
**Importe**
```
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.Bucket;
import java.util.List;
```
**Code**
```
List buckets = s3.listBuckets();
System.out.println("Your {S3} buckets are:");
for (Bucket b : buckets) {
System.out.println("* " + b.getName());
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/ListBuckets.java) finden Sie unter. GitHub
## Bucket löschen
Bevor Sie einen Amazon S3 Bucket löschen können, müssen Sie sicherstellen, dass der Bucket leer ist. Andernfalls tritt ein Fehler auf. Wenn Sie einen [versionierten Bucket](https://docs.aws.amazon.com/AmazonS3/latest/dev/Versioning.html) nutzen, müssen Sie außerdem alle versionierten Objekte löschen, die mit dem Bucket verknüpft sind.
**Anmerkung**
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/DeleteBucket.java) umfasst die einzelnen Schritte der Reihe nach und bietet somit eine vollständige Lösung für das Löschen eines Amazon S3 Buckets und seines Inhalts.
**Topics**
+ [Entfernen von Objekten aus einem nicht versionierten Bucket vor dem Löschen](#remove-objects-from-an-unversioned-bucket-before-deleting-it)
+ [Entfernen von Objekten aus einem versionierten Bucket vor dem Löschen](#remove-objects-from-a-versioned-bucket-before-deleting-it)
+ [Löschen eines leeren Buckets](#delete-an-empty-bucket)
### Entfernen von Objekten aus einem nicht versionierten Bucket vor dem Löschen
Verwenden Sie die `listObjects` Methode des AmazonS3-Clients, um die Objektliste abzurufen und jedes Objekt `deleteObject` zu löschen.
**Importe**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.*;
import java.util.Iterator;
```
**Code**
```
System.out.println(" - removing objects from bucket");
ObjectListing object_listing = s3.listObjects(bucket_name);
while (true) {
for (Iterator iterator =
object_listing.getObjectSummaries().iterator();
iterator.hasNext(); ) {
S3ObjectSummary summary = (S3ObjectSummary) iterator.next();
s3.deleteObject(bucket_name, summary.getKey());
}
// more object_listing to retrieve?
if (object_listing.isTruncated()) {
object_listing = s3.listNextBatchOfObjects(object_listing);
} else {
break;
}
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/DeleteBucket.java) finden Sie unter. GitHub
### Entfernen von Objekten aus einem versionierten Bucket vor dem Löschen
Wenn Sie einen [versionierten Bucket](https://docs.aws.amazon.com/AmazonS3/latest/dev/Versioning.html) nutzen, müssen Sie auch alle gespeicherten Versionen der Objekte im Bucket entfernen, bevor der Bucket gelöscht werden kann.
Verwenden Sie ein ähnliches Muster wie beim Entfernen von Objekten innerhalb eines Buckets. Entfernen Sie versionierte Objekte, indem Sie die `listVersions` Methode des AmazonS3-Clients verwenden, um alle versionierten Objekte aufzulisten und dann jedes einzelne `deleteVersion` zu löschen.
**Importe**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.*;
import java.util.Iterator;
```
**Code**
```
System.out.println(" - removing versions from bucket");
VersionListing version_listing = s3.listVersions(
new ListVersionsRequest().withBucketName(bucket_name));
while (true) {
for (Iterator iterator =
version_listing.getVersionSummaries().iterator();
iterator.hasNext(); ) {
S3VersionSummary vs = (S3VersionSummary) iterator.next();
s3.deleteVersion(
bucket_name, vs.getKey(), vs.getVersionId());
}
if (version_listing.isTruncated()) {
version_listing = s3.listNextBatchOfVersions(
version_listing);
} else {
break;
}
}
```
[Das vollständige Beispiel finden Sie unter.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/DeleteBucket.java) GitHub
### Löschen eines leeren Buckets
Sobald Sie die Objekte aus einem Bucket entfernt haben (einschließlich aller versionierten Objekte), können Sie den Bucket selbst mithilfe der Methode des AmazonS3-Clients löschen. `deleteBucket`
**Importe**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.*;
import java.util.Iterator;
```
**Code**
```
System.out.println(" OK, bucket ready to delete!");
s3.deleteBucket(bucket_name);
```
Das [vollständige](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/DeleteBucket.java) Beispiel finden Sie unter. GitHub
# Operationen an Amazon S3 Objekten ausführen
Ein Amazon S3 Objekt steht für eine *Datei* oder eine Sammlung von Daten. Jedes Objekt muss in einem [Bucket](examples-s3-buckets.md) enthalten sein.
**Anmerkung**
Bei diesen Codebeispielen wird vorausgesetzt, dass Sie die Informationen [unter Verwenden von](basics.md) verstehen AWS SDK für Java und AWS Standardanmeldedaten anhand der Informationen unter [AWS Anmeldeinformationen einrichten und Region für die Entwicklung](setup-credentials.md) konfiguriert haben.
**Topics**
+ [Hochladen eines Objekts](#upload-object)
+ [Auflisten von Objekten](#list-objects)
+ [Herunterladen eines Objekts](#download-object)
+ [Kopieren, Verschieben oder Umbenennen von Objekten](#copy-object)
+ [Objekte löschen](#delete-object)
+ [Löschen mehrerer Objekte auf einmal](#delete-objects)
## Hochladen eines Objekts
Verwenden Sie die `putObject` Methode des AmazonS3-Clients und geben Sie einen Bucket-Namen, einen Schlüsselnamen und eine Datei für den Upload an. *Der Bucket muss vorhanden sein, andernfalls tritt ein Fehler auf*.
**Importe**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
```
**Code**
```
System.out.format("Uploading %s to S3 bucket %s...\n", file_path, bucket_name);
final AmazonS3 s3 = AmazonS3ClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
try {
s3.putObject(bucket_name, key_name, new File(file_path));
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/PutObject.java) finden Sie unter. GitHub
## Auflisten von Objekten
Um eine Liste der Objekte in einem Bucket abzurufen, verwenden Sie die `listObjects` Methode des AmazonS3-Clients und geben Sie den Namen eines Buckets an.
Die `listObjects` Methode gibt ein [ObjectListing](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/ObjectListing.html)Objekt zurück, das Informationen über die Objekte im Bucket bereitstellt. Um die Objektnamen (Schlüssel) aufzulisten, verwenden Sie die `getObjectSummaries` Methode, um eine Liste von [ObjectSummaryS3-Objekten](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/S3ObjectSummary.html) abzurufen, von denen jedes ein einzelnes Objekt im Bucket darstellt. Rufen Sie dann dessen `getKey`-Methode zum Abrufen des Objektnamens auf.
**Importe**
```
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.ListObjectsV2Result;
import com.amazonaws.services.s3.model.S3ObjectSummary;
```
**Code**
```
System.out.format("Objects in S3 bucket %s:\n", bucket_name);
final AmazonS3 s3 = AmazonS3ClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
ListObjectsV2Result result = s3.listObjectsV2(bucket_name);
List objects = result.getObjectSummaries();
for (S3ObjectSummary os : objects) {
System.out.println("* " + os.getKey());
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/ListObjects.java) finden Sie unter GitHub.
## Herunterladen eines Objekts
Verwenden Sie die `getObject` Methode des AmazonS3-Clients und übergeben Sie ihm den Namen eines Buckets und eines Objekts zum Herunterladen. Bei Erfolg gibt die Methode ein [S3Object](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/S3Object.html) zurück. *Der angegebene Bucket und der Objektschlüssel müssen vorhanden sein, andernfalls tritt ein Fehler auf*.
Sie können den Inhalt des Objekts anfordern, indem Sie `getObjectContent` für das Objekt `S3Object` aufrufen. Dies gibt ein [S3](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/S3ObjectInputStream.html) zurückObjectInputStream, das sich wie ein Standard-Java-Objekt verhält. `InputStream`
Das folgende Beispiel lädt ein Objekt von S3 herunter und speichert die Inhalte in einer Datei mit dem Namen des Objektschlüssels.
**Importe**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.S3Object;
import com.amazonaws.services.s3.model.S3ObjectInputStream;
import java.io.File;
```
**Code**
```
System.out.format("Downloading %s from S3 bucket %s...\n", key_name, bucket_name);
final AmazonS3 s3 = AmazonS3ClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
try {
S3Object o = s3.getObject(bucket_name, key_name);
S3ObjectInputStream s3is = o.getObjectContent();
FileOutputStream fos = new FileOutputStream(new File(key_name));
byte[] read_buf = new byte[1024];
int read_len = 0;
while ((read_len = s3is.read(read_buf)) > 0) {
fos.write(read_buf, 0, read_len);
}
s3is.close();
fos.close();
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
} catch (FileNotFoundException e) {
System.err.println(e.getMessage());
System.exit(1);
} catch (IOException e) {
System.err.println(e.getMessage());
System.exit(1);
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/GetObject.java) finden Sie unter. GitHub
## Kopieren, Verschieben oder Umbenennen von Objekten
Sie können ein Objekt mithilfe der Methode des AmazonS3-Clients von einem Bucket in einen anderen kopieren. `copyObject` Sie nimmt den Namen des Buckets, aus dem kopiert werden soll, das zu kopierende Objekt sowie den Namen des Zielbuckets entgegen.
**Importe**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
```
**Code**
```
try {
s3.copyObject(from_bucket, object_key, to_bucket, object_key);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
System.out.println("Done!");
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/CopyObject.java) finden Sie unter. GitHub
**Anmerkung**
Sie können `copyObject` mit [deleteObject](#delete-object) verwenden, um ein Objekt zu **verschieben** oder **umzubenennen**. Kopieren Sie das Objekt dazu als Erstes auf einen neuen Namen (Sie können den gleichen Bucket als Quelle und Ziel angeben) und löschen Sie das Objekt dann von seinem bisherigen Speicherort.
## Objekte löschen
Verwenden Sie die `deleteObject` Methode des AmazonS3-Clients und übergeben Sie ihm den Namen eines Buckets und eines Objekts, das gelöscht werden soll. *Der angegebene Bucket und der Objektschlüssel müssen vorhanden sein, andernfalls tritt ein Fehler auf*.
**Importe**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
```
**Code**
```
final AmazonS3 s3 = AmazonS3ClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
try {
s3.deleteObject(bucket_name, object_key);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/DeleteObject.java) finden Sie unter. GitHub
## Löschen mehrerer Objekte auf einmal
Mit der `deleteObjects` Methode des AmazonS3-Clients können Sie mehrere Objekte aus demselben Bucket löschen, indem Sie ihre Namen an die Methode link:sdk-for-java/v1/reference/com/amazonaws/services/s3/model/DeleteObjectsRequest.html `` übergeben.
**Importe**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
```
**Code**
```
final AmazonS3 s3 = AmazonS3ClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
try {
DeleteObjectsRequest dor = new DeleteObjectsRequest(bucket_name)
.withKeys(object_keys);
s3.deleteObjects(dor);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/DeleteObjects.java) finden Sie unter. GitHub
# Amazon S3 Zugriffsberechtigungen für Buckets und Objekte verwalten
Sie können Zugriffskontrolllisten (ACLs) für Amazon S3 Buckets und Objekte verwenden, um Ihre Ressourcen detailliert zu steuern. Amazon S3
**Anmerkung**
Bei diesen Codebeispielen wird vorausgesetzt, dass Sie die Informationen [unter Verwenden von](basics.md) verstehen AWS SDK für Java und AWS Standardanmeldedaten anhand der Informationen unter [AWS Anmeldeinformationen einrichten und Region](setup-credentials.md) für die Entwicklung konfiguriert haben.
## Abrufen der Zugriffskontrollliste für einen Bucket
Um die aktuelle ACL für einen Bucket abzurufen, rufen Sie die `getBucketAcl` Methode von AmazonS3 auf und übergeben ihr den *Bucket-Namen* für die Abfrage. Diese Methode gibt ein [AccessControlList](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/AccessControlList.html)Objekt zurück. Um jede Zugriffsberechtigung in der Liste abzurufen, rufen Sie die `getGrantsAsList`-Methode des Objekts auf. Sie erhalten dann eine Standard-Java-Liste mit [Grant](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/Grant.html)-Objekten.
**Importe**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.AccessControlList;
import com.amazonaws.services.s3.model.Grant;
```
**Code**
```
final AmazonS3 s3 = AmazonS3ClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
try {
AccessControlList acl = s3.getBucketAcl(bucket_name);
List grants = acl.getGrantsAsList();
for (Grant grant : grants) {
System.out.format(" %s: %s\n", grant.getGrantee().getIdentifier(),
grant.getPermission().toString());
}
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/GetAcl.java) finden Sie unter GitHub.
## Festlegen der Zugriffskontrollliste für einen Bucket
Um einer ACL für einen Bucket Berechtigungen hinzuzufügen oder zu ändern, rufen Sie die Methode von `setBucketAcl` AmazonS3 auf. Sie benötigt ein [AccessControlList](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/AccessControlList.html)Objekt, das eine Liste von Empfängern und Zugriffsebenen für die Einrichtung enthält.
**Importe**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.AccessControlList;
import com.amazonaws.services.s3.model.EmailAddressGrantee;
```
**Code**
```
final AmazonS3 s3 = AmazonS3ClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
try {
// get the current ACL
AccessControlList acl = s3.getBucketAcl(bucket_name);
// set access for the grantee
EmailAddressGrantee grantee = new EmailAddressGrantee(email);
Permission permission = Permission.valueOf(access);
acl.grantPermission(grantee, permission);
s3.setBucketAcl(bucket_name, acl);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
**Anmerkung**
Sie können die eindeutige ID des Empfängers direkt mithilfe der Klasse [Stipendiat](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/Grantee.html) angeben oder die Klasse verwenden, um den [EmailAddressGrantee](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/EmailAddressGrantee.html)Empfänger per E-Mail festzulegen, wie wir es hier getan haben.
Das [vollständige](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/SetAcl.java) Beispiel finden Sie unter. GitHub
## Abrufen der Zugriffskontrollliste für ein Objekt
Um die aktuelle ACL für ein Objekt abzurufen, rufen Sie die `getObjectAcl` Methode von AmazonS3 auf und übergeben ihr den *Bucket-Namen und den *Objektnamen** für die Abfrage. [Diese Methode gibt zum Beispiel `getBucketAcl` ein [AccessControlList](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/AccessControlList.html)Objekt zurück, mit dem Sie jeden Grant untersuchen können.](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/Grant.html)
**Importe**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.AccessControlList;
import com.amazonaws.services.s3.model.Grant;
```
**Code**
```
try {
AccessControlList acl = s3.getObjectAcl(bucket_name, object_key);
List grants = acl.getGrantsAsList();
for (Grant grant : grants) {
System.out.format(" %s: %s\n", grant.getGrantee().getIdentifier(),
grant.getPermission().toString());
}
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/GetAcl.java) finden Sie unter GitHub.
## Festlegen der Zugriffskontrollliste für ein Objekt
Um einer ACL für ein Objekt Berechtigungen hinzuzufügen oder zu ändern, rufen Sie die Methode von `setObjectAcl` AmazonS3 auf. Sie benötigt ein [AccessControlList](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/AccessControlList.html)Objekt, das eine Liste von Empfängern und Zugriffsebenen für die Einrichtung enthält.
**Importe**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.AccessControlList;
import com.amazonaws.services.s3.model.EmailAddressGrantee;
```
**Code**
```
try {
// get the current ACL
AccessControlList acl = s3.getObjectAcl(bucket_name, object_key);
// set access for the grantee
EmailAddressGrantee grantee = new EmailAddressGrantee(email);
Permission permission = Permission.valueOf(access);
acl.grantPermission(grantee, permission);
s3.setObjectAcl(bucket_name, object_key, acl);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
}
```
**Anmerkung**
Sie können die eindeutige ID des Empfängers direkt mithilfe der Klasse [Stipendiat](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/Grantee.html) angeben oder die Klasse verwenden, um den [EmailAddressGrantee](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/EmailAddressGrantee.html)Empfänger per E-Mail festzulegen, wie wir es hier getan haben.
Das [vollständige](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/SetAcl.java) Beispiel finden Sie unter. GitHub
## Weitere Informationen
+ [GET Bucket acl](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketGETacl.html) in der Amazon S3 API-Referenz
+ [Fügen Sie Bucket ACL](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTacl.html) in die Amazon S3 API-Referenz ein
+ [GET Object acl](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectGETacl.html) in der Amazon S3 API-Referenz
+ [PUT Object acl](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUTacl.html) in der Amazon S3 API-Referenz
# Verwaltung des Zugriffs auf Amazon S3 Buckets mithilfe von Bucket-Richtlinien
Sie können eine *Bucket-Richtlinie* einrichten, abrufen oder löschen, um den Zugriff auf Ihre Amazon S3 Buckets zu verwalten.
## Festlegen einer Bucket-Richtlinie
Sie können die Bucket-Richtlinie für einen bestimmten S3-Bucket wie folgt festlegen:
+ Rufen Sie den AmazonS3-Client an `setBucketPolicy` und stellen Sie ihm eine [SetBucketPolicyRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/SetBucketPolicyRequest.html)
+ Durch direktes Festlegen der Richtlinie unter Verwendung der `setBucketPolicy`-Überladung, die einen Bucket-Namen und einen Richtlinientext (im JSON-Format) entgegen nimmt
**Importe**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.auth.policy.Policy;
import com.amazonaws.auth.policy.Principal;
```
**Code**
```
s3.setBucketPolicy(bucket_name, policy_text);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
### Verwenden der Policy-Klasse zum Generieren oder Überprüfen einer Richtlinie
Wenn Sie `setBucketPolicy` eine Bucket-Richtlinie übergeben, können Sie die folgenden Aufgaben ausführen:
+ Direktes Übergeben der Richtlinie als Zeichenfolge mit Text im JSON-Format
+ Erstellen der Richtlinie mit der [Policy](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/policy/Policy.html)-Klasse
Bei Verwendung der `Policy`-Klasse müssen Sie sich keine Gedanken über die korrekte Formatierung Ihrer Text-Zeichenfolge machen. Sie können die Richtlinie als JSON-Text von der `Policy`-Klasse erhalten, indem Sie die `toJson`-Methode aufrufen.
**Importe**
```
import com.amazonaws.auth.policy.Resource;
import com.amazonaws.auth.policy.Statement;
import com.amazonaws.auth.policy.actions.S3Actions;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
```
**Code**
```
new Statement(Statement.Effect.Allow)
.withPrincipals(Principal.AllUsers)
.withActions(S3Actions.GetObject)
.withResources(new Resource(
"{region-arn}s3:::" + bucket_name + "/*")));
return bucket_policy.toJson();
```
Die `Policy`-Klasse bietet außerdem eine `fromJson`-Methode, mit der versucht werden kann, eine Richtlinie aus einer übergebenen JSON-Zeichenfolge zu erstellen. Die Methode überprüft die Zeichenfolge und stellt so sicher, dass sich der Text in eine gültige Richtlinienstruktur umwandeln lässt. Sie löst einen Fehler mit einer `IllegalArgumentException` aus, wenn der Richtlinientext ungültig ist.
```
Policy bucket_policy = null;
try {
bucket_policy = Policy.fromJson(file_text.toString());
} catch (IllegalArgumentException e) {
System.out.format("Invalid policy text in file: \"%s\"",
policy_file);
System.out.println(e.getMessage());
}
```
Mit dieser Technik können Sie eine Richtlinie im Voraus validieren, die Sie aus einer Datei oder anderweitig einlesen.
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/SetBucketPolicy.java) finden Sie unter. GitHub
## Abrufen einer Bucket-Richtlinie
Um die Richtlinie für einen Amazon S3 Bucket abzurufen, rufen Sie die `getBucketPolicy` Methode des AmazonS3-Clients auf und übergeben Sie ihr den Namen des Buckets, aus dem die Richtlinie abgerufen werden soll.
**Importe**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
```
**Code**
```
try {
BucketPolicy bucket_policy = s3.getBucketPolicy(bucket_name);
policy_text = bucket_policy.getPolicyText();
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
Wenn der angegebene Bucket nicht vorhanden ist, Sie nicht darauf zugreifen können oder wenn keine Bucket-Richtlinie eingerichtet ist, wird eine `AmazonServiceException` ausgelöst.
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/GetBucketPolicy.java) finden Sie unter. GitHub
## Löschen einer Bucket-Richtlinie
Um eine Bucket-Richtlinie zu löschen, rufen Sie den AmazonS3-Client auf und geben Sie ihm den Bucket-Namen. `deleteBucketPolicy`
**Importe**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
```
**Code**
```
try {
s3.deleteBucketPolicy(bucket_name);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
Diese Methode wird auch dann erfolgreich ausgeführt, wenn der Bucket noch nicht über eine Richtlinie verfügt. Wenn Sie den Namen eines Buckets angeben, der noch nicht vorhanden ist oder für den Sie keinen Zugriff haben, wird eine `AmazonServiceException` ausgelöst.
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/DeleteBucketPolicy.java) finden Sie unter. GitHub
## Weitere Infos
+ [Überblick über die Sprache der Access Policy](https://docs.aws.amazon.com/AmazonS3/latest/dev/access-policy-language-overview.html) im Amazon Simple Storage Service Benutzerhandbuch
+ [Beispiele für Bucket-Richtlinien](https://docs.aws.amazon.com/AmazonS3/latest/dev/example-bucket-policies.html) im Amazon Simple Storage Service Benutzerhandbuch
# TransferManager Für Amazon S3 Operationen verwenden
Sie können die AWS SDK für Java TransferManager Klasse verwenden, um Dateien zuverlässig aus der lokalen Umgebung zu übertragen Amazon S3 und Objekte von einem S3-Speicherort an einen anderen zu kopieren. `TransferManager`kann den Fortschritt einer Übertragung abrufen und Uploads und Downloads anhalten oder fortsetzen.
**Anmerkung**
Bewährte Methode
Wir empfehlen Ihnen, die [AbortIncompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTlifecycle.html)Lebenszyklusregel für Ihre Amazon S3 Buckets zu aktivieren.
Diese Regel weist darauf Amazon S3 hin, dass mehrteilige Uploads abgebrochen werden, die nicht innerhalb einer bestimmten Anzahl von Tagen nach der Initiierung abgeschlossen werden. Wenn das festgelegte Zeitlimit überschritten wird, wird der Upload Amazon S3 abgebrochen und anschließend die unvollständigen Upload-Daten gelöscht.
Weitere Informationen finden Sie unter [Lebenszykluskonfiguration für einen Bucket mit Versionierung](https://docs.aws.amazon.com/AmazonS3/latest/userguide/lifecycle-configuration-bucket-with-versioning.html) im Amazon S3 Benutzerhandbuch.
**Anmerkung**
Bei diesen Codebeispielen wird vorausgesetzt, dass Sie die Informationen [unter Verwenden von](basics.md) verstehen AWS SDK für Java und AWS Standardanmeldedaten anhand der Informationen unter [AWS Anmeldeinformationen einrichten und Region für die Entwicklung](setup-credentials.md) konfiguriert haben.
## Hochladen von Dateien und Verzeichnissen
TransferManager kann Dateien, Dateilisten und Verzeichnisse in alle Amazon S3 Buckets hochladen, die Sie [zuvor erstellt](examples-s3-buckets.md#create-bucket) haben.
**Topics**
+ [Hochladen einer einzelnen Datei](#transfermanager-upload-file)
+ [Hochladen einer Dateiliste](#transfermanager-upload-file-list)
+ [Upload eines Verzeichnisses](#transfermanager-upload-directory)
### Hochladen einer einzelnen Datei
Rufen Sie TransferManager die `upload` Methode auf und geben Sie einen Amazon S3 Bucket-Namen, einen Schlüsselnamen (Objektnamen) und ein [Standard-Java-Dateiobjekt](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/File.html) an, das die hochzuladende Datei darstellt.
**Importe**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.s3.transfer.MultipleFileUpload;
import com.amazonaws.services.s3.transfer.TransferManager;
import com.amazonaws.services.s3.transfer.TransferManagerBuilder;
import com.amazonaws.services.s3.transfer.Upload;
import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
```
**Code**
```
File f = new File(file_path);
TransferManager xfer_mgr = TransferManagerBuilder.standard().build();
try {
Upload xfer = xfer_mgr.upload(bucket_name, key_name, f);
// loop with Transfer.isDone()
XferMgrProgress.showTransferProgress(xfer);
// or block with Transfer.waitForCompletion()
XferMgrProgress.waitForCompletion(xfer);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
xfer_mgr.shutdownNow();
```
Die `upload`-Methode kehrt *sofort* zurück und stellt ein `Upload`-Objekt bereit, mit dem Sie den Übertragungsstatus abrufen oder auf die Fertigstellung warten können.
Informationen [dazu, wie Sie eine Übertragung vor dem Aufrufen der `shutdownNow` Methode erfolgreich abschließen `waitForCompletion` können, finden Sie unter Warten](#transfermanager-wait-for-completion), bis eine Übertragung abgeschlossen TransferManager ist. Während Sie darauf warten, dass die Übertragung abgeschlossen ist, können Sie Aktualisierungen zum Status und Fortschritt abfragen oder diese als Ereignisse empfangen. Weitere Informationen finden Sie unter [Abrufen des Übertragungsstatus und ‑fortschritts](#transfermanager-get-status-and-progress).
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrUpload.java) finden Sie unter GitHub.
### Hochladen einer Dateiliste
Sie können mehrere Dateien auf einmal hochladen, indem Sie die TransferManager-Methode des `uploadFileList` aufrufen und dabei Folgendes angeben:
+ Ein Amazon S3 Bucket-Name
+ *Schlüsselpräfix*, das dem Namen der erstellten Objekte vorangestellt wird (Pfad innerhalb des Buckets, wo die Objekte abgespeichert werden sollen)
+ [File](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/File.html)-Objekt, das das relative Verzeichnis darstellt, von dem aus die Dateipfade erstellt werden sollen
+ [List](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/List.html)-Objekt mit einer Reihe von [File](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/File.html)-Objekten zum Hochladen
**Importe**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.s3.transfer.MultipleFileUpload;
import com.amazonaws.services.s3.transfer.TransferManager;
import com.amazonaws.services.s3.transfer.TransferManagerBuilder;
import com.amazonaws.services.s3.transfer.Upload;
import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
```
**Code**
```
ArrayList files = new ArrayList();
for (String path : file_paths) {
files.add(new File(path));
}
TransferManager xfer_mgr = TransferManagerBuilder.standard().build();
try {
MultipleFileUpload xfer = xfer_mgr.uploadFileList(bucket_name,
key_prefix, new File("."), files);
// loop with Transfer.isDone()
XferMgrProgress.showTransferProgress(xfer);
// or block with Transfer.waitForCompletion()
XferMgrProgress.waitForCompletion(xfer);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
xfer_mgr.shutdownNow();
```
Informationen dazu, wie Sie [die `shutdownNow` Methode verwenden, um eine Übertragung vor dem Aufrufen TransferManager erfolgreich abzuschließen`waitForCompletion`, finden Sie unter Warten](#transfermanager-wait-for-completion) auf den Abschluss einer Übertragung. Während Sie darauf warten, dass die Übertragung abgeschlossen ist, können Sie Aktualisierungen zum Status und Fortschritt abfragen oder diese als Ereignisse empfangen. Weitere Informationen finden Sie unter [Abrufen des Übertragungsstatus und ‑fortschritts](#transfermanager-get-status-and-progress).
Das von zurückgegebene [MultipleFileUpload](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/MultipleFileUpload.html)Objekt `uploadFileList` kann verwendet werden, um den Status oder den Fortschritt der Übertragung abzufragen. Weitere [Informationen finden Sie unter Den aktuellen Status einer Übertragung](#transfermanager-get-progress-polling) [abfragen und ProgressListener Übertragungsstatus abrufen mit](#transfermanager-progress-listener) a.
Sie können auch die `MultipleFileUpload`-Methode der `getSubTransfers`-Klasse verwenden, um die einzelnen `Upload`-Objekte für jede zu übertragende Datei zu erhalten. Weitere Informationen finden Sie unter [Abruf des Fortschritts von untergeordneten Übertragungen](#transfermanager-get-subtransfer-progress).
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrUpload.java) finden Sie unter GitHub.
### Upload eines Verzeichnisses
Sie können die `uploadDirectory` Methode verwenden TransferManager, um ein ganzes Verzeichnis von Dateien hochzuladen, mit der Option, Dateien in Unterverzeichnisse rekursiv zu kopieren. Sie geben einen Amazon S3 Bucket-Namen, ein S3-Schlüsselpräfix, ein [File-Objekt](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/File.html), das das zu kopierende lokale Verzeichnis darstellt, und einen `boolean` Wert an, der angibt, ob Sie Unterverzeichnisse rekursiv kopieren möchten (*true* oder *false*).
**Importe**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.s3.transfer.MultipleFileUpload;
import com.amazonaws.services.s3.transfer.TransferManager;
import com.amazonaws.services.s3.transfer.TransferManagerBuilder;
import com.amazonaws.services.s3.transfer.Upload;
import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
```
**Code**
```
TransferManager xfer_mgr = TransferManagerBuilder.standard().build();
try {
MultipleFileUpload xfer = xfer_mgr.uploadDirectory(bucket_name,
key_prefix, new File(dir_path), recursive);
// loop with Transfer.isDone()
XferMgrProgress.showTransferProgress(xfer);
// or block with Transfer.waitForCompletion()
XferMgrProgress.waitForCompletion(xfer);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
xfer_mgr.shutdownNow();
```
Informationen dazu, wie Sie [eine Übertragung vor dem Aufrufen TransferManager der Methode erfolgreich abschließen `waitForCompletion` können, finden Sie unter Warten](#transfermanager-wait-for-completion) auf den Abschluss einer Übertragung. `shutdownNow` Während Sie darauf warten, dass die Übertragung abgeschlossen ist, können Sie Aktualisierungen zum Status und Fortschritt abfragen oder diese als Ereignisse empfangen. Weitere Informationen finden Sie unter [Abrufen des Übertragungsstatus und ‑fortschritts](#transfermanager-get-status-and-progress).
Das von zurückgegebene [MultipleFileUpload](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/MultipleFileUpload.html)Objekt `uploadFileList` kann verwendet werden, um den Status oder den Fortschritt der Übertragung abzufragen. Weitere [Informationen finden Sie unter Den aktuellen Status einer Übertragung](#transfermanager-get-progress-polling) [abfragen und ProgressListener Übertragungsstatus abrufen mit](#transfermanager-progress-listener) a.
Sie können auch die `MultipleFileUpload`-Methode der `getSubTransfers`-Klasse verwenden, um die einzelnen `Upload`-Objekte für jede zu übertragende Datei zu erhalten. Weitere Informationen finden Sie unter [Abruf des Fortschritts von untergeordneten Übertragungen](#transfermanager-get-subtransfer-progress).
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrUpload.java) finden Sie unter GitHub.
## Herunterladen von Dateien oder Verzeichnissen
Verwenden Sie die TransferManager Klasse, um entweder eine einzelne Datei (Amazon S3 Objekt) oder ein Verzeichnis (ein Amazon S3 Bucket-Name gefolgt von einem Objektpräfix) herunterzuladen Amazon S3.
**Topics**
+ [Herunterladen einer einzelnen Datei](#transfermanager-download-file)
+ [Herunterladen eines Verzeichnisses](#tranfermanager-download-directory)
### Herunterladen einer einzelnen Datei
Verwenden Sie die `download` Methode TransferManager's und geben Sie den Amazon S3 Bucket-Namen an, der das Objekt enthält, das Sie herunterladen möchten, den Schlüssel- (Objekt-) Namen und ein [File-Objekt](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/File.html), das die Datei darstellt, die auf Ihrem lokalen System erstellt werden soll.
**Importe**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.s3.transfer.Download;
import com.amazonaws.services.s3.transfer.MultipleFileDownload;
import com.amazonaws.services.s3.transfer.TransferManager;
import com.amazonaws.services.s3.transfer.TransferManagerBuilder;
import java.io.File;
```
**Code**
```
File f = new File(file_path);
TransferManager xfer_mgr = TransferManagerBuilder.standard().build();
try {
Download xfer = xfer_mgr.download(bucket_name, key_name, f);
// loop with Transfer.isDone()
XferMgrProgress.showTransferProgress(xfer);
// or block with Transfer.waitForCompletion()
XferMgrProgress.waitForCompletion(xfer);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
xfer_mgr.shutdownNow();
```
Informationen [dazu, wie Sie eine Übertragung vor dem Aufrufen TransferManager der `shutdownNow` Methode erfolgreich abschließen `waitForCompletion` können, finden Sie unter Warten](#transfermanager-wait-for-completion) auf den Abschluss einer Übertragung. Während Sie darauf warten, dass die Übertragung abgeschlossen ist, können Sie Aktualisierungen zum Status und Fortschritt abfragen oder diese als Ereignisse empfangen. Weitere Informationen finden Sie unter [Abrufen des Übertragungsstatus und ‑fortschritts](#transfermanager-get-status-and-progress).
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrDownload.java) finden Sie unter GitHub.
### Herunterladen eines Verzeichnisses
Verwenden Sie die TransferManager `downloadDirectory` Methode, um eine Reihe von Dateien herunterzuladen, die ein gemeinsames key prefix haben (analog zu einem Verzeichnis in einem Dateisystem). Amazon S3 Die Methode verwendet den Amazon S3 Bucket-Namen, der die Objekte enthält, die Sie herunterladen möchten, das Objektpräfix, das von allen Objekten gemeinsam genutzt wird, und ein [File-Objekt](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/File.html), das das Verzeichnis darstellt, in das die Dateien auf Ihrem lokalen System heruntergeladen werden sollen. Wenn das angegebene Verzeichnis noch nicht vorhanden ist, wird es erstellt.
**Importe**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.s3.transfer.Download;
import com.amazonaws.services.s3.transfer.MultipleFileDownload;
import com.amazonaws.services.s3.transfer.TransferManager;
import com.amazonaws.services.s3.transfer.TransferManagerBuilder;
import java.io.File;
```
**Code**
```
TransferManager xfer_mgr = TransferManagerBuilder.standard().build();
try {
MultipleFileDownload xfer = xfer_mgr.downloadDirectory(
bucket_name, key_prefix, new File(dir_path));
// loop with Transfer.isDone()
XferMgrProgress.showTransferProgress(xfer);
// or block with Transfer.waitForCompletion()
XferMgrProgress.waitForCompletion(xfer);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
xfer_mgr.shutdownNow();
```
Informationen [dazu, wie Sie eine Übertragung vor dem Aufrufen TransferManager der `shutdownNow` Methode erfolgreich abschließen `waitForCompletion` können, finden Sie unter Warten](#transfermanager-wait-for-completion) auf den Abschluss einer Übertragung. Während Sie darauf warten, dass die Übertragung abgeschlossen ist, können Sie Aktualisierungen zum Status und Fortschritt abfragen oder diese als Ereignisse empfangen. Weitere Informationen finden Sie unter [Abrufen des Übertragungsstatus und ‑fortschritts](#transfermanager-get-status-and-progress).
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrDownload.java) finden Sie unter GitHub.
## Kopieren von Objekten
Rufen Sie die `copy`-Methode von TransferManager auf, um ein Objekt von einem S3-Bucket in einen anderen zu kopieren.
**Importe**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.s3.transfer.Copy;
import com.amazonaws.services.s3.transfer.TransferManager;
import com.amazonaws.services.s3.transfer.TransferManagerBuilder;
```
**Code**
```
System.out.println("Copying s3 object: " + from_key);
System.out.println(" from bucket: " + from_bucket);
System.out.println(" to s3 object: " + to_key);
System.out.println(" in bucket: " + to_bucket);
TransferManager xfer_mgr = TransferManagerBuilder.standard().build();
try {
Copy xfer = xfer_mgr.copy(from_bucket, from_key, to_bucket, to_key);
// loop with Transfer.isDone()
XferMgrProgress.showTransferProgress(xfer);
// or block with Transfer.waitForCompletion()
XferMgrProgress.waitForCompletion(xfer);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
xfer_mgr.shutdownNow();
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrCopy.java) finden Sie unter GitHub.
## Warten auf die Fertigstellung einer Übertragung
Wenn Ihre Anwendung (oder Ihr Thread) blockieren kann, bis die Übertragung abgeschlossen ist, können Sie die `waitForCompletion` Methode der [Transfer-Schnittstelle](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/Transfer.html) verwenden, um zu blockieren, bis die Übertragung abgeschlossen ist oder eine Ausnahme auftritt.
```
try {
xfer.waitForCompletion();
} catch (AmazonServiceException e) {
System.err.println("Amazon service error: " + e.getMessage());
System.exit(1);
} catch (AmazonClientException e) {
System.err.println("Amazon client error: " + e.getMessage());
System.exit(1);
} catch (InterruptedException e) {
System.err.println("Transfer interrupted: " + e.getMessage());
System.exit(1);
}
```
Sie erhalten den Fortschritt der Übertragungen, wenn Sie *vor dem* Aufrufen Ereignisse abfragen`waitForCompletion`, einen Abfragemechanismus in einem separaten Thread implementieren oder Fortschrittsaktualisierungen asynchron mit einem empfangen. [ProgressListener](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/event/ProgressListener.html)
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrProgress.java) finden Sie unter. GitHub
## Abrufen des Übertragungsstatus und ‑fortschritt
Jede der von den `copy` Methoden TransferManager `upload*``download*`, und zurückgegebenen Klassen gibt eine Instanz einer der folgenden Klassen zurück, je nachdem, ob es sich um eine Operation mit einer oder mehreren Dateien handelt.
****
| Klasse | Zurückgegeben von |
| --- | --- |
| [Copy](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/Copy.html) | `copy` |
| [Download](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/Download.html) | `download` |
| [MultipleFileDownload](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/MultipleFileDownload.html) | `downloadDirectory` |
| [Hochladen](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/Upload.html) | `upload` |
| [MultipleFileUpload](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/MultipleFileUpload.html) | `uploadFileList`, `uploadDirectory` |
Alle diese Klassen implementieren die [Transfer](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/Transfer.html)-Schnittstelle. `Transfer` liefert nützliche Methoden, um den Fortschritt einer Übertragung abzurufen, die Übertragung zu pausieren oder fortzusetzen sowie den aktuellen oder abschließenden Status der Übertragung abzurufen.
**Topics**
+ [Abfragen des aktuellen Fortschritts einer Übertragung](#transfermanager-get-progress-polling)
+ [Holen Sie sich den Übertragungsfortschritt mit einem ProgressListener](#transfermanager-progress-listener)
+ [Abruf des Fortschritts von untergeordneten Übertragungen](#transfermanager-get-subtransfer-progress)
### Abfragen des aktuellen Fortschritts einer Übertragung
Diese Schleife gibt den Fortschritt einer Übertragung aus, untersucht den aktuellen Fortschritt während der Ausführung und gibt beim Abschluss den abschließenden Status aus.
**Importe**
```
import com.amazonaws.AmazonClientException;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.event.ProgressEvent;
import com.amazonaws.event.ProgressListener;
import com.amazonaws.services.s3.transfer.*;
import com.amazonaws.services.s3.transfer.Transfer.TransferState;
import java.io.File;
import java.util.ArrayList;
import java.util.Collection;
```
**Code**
```
// print the transfer's human-readable description
System.out.println(xfer.getDescription());
// print an empty progress bar...
printProgressBar(0.0);
// update the progress bar while the xfer is ongoing.
do {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
return;
}
// Note: so_far and total aren't used, they're just for
// documentation purposes.
TransferProgress progress = xfer.getProgress();
long so_far = progress.getBytesTransferred();
long total = progress.getTotalBytesToTransfer();
double pct = progress.getPercentTransferred();
eraseProgressBar();
printProgressBar(pct);
} while (xfer.isDone() == false);
// print the final state of the transfer.
TransferState xfer_state = xfer.getState();
System.out.println(": " + xfer_state);
```
[Das vollständige Beispiel finden Sie unter.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrProgress.java) GitHub
### Holen Sie sich den Übertragungsfortschritt mit einem ProgressListener
Mithilfe der `addProgressListener` Methode der Transfer-Schnittstelle können Sie jeder [Übertragung](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/Transfer.html) eine [ProgressListener](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/event/ProgressListener.html)hinzufügen.
A [ProgressListener](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/event/ProgressListener.html)benötigt nur eine Methode`progressChanged`, die ein [ProgressEvent](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/event/ProgressEvent.html)Objekt akzeptiert. Mit diesem Objekt können Sie die Gesamtzahl der Bytes der Operation ermitteln, indem Sie die `getBytes`-Methode aufrufen. Die Gesamtzahl der übertragenen Bytes erfahren Sie mit Aufruf von `getBytesTransferred`.
**Importe**
```
import com.amazonaws.AmazonClientException;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.event.ProgressEvent;
import com.amazonaws.event.ProgressListener;
import com.amazonaws.services.s3.transfer.*;
import com.amazonaws.services.s3.transfer.Transfer.TransferState;
import java.io.File;
import java.util.ArrayList;
import java.util.Collection;
```
**Code**
```
File f = new File(file_path);
TransferManager xfer_mgr = TransferManagerBuilder.standard().build();
try {
Upload u = xfer_mgr.upload(bucket_name, key_name, f);
// print an empty progress bar...
printProgressBar(0.0);
u.addProgressListener(new ProgressListener() {
public void progressChanged(ProgressEvent e) {
double pct = e.getBytesTransferred() * 100.0 / e.getBytes();
eraseProgressBar();
printProgressBar(pct);
}
});
// block with Transfer.waitForCompletion()
XferMgrProgress.waitForCompletion(u);
// print the final state of the transfer.
TransferState xfer_state = u.getState();
System.out.println(": " + xfer_state);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
xfer_mgr.shutdownNow();
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrProgress.java) finden Sie unter GitHub.
### Abruf des Fortschritts von untergeordneten Übertragungen
Die [MultipleFileUpload](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/MultipleFileUpload.html)Klasse kann Informationen über ihre Unterübertragungen zurückgeben, indem sie ihre `getSubTransfers` Methode aufruft. Sie gibt eine unveränderbare [Sammlung](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/Collection.html) von [Upload-Objekten](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/Upload.html) zurück, die den individuellen Übertragungsstatus und den Fortschritt jeder Unterübertragung angeben.
**Importe**
```
import com.amazonaws.AmazonClientException;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.event.ProgressEvent;
import com.amazonaws.event.ProgressListener;
import com.amazonaws.services.s3.transfer.*;
import com.amazonaws.services.s3.transfer.Transfer.TransferState;
import java.io.File;
import java.util.ArrayList;
import java.util.Collection;
```
**Code**
```
Collection sub_xfers = new ArrayList();
sub_xfers = multi_upload.getSubTransfers();
do {
System.out.println("\nSubtransfer progress:\n");
for (Upload u : sub_xfers) {
System.out.println(" " + u.getDescription());
if (u.isDone()) {
TransferState xfer_state = u.getState();
System.out.println(" " + xfer_state);
} else {
TransferProgress progress = u.getProgress();
double pct = progress.getPercentTransferred();
printProgressBar(pct);
System.out.println();
}
}
// wait a bit before the next update.
try {
Thread.sleep(200);
} catch (InterruptedException e) {
return;
}
} while (multi_upload.isDone() == false);
// print the final state of the transfer.
TransferState xfer_state = multi_upload.getState();
System.out.println("\nMultipleFileUpload " + xfer_state);
```
Das [vollständige](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrProgress.java) Beispiel finden Sie unter. GitHub
## Weitere Infos
+ [Objektschlüssel](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingMetadata.html) im Amazon Simple Storage Service Benutzerhandbuch
# Einen Amazon S3 Bucket als Website konfigurieren
Sie können einen Amazon S3 Bucket so konfigurieren, dass er sich wie eine Website verhält. Hierzu müssen Sie die Website-Konfiguration festlegen.
**Anmerkung**
Bei diesen Codebeispielen wird vorausgesetzt, dass Sie die Informationen [unter Verwenden von](basics.md) verstehen AWS SDK für Java und AWS Standardanmeldedaten anhand der Informationen unter [AWS Anmeldeinformationen einrichten und Region für die Entwicklung](setup-credentials.md) konfiguriert haben.
## Festlegen der Website-Konfiguration eines Buckets
Um die Website-Konfiguration eines Amazon S3 Buckets festzulegen, rufen Sie die `setWebsiteConfiguration` AmazonS3-Methode mit dem Bucket-Namen auf, für den die Konfiguration festgelegt werden soll, und einem [BucketWebsiteConfiguration](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/BucketWebsiteConfiguration.html)Objekt, das die Website-Konfiguration des Buckets enthält.
Das Festlegen eines Index-Dokuments ist *erforderlich*. Alle anderen Parameter sind optional.
**Importe**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.BucketWebsiteConfiguration;
```
**Code**
```
String bucket_name, String index_doc, String error_doc) {
BucketWebsiteConfiguration website_config = null;
if (index_doc == null) {
website_config = new BucketWebsiteConfiguration();
} else if (error_doc == null) {
website_config = new BucketWebsiteConfiguration(index_doc);
} else {
website_config = new BucketWebsiteConfiguration(index_doc, error_doc);
}
final AmazonS3 s3 = AmazonS3ClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
try {
s3.setBucketWebsiteConfiguration(bucket_name, website_config);
} catch (AmazonServiceException e) {
System.out.format(
"Failed to set website configuration for bucket '%s'!\n",
bucket_name);
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
**Anmerkung**
Beim Festlegen einer Website-Konfiguration werden die Zugriffsberechtigungen für den Bucket nicht geändert. Um die enthaltenen Dateien im Internet sichtbar zu machen, müssen Sie zusätzlich eine *Bucket-Richtlinie* festlegen, durch die der öffentliche Lesezugriff für die Dateien in dem Bucket ermöglicht wird. Weitere Informationen finden Sie unter [Zugriff auf Amazon S3 Buckets mithilfe von Bucket-Richtlinien verwalten](examples-s3-bucket-policies.md).
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/SetWebsiteConfiguration.java) finden Sie unter. GitHub
## Abruf der Website-Konfiguration eines Buckets
Um die Website-Konfiguration eines Amazon S3 Buckets abzurufen, rufen Sie die `getWebsiteConfiguration` AmazonS3-Methode mit dem Namen des Buckets auf, für den die Konfiguration abgerufen werden soll.
Die Konfiguration wird als Objekt zurückgegeben. [BucketWebsiteConfiguration](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/BucketWebsiteConfiguration.html) Wenn keine Website-Konfiguration für den Bucket vorhanden ist, wird `null` zurückgegeben.
**Importe**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.BucketWebsiteConfiguration;
```
**Code**
```
final AmazonS3 s3 = AmazonS3ClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
try {
BucketWebsiteConfiguration config =
s3.getBucketWebsiteConfiguration(bucket_name);
if (config == null) {
System.out.println("No website configuration found!");
} else {
System.out.format("Index document: %s\n",
config.getIndexDocumentSuffix());
System.out.format("Error document: %s\n",
config.getErrorDocument());
}
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.out.println("Failed to get website configuration!");
System.exit(1);
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/GetWebsiteConfiguration.java) finden Sie unter GitHub.
## Löschen der Website-Konfiguration eines Buckets
Um die Website-Konfiguration eines Amazon S3 Buckets zu löschen, rufen Sie die `deleteWebsiteConfiguration` Methode von AmazonS3 mit dem Namen des Buckets auf, aus dem die Konfiguration gelöscht werden soll.
**Importe**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
```
**Code**
```
final AmazonS3 s3 = AmazonS3ClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
try {
s3.deleteBucketWebsiteConfiguration(bucket_name);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.out.println("Failed to delete website configuration!");
System.exit(1);
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/DeleteWebsiteConfiguration.java) finden Sie unter. GitHub
## Weitere Informationen
+ [PUT Bucket-Website](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTwebsite.html) in der Amazon S3 API-Referenz
+ [GET Bucket-Website](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketGETwebsite.html) in der Amazon S3 API-Referenz
+ [DELETE Bucket-Website](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketDELETEwebsite.html) in der Amazon S3 API-Referenz
# Amazon S3 Clientseitige Verschlüsselung verwenden
Das Verschlüsseln von Daten mit dem Amazon S3 Verschlüsselungsclient ist eine Möglichkeit, eine zusätzliche Schutzebene für vertrauliche Informationen bereitzustellen, in denen Sie gespeichert sind. Amazon S3 Die Beispiele in diesem Abschnitt zeigen, wie Sie den Amazon S3 Verschlüsselungsclient für Ihre Anwendung erstellen und konfigurieren.
Wenn Sie mit Kryptografie noch nicht vertraut sind, finden Sie in den [Grundlagen der Kryptografie](https://docs.aws.amazon.com/kms/latest/developerguide/crypto-intro.html) im AWS KMS-Entwicklerhandbuch einen grundlegenden Überblick über Begriffe und Algorithmen der Kryptografie. Informationen zur allgemeinen Kryptografieunterstützung finden Sie AWS SDKs unter [AWS SDK-Unterstützung für Amazon S3 clientseitige Verschlüsselung](https://docs.aws.amazon.com/general/latest/gr/aws_sdk_cryptography.html) in der Amazon Web Services Allgemeinen Referenz.
**Anmerkung**
Bei diesen Codebeispielen wird vorausgesetzt, dass Sie die Informationen [unter Verwenden von](basics.md) verstehen AWS SDK für Java und AWS Standardanmeldedaten anhand der Informationen unter [AWS Anmeldeinformationen einrichten und Region](setup-credentials.md) für die Entwicklung konfiguriert haben.
Wenn Sie Version 1.11.836 oder eine frühere Version von verwenden AWS SDK für Java, finden Sie unter [Amazon S3 Encryption Client Migration Informationen zur Migration](s3-encryption-migration.md) Ihrer Anwendungen auf spätere Versionen. Wenn Sie nicht migrieren können, finden Sie [dieses](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/S3Encrypt.java) vollständige Beispiel unter. GitHub
Wenn Sie Version 1.11.837 oder höher von verwenden AWS SDK für Java, sollten Sie sich andernfalls die unten aufgeführten Beispielthemen zur Verwendung Amazon S3 der clientseitigen Verschlüsselung ansehen.
**Topics**
+ [Amazon S3 clientseitige Verschlüsselung mit Client-Hauptschlüsseln](examples-crypto-masterkey.md)
+ [Amazon S3 clientseitige Verschlüsselung mit AWS KMS-verwalteten Schlüsseln](examples-crypto-kms.md)
# Amazon S3 clientseitige Verschlüsselung mit Client-Hauptschlüsseln
In den folgenden Beispielen wird die [AmazonS3 EncryptionClient V2Builder-Klasse](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/AmazonS3EncryptionClientV2Builder.html) verwendet, um einen Amazon S3 Client mit aktivierter clientseitiger Verschlüsselung zu erstellen. Nach der Aktivierung werden alle Objekte, auf die Sie mit diesem Client hochladen, Amazon S3 verschlüsselt. Alle Objekte, die Sie Amazon S3 mit diesem Client erhalten, werden automatisch entschlüsselt.
**Anmerkung**
Die folgenden Beispiele zeigen die Verwendung der Amazon S3 clientseitigen Verschlüsselung mit kundenverwalteten Client-Hauptschlüsseln. Informationen zur Verwendung der Verschlüsselung mit von AWS KMS verwalteten Schlüsseln finden Sie unter [Amazon S3 Clientseitige Verschlüsselung](examples-crypto-kms.md) mit von KMS verwalteten Schlüsseln. AWS
Bei der Aktivierung der clientseitigen Verschlüsselung können Sie zwischen zwei Verschlüsselungsmodi wählen: strikt authentifiziert Amazon S3 oder authentifiziert. In den folgenden Abschnitten sehen Sie, wie die unterschiedlichen Modi aktiviert werden. Informationen zu den Algorithmen, die in den einzelnen Modi verwendet werden, finden Sie in der Definition. [CryptoMode](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/CryptoMode.html)
## Erforderliche Importe
Importieren Sie für diese Beispiele die folgenden Klassen.
**Importe**
```
import com.amazonaws.ClientConfiguration;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3EncryptionClientV2Builder;
import com.amazonaws.services.s3.AmazonS3EncryptionV2;
import com.amazonaws.services.s3.model.CryptoConfigurationV2;
import com.amazonaws.services.s3.model.CryptoMode;
import com.amazonaws.services.s3.model.EncryptionMaterials;
import com.amazonaws.services.s3.model.StaticEncryptionMaterialsProvider;
```
## Strikte authentifizierte Verschlüsselung
Strikte authentifizierte Verschlüsselung ist der Standardmodus, wenn kein Modus angegeben `CryptoMode` ist.
Um diesen Modus explizit zu aktivieren, geben Sie den `StrictAuthenticatedEncryption` Wert in der `withCryptoConfiguration` Methode an.
**Anmerkung**
Bei Verwendung der clientseitigen authentifizierten Verschlüsselung müssen Sie die neueste [Bouncy Castle jar](https://www.bouncycastle.org/download/bouncy-castle-java/)-Datei im Klassenpfad Ihrer Anwendung einschließen.
**Code**
```
AmazonS3EncryptionV2 s3Encryption = AmazonS3EncryptionClientV2Builder.standard()
.withRegion(Regions.US_WEST_2)
.withCryptoConfiguration(new CryptoConfigurationV2().withCryptoMode((CryptoMode.StrictAuthenticatedEncryption)))
.withEncryptionMaterialsProvider(new StaticEncryptionMaterialsProvider(new EncryptionMaterials(secretKey)))
.build();
s3Encryption.putObject(bucket_name, ENCRYPTED_KEY2, "This is the 2nd content to encrypt");
```
## Authentifizierter Verschlüsselungsmodus
Beim Modus `AuthenticatedEncryption` wird während der Verschlüsselung ein verbesserter Schlüsselverpackungsalgorithmus angewendet. Bei einer Entschlüsselung in diesem Modus verifiziert der Algorithmus die Integrität des entschlüsselten Objekts und löst eine Ausnahme aus, wenn das Objekt nicht verifiziert werden kann. Weitere Informationen zur Funktionsweise der authentifizierten Verschlüsselung finden Sie im Blogbeitrag [Amazon S3 Client-Side Authenticated](https://aws.amazon.com/blogs/developer/amazon-s3-client-side-authenticated-encryption) Encryption.
**Anmerkung**
Bei Verwendung der clientseitigen authentifizierten Verschlüsselung müssen Sie die neueste [Bouncy Castle jar](https://www.bouncycastle.org/download/bouncy-castle-java/)-Datei im Klassenpfad Ihrer Anwendung einschließen.
Zur Aktivierung des Modus geben Sie den `AuthenticatedEncryption`-Wert in der `withCryptoConfiguration`-Methode an.
**Code**
```
AmazonS3EncryptionV2 s3EncryptionClientV2 = AmazonS3EncryptionClientV2Builder.standard()
.withRegion(Regions.DEFAULT_REGION)
.withClientConfiguration(new ClientConfiguration())
.withCryptoConfiguration(new CryptoConfigurationV2().withCryptoMode(CryptoMode.AuthenticatedEncryption))
.withEncryptionMaterialsProvider(new StaticEncryptionMaterialsProvider(new EncryptionMaterials(secretKey)))
.build();
s3EncryptionClientV2.putObject(bucket_name, ENCRYPTED_KEY1, "This is the 1st content to encrypt");
```
# Amazon S3 clientseitige Verschlüsselung mit AWS KMS-verwalteten Schlüsseln
In den folgenden Beispielen wird die [AmazonS3 EncryptionClient V2Builder-Klasse](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/AmazonS3EncryptionClientV2Builder.html) verwendet, um einen Amazon S3 Client mit aktivierter clientseitiger Verschlüsselung zu erstellen. Nach der Konfiguration werden alle Objekte, auf die Sie mit diesem Client hochladen, Amazon S3 verschlüsselt. Alle Objekte, die Sie Amazon S3 über diesen Client erhalten, werden automatisch entschlüsselt.
**Anmerkung**
Die folgenden Beispiele zeigen, wie die Amazon S3 clientseitige Verschlüsselung mit verwalteten AWS KMS-Schlüsseln verwendet wird. Informationen zur Verwendung der Verschlüsselung mit Ihren eigenen Schlüsseln finden Sie unter [Amazon S3 Clientseitige Verschlüsselung mit Client-Hauptschlüsseln](examples-crypto-masterkey.md).
Bei der Aktivierung der clientseitigen Verschlüsselung können Sie zwischen zwei Verschlüsselungsmodi wählen: strikt authentifiziert Amazon S3 oder authentifiziert. In den folgenden Abschnitten sehen Sie, wie die unterschiedlichen Modi aktiviert werden. Informationen zu den Algorithmen, die in den einzelnen Modi verwendet werden, finden Sie in der Definition. [CryptoMode](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/CryptoMode.html)
## Erforderliche Importe
Importieren Sie für diese Beispiele die folgenden Klassen.
**Importe**
```
import com.amazonaws.ClientConfiguration;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.kms.AWSKMS;
import com.amazonaws.services.kms.AWSKMSClientBuilder;
import com.amazonaws.services.kms.model.GenerateDataKeyRequest;
import com.amazonaws.services.kms.model.GenerateDataKeyResult;
import com.amazonaws.services.s3.AmazonS3EncryptionClientV2Builder;
import com.amazonaws.services.s3.AmazonS3EncryptionV2;
import com.amazonaws.services.s3.model.CryptoConfigurationV2;
import com.amazonaws.services.s3.model.CryptoMode;
import com.amazonaws.services.s3.model.EncryptionMaterials;
import com.amazonaws.services.s3.model.KMSEncryptionMaterialsProvider;
```
## Strikte authentifizierte Verschlüsselung
Strikte authentifizierte Verschlüsselung ist der Standardmodus, wenn kein Modus angegeben `CryptoMode` ist.
Um diesen Modus explizit zu aktivieren, geben Sie den `StrictAuthenticatedEncryption` Wert in der `withCryptoConfiguration` Methode an.
**Anmerkung**
Bei Verwendung der clientseitigen authentifizierten Verschlüsselung müssen Sie die neueste [Bouncy Castle jar](https://www.bouncycastle.org/download/bouncy-castle-java/)-Datei im Klassenpfad Ihrer Anwendung einschließen.
**Code**
```
AmazonS3EncryptionV2 s3Encryption = AmazonS3EncryptionClientV2Builder.standard()
.withRegion(Regions.US_WEST_2)
.withCryptoConfiguration(new CryptoConfigurationV2().withCryptoMode((CryptoMode.StrictAuthenticatedEncryption)))
.withEncryptionMaterialsProvider(new KMSEncryptionMaterialsProvider(keyId))
.build();
s3Encryption.putObject(bucket_name, ENCRYPTED_KEY3, "This is the 3rd content to encrypt with a key created in the {console}");
System.out.println(s3Encryption.getObjectAsString(bucket_name, ENCRYPTED_KEY3));
```
Rufen Sie die `putObject` Methode auf dem Amazon S3 Verschlüsselungsclient auf, um Objekte hochzuladen.
**Code**
```
s3Encryption.putObject(bucket_name, ENCRYPTED_KEY3, "This is the 3rd content to encrypt with a key created in the {console}");
```
Sie können das Objekt mit demselben Client abrufen. Bei diesem Beispiel wird die `getObjectAsString`-Methode zum Abrufen der gespeicherten Zeichenfolge eingesetzt.
**Code**
```
System.out.println(s3Encryption.getObjectAsString(bucket_name, ENCRYPTED_KEY3));
```
## Authentifizierter Verschlüsselungsmodus
Beim Modus `AuthenticatedEncryption` wird während der Verschlüsselung ein verbesserter Schlüsselverpackungsalgorithmus angewendet. Bei einer Entschlüsselung in diesem Modus verifiziert der Algorithmus die Integrität des entschlüsselten Objekts und löst eine Ausnahme aus, wenn das Objekt nicht verifiziert werden kann. Weitere Informationen zur Funktionsweise der authentifizierten Verschlüsselung finden Sie im Blogbeitrag [Amazon S3 Client-Side Authenticated](https://aws.amazon.com/blogs/developer/amazon-s3-client-side-authenticated-encryption) Encryption.
**Anmerkung**
Bei Verwendung der clientseitigen authentifizierten Verschlüsselung müssen Sie die neueste [Bouncy Castle jar](https://www.bouncycastle.org/download/bouncy-castle-java/)-Datei im Klassenpfad Ihrer Anwendung einschließen.
Zur Aktivierung des Modus geben Sie den `AuthenticatedEncryption`-Wert in der `withCryptoConfiguration`-Methode an.
**Code**
```
AmazonS3EncryptionV2 s3Encryption = AmazonS3EncryptionClientV2Builder.standard()
.withRegion(Regions.US_WEST_2)
.withCryptoConfiguration(new CryptoConfigurationV2().withCryptoMode((CryptoMode.AuthenticatedEncryption)))
.withEncryptionMaterialsProvider(new KMSEncryptionMaterialsProvider(keyId))
.build();
```
## AWS KMS Den Client konfigurieren
Der Amazon S3 Verschlüsselungsclient erstellt standardmäßig einen AWS KMS Client, sofern nicht explizit einer angegeben ist.
Um die Region für diesen automatisch erstellten AWS KMS Client festzulegen, legen Sie den fest. `awsKmsRegion`
**Code**
```
Region kmsRegion = Region.getRegion(Regions.AP_NORTHEAST_1);
AmazonS3EncryptionV2 s3Encryption = AmazonS3EncryptionClientV2Builder.standard()
.withRegion(Regions.US_WEST_2)
.withCryptoConfiguration(new CryptoConfigurationV2().withAwsKmsRegion(kmsRegion))
.withEncryptionMaterialsProvider(new KMSEncryptionMaterialsProvider(keyId))
.build();
```
Alternativ können Sie Ihren eigenen AWS KMS Client verwenden, um den Verschlüsselungsclient zu initialisieren.
**Code**
```
AWSKMS kmsClient = AWSKMSClientBuilder.standard()
.withRegion(Regions.US_WEST_2);
.build();
AmazonS3EncryptionV2 s3Encryption = AmazonS3EncryptionClientV2Builder.standard()
.withRegion(Regions.US_WEST_2)
.withKmsClient(kmsClient)
.withCryptoConfiguration(new CryptoConfigurationV2().withCryptoMode((CryptoMode.AuthenticatedEncryption)))
.withEncryptionMaterialsProvider(new KMSEncryptionMaterialsProvider(keyId))
.build();
```
# Amazon SQS Beispiele für die Verwendung der AWS SDK für Java
Dieser Abschnitt bietet Beispiele für die Programmierung von [Amazon SQS](https://aws.amazon.com/sqs/) mithilfe des [AWS SDK für Java](https://aws.amazon.com/sdk-for-java/).
**Anmerkung**
Die Beispiele enthalten nur den Code, der zur Demonstration jeder Technik nötig ist. Der [vollständige Beispielcode ist verfügbar unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/java). Von dort aus können Sie eine einzelne Quelldatei herunterladen oder das Repository klonen, um alle Beispiele lokal zu erstellen und auszuführen.
**Topics**
+ [Mit Amazon SQS Nachrichtenwarteschlangen arbeiten](examples-sqs-message-queues.md)
+ [Amazon SQS Nachrichten senden, empfangen und löschen](examples-sqs-messages.md)
+ [Long Polling für Amazon SQS Nachrichtenwarteschlangen aktivieren](examples-sqs-long-polling.md)
+ [Sichtbarkeits-Timeout einrichten in Amazon SQS](examples-sqs-visibility-timeout.md)
+ [Verwenden von Warteschlangen für unzustellbare Briefe in Amazon SQS](examples-sqs-dead-letter-queues.md)
# Mit Amazon SQS Nachrichtenwarteschlangen arbeiten
Eine *Nachrichtenwarteschlange* ist der logische Container, in den Nachrichten zuverlässig gesendet werden Amazon SQS. Es gibt zwei Arten von Warteschlangen: *Standard* und *First-in-First-out-Verfahren* (FIFO). Weitere Informationen zu Warteschlangen und den Unterschieden zwischen diesen Typen finden Sie im [Amazon SQS Entwicklerhandbuch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/).
In diesem Thema wird beschrieben, wie Sie mithilfe von eine Amazon SQS Warteschlange erstellen, auflisten, löschen und deren URL abrufen. AWS SDK für Java
## Erstellen einer Warteschlange
Verwenden Sie die `createQueue` Methode des AmazonSQS-Clients und stellen Sie ein [CreateQueueRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/CreateQueueRequest.html)Objekt bereit, das die Warteschlangenparameter beschreibt.
**Importe**
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
import com.amazonaws.services.sqs.model.AmazonSQSException;
import com.amazonaws.services.sqs.model.CreateQueueRequest;
```
**Code**
```
AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();
CreateQueueRequest create_request = new CreateQueueRequest(QUEUE_NAME)
.addAttributesEntry("DelaySeconds", "60")
.addAttributesEntry("MessageRetentionPeriod", "86400");
try {
sqs.createQueue(create_request);
} catch (AmazonSQSException e) {
if (!e.getErrorCode().equals("QueueAlreadyExists")) {
throw e;
}
}
```
Sie können die vereinfachte Form von `createQueue` verwenden, die nur einen Namen für die Warteschlange benötigt, um eine Standard-Warteschlange zu erstellen.
```
sqs.createQueue("MyQueue" + new Date().getTime());
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/UsingQueues.java) finden Sie unter. GitHub
## Auflisten von Warteschlangen
Rufen Sie die Methode des AmazonSQS-Clients auf, um die Amazon SQS Warteschlangen für Ihr Konto aufzulisten. `listQueues`
**Importe**
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
import com.amazonaws.services.sqs.model.ListQueuesResult;
```
**Code**
```
AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();
ListQueuesResult lq_result = sqs.listQueues();
System.out.println("Your SQS Queue URLs:");
for (String url : lq_result.getQueueUrls()) {
System.out.println(url);
}
```
Wenn Sie die `listQueues`-Überladung ohne Parameter aufrufen, werden *alle Warteschlangen* zurückgegeben. Sie können die zurückgegebenen Ergebnisse filtern, indem Sie ein `ListQueuesRequest`-Objekt übergeben.
**Importe**
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
import com.amazonaws.services.sqs.model.ListQueuesRequest;
```
**Code**
```
AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();
String name_prefix = "Queue";
lq_result = sqs.listQueues(new ListQueuesRequest(name_prefix));
System.out.println("Queue URLs with prefix: " + name_prefix);
for (String url : lq_result.getQueueUrls()) {
System.out.println(url);
}
```
Das [vollständige](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/UsingQueues.java) Beispiel finden Sie unter. GitHub
## Abrufen der URL für eine Warteschlange
Rufen Sie die Methode des AmazonSQS-Clients auf. `getQueueUrl`
**Importe**
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
```
**Code**
```
AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();
String queue_url = sqs.getQueueUrl(QUEUE_NAME).getQueueUrl();
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/UsingQueues.java) finden Sie unter. GitHub
## Löschen einer Warteschlange
Geben Sie die [URL](#sqs-get-queue-url) der Warteschlange für die Methode des AmazonSQS-Clients an`deleteQueue`.
**Importe**
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
```
**Code**
```
AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();
sqs.deleteQueue(queue_url);
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/UsingQueues.java) finden Sie unter. GitHub
## Weitere Infos
+ [So funktionieren Amazon SQS Warteschlangen](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-how-it-works.html) im Amazon SQS Entwicklerhandbuch
+ [CreateQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html)in der Amazon SQS API-Referenz
+ [GetQueueUrl](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueUrl.html)in der Amazon SQS API-Referenz
+ [ListQueues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ListQueues.html)in der Amazon SQS API-Referenz
+ [DeleteQueues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteQueues.html)in der Amazon SQS API-Referenz
# Amazon SQS Nachrichten senden, empfangen und löschen
In diesem Thema wird beschrieben, wie Sie Amazon SQS Nachrichten senden, empfangen und löschen. Nachrichten werden immer mit einer [SQS-Warteschlange](examples-sqs-message-queues.md) geliefert.
## Senden einer Nachricht
Fügen Sie einer Amazon SQS Warteschlange eine einzelne Nachricht hinzu, indem Sie die Methode des AmazonSQS-Clients aufrufen. `sendMessage` Geben Sie ein [SendMessageRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/SendMessageRequest.html)Objekt an, das die [URL](examples-sqs-message-queues.md#sqs-get-queue-url) der Warteschlange, den Nachrichtentext und den optionalen Verzögerungswert (in Sekunden) enthält.
**Importe**
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
import com.amazonaws.services.sqs.model.SendMessageRequest;
```
**Code**
```
SendMessageRequest send_msg_request = new SendMessageRequest()
.withQueueUrl(queueUrl)
.withMessageBody("hello world")
.withDelaySeconds(5);
sqs.sendMessage(send_msg_request);
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/SendReceiveMessages.java) finden Sie unter GitHub.
### Senden mehrerer Nachrichten gleichzeitig
Sie können mehrere Nachrichten in einer einzigen Anforderung senden. Um mehrere Nachrichten zu senden, verwenden Sie die `sendMessageBatch` Methode des AmazonSQS-Clients, die eine URL [SendMessageBatchRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/SendMessageBatchRequest.html)mit der Warteschlange und eine Liste von Nachrichten (jeweils eine [SendMessageBatchRequestEntry](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/SendMessageBatchRequestEntry.html)) zum Senden verwendet. Sie können auch eine optionale Verzögerung pro Nachricht festlegen.
**Importe**
```
import com.amazonaws.services.sqs.model.SendMessageBatchRequest;
import com.amazonaws.services.sqs.model.SendMessageBatchRequestEntry;
```
**Code**
```
SendMessageBatchRequest send_batch_request = new SendMessageBatchRequest()
.withQueueUrl(queueUrl)
.withEntries(
new SendMessageBatchRequestEntry(
"msg_1", "Hello from message 1"),
new SendMessageBatchRequestEntry(
"msg_2", "Hello from message 2")
.withDelaySeconds(10));
sqs.sendMessageBatch(send_batch_request);
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/SendReceiveMessages.java) finden Sie unter. GitHub
## Empfangen von Nachrichten
Rufen Sie alle Nachrichten ab, die sich derzeit in der Warteschlange befinden, indem Sie die `receiveMessage` Methode des AmazonSQS-Clients aufrufen und ihr die URL der Warteschlange übergeben. Nachrichten werden als Liste von [Message](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/Message.html)-Objekten zurückgegeben.
**Importe**
```
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
import com.amazonaws.services.sqs.model.AmazonSQSException;
import com.amazonaws.services.sqs.model.SendMessageBatchRequest;
```
**Code**
```
List messages = sqs.receiveMessage(queueUrl).getMessages();
```
## Löschen von Nachrichten nach dem Empfangen
Nachdem Sie eine Nachricht empfangen und ihren Inhalt verarbeitet haben, löschen Sie die Nachricht aus der Warteschlange, indem Sie die Empfangsnummer und die Warteschlangen-URL der Nachricht an die Methode des AmazonSQS-Clients senden. `deleteMessage`
**Code**
```
for (Message m : messages) {
sqs.deleteMessage(queueUrl, m.getReceiptHandle());
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/SendReceiveMessages.java) finden Sie unter. GitHub
## Weitere Infos
+ [So funktionieren Amazon SQS Warteschlangen](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-how-it-works.html) im Amazon SQS Entwicklerhandbuch
+ [SendMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html)in der Amazon SQS API-Referenz
+ [SendMessageBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessageBatch.html)in der Amazon SQS API-Referenz
+ [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)in der Amazon SQS API-Referenz
+ [DeleteMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteMessage.html)in der Amazon SQS API-Referenz
# Long Polling für Amazon SQS Nachrichtenwarteschlangen aktivieren
Amazon SQS verwendet standardmäßig *kurze Abfragen*, bei denen nur eine Teilmenge der Server anhand einer gewichteten Zufallsverteilung abgefragt wird, um festzustellen, ob Nachrichten für die Antwort verfügbar sind.
Lange Abfragen tragen dazu bei, die Nutzungskosten zu senken, Amazon SQS indem die Anzahl der leeren Antworten reduziert wird, wenn keine Nachrichten als Antwort auf eine an eine Warteschlange gesendete ReceiveMessage Anfrage zur Verfügung stehen, und falsche Leerantworten vermieden werden. Amazon SQS
**Anmerkung**
Sie können eine lange Abfragefrequenz zwischen *1* und 20 Sekunden festlegen.
## Aktivieren der Langabfrage beim Erstellen einer Warteschlange
Um lange Abfragen beim Erstellen einer Amazon SQS Warteschlange zu aktivieren, legen Sie das `ReceiveMessageWaitTimeSeconds` Attribut für das [CreateQueueRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/CreateQueueRequest.html)Objekt fest, bevor Sie die Methode der AmazonSQS-Klasse aufrufen. `createQueue`
**Importe**
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
import com.amazonaws.services.sqs.model.AmazonSQSException;
import com.amazonaws.services.sqs.model.CreateQueueRequest;
```
**Code**
```
final AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();
// Enable long polling when creating a queue
CreateQueueRequest create_request = new CreateQueueRequest()
.withQueueName(queue_name)
.addAttributesEntry("ReceiveMessageWaitTimeSeconds", "20");
try {
sqs.createQueue(create_request);
} catch (AmazonSQSException e) {
if (!e.getErrorCode().equals("QueueAlreadyExists")) {
throw e;
}
}
```
[Das vollständige Beispiel finden Sie unter.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/LongPolling.java) GitHub
## Aktivieren der Langabfrage für eine vorhandene Warteschlange
Sie können nicht nur die lange Abfrage beim Erstellen einer Warteschlange aktivieren, sondern sie auch für eine bestehende Warteschlange aktivieren, indem Sie die Methode [SetQueueAttributesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/SetQueueAttributesRequest.html)vor `ReceiveMessageWaitTimeSeconds` dem Aufrufen der AmazonSQS-Klasse aktivieren. `setQueueAttributes`
**Importe**
```
import com.amazonaws.services.sqs.model.SetQueueAttributesRequest;
```
**Code**
```
SetQueueAttributesRequest set_attrs_request = new SetQueueAttributesRequest()
.withQueueUrl(queue_url)
.addAttributesEntry("ReceiveMessageWaitTimeSeconds", "20");
sqs.setQueueAttributes(set_attrs_request);
```
[Das vollständige Beispiel finden Sie unter.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/LongPolling.java) GitHub
## Aktivieren von Langabfragen beim Nachrichteneingang
Sie können lange Abfragen beim Empfang einer Nachricht aktivieren, indem Sie die Wartezeit in Sekunden für die Methode festlegen [ReceiveMessageRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/ReceiveMessageRequest.html), die Sie an die Methode der AmazonSQS-Klasse übergeben. `receiveMessage`
**Anmerkung**
Sie sollten sicherstellen, dass das Anfrage-Timeout des AWS Kunden größer ist als die maximale lange Abfragezeit (20 s), damit es bei Ihren `receiveMessage` Anfragen nicht zu einem Timeout kommt, während Sie auf das nächste Umfrageereignis warten\$1
**Importe**
```
import com.amazonaws.services.sqs.model.ReceiveMessageRequest;
```
**Code**
```
ReceiveMessageRequest receive_request = new ReceiveMessageRequest()
.withQueueUrl(queue_url)
.withWaitTimeSeconds(20);
sqs.receiveMessage(receive_request);
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/LongPolling.java) finden Sie unter. GitHub
## Weitere Infos
+ [Amazon SQS Long Polling](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-long-polling.html) im Amazon SQS Entwicklerhandbuch
+ [CreateQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html)in der Amazon SQS API-Referenz
+ [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)in der Amazon SQS API-Referenz
+ [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html)in der Amazon SQS API-Referenz
# Sichtbarkeits-Timeout einrichten in Amazon SQS
Wenn eine Nachricht empfangen wird Amazon SQS, verbleibt sie in der Warteschlange, bis sie gelöscht wird, um den Empfang sicherzustellen. Eine empfangene, aber nicht gelöschte Nachricht erscheint erst nach Ablauf einer bestimmten *Zeitbeschränkung für die Sichtbarkeit* in nachfolgenden Anforderungen. Dadurch wird gewährleistet, dass die Nachricht nicht mehrmals empfangen wird, bevor sie verarbeitet und gelöscht werden kann.
**Anmerkung**
Bei Nutzung von [Standard-Warteschlangen](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/standard-queues.html) kann durch die Zeitbeschränkung für die Sichtbarkeit nicht garantiert werden, dass eine Nachricht mehrmals empfangen wird. Wenn Sie eine Standard-Warteschlange verwenden, achten Sie darauf, dass Ihr Code mit dem Fall umgehen kann, dass dieselbe Nachricht mehrmals eingeht.
## Einrichten der Zeitbeschränkung für die Sichtbarkeit einer einzelnen Nachricht
Wenn Sie eine Nachricht erhalten haben, können Sie ihr Sichtbarkeits-Timeout ändern, indem Sie ihre Empfangsnummer in einer Methode übergeben [ChangeMessageVisibilityRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/ChangeMessageVisibilityRequest.html), die Sie an die Methode der AmazonSQS-Klasse übergeben. `changeMessageVisibility`
**Importe**
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
```
**Code**
```
AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();
// Get the receipt handle for the first message in the queue.
String receipt = sqs.receiveMessage(queue_url)
.getMessages()
.get(0)
.getReceiptHandle();
sqs.changeMessageVisibility(queue_url, receipt, timeout);
```
[Das vollständige Beispiel finden Sie unter.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/VisibilityTimeout.java) GitHub
## Einrichten der Zeitbeschränkung für die Sichtbarkeit mehrerer Nachrichten auf einmal
Um das Timeout für die Nachrichtensichtbarkeit für mehrere Nachrichten gleichzeitig festzulegen, erstellen Sie eine Liste von [ChangeMessageVisibilityBatchRequestEntry](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/ChangeMessageVisibilityBatchRequestEntry.html)Objekten, die jeweils eine eindeutige ID-Zeichenfolge und ein Empfangs-Handle enthalten. Übergeben Sie dann die Liste an die Methode der Amazon SQS Client-Klasse. `changeMessageVisibilityBatch`
**Importe**
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
import com.amazonaws.services.sqs.model.ChangeMessageVisibilityBatchRequestEntry;
import java.util.ArrayList;
import java.util.List;
```
**Code**
```
AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();
List entries =
new ArrayList();
entries.add(new ChangeMessageVisibilityBatchRequestEntry(
"unique_id_msg1",
sqs.receiveMessage(queue_url)
.getMessages()
.get(0)
.getReceiptHandle())
.withVisibilityTimeout(timeout));
entries.add(new ChangeMessageVisibilityBatchRequestEntry(
"unique_id_msg2",
sqs.receiveMessage(queue_url)
.getMessages()
.get(0)
.getReceiptHandle())
.withVisibilityTimeout(timeout + 200));
sqs.changeMessageVisibilityBatch(queue_url, entries);
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/VisibilityTimeout.java) finden Sie unter. GitHub
## Weitere Infos
+ [Visibility Timeout](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html) im Amazon SQS Developer Guide
+ [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html)in der Amazon SQS API-Referenz
+ [GetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueAttributes.html)in der Amazon SQS API-Referenz
+ [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)in der Amazon SQS API-Referenz
+ [ChangeMessageVisibility](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ChangeMessageVisibility.html)in der Amazon SQS API-Referenz
+ [ChangeMessageVisibilityBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ChangeMessageVisibilityBatch.html)in der Amazon SQS API-Referenz
# Verwenden von Warteschlangen für unzustellbare Briefe in Amazon SQS
Amazon SQS bietet Unterstützung für Warteschlangen mit *uneingeschränkten Briefen*. Andere (Quell-)Warteschlangen können Nachrichten, die nicht erfolgreich verarbeitet werden konnten, an die Warteschlange für unzustellbare Nachrichten senden. Sie können diese Nachrichten in der Warteschlange für unzustellbare Nachrichten sammeln und isolieren, um zu bestimmen, warum die Verarbeitung fehlgeschlagen ist.
## Erstellen einer Warteschlange für unzustellbare Nachrichten
Eine Warteschlange für unzustellbare Nachrichten wird wie eine reguläre Warteschlange erstellt, hat aber folgende Einschränkungen:
+ Eine Warteschlange für unzustellbare Nachrichten muss den gleichen Typ der Warteschlange (FIFO oder Standard) wie die Quell-Warteschlange haben.
+ Eine Warteschlange für eingehende Nachrichten muss mit derselben AWS-Konto AND-Region wie die Quellwarteschlange erstellt werden.
Hier erstellen wir zwei identische Amazon SQS Warteschlangen, von denen eine als Warteschlange für eingehende Nachrichten dient:
**Importe**
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
import com.amazonaws.services.sqs.model.AmazonSQSException;
```
**Code**
```
final AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();
// Create source queue
try {
sqs.createQueue(src_queue_name);
} catch (AmazonSQSException e) {
if (!e.getErrorCode().equals("QueueAlreadyExists")) {
throw e;
}
}
// Create dead-letter queue
try {
sqs.createQueue(dl_queue_name);
} catch (AmazonSQSException e) {
if (!e.getErrorCode().equals("QueueAlreadyExists")) {
throw e;
}
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/DeadLetterQueues.java) finden Sie unter. GitHub
## Zuweisen einer Warteschlange für unzustellbare Nachrichten an eine Quell-Warteschlange
Sie können eine Warteschlange für unzustellbare Nachrichten zuweisen, indem Sie als Erstes eine *Redrive-Richtlinie* erstellen und die Richtlinie dann in den Attributen der Warteschlange festlegen. Eine Redrive-Richtlinie wird in JSON angegeben und enthält den ARN der Warteschlange für unzustellbare Nachrichten sowie die maximale Anzahl an Malen, die eine Nachricht empfangen und nicht verarbeitet werden kann, bevor sie an die Warteschlange für unzustellbare Nachrichten gesendet wird.
Um die Redrive-Richtlinie für Ihre Quell-Warteschlange festzulegen, rufen Sie die `setQueueAttributes` Methode der AmazonSQS-Klasse mit einem [SetQueueAttributesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/SetQueueAttributesRequest.html)Objekt auf, für das Sie das `RedrivePolicy` Attribut mit Ihrer JSON-Redrive-Richtlinie festgelegt haben.
**Importe**
```
import com.amazonaws.services.sqs.model.GetQueueAttributesRequest;
import com.amazonaws.services.sqs.model.GetQueueAttributesResult;
import com.amazonaws.services.sqs.model.SetQueueAttributesRequest;
```
**Code**
```
String dl_queue_url = sqs.getQueueUrl(dl_queue_name)
.getQueueUrl();
GetQueueAttributesResult queue_attrs = sqs.getQueueAttributes(
new GetQueueAttributesRequest(dl_queue_url)
.withAttributeNames("QueueArn"));
String dl_queue_arn = queue_attrs.getAttributes().get("QueueArn");
// Set dead letter queue with redrive policy on source queue.
String src_queue_url = sqs.getQueueUrl(src_queue_name)
.getQueueUrl();
SetQueueAttributesRequest request = new SetQueueAttributesRequest()
.withQueueUrl(src_queue_url)
.addAttributesEntry("RedrivePolicy",
"{\"maxReceiveCount\":\"5\", \"deadLetterTargetArn\":\""
+ dl_queue_arn + "\"}");
sqs.setQueueAttributes(request);
```
[Das vollständige Beispiel finden Sie unter.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/DeadLetterQueues.java) GitHub
## Weitere Infos
+ [Verwenden von Amazon SQS Dead Letter Queues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html) im Amazon SQS Entwicklerhandbuch
+ [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html)in der Amazon SQS API-Referenz
# Amazon SWF Beispiele für die Verwendung der AWS SDK für Java
[Amazon SWF](https://aws.amazon.com/swf/)[ist ein Workflow-Management-Service, der Entwicklern hilft, verteilte Workflows zu erstellen und zu skalieren, die parallel oder sequentielle Schritte umfassen können, die aus Aktivitäten, untergeordneten Workflows oder sogar Lambda-Aufgaben bestehen können.](https://aws.amazon.com/lambda/)
Es gibt zwei Möglichkeiten, mit dem zu arbeiten: Amazon SWF mit dem AWS SDK für Java*SWF-Client-Objekt* oder mit dem für Java. AWS Flow Framework Das AWS Flow Framework für Java ist anfangs schwieriger zu konfigurieren, da es häufig Anmerkungen verwendet und auf zusätzliche Bibliotheken wie AspectJ und das Spring Framework angewiesen ist. Bei großen oder komplexen Projekten sparen Sie jedoch Codierungszeit, indem Sie for Java verwenden. AWS Flow Framework Weitere Informationen finden Sie im [AWS Flow Framework for Java Developer Guide](https://docs.aws.amazon.com/amazonswf/latest/awsflowguide/).
Dieser Abschnitt enthält Beispiele für die direkte Programmierung Amazon SWF mit dem AWS SDK für Java Client.
**Topics**
+ [SWF-Grundlagen](swf-basics.md)
+ [Eine einfache Amazon SWF Anwendung erstellen](swf-hello.md)
+ [Lambda Aufgaben](swf-lambda-task.md)
+ [Korrektes Herunterfahren von Aktivitäts- und Workflow-Workern](swf-graceful-shutdown.md)
+ [Registrieren von Domänen](prog-services-swf-register-domain.md)
+ [Auflisten von Domänen](prog-services-swf-list-domains.md)
# SWF-Grundlagen
Dies sind allgemeine Muster für die Arbeit Amazon SWF mit der AWS SDK für Java. Dies soll hauptsächlich als Referenz dienen. Ein vollständigeres Einführungstutorial finden Sie unter [Erstellen einer einfachen Amazon SWF Anwendung](swf-hello.md).
## Abhängigkeiten
Für Amazon SWF Basisanwendungen sind die folgenden Abhängigkeiten erforderlich, die im Lieferumfang von enthalten sind AWS SDK für Java:
+ aws-java-sdk-1.12.\$1.jar
+ commons-logging-1.2.\$1.jar
+ httpclient-4.3.\$1.jar
+ httpcore-4.3.\$1.jar
+ jackson-annotations-2.12.\$1.jar
+ jackson-core-2.12.\$1.jar
+ jackson-databind-2.12.\$1.jar
+ joda-time-2.8.\$1.jar
**Anmerkung**
Die Versionsnummern dieser Pakete hängen von der Version des SDK ab, die Sie haben, aber die Versionen, die mit dem SDK geliefert werden, wurden auf Kompatibilität getestet und sollten Sie verwenden.
AWS Flow Framework für Java-Anwendungen sind zusätzliche Einstellungen *und* zusätzliche Abhängigkeiten erforderlich. Weitere Informationen [AWS Flow Framework zur Verwendung des Frameworks finden Sie im for Java Developer Guide](https://docs.aws.amazon.com/amazonswf/latest/awsflowguide/).
## Importe
Im Allgemeinen können Sie die folgenden Importe für Code-Entwicklung nutzen:
```
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflowClientBuilder;
import com.amazonaws.services.simpleworkflow.model.*;
```
Sie sollten jedoch nur die Klassen importieren, die Sie wirklich benötigen. Dazu geben Sie wahrscheinlich bestimmte Klassen im Workspace `com.amazonaws.services.simpleworkflow.model` an:
```
import com.amazonaws.services.simpleworkflow.model.PollForActivityTaskRequest;
import com.amazonaws.services.simpleworkflow.model.RespondActivityTaskCompletedRequest;
import com.amazonaws.services.simpleworkflow.model.RespondActivityTaskFailedRequest;
import com.amazonaws.services.simpleworkflow.model.TaskList;
```
Wenn Sie das AWS Flow Framework für Java verwenden, importieren Sie Klassen aus dem `com.amazonaws.services.simpleworkflow.flow` Workspace. Zum Beispiel:
```
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflow;
import com.amazonaws.services.simpleworkflow.flow.ActivityWorker;
```
**Anmerkung**
AWS Flow Framework Für Java gelten zusätzliche Anforderungen, die über die Basisversion hinausgehen AWS SDK für Java. Weitere Informationen finden Sie im [AWS Flow Framework for Java Developer Guide](https://docs.aws.amazon.com/amazonswf/latest/awsflowguide/).
## Verwenden der SWF-Client-Klasse
Ihre grundlegende Schnittstelle zu Amazon SWF sind entweder die [AmazonSimpleWorkflowAsyncClient](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowAsyncClient.html)Klassen [AmazonSimpleWorkflowClient](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html)oder. Der Unterschied zwischen diesen Klassen besteht darin, dass die `\*AsyncClient`-Klasse [Future](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/concurrent/Future.html)-Objekte für gleichzeitige (asynchrone) Programmierung zurückgibt.
```
AmazonSimpleWorkflowClient swf = AmazonSimpleWorkflowClientBuilder.defaultClient();
```
# Eine einfache Amazon SWF Anwendung erstellen
In diesem Thema werden Sie in die Programmierung von [Amazon SWF](https://aws.amazon.com/swf/)Anwendungen mit dem AWS SDK für Java eingeführt und dabei einige wichtige Konzepte vorgestellt.
## Über das Beispiel
Das Beispielprojekt erstellt einen Workflow mit einer einzigen Aktivität, der Workflow-Daten akzeptiert, die über die AWS Cloud übertragen werden (in der HelloWorld Tradition ist dies der Name einer zu begrüßenden Person) und anschließend eine Begrüßung als Antwort ausgibt.
Obwohl dies auf den ersten Blick sehr einfach erscheint, bestehen Amazon SWF Anwendungen aus einer Reihe von Teilen, die zusammenarbeiten:
+ Einer **Domäne** als logischem Container für die Ausführungsdaten des Workflows.
+ Einem oder mehreren **Workflows**, die Code-Komponenten darstellen, mit denen die logische Reihenfolge der Ausführung für die Aktivitäten und untergeordneten Workflows Ihres Workflows definiert wird.
+ Einem **Workflow-Worker**, auch *Entscheider* genannt, der Abfragen für Entscheidungsaufgaben ausführt und daraufhin Aktivitäten oder untergeordnete Workflows plant.
+ Einer oder mehreren **Aktivitäten**, die jeweils eine Arbeitseinheit im Workflow darstellen.
+ Einem **Aktivitäts-Worker**, der Abfragen für Aktivitätsaufgaben durchführt und als Reaktion Aktivitätsmethoden ausführt.
+ Eine oder mehrere **Aufgabenlisten**, bei denen es sich um Warteschlangen handelt, die Amazon SWF dazu dienen, Anfragen an die Workflow- und Aktivitätsmitarbeiter zu richten. Aufgaben in einer Aufgabenliste für Workflow-Worker werden *Entscheidungsaufgaben* genannt. Aufgaben für Aktivitäts-Worker nennen sich *Aktivitätsaufgaben*.
+ Einem **Workflow-Starter**, der mit der Ausführung des Workflows beginnt.
Amazon SWF Orchestriert hinter den Kulissen den Betrieb dieser Komponenten, koordiniert ihren Fluss aus der AWS Cloud, leitet Daten zwischen ihnen weiter, verarbeitet Timeouts und Heartbeat-Benachrichtigungen und protokolliert den Verlauf der Workflow-Ausführung.
## Voraussetzungen
### Entwicklungsumgebung
Die Entwicklungsumgebung in dieser Anleitung besteht aus:
+ Das Tool [AWS SDK für Java](https://aws.amazon.com/sdk-for-java/).
+ [Apache Maven](http://maven.apache.org/) (3.3.1).
+ JDK 1.7 oder neuer. Diese Anleitung wurde mit JDK 1.8.0 entwickelt und getestet.
+ Einen guten Java-Texteditor (Ihrer Wahl).
**Anmerkung**
Wenn Sie ein anderes Build-System als Maven verwenden, können Sie trotzdem ein Projekt mit den entsprechenden Schritten für Ihre Umgebung erstellen und dabei die hier bereitgestellten Konzepte verwenden. Weitere Informationen zur Konfiguration und Verwendung von AWS SDK für Java mit den verschiedenen Build-Systemen finden Sie unter [Erste Schritte](getting-started.md).
Ebenso, aber mit größerem Aufwand, können die hier gezeigten Schritte mit jedem der AWS SDKs mit Unterstützung für implementiert werden Amazon SWF.
Alle erforderlichen externen Abhängigkeiten sind im Lieferumfang von enthalten AWS SDK für Java, sodass Sie nichts zusätzlich herunterladen müssen.
### AWS Zugriff
Um dieses Tutorial erfolgreich durcharbeiten zu können, benötigen Sie Zugriff auf das AWS Zugangsportal, wie [im Abschnitt zur Grundkonfiguration dieses Handbuchs beschrieben](signup-create-iam-user.md#signup-create-iam-user-overview).
In den Anweisungen wird beschrieben, wie Sie auf temporäre Anmeldeinformationen zugreifen, die Sie kopieren und in Ihre lokale gemeinsam genutzte `credentials` Datei einfügen. Die temporären Anmeldeinformationen, die Sie einfügen, müssen einer IAM-Rolle zugeordnet sein AWS IAM Identity Center , die über Zugriffsberechtigungen für Amazon SWF verfügt. Nach dem Einfügen der temporären Anmeldeinformationen sieht Ihre `credentials` Datei wie folgt aus.
```
[default]
aws_access_key_id=AKIAIOSFODNN7EXAMPLE
aws_secret_access_key=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
aws_session_token=IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZVERYLONGSTRINGEXAMPLE
```
Diese temporären Anmeldeinformationen sind mit dem `default` Profil verknüpft.
## Erstellen eines SWF-Projekts
1. Starten Sie ein neues Projekt mit Maven:
```
mvn archetype:generate -DartifactId=helloswf \
-DgroupId=aws.example.helloswf -DinteractiveMode=false
```
Dadurch wird ein neues Projekt mit einer Standard-Projektstruktur für Maven erzeugt:
```
helloswf
├── pom.xml
└── src
├── main
│ └── java
│ └── aws
│ └── example
│ └── helloswf
│ └── App.java
└── test
└── ...
```
Sie können das `test`-Verzeichnis und dessen Inhalte ignorieren oder löschen, da wir es für diese Anleitung nicht verwenden. Sie können auch `App.java` löschen, da wir sie durch neue Klassen ersetzen.
1. Bearbeiten Sie die `pom.xml` Projektdatei und fügen Sie das **aws-java-sdk-simpleworkflow**Modul hinzu, indem Sie dem `` Block eine Abhängigkeit hinzufügen.
```
com.amazonawsaws-java-sdk-simpleworkflow1.11.1000
```
1. *Achten Sie darauf, dass Maven das Projekt mit Unterstützung für JDK 1.7\$1 erstellt*. Fügen Sie Folgendes in der Datei `` zu Ihrem Projekt hinzu (vor oder nach dem Block `pom.xml`):
```
maven-compiler-plugin3.6.11.81.8
```
## Entwickeln des Projekts
Das Beispielprojekt umfasst vier separate Anwendungen, die wir einzeln untersuchen:
+ **HelloTypes.java** — enthält die Domänen-, Aktivitäts- und Workflow-Typdaten des Projekts, die mit den anderen Komponenten gemeinsam genutzt werden. Außerdem übernimmt diese Datei das Registrieren dieser Typen mit SWF.
+ **ActivityWorker.java** --enthält den Activity Worker, der nach Aktivitätsaufgaben fragt und daraufhin Aktivitäten ausführt.
+ **WorkflowWorker.java** — enthält den Workflow-Worker (Decider), der Entscheidungsaufgaben abfragt und neue Aktivitäten plant.
+ **WorkflowStarter.java** --enthält den Workflow-Starter, der eine neue Workflow-Ausführung startet, wodurch SWF beginnt, Entscheidungs- und Workflow-Aufgaben zu generieren, die Ihre Worker bearbeiten können.
### Allgemeine Schritte für alle Quelldateien
Alle Dateien, die Sie erstellen, um Ihre Java-Klassen zu integrieren, haben ein paar Dinge gemeinsam. Aus zeitlichen Gründen werden die folgenden Schritte *jedes Mal implizit vorausgesetzt, wenn Sie eine neue Datei zum Projekt hinzufügen*:
1. Erstellen Sie die Datei im Verzeichnis `src/main/java/aws/example/helloswf/` des Projekts.
1. Fügen Sie eine `package`-Deklaration am Anfang jeder Datei hinzu, um ihren Namespace zu deklarieren. Das Beispielprojekt nutzt:
```
package aws.example.helloswf;
```
1. Fügen Sie `import` Deklarationen für die [AmazonSimpleWorkflowClient](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html)Klasse und für mehrere Klassen im `com.amazonaws.services.simpleworkflow.model` Namespace hinzu. Der Einfachheit halber verwenden wir:
```
import com.amazonaws.regions.Regions;
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflow;
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflowClientBuilder;
import com.amazonaws.services.simpleworkflow.model.*;
```
### Registrieren von Domäne und Workflow- und Aktivitätstypen
Als Erstes erstellen wir eine neue ausführbare Klasse, `HelloTypes.java`. Diese Datei enthält freigegebene Daten, die verschiedenen Teilen Ihres Workflows bekannt sein müssen, z. B. die Namen und Version Ihrer Aktivitäten und Workflow-Typen, den Namen der Domäne und den Namen der Aufgabenliste.
1. Öffnen Sie den Texteditor und erstellen Sie die Datei `HelloTypes.java`. Fügen Sie eine Package-Deklaration und die Importe laut den [allgemeinen Schritten](#swf-hello-common) hinzu.
1. Deklarieren Sie die `HelloTypes`-Klasse und geben Sie Werte für Ihre registrierten Aktivitäts- und Workflow-Typen an:
```
public static final String DOMAIN = "HelloDomain";
public static final String TASKLIST = "HelloTasklist";
public static final String WORKFLOW = "HelloWorkflow";
public static final String WORKFLOW_VERSION = "1.0";
public static final String ACTIVITY = "HelloActivity";
public static final String ACTIVITY_VERSION = "1.0";
```
Diese Werte werden im gesamten Code verwendet.
1. Erstellen Sie nach den String-Deklarationen eine Instanz der [AmazonSimpleWorkflowClient](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html)Klasse. Dies ist die grundlegende Schnittstelle zu den Amazon SWF Methoden, die von der bereitgestellt werden AWS SDK für Java.
```
private static final AmazonSimpleWorkflow swf =
AmazonSimpleWorkflowClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
```
Im vorherigen Codeausschnitt wird davon ausgegangen, dass dem Profil temporäre Anmeldeinformationen zugeordnet sind. `default` Wenn Sie ein anderes Profil verwenden, ändern Sie den obigen Code wie folgt und *profile\$1name * ersetzen Sie ihn durch den Namen des tatsächlichen Profilnamens.
```
private static final AmazonSimpleWorkflow swf =
AmazonSimpleWorkflowClientBuilder
.standard()
.withCredentials(new ProfileCredentialsProvider("profile_name"))
.withRegion(Regions.DEFAULT_REGION)
.build();
```
1. Fügen Sie eine neue Funktion für die Registrierung einer SWF-Domäne hinzu. Bei einer *Domäne* handelt es sich um einen logischen Container für eine Reihe von zugehörigen SWF-Aktivitäten und Workflow-Typen. SWF-Komponenten können nur miteinander kommunizieren, wenn sie in derselben Domäne sind.
```
try {
System.out.println("** Registering the domain '" + DOMAIN + "'.");
swf.registerDomain(new RegisterDomainRequest()
.withName(DOMAIN)
.withWorkflowExecutionRetentionPeriodInDays("1"));
} catch (DomainAlreadyExistsException e) {
System.out.println("** Domain already exists!");
}
```
Wenn Sie eine Domain registrieren, geben Sie ihr einen *Namen* (eine beliebige Gruppe von 1 bis 256 Zeichen mit Ausnahme von`:`,,`/`,`|`, Steuerzeichen oder der wörtlichen Zeichenfolge '`arn') und eine *Aufbewahrungsfrist*, d. h. die Anzahl der Tage, in denen die Ausführungsverlaufsdaten Ihres Workflows nach Abschluss einer Workflow-Ausführung aufbewahrt Amazon SWF werden. Der maximale Aufbewahrungszeitraum für die Workflow-Ausführung ist 90 Tage. Weitere Informationen finden Sie unter [RegisterDomainRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/RegisterDomainRequest.html).
Wenn eine Domäne mit diesem Namen bereits existiert, [DomainAlreadyExistsException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/DomainAlreadyExistsException.html)wird a aktiviert. Da uns nicht interessiert, ob die Domäne schon erstellt wurde, können wir die Ausnahme ignorieren.
**Anmerkung**
Dieser Code veranschaulicht ein allgemeines Muster bei der Arbeit mit AWS SDK für Java Methoden: Daten für die Methode werden von einer Klasse im `simpleworkflow.model` Namespace bereitgestellt, die Sie mithilfe der verkettbaren Methoden instanziieren und auffüllen. `0with*`
1. Fügen Sie eine neue Funktion für die Registrierung eines neuen Aktivitätstyps hinzu. Eine *Aktivität* stellt eine Arbeitseinheit in Ihrem Workflow dar.
```
try {
System.out.println("** Registering the activity type '" + ACTIVITY +
"-" + ACTIVITY_VERSION + "'.");
swf.registerActivityType(new RegisterActivityTypeRequest()
.withDomain(DOMAIN)
.withName(ACTIVITY)
.withVersion(ACTIVITY_VERSION)
.withDefaultTaskList(new TaskList().withName(TASKLIST))
.withDefaultTaskScheduleToStartTimeout("30")
.withDefaultTaskStartToCloseTimeout("600")
.withDefaultTaskScheduleToCloseTimeout("630")
.withDefaultTaskHeartbeatTimeout("10"));
} catch (TypeAlreadyExistsException e) {
System.out.println("** Activity type already exists!");
}
```
Ein Aktivitätstyp wird durch einen *Namen* und eine *Version* angegeben, die zum Unterscheiden der Aktivitäten von denen anderen Dateien in der Domäne, in der sie registriert sind, verwendet werden. Aktivitäten enthalten außerdem eine Reihe von optionalen Parametern, wie die Standard-Aufgabenliste für den Empfang von Aufgaben und Daten aus SWF und eine Reihe verschiedener Timeouts, mit denen Sie Einschränkungen dafür, wie lange verschiedene Teile der Aktivität ausgeführt werden dürfen, festlegen können. Weitere Informationen finden Sie unter [RegisterActivityTypeRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/RegisterActivityTypeRequest.html).
**Anmerkung**
Alle Timeout-Werte werden in *Sekunden* angegeben. Eine vollständige Beschreibung der Auswirkungen von [Amazon SWF Timeouts auf Ihre Workflow-Ausführungen finden Sie unter Timeout-Typen](https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-timeout-types.html).
Wenn der Aktivitätstyp, den Sie registrieren möchten, bereits existiert, [TypeAlreadyExistsException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/TypeAlreadyExistsException.html)wird ein ausgelöst. Fügen Sie eine neue Funktion für die Registrierung eines neuen Workflow-Typs hinzu. Ein *Workflow*, auch *Entscheider* genannt, stellt die Logik Ihrer Workflow-Ausführung dar.
\$1
```
try {
System.out.println("** Registering the workflow type '" + WORKFLOW +
"-" + WORKFLOW_VERSION + "'.");
swf.registerWorkflowType(new RegisterWorkflowTypeRequest()
.withDomain(DOMAIN)
.withName(WORKFLOW)
.withVersion(WORKFLOW_VERSION)
.withDefaultChildPolicy(ChildPolicy.TERMINATE)
.withDefaultTaskList(new TaskList().withName(TASKLIST))
.withDefaultTaskStartToCloseTimeout("30"));
} catch (TypeAlreadyExistsException e) {
System.out.println("** Workflow type already exists!");
}
```
\$1
Ähnlich wie bei Aktivitätstypen werden Workflow-Typen durch einen *Namen* und eine *Version* identifiziert und haben auch konfigurierbare Timeouts. Weitere Informationen finden Sie unter [RegisterWorkflowTypeRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/RegisterWorkflowTypeRequest.html).
\$1
Wenn der Workflowtyp, den Sie registrieren möchten, bereits existiert, [TypeAlreadyExistsException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/TypeAlreadyExistsException.html)wird ein ausgelöst. Markieren Sie die Klasse schließlich als ausführbar, indem Sie eine `main`-Methode hinzufügen. Diese registriert die Domäne, den Aktivitätstyp sowie den Workflow-Typ:
\$1
```
registerDomain();
registerWorkflowType();
registerActivityType();
```
Jetzt können Sie die Anwendung [erstellen](#swf-hello-build) und [ausführen](#swf-hello-run-register), um das Registrierungsskript auszuführen. Sie können aber auch mit dem Entwickeln der Aktivitäts- und Workflow-Worker fortfahren. Sobald die Domäne, der Workflow und die Aktivität registriert wurden, müssen Sie sie nicht erneut ausführen. Diese Typen bleiben bestehen, bis Sie sie selbst als veraltet kennzeichnen.
### Implementieren des Aktivitäts-Workers
Eine *Aktivität* ist die grundlegende Arbeitseinheit in einem Workflow. Ein Workflow stellt die Logik bereit und plant auszuführende Aktivitäten (oder andere Aktionen) als Reaktion auf Entscheidungsaufgaben. Ein typischer Workflow besteht normalerweise aus einer Reihe von Aktivitäten, die synchron, asynchron oder gemischt ausgeführt werden können.
Der *Activity Worker* ist der Code, der nach Aktivitätsaufgaben fragt, die von Amazon SWF als Reaktion auf Workflow-Entscheidungen generiert werden. Wird eine Aktivitätsaufgabe empfangen, wird die zugehörige Aktivität ausgeführt und eine Erfolg-/Fehlermeldung an den Workflow zurückgegeben.
Wir implementieren einen einfachen Aktivitäts-Worker, der eine einzelne Aktivität ausführt.
1. Öffnen Sie den Texteditor und erstellen Sie die Datei `ActivityWorker.java`. Fügen Sie eine Package-Deklaration und die Importe laut den [allgemeinen Schritten](#swf-hello-common) hinzu.
```
import com.amazonaws.regions.Regions;
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflow;
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflowClientBuilder;
import com.amazonaws.services.simpleworkflow.model.*;
```
1. Fügen Sie die `ActivityWorker` Klasse der Datei hinzu und geben Sie ihr ein Datenelement für einen SWF-Client, mit dem Amazon SWF wir interagieren werden:
```
private static final AmazonSimpleWorkflow swf =
AmazonSimpleWorkflowClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
```
1. Fügen Sie die Methode, die wir nutzen werden, als Aktivität hinzu:
```
private static String sayHello(String input) throws Throwable {
return "Hello, " + input + "!";
}
```
Die Aktivität nimmt einfach eine Zeichenfolge entgegen, kombiniert sie zu einer Begrüßung und gibt das Ergebnis zurück. Es ist zwar unwahrscheinlich, dass diese Aktivität eine Ausnahme auslöst. Dennoch empfiehlt es sich, Aktivitäten zu entwerfen, die einen Fehler auslösen können, wenn ein Fehler auftritt.
1. Fügen Sie eine `main`-Methode hinzu. Wir verwenden sie als Abfragemethode der Aktivitätsaufgabe. Wir starten sie, indem wir Code hinzufügen, der die Aufgabenliste nach Aktivitätsaufgaben abfragt:
```
System.out.println("Polling for an activity task from the tasklist '"
+ HelloTypes.TASKLIST + "' in the domain '" +
HelloTypes.DOMAIN + "'.");
ActivityTask task = swf.pollForActivityTask(
new PollForActivityTaskRequest()
.withDomain(HelloTypes.DOMAIN)
.withTaskList(
new TaskList().withName(HelloTypes.TASKLIST)));
String task_token = task.getTaskToken();
```
Die Aktivität empfängt Aufgaben von, Amazon SWF indem sie die `pollForActivityTask` Methode des SWF-Clients aufruft und dabei die Domäne und die Aufgabenliste angibt, die in der übergebenen Datei verwendet werden sollen. [PollForActivityTaskRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/PollForActivityTaskRequest.html)
Sobald eine Aufgabe empfangen wird, rufen wir eine eindeutige Kennung für sie ab, indem wir die `getTaskToken`-Methode der Aufgabe aufrufen.
1. Schreiben Sie als Nächstes Code zum Verarbeiten der eingehenden Aufgaben. Fügen Sie Folgendes zur `main`-Methode hinzu, und zwar direkt nach dem Code, der die Aufgabe abruft und deren Aufgabentoken ermittelt.
```
if (task_token != null) {
String result = null;
Throwable error = null;
try {
System.out.println("Executing the activity task with input '" +
task.getInput() + "'.");
result = sayHello(task.getInput());
} catch (Throwable th) {
error = th;
}
if (error == null) {
System.out.println("The activity task succeeded with result '"
+ result + "'.");
swf.respondActivityTaskCompleted(
new RespondActivityTaskCompletedRequest()
.withTaskToken(task_token)
.withResult(result));
} else {
System.out.println("The activity task failed with the error '"
+ error.getClass().getSimpleName() + "'.");
swf.respondActivityTaskFailed(
new RespondActivityTaskFailedRequest()
.withTaskToken(task_token)
.withReason(error.getClass().getSimpleName())
.withDetails(error.getMessage()));
}
}
```
Wenn das Aufgabentoken ungleich `null` ist, beginnen wir die Ausführung der Aktivitätsmethode (`sayHello`) und übergeben dabei die Eingabedaten, die mit der Aufgabe mitgesendet wurden.
Wenn die Aufgabe *erfolgreich war (es* wurde kein Fehler generiert), reagiert der Worker auf SWF, indem er die `respondActivityTaskCompleted` Methode des SWF-Clients mit einem [RespondActivityTaskCompletedRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/RespondActivityTaskCompletedRequest.html)Objekt aufruft, das das Task-Token und die Ergebnisdaten der Aktivität enthält.
Wenn die Aufgabe dagegen *fehlgeschlagen* ist, antworten wir, indem wir die `respondActivityTaskFailed` Methode mit einem [RespondActivityTaskFailedRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/RespondActivityTaskFailedRequest.html)Objekt aufrufen und ihr das Task-Token und Informationen über den Fehler übergeben.
**Anmerkung**
Diese Aktivität wird nicht korrekt beendet, wenn sie unsanft abgebrochen wird. Dies geht zwar über die Grenzen dieser Anleitung hinaus, doch eine alternative Implementierung dieses Aktivitäts-Workers finden Sie im begleitenden Thema [Korrektes Herunterfahren von Aktivitäts- und Workflow-Workern](swf-graceful-shutdown.md).
### Implementieren des Workflow-Workers
Die Workflow-Logik liegt in einem Codeteil, der **Workflow-Worker** genannt wird. Der Workflow-Worker fragt nach Entscheidungsaufgaben ab, die Amazon SWF in der Domäne und in der Standard-Taskliste gesendet wurden, für die der Workflowtyp registriert wurde.
Wenn der Workflow-Worker eine Aufgabe erhält, wird eine Art Entscheidung gefällt (in der Regel, ob eine neue Aktivität geplant werden soll oder nicht) und eine entsprechende Aktion ausgeführt (z. B. zur Planung der Aktivität).
1. Öffnen Sie den Texteditor und erstellen Sie die Datei `WorkflowWorker.java`. Fügen Sie eine Package-Deklaration und die Importe laut den [allgemeinen Schritten](#swf-hello-common) hinzu.
1. Fügen Sie einige zusätzliche Importe in die Datei ein:
```
import com.amazonaws.regions.Regions;
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflow;
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflowClientBuilder;
import com.amazonaws.services.simpleworkflow.model.*;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
```
1. Deklarieren Sie die `WorkflowWorker` Klasse und erstellen Sie eine Instanz der [AmazonSimpleWorkflowClient](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html)Klasse, die für den Zugriff auf SWF-Methoden verwendet wird.
```
private static final AmazonSimpleWorkflow swf =
AmazonSimpleWorkflowClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
```
1. Fügen Sie die `main`-Methode hinzu. Die Methode wird in Schleife ausgeführt und ruft Entscheidungsaufgaben mit der `pollForDecisionTask`-Methode des SWF-Clients ab. Die [PollForDecisionTaskRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/PollForDecisionTaskRequest.html)stellt die Details bereit.
```
PollForDecisionTaskRequest task_request =
new PollForDecisionTaskRequest()
.withDomain(HelloTypes.DOMAIN)
.withTaskList(new TaskList().withName(HelloTypes.TASKLIST));
while (true) {
System.out.println(
"Polling for a decision task from the tasklist '" +
HelloTypes.TASKLIST + "' in the domain '" +
HelloTypes.DOMAIN + "'.");
DecisionTask task = swf.pollForDecisionTask(task_request);
String taskToken = task.getTaskToken();
if (taskToken != null) {
try {
executeDecisionTask(taskToken, task.getEvents());
} catch (Throwable th) {
th.printStackTrace();
}
}
}
```
Sobald eine Aufgabe empfangen wird, rufen wir ihre `getTaskToken`-Methode auf. Diese gibt eine Zeichenfolge zur Erkennung der Aufgabe zurück. Wenn das zurückgegebene Token nicht vorhanden ist`null`, verarbeiten wir es in der `executeDecisionTask` Methode weiter und übergeben ihm das Task-Token und die Liste der mit der Aufgabe gesendeten [HistoryEvent](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/HistoryEvent.html)Objekte.
1. Fügen Sie die `executeDecisionTask`-Methode hinzu. Sie nimmt das Aufgabentoken (einen `String`) und eine `HistoryEvent`-Liste entgegen.
```
List decisions = new ArrayList();
String workflow_input = null;
int scheduled_activities = 0;
int open_activities = 0;
boolean activity_completed = false;
String result = null;
```
Wir richten auch einige Datenmitglieder zur Nachverfolgung ein, u. a.:
+ Eine Liste mit [Decision](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/Decision.html)-Objekten, mit denen die Ergebnisse der Aufgabenverarbeitung berichtet werden.
+ Eine Zeichenfolge für die Workflow-Eingabe, die durch das Ereignis "WorkflowExecutionStarted" bereitgestellt wird
+ Eine Zählung der geplanten und offenen (aktiven) Aktivitäten. So wird die Planung von Aktivitäten vermieden, die bereits geplant wurden oder momentan ausgeführt werden.
+ Einen boolescher Wert, der angibt, ob die Aktivität abgeschlossen ist.
+ Eine Zeichenfolge, die die Aktivitätsergebnisse für die Rückgabe als unser Workflow-Ergebnis speichert.
1. Fügen Sie als Nächstes Code in die `executeDecisionTask`-Methode ein, der die mit der Aufgabe mitgesendeten `HistoryEvent`-Objekte verarbeitet, je nachdem, welcher Ereignistyp von der `getEventType`-Methode gemeldet wurde.
```
System.out.println("Executing the decision task for the history events: [");
for (HistoryEvent event : events) {
System.out.println(" " + event);
switch(event.getEventType()) {
case "WorkflowExecutionStarted":
workflow_input =
event.getWorkflowExecutionStartedEventAttributes()
.getInput();
break;
case "ActivityTaskScheduled":
scheduled_activities++;
break;
case "ScheduleActivityTaskFailed":
scheduled_activities--;
break;
case "ActivityTaskStarted":
scheduled_activities--;
open_activities++;
break;
case "ActivityTaskCompleted":
open_activities--;
activity_completed = true;
result = event.getActivityTaskCompletedEventAttributes()
.getResult();
break;
case "ActivityTaskFailed":
open_activities--;
break;
case "ActivityTaskTimedOut":
open_activities--;
break;
}
}
System.out.println("]");
```
Für die Zwecke unseres Workflows interessieren wir uns am meisten für:
+ das Ereignis WorkflowExecutionStarted "", das angibt, dass die Workflow-Ausführung gestartet wurde (was normalerweise bedeutet, dass Sie die erste Aktivität im Workflow ausführen sollten), und das die erste Eingabe für den Workflow bereitstellt. In diesem Fall handelt es sich um den Namen für unsere Begrüßung. Deswegen speichern wir die Daten in einer Zeichenfolge, während wir die auszuführende Aktivität planen.
+ das Ereignis ActivityTaskCompleted "", das gesendet wird, sobald die geplante Aktivität abgeschlossen ist. Die Ereignisdaten enthalten auch den Rückgabewert der abgeschlossenen Aktivität. Da wir nur eine Aktivität haben, verwenden wir diesen Wert als Ergebnis des gesamten Workflows.
Die anderen Ereignistypen können verwendet werden, wenn Ihre Workflows es erfordern. Informationen zu den einzelnen Ereignistypen finden Sie in der [HistoryEvent](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/HistoryEvent.html)Kursbeschreibung.
\$1 HINWEIS: Zeichenketten in `switch` Anweisungen wurden in Java 7 eingeführt. Wenn Sie eine frühere Version von Java verwenden, können Sie die [EventType](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/model/EventType.html)Klasse verwenden, um den von `String` `history_event.getType()` zurückgegebenen Wert in einen Enum-Wert und dann, `String` falls erforderlich, wieder in einen umzuwandeln:
```
EventType et = EventType.fromValue(event.getEventType());
```
1. Fügen Sie nach der `switch`-Anweisung weiteren Code hinzu, um mit einer passenden *Entscheidung* auf die empfangene Aufgabe zu reagieren.
```
if (activity_completed) {
decisions.add(
new Decision()
.withDecisionType(DecisionType.CompleteWorkflowExecution)
.withCompleteWorkflowExecutionDecisionAttributes(
new CompleteWorkflowExecutionDecisionAttributes()
.withResult(result)));
} else {
if (open_activities == 0 && scheduled_activities == 0) {
ScheduleActivityTaskDecisionAttributes attrs =
new ScheduleActivityTaskDecisionAttributes()
.withActivityType(new ActivityType()
.withName(HelloTypes.ACTIVITY)
.withVersion(HelloTypes.ACTIVITY_VERSION))
.withActivityId(UUID.randomUUID().toString())
.withInput(workflow_input);
decisions.add(
new Decision()
.withDecisionType(DecisionType.ScheduleActivityTask)
.withScheduleActivityTaskDecisionAttributes(attrs));
} else {
// an instance of HelloActivity is already scheduled or running. Do nothing, another
// task will be scheduled once the activity completes, fails or times out
}
}
System.out.println("Exiting the decision task with the decisions " + decisions);
```
+ Wenn die Aktivität noch nicht geplant wurde, antworten wir mit einer `ScheduleActivityTask` Entscheidung, die Informationen in einer [ScheduleActivityTaskDecisionAttributes](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/ScheduleActivityTaskDecisionAttributes.html)Struktur über die Aktivität bereitstellt, die als Nächstes geplant Amazon SWF werden soll, einschließlich aller Daten, die an die Aktivität gesendet Amazon SWF werden sollen.
+ Wenn die Aktivität abgeschlossen wurde, betrachten wir den gesamten Workflow als abgeschlossen und antworten mit einer `CompletedWorkflowExecution` Entscheidung, indem wir eine [CompleteWorkflowExecutionDecisionAttributes](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/CompleteWorkflowExecutionDecisionAttributes.html)Struktur ausfüllen, um Einzelheiten über den abgeschlossenen Workflow bereitzustellen. In diesem Fall geben wir das Ergebnis der Aktivität zurück.
In beiden Fällen werden die Entscheidungsinformationen zur `Decision`-Liste hinzugefügt, die oben in der Methode deklariert wurde.
1. Vervollständigen Sie die Entscheidungsaufgabe, indem Sie die Liste der `Decision`-Objekte zurückgeben, die bei der Verarbeitung der Aufgabe erfasst wurden. Fügen Sie den Code am Ende der `executeDecisionTask`-Methode hinzu, die wir schreiben:
```
swf.respondDecisionTaskCompleted(
new RespondDecisionTaskCompletedRequest()
.withTaskToken(taskToken)
.withDecisions(decisions));
```
Die `respondDecisionTaskCompleted`-Methode des SWF-Clients nimmt das Aufgabentoken zur Erkennung der Aufgabe sowie die Liste der `Decision`-Objekte entgegen.
### Implementieren des Workflow-Starters
Schließlich erstellen wir Code zum Starten der Workflow-Ausführung.
1. Öffnen Sie den Texteditor und erstellen Sie die Datei `WorkflowStarter.java`. Fügen Sie eine Package-Deklaration und die Importe laut den [allgemeinen Schritten](#swf-hello-common) hinzu.
1. Fügen Sie die `WorkflowStarter`-Klasse hinzu:
```
package aws.example.helloswf;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflow;
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflowClientBuilder;
import com.amazonaws.services.simpleworkflow.model.*;
public class WorkflowStarter {
private static final AmazonSimpleWorkflow swf =
AmazonSimpleWorkflowClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
public static final String WORKFLOW_EXECUTION = "HelloWorldWorkflowExecution";
public static void main(String[] args) {
String workflow_input = "{SWF}";
if (args.length > 0) {
workflow_input = args[0];
}
System.out.println("Starting the workflow execution '" + WORKFLOW_EXECUTION +
"' with input '" + workflow_input + "'.");
WorkflowType wf_type = new WorkflowType()
.withName(HelloTypes.WORKFLOW)
.withVersion(HelloTypes.WORKFLOW_VERSION);
Run run = swf.startWorkflowExecution(new StartWorkflowExecutionRequest()
.withDomain(HelloTypes.DOMAIN)
.withWorkflowType(wf_type)
.withWorkflowId(WORKFLOW_EXECUTION)
.withInput(workflow_input)
.withExecutionStartToCloseTimeout("90"));
System.out.println("Workflow execution started with the run id '" +
run.getRunId() + "'.");
}
}
```
Die `WorkflowStarter`-Klasse besteht aus einer einzelnen Methode `main`, die ein optionales Argument entgegen nimmt. Dieses wird auf der Befehlszeile als Eingabedaten für den Workflow übergeben.
Die SWF-Client-Methode`startWorkflowExecution`, verwendet ein [StartWorkflowExecutionRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/StartWorkflowExecutionRequest.html)Objekt als Eingabe. Zusätzlich zur Angabe der Domäne und des auszuführenden Workflow-Typs geben wir hier Folgendes an:
+ einen lesbaren Namen für die Workflow-Ausführung,
+ Workflow-Eingabedaten (in unserem Beispiel auf der Befehlszeile angegeben) sowie
+ einen Timeout-Wert, der in Sekunden angibt, wie lange die Ausführung des gesamten Workflows dauern darf.
Das [zurückgegebene `startWorkflowExecution` Run-Objekt](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/Run.html) stellt eine *Run-ID* bereit, einen Wert, der verwendet werden kann, um diese bestimmte Workflow-Ausführung in Amazon SWF der Historie Ihrer Workflow-Ausführungen zu identifizieren.
\$1 HINWEIS: Die Lauf-ID wird von dem Namen der Workflow-Ausführung generiert Amazon SWF, den Sie beim Start der Workflow-Ausführung übergeben, und ist *nicht* identisch mit diesem.
## Erstellen des Beispiels
Sie können das Beispielprojekt mit Maven erstellen, indem Sie zum `helloswf`-Verzeichnis wechseln und Folgendes eingeben:
```
mvn package
```
Die resultierende `helloswf-1.0.jar`-Datei wird im `target`-Verzeichnis erstellt.
## Ausführen des Beispiels
Das Beispiel besteht aus vier separaten ausführbaren Klassen, die unabhängig voneinander ausgeführt werden.
**Anmerkung**
Wenn Sie ein Linux-, MacOS- oder Unix-System verwenden, können Sie alle nacheinander in einem einzigen Terminalfenster ausführen. Wenn Sie Windows verwenden, sollten Sie zwei weitere Instances der Eingabeaufforderung öffnen und in jedem Fenster zum `helloswf`-Verzeichnis wechseln.
### Festlegen des Java-Klassenpfads
Obwohl Maven die Abhängigkeiten für Sie erledigt hat, müssen Sie zur Ausführung des AWS Beispiels die SDK-Bibliothek und ihre Abhängigkeiten in Ihrem Java-Klassenpfad bereitstellen. Sie können die `CLASSPATH` Umgebungsvariable entweder auf den Speicherort Ihrer AWS SDK-Bibliotheken und das `third-party/lib` Verzeichnis im SDK setzen, das die erforderlichen Abhängigkeiten enthält:
```
export CLASSPATH='target/helloswf-1.0.jar:/path/to/sdk/lib/*:/path/to/sdk/third-party/lib/*'
java example.swf.hello.HelloTypes
```
oder verwenden Sie die `-cp` Option des **` java `**Befehls, um den Klassenpfad festzulegen, während die einzelnen Anwendungen ausgeführt werden.
```
java -cp target/helloswf-1.0.jar:/path/to/sdk/lib/*:/path/to/sdk/third-party/lib/* \
example.swf.hello.HelloTypes
```
Welche Version Sie bevorzugen, liegt an Ihnen. Wenn Sie keine Probleme beim Erstellen des Codes hatten, versuchen beide, die Beispiele auszuführen, und es wird eine Reihe von "NoClassDefFound" -Fehlern angezeigt. Dies liegt wahrscheinlich daran, dass der Klassenpfad falsch gesetzt ist.
### Registrieren von Domäne und Workflow- und Aktivitätstypen
Vor der Ausführung Ihrer Worker und des Workflow-Starters müssen Sie die Domäne und die Workflow- und Aktivitätstypen registrieren. Der entsprechende Code wurde in den [Arbeitsablauf „Eine Domäne registrieren“ und](#swf-hello-hellotypes) in den Aktivitätstypen implementiert.
Nach dem Erstellen und [Festlegen des CLASSPATH](#swf-hello-set-classpath) können Sie den Code zur Registrierung mit folgendem Befehl ausführen:
```
echo 'Supply the name of one of the example classes as an argument.'
```
### Starten der Aktivitäts- und Workflow-Worker
Nachdem die Typen nun registriert sind, können Sie die Aktivitäts- und Workflow-Worker starten. Diese werden weiterhin ausgeführt und nach Aufgaben abgefragt, bis sie beendet werden. Sie sollten sie also entweder in separaten Terminalfenstern ausführen, oder, wenn Sie unter Linux, macOS oder Unix arbeiten, können Sie den `&` Operator verwenden, um zu veranlassen, dass jeder von ihnen bei der Ausführung einen eigenen Prozess erzeugt.
```
echo 'If there are arguments to the class, put them in quotes after the class name.'
exit 1
```
Wenn Sie diese Befehle in separaten Fenstern laufen lassen, lassen Sie den letzten `&`-Operator in jeder Zeile weg.
### Starten der Workflow-Ausführung
Nachdem die Aktivitäts- und Workflow-Worker nun Abfragen durchführen, können Sie die Workflow-Ausführung starten. Dieser Prozess läuft so lange, bis der Workflow den Status "abgeschlossen" zurückgibt. Führen Sie ihn in einem neuen Terminal-Fenster aus (außer Sie haben die Worker mit dem `&`-Operator in ihre eigenen separaten Prozesse abzweigen lassen).
```
fi
```
**Anmerkung**
Wenn Sie eigene Eingabedaten angeben möchten, die zuerst an den Workflow und dann an die Aktivität übergeben werden, fügen Sie sie zur Befehlszeile hinzu. Zum Beispiel:
```
echo "## Running $className..."
```
Sobald Sie die Workflow-Ausführung starten, sollten Sie Ausgaben von beiden Workern und von der Workflow-Ausführung selbst sehen. Wenn der Workflow schließlich abgeschlossen ist, wird die Ausgabe auf dem Bildschirm angezeigt.
## Vollständiger Quellcode für dieses Beispiel
Du kannst den [kompletten Quellcode](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/java/example_code/swf) für dieses Beispiel auf Github im *aws-java-developer-guide*Repository durchsuchen.
## Weitere Informationen
+ Die hier gezeigten Worker können zu verloren gegangenen Aufgaben führen, wenn sie beendet werden, während noch eine Workflow-Abfrage läuft. Unter [Korrektes Herunterfahren von Aktivitäts- und Workflow-Workern](swf-graceful-shutdown.md) erfahren Sie, wie sich Worker korrekt herunterfahren lassen.
+ Weitere Informationen Amazon SWF finden Sie auf der [Amazon SWF](https://aws.amazon.com/swf/)Startseite oder im [Amazon SWF Developer Guide](https://docs.aws.amazon.com/amazonswf/latest/developerguide/).
+ Sie können AWS Flow Framework for Java verwenden, um mithilfe von Anmerkungen komplexere Workflows in einem eleganten Java-Stil zu schreiben. Weitere Informationen finden Sie im [AWS Flow Framework for Java Developer Guide](https://docs.aws.amazon.com/amazonswf/latest/awsflowguide/).
# 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\$1source/snippets/helloswf \$1lambda/>* nach diesem Beispiel auf Github im Repository durchsuchen. *aws-java-developer-guide*
# Korrektes Herunterfahren von Aktivitäts- und Workflow-Workern
Das Thema [Erstellen einer einfachen Amazon SWF Anwendung](swf-hello.md) bot eine vollständige Implementierung einer einfachen Workflow-Anwendung, die aus einer Registrierungsanwendung, einem Aktivitäts- und Workflow-Worker sowie einem Workflow-Starter bestand.
Worker-Klassen sind so konzipiert, dass sie kontinuierlich ausgeführt werden und nach Aufgaben suchen, die von Amazon SWF gesendet wurden, um Aktivitäten auszuführen oder Entscheidungen zurückzugeben. Sobald eine Umfrage angefordert wurde, wird der Abfragende Amazon SWF aufgezeichnet und versucht, ihm eine Aufgabe zuzuweisen.
Wenn der Workflow-Worker während einer langen Umfrage beendet wird, versucht er Amazon SWF möglicherweise trotzdem, eine Aufgabe an den abgebrochenen Mitarbeiter zu senden, was dazu führt, dass die Aufgabe verloren geht (bis die Aufgabe das Timeout erreicht).
Eine Möglichkeit zur Bewältigung dieser Situation besteht darin, zu warten, bis alle Long-Poll-Anforderungen zurückkehren, bevor der Worker beendet wird.
In diesem Thema schreiben wir den Aktivitäts-Worker von `helloswf` um und verwenden Java-Hooks für das Herunterfahren. So versuchen wir, den Aktivitäts-Worker ordnungsgemäß herunterzufahren.
Hier finden Sie den vollständigen Code:
```
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflow;
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflowClientBuilder;
import com.amazonaws.services.simpleworkflow.model.ActivityTask;
import com.amazonaws.services.simpleworkflow.model.PollForActivityTaskRequest;
import com.amazonaws.services.simpleworkflow.model.RespondActivityTaskCompletedRequest;
import com.amazonaws.services.simpleworkflow.model.RespondActivityTaskFailedRequest;
import com.amazonaws.services.simpleworkflow.model.TaskList;
public class ActivityWorkerWithGracefulShutdown {
private static final AmazonSimpleWorkflow swf =
AmazonSimpleWorkflowClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
private static final CountDownLatch waitForTermination = new CountDownLatch(1);
private static volatile boolean terminate = false;
private static String executeActivityTask(String input) throws Throwable {
return "Hello, " + input + "!";
}
public static void main(String[] args) {
Runtime.getRuntime().addShutdownHook(new Thread() {
@Override
public void run() {
try {
terminate = true;
System.out.println("Waiting for the current poll request" +
" to return before shutting down.");
waitForTermination.await(60, TimeUnit.SECONDS);
}
catch (InterruptedException e) {
// ignore
}
}
});
try {
pollAndExecute();
}
finally {
waitForTermination.countDown();
}
}
public static void pollAndExecute() {
while (!terminate) {
System.out.println("Polling for an activity task from the tasklist '"
+ HelloTypes.TASKLIST + "' in the domain '" +
HelloTypes.DOMAIN + "'.");
ActivityTask task = swf.pollForActivityTask(new PollForActivityTaskRequest()
.withDomain(HelloTypes.DOMAIN)
.withTaskList(new TaskList().withName(HelloTypes.TASKLIST)));
String taskToken = task.getTaskToken();
if (taskToken != null) {
String result = null;
Throwable error = null;
try {
System.out.println("Executing the activity task with input '"
+ task.getInput() + "'.");
result = executeActivityTask(task.getInput());
}
catch (Throwable th) {
error = th;
}
if (error == null) {
System.out.println("The activity task succeeded with result '"
+ result + "'.");
swf.respondActivityTaskCompleted(
new RespondActivityTaskCompletedRequest()
.withTaskToken(taskToken)
.withResult(result));
}
else {
System.out.println("The activity task failed with the error '"
+ error.getClass().getSimpleName() + "'.");
swf.respondActivityTaskFailed(
new RespondActivityTaskFailedRequest()
.withTaskToken(taskToken)
.withReason(error.getClass().getSimpleName())
.withDetails(error.getMessage()));
}
}
}
}
}
```
In dieser Version wurde der Polling-Code aus der `main`-Funktion in der ursprünglichen Version in eine eigene Methode `pollAndExecute` verschoben.
Die `main` Funktion verwendet nun einen [CountDownLatch](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/concurrent/CountDownLatch.html)in Verbindung mit einem [Shutdown-Hook](https://docs.oracle.com/javase/8/docs/api/index.html?java/lang/Runtime.html), damit der Thread bis zu 60 Sekunden wartet, nachdem seine Beendigung angefordert wurde, bevor der Thread beendet wird.
# Registrieren von Domänen
Jeder Workflow und jede Aktivität in [Amazon SWF](https://aws.amazon.com/swf/)benötigt eine *Domain*, in der sie ausgeführt werden kann.
1. Erstellen Sie ein neues [RegisterDomainRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/RegisterDomainRequest.html)Objekt und geben Sie ihm mindestens den Domänennamen und die Aufbewahrungsfrist für die Workflow-Ausführung an (diese Parameter sind beide erforderlich).
1. Rufen Sie die [AmazonSimpleWorkflowClient.registerDomain-Methode](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html#registerDomain-com.amazonaws.services.simpleworkflow.model.RegisterDomainRequest-) mit dem Objekt auf *RegisterDomainRequest*.
1. Ermitteln Sie [DomainAlreadyExistsException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/DomainAlreadyExistsException.html), ob die Domain, die Sie anfordern, bereits existiert (in diesem Fall ist normalerweise keine Aktion erforderlich).
Der folgende Code veranschaulicht dieses Vorgehen:
```
public void register_swf_domain(AmazonSimpleWorkflowClient swf, String name)
{
RegisterDomainRequest request = new RegisterDomainRequest().withName(name);
request.setWorkflowExecutionRetentionPeriodInDays("10");
try
{
swf.registerDomain(request);
}
catch (DomainAlreadyExistsException e)
{
System.out.println("Domain already exists!");
}
}
```
# Auflisten von Domänen
Sie können die mit Ihrem Konto und Ihrer AWS Region verknüpften [Amazon SWF](https://aws.amazon.com/swf/)Domains nach Registrierungstyp auflisten.
1. Erstellen Sie ein [ListDomainsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/ListDomainsRequest.html)Objekt und geben Sie den Registrierungsstatus der Domains an, an denen Sie interessiert sind — dies ist erforderlich.
1. Rufen Sie [AmazonSimpleWorkflowClient.listDomains](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html#listDomains-com.amazonaws.services.simpleworkflow.model.ListDomainsRequest-) mit dem Objekt auf. *ListDomainRequest* Die Ergebnisse werden in einem [DomainInfos](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/DomainInfos.html)Objekt bereitgestellt.
1. Rufen Sie das zurückgegebene Objekt [getDomainInfos](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/DomainInfos.html#getDomainInfos--)auf, um eine Liste von [DomainInfo](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/DomainInfo.html)Objekten zu erhalten.
1. Rufen Sie [GetName](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/DomainInfo.html#getName--) für jedes *DomainInfo*Objekt auf, um seinen Namen zu erhalten.
Der folgende Code veranschaulicht dieses Vorgehen:
```
public void list_swf_domains(AmazonSimpleWorkflowClient swf)
{
ListDomainsRequest request = new ListDomainsRequest();
request.setRegistrationStatus("REGISTERED");
DomainInfos domains = swf.listDomains(request);
System.out.println("Current Domains:");
for (DomainInfo di : domains.getDomainInfos())
{
System.out.println(" * " + di.getName());
}
}
```
# Im SDK enthaltene Codebeispiele
Das AWS SDK für Java wird mit Codebeispielen geliefert, die viele Funktionen des SDK in baubaren, ausführbaren Programmen demonstrieren. Sie können diese studieren oder ändern, um Ihre eigenen AWS Lösungen mithilfe von zu implementieren. AWS SDK für Java
## Abrufen der Beispiele
Die AWS SDK für Java Codebeispiele befinden sich im *Beispielverzeichnis* des SDK. Wenn Sie das SDK anhand der Informationen unter [Einrichten](setup-install.md) von heruntergeladen und installiert haben AWS SDK für Java, haben Sie die Beispiele bereits auf Ihrem System.
Sie können sich die neuesten Beispiele auch im AWS SDK für Java GitHub Repository im Verzeichnis [src/samples](https://github.com/aws/aws-sdk-java/tree/master/src/samples) ansehen.
## Erstellen und Ausführen der Beispiele in der Befehlszeile
Mithilfe der enthaltenen [Ant](http://ant.apache.org/)-Build-Skripts können Sie die Beispiele leicht erstellen und in der Befehlszeile ausführen. Jedes Beispiel enthält eine README-Datei im HTML-Format mit speziellen Informationen für das jeweilige Beispiel.
**Anmerkung**
Wenn Sie sich den Beispielcode ansehen GitHub, klicken Sie in der Quellcode-Anzeige auf die Schaltfläche **Raw**, wenn Sie sich die Datei README.html des Beispiels ansehen. Im Raw-Modus wird das HTML korrekt im Browser dargestellt.
### Voraussetzungen
Bevor Sie eines der AWS SDK für Java Beispiele ausführen, müssen Sie Ihre AWS Anmeldeinformationen in der Umgebung oder mit den einrichten AWS CLI, wie unter [AWS Anmeldeinformationen einrichten und Region für die Entwicklung](setup-credentials.md) angegeben, festlegen. Die Beispiele verwenden die standardmäßige Anbieterkette von Anmeldeinformationen, sofern möglich. Wenn Sie Ihre Anmeldeinformationen auf diese Weise festlegen, können Sie die riskante Praxis vermeiden, Ihre AWS Anmeldeinformationen in Dateien im Quellcodeverzeichnis einzufügen (wo sie versehentlich eingecheckt und öffentlich zugänglich gemacht werden könnten).
### Ausführen der Beispiele
1. Wechseln Sie in das Verzeichnis mit dem Beispiel-Code. Wenn Sie sich beispielsweise im Stammverzeichnis des AWS SDK-Downloads befinden und das `AwsConsoleApp` Beispiel ausführen möchten, geben Sie Folgendes ein:
```
cd samples/AwsConsoleApp
```
1. Erstellen und führen Sie das Beispiel mit Ant aus. Das Standard-Build-Ziel führt beide Aktionen aus, daher können Sie einfach Folgendes eingeben:
```
ant
```
Das Beispiel druckt Informationen auf die Standardausgabe, zum Beispiel:
```
===========================================
Welcome to the {AWS} Java SDK!
===========================================
You have access to 4 Availability Zones.
You have 0 {EC2} instance(s) running.
You have 13 Amazon SimpleDB domain(s) containing a total of 62 items.
You have 23 {S3} bucket(s), containing 44 objects with a total size of 154767691 bytes.
```
## Erstellen und Ausführen der Beispiele in der Eclipse-IDE
Wenn Sie das verwenden AWS Toolkit for Eclipse, können Sie auch ein neues Projekt in Eclipse starten, das auf dem basiert, AWS SDK für Java oder das SDK zu einem vorhandenen Java-Projekt hinzufügen.
### Voraussetzungen
Nach der Installation von empfehlen wir AWS Toolkit for Eclipse, das Toolkit mit Ihren Sicherheitsanmeldedaten zu konfigurieren. Sie können dies jederzeit tun, indem Sie in Eclipse im Menü „**Fenster**“ die Option „**Einstellungen**“ und dann den Abschnitt „** AWS Toolkit“** auswählen.
### Ausführen der Beispiele
1. Öffnen Sie Eclipse.
1. Erstellen Sie ein neues AWS Java-Projekt. Klicken Sie in Eclipse im Menü **Datei** auf **Neu** und dann auf **Projekt**. Der Assistent **Neues Projekt** wird geöffnet.
1. Erweitern Sie die ** AWS **Kategorie und wählen Sie dann ** AWS Java-Projekt** aus.
1. Wählen Sie **Weiter**. Die Seite "Projekteinstellungen" wird angezeigt.
1. Geben Sie einen Namen in das Feld **Projektname** ein. In der Gruppe AWS SDK für Java Beispiele werden die im SDK verfügbaren Beispiele angezeigt, wie zuvor beschrieben.
1. Wählen Sie durch Markieren der Kontrollkästchen die Beispiele aus, die Sie in Ihr Projekt aufnehmen möchten.
1. Geben Sie Ihre AWS Anmeldedaten ein. Wenn Sie das bereits AWS Toolkit for Eclipse mit Ihren Anmeldeinformationen konfiguriert haben, wird dies automatisch ausgefüllt.
1. Wählen Sie **Finish** (Abschließen). Das Projekt wird erstellt und zum **Projekt-Explorer** hinzugefügt.
1. Wählen Sie die `.java`-Beispieldatei aus, die Sie ausführen möchten. Wählen Sie für das Amazon S3 Beispiel beispielsweise`S3Sample.java`.
1. Klicken Sie im Menü **Ausführen** auf **Ausführen**.
1. Klicken Sie im **Projekt-Explorer** mit der rechten Maustaste auf das Projekt, zeigen Sie dann auf **Build-Pfad** und wählen Sie **Bibliotheken hinzufügen**.
1. Wählen Sie ** AWS Java SDK**, wählen Sie **Weiter** und folgen Sie dann den weiteren Anweisungen auf dem Bildschirm.