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. # Erste Schritte mit der AWS SDK für Java 2.x In den Abschnitten dieses Themas werden Sie durch die wichtigsten Schritte geführt, um mit der Erstellung von Java-Anwendungen zu beginnen, mit denen eine Verbindung hergestellt werden kann AWS-Service. In den Abschnitten werden die Einrichtung Ihrer Entwicklungsumgebung mit Java und die Erstellung von Tools wie Maven oder Gradle, die Konfiguration der sicheren Authentifizierung und die AWS Erstellung Ihrer ersten funktionierenden Anwendung anhand eines praktischen Tutorials behandelt. Dieses anfängerfreundliche Thema dient als Einstieg in die AWS Entwicklung mit Java und bietet die Grundlage, die Sie benötigen, um sich mit fortgeschritteneren Funktionen vertraut zu machen. **Contents** + [AWS SDK für Java 2.x einrichten](setup.md) + [Übersicht über die Einrichtung](setup.md#setup-overview) + [Installieren Sie Java und ein Build-Tool, um mit dem zu arbeiten AWS SDK for Java 2.x](setup-java-buildtool.md) + [Richten Sie ein Apache Maven-Projekt ein, das AWS SDK for Java 2.x](setup-project-maven.md) + [Voraussetzungen](setup-project-maven.md#prerequisitesmaven) + [Erstellen eines Maven-Projekts](setup-project-maven.md#create-maven-project) + [Konfigurieren des Java-Compilers für Maven](setup-project-maven.md#configure-maven-compiler) + [Deklarieren des SDK als Abhängigkeit](setup-project-maven.md#sdk-as-dependency) + [Festlegen von Abhängigkeiten für SDK-Module](setup-project-maven.md#modules-dependencies) + [Aufnehmen des gesamten SDK in Ihr Projekt](setup-project-maven.md#build-the-entire-sdk-into-your-project) + [Erstellen Ihres Projekts](setup-project-maven.md#build-project) + [Richten Sie ein Gradle-Projekt ein, das AWS SDK for Java 2.x](setup-project-gradle.md) + [Richten Sie ein GraalVM Native Image-Projekt ein, das den AWS SDK for Java 2.x](setup-project-graalvm.md) + [Voraussetzungen](setup-project-graalvm.md#setup-graalvmnativeimage-prereq) + [Erstellen Sie ein Projekt mit dem Archetyp](setup-project-graalvm.md#setup-graalvmnativeimage-project) + [Erstellen Sie ein systemeigenes Image](setup-project-graalvm.md#build-graalvmnativeimage-project) + [Authentifizierung AWS mit dem AWS SDK for Java 2.x](get-started-auth.md) + [Für die Authentifizierung einrichten](get-started-auth.md#setup-auth) + [1. Lokale Entwicklung mit kurzfristigen Referenzen](get-started-auth.md#setup-login) + [2. Einrichtung für den Single Sign-On-Zugriff für das SDK](get-started-auth.md#setup-credentials) + [3. Melden Sie sich mit dem AWS CLI](get-started-auth.md#setup-login-sso) + [Zusätzliche Authentifizierungsoptionen](get-started-auth.md#setup-additional) + [Erstellen einer einfachen Anwendung mit dem AWS SDK for Java 2.x](get-started-tutorial.md) + [Schritt 1: Einrichtung für dieses Tutorial](get-started-tutorial.md#get-started-setup) + [Schritt 2: Erstellen des Projekts](get-started-tutorial.md#get-started-projectsetup) + [Schritt 3: Schreiben des Codes](get-started-tutorial.md#get-started-code) + [Schritt 4: Anwendung erstellen und ausführen](get-started-tutorial.md#get-started-run) + [Herzlichen Glückwunsch](get-started-tutorial.md#get-started-success) + [Bereinigen](get-started-tutorial.md#cleanup) + [Nächste Schritte](get-started-tutorial.md#get-started-next) # AWS SDK für Java 2.x einrichten Dieser Abschnitt enthält Informationen darüber, wie Sie Ihre Entwicklungsumgebung und Projekte für die Verwendung von einrichten AWS SDK for Java 2.x. ## Übersicht über die Einrichtung Für die erfolgreiche Entwicklung von Anwendungen, die AWS-Services über das zugreifen AWS SDK für Java, sind die folgenden Bedingungen erforderlich: + Das Java SDK muss Zugriff auf Anmeldeinformationen haben, um [Anfragen in Ihrem Namen zu authentifizieren](get-started-auth.md#setup-auth). + Die für das SDK konfigurierten [Berechtigungen der IAM-Rolle](https://docs.aws.amazon.com/singlesignon/latest/userguide/permissionsetsconcept.html) müssen den Zugriff auf die Berechtigungen ermöglichen AWS-Services , die Ihre Anwendung benötigt. Die mit der **PowerUserAccess** AWS verwalteten Richtlinie verbundenen Berechtigungen reichen für die meisten Entwicklungsanforderungen aus. + Eine Entwicklungsumgebung mit den folgenden Elementen: + [Gemeinsam genutzte Konfigurationsdateien](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html), die auf mindestens eine der folgenden Arten eingerichtet wurden: + Die `config` Datei enthält [Single-Sign-On-Einstellungen für IAM Identity Center](get-started-auth.md#setup-credentials), sodass das SDK Anmeldeinformationen abrufen AWS kann. + Die `credentials` Datei enthält temporäre Anmeldeinformationen. + Eine [Installation von Java 8](setup-java-buildtool.md) oder höher. + Ein [Tool zur Build-Automatisierung](setup-java-buildtool.md) wie [Maven](https://maven.apache.org/download.cgi) oder [Gradle](https://gradle.org/install/). + Ein Texteditor für die Arbeit mit Code. + (Optional, aber empfohlen) Eine IDE (integrierte Entwicklungsumgebung) wie [IntelliJ IDEA](https://www.jetbrains.com/idea/download/#section=windows), [Eclipse](https://www.eclipse.org/ide/) oder. [NetBeans](https://netbeans.apache.org/front/main/download/index.html) Wenn Sie IntelliJ IDEA verwenden, können Sie die [AWS Toolkit for IntelliJ IDEA](https://docs.aws.amazon.com/toolkit-for-jetbrains/latest/userguide/welcome.html) auch hinzufügen, um sie AWS-Services direkt in die IDE zu integrieren, um die Entwicklung zu optimieren. + Eine aktive AWS Access-Portalsitzung, wenn Sie bereit sind, Ihre Anwendung auszuführen. Sie verwenden den AWS Command Line Interface , um den [Anmeldevorgang für das AWS Zugangsportal von IAM Identity Center zu initiieren](get-started-auth.md#setup-login-sso). **Wichtig** Bei den Anweisungen in diesem Abschnitt zur Einrichtung wird davon ausgegangen, dass Sie oder Ihre Organisation IAM Identity Center verwenden. Wenn Ihre Organisation einen externen Identitätsanbieter verwendet, der unabhängig von IAM Identity Center arbeitet, finden Sie heraus, wie Sie temporäre Anmeldeinformationen für das SDK for Java erhalten können. Folgen Sie [diesen Anweisungen](credentials-temporary.md#credentials-temporary-from-portal), um der `~/.aws/credentials` Datei temporäre Anmeldeinformationen hinzuzufügen. Wenn Ihr Identitätsanbieter der `~/.aws/credentials` Datei automatisch temporäre Anmeldeinformationen hinzufügt, stellen Sie sicher, dass der Profilname `[default]` so lautet, dass Sie dem SDK keinen Profilnamen angeben müssen oder AWS CLI. # Installieren Sie Java und ein Build-Tool, um mit dem zu arbeiten AWS SDK for Java 2.x Sie benötigen die folgenden Anforderungen an die Java-Entwicklungsumgebung, um mit SDK for Java 2.x zu arbeiten: + Java 8 oder höher. [Das AWS SDK für Java funktioniert mit dem [Oracle Java SE Development Kit](https://www.oracle.com/java/technologies/downloads/) und mit Distributionen von Open Java Development Kit (OpenJDK) wie [Amazon Corretto](https://aws.amazon.com/corretto/)[Red Hat OpenJDK](https://developers.redhat.com/products/openjdk/overview) und Adoptium.](https://adoptium.net/) + Ein Maven-kompatibles Build-Tool wie Apache Maven, Apache Ant mit Ivy, Gradle oder IntelliJ. + [Informationen zur Installation und Verwendung von Maven finden Sie unter https://maven.apache.org/.](https://maven.apache.org/) + [Informationen zur Installation und Verwendung von Apache Ivy finden Sie unter https://ant.apache.org/ivy/.](https://ant.apache.org/ivy/) + [Informationen zur Installation und Verwendung von Gradle finden Sie unter https://gradle.org/.](https://gradle.org/) + Informationen zur Installation und Verwendung von IntelliJ IDEA finden Sie unter. [https://www.jetbrains.com/idea/](https://www.jetbrains.com/idea/) # Richten Sie ein Apache Maven-Projekt ein, das AWS SDK for Java 2.x Sie können [Apache Maven](https://maven.apache.org/) verwenden, um AWS SDK for Java 2.x Projekte einzurichten und zu erstellen oder um [das SDK selbst zu erstellen](https://github.com/aws/aws-sdk-java-v2/tree/master#building-from-source). ## Voraussetzungen Um das SDK for Java 2.x mit Maven zu verwenden, benötigen Sie Folgendes: + Java *8.0 oder höher* [Sie können die neueste Java SE Development Kit-Software von http://www.oracle herunterladen. com/technetwork/java/javase/downloads](https://www.oracle.com/java/technologies/downloads/)/. Das SDK for Java 2.x funktioniert auch mit [OpenJDK](https://openjdk.org/) und Amazon Corretto, einer Distribution des Open Java Development Kit (OpenJDK). Laden Sie die neueste OpenJDK-Version von herunter. [https://openjdk.java.net/install/index.html](https://openjdk.org/install/index.html) Laden Sie die neueste Version Amazon Corretto 8 oder Amazon Corretto 11 von [der Corretto](https://aws.amazon.com/corretto/) Seite herunter. + *Apache Maven*. Wenn Sie Maven installieren müssen, navigieren Sie zu [http://maven.apache.org/](https://maven.apache.org/), um das Tool herunterzuladen und zu installieren. ## Erstellen eines Maven-Projekts Um ein Maven-Projekt von der Befehlszeile aus zu erstellen, führen Sie den folgenden Befehl in einem Terminal- oder Befehlszeilenfenster `` `` aus. ``` mvn -B archetype:generate \ -DarchetypeGroupId=software.amazon.awssdk \ -DarchetypeArtifactId=archetype-lambda -Dservice=s3 -Dregion=US_WEST_2 \ -DarchetypeVersion=2.X.X \ -DgroupId=com.example.myapp \ -DartifactId=myapp ``` **Anmerkung** Ersetzen Sie *com.example.myapp* durch den vollständigen Paket-Namespace Ihrer Anwendung. Ersetzen Sie auch *myapp* durch Ihren Projektnamen. Dies wird der Name des Verzeichnisses für Ihr Projekt. Um die neueste Version des Archetyps zu verwenden, *2.X.X* ersetzen Sie ihn durch die [neueste Version von](https://central.sonatype.com/artifact/software.amazon.awssdk/archetype-lambda) Maven Central. Dieser Befehl erstellt ein Maven-Projekt mit dem Archetype Templating Toolkit. Der Archetyp generiert das Gerüst für ein Function-Handler-Projekt. AWS Lambda Dieser Projekt-Archetyp ist für die Kompilierung mit Java SE 8 vorkonfiguriert und beinhaltet eine Abhängigkeit von der Version des SDK for Java 2.x, die mit spezifiziert ist. `-DarchetypeVersion` Weitere Informationen zum Erstellen und Konfigurieren von Maven-Projekten finden Sie im [Maven-Handbuch „Erste Schritte“](https://maven.apache.org/guides/getting-started/). ## Konfigurieren des Java-Compilers für Maven Wenn Sie Ihr Projekt mit dem AWS Lambda Projekt-Archetyp wie zuvor beschrieben erstellt haben, ist die Konfiguration des Java-Compilers bereits für Sie erledigt. Um zu überprüfen, ob diese Konfiguration vorhanden ist, öffnen Sie zunächst die Datei `pom.xml` aus dem Projektordner, den Sie erstellt haben (z. B. `myapp`), als Sie den vorherigen Befehl ausgeführt haben. In den Zeilen 11 und 12 sehen Sie die Einstellung der Java-Compiler-Version für dieses Maven-Projekt und in den Zeilen 71 bis 75 die erforderliche Einbindung des Maven-Compiler-Plug-ins. ``` 1.8 1.8 org.apache.maven.plugins maven-compiler-plugin ${maven.compiler.plugin.version} ``` **Wenn Sie Ihr Projekt mit einem anderen Archetyp oder mit einer anderen Methode erstellen, müssen Sie sicherstellen, dass das Maven-Compiler-Plugin Teil des Builds ist und dass seine Quell- und Zieleigenschaften in der Datei beide auf 1.8 gesetzt sind.** `pom.xml` Eine Möglichkeit, diese erforderlichen Einstellungen zu konfigurieren, finden Sie im vorherigen Snippet. Alternativ können Sie die Compiler-Konfiguration inline wie folgt mit der Plug-in-Deklaration konfigurieren. ``` org.apache.maven.plugins maven-compiler-plugin 1.8 1.8 ``` ## Deklarieren des SDK als Abhängigkeit Um das AWS SDK für Java in Ihrem Projekt zu verwenden, müssen Sie es als Abhängigkeit in der Datei Ihres Projekts deklarieren. `pom.xml` Wenn Sie Ihr Projekt mit dem Projekt-Archetyp wie zuvor beschrieben erstellt haben, ist die neueste Version des SDK bereits als Abhängigkeit in Ihrem Projekt konfiguriert. Der Archetyp generiert eine Stücklisten-Artefaktabhängigkeit (Stückliste) für die Gruppen-ID. `software.amazon.awssdk` Bei einer Stückliste müssen Sie die Maven-Version nicht für einzelne Artefaktabhängigkeiten angeben, die dieselbe Gruppen-ID haben. Wenn Sie Ihr Maven-Projekt auf andere Weise erstellt haben, konfigurieren Sie die neueste Version des SDK für Ihr Projekt, indem Sie sicherstellen, dass die Datei `pom.xml` Folgendes enthält. ``` 2.X.X software.amazon.awssdk bom ${aws.java.sdk.version} pom import ``` **Anmerkung** Ersetzen Sie *2.X.X* die `pom.xml` Datei durch die [neueste Version von](https://central.sonatype.com/artifact/software.amazon.awssdk/bom). AWS SDK for Java 2.x ## Festlegen von Abhängigkeiten für SDK-Module Nachdem Sie das SDK konfiguriert haben, können Sie Abhängigkeiten für eines oder mehrere der AWS SDK für Java Module hinzufügen, die Sie in Ihrem Projekt verwenden möchten. Sie können zwar die Versionsnummer für jede Komponente angeben, müssen dies jedoch nicht, da Sie die SDK-Version bereits in dem `dependencyManagement` Abschnitt mit dem Stücklisten-Artefakt deklariert haben. Um eine andere Version eines bestimmten Moduls zu laden, geben Sie eine Versionsnummer für dessen Abhängigkeit an. Wenn Sie Ihr Projekt mit dem Projekt-Archetyp wie zuvor beschrieben erstellt haben, ist Ihr Projekt bereits mit mehreren Abhängigkeiten konfiguriert. Dazu gehören Abhängigkeiten für AWS Lambda Funktionshandler und Amazon S3, wie folgt. ``` software.amazon.awssdk s3 software.amazon.awssdk netty-nio-client software.amazon.awssdk apache-client software.amazon.awssdk url-connection-client com.amazonaws aws-lambda-java-core ${aws.lambda.java.version} ``` **Anmerkung** Im obigen `pom.xml` Beispiel stammen die Abhängigkeiten von verschiedenen s. `groupId` Die `s3` Abhängigkeit ist von`software.amazon.awssdk`, wohingegen die `aws-lambda-java-core` Abhängigkeit von ist`com.amazonaws`. Die Konfiguration der STL-Abhängigkeitsverwaltung wirkt sich auf Artefakte für aus`software.amazon.awssdk`, sodass für das `aws-lambda-java-core` Artefakt eine Version erforderlich ist. Für die Entwicklung von *Lambda-Funktionshandlern*, die das SDK for Java 2.x verwenden, `aws-lambda-java-core` ist dies die richtige Abhängigkeit. Wenn Ihre Anwendung jedoch Lambda-Ressourcen mithilfe von Operationen wie,`listFunctions`, und `createFunction` verwalten muss `deleteFunction``invokeFunction`, erfordert Ihre Anwendung die folgende Abhängigkeit. ``` software.amazon.awssdk lambda ``` **Anmerkung** Die `s3` Abhängigkeit schließt die `netty-nio-client` und die `apache-client` transitiven Abhängigkeiten aus. Anstelle eines dieser HTTP-Clients beinhaltet der Archetyp die `url-connection-client` Abhängigkeit, wodurch die [Startlatenz für Funktionen reduziert wird](lambda-optimize-starttime.md#lambda-quick-url). AWS Lambda Fügen Sie Ihrem Projekt die Module für die Funktionen hinzu, die AWS-Service Sie für Ihr Projekt benötigen. Die Module (Abhängigkeiten), die von der AWS SDK für Java BOM verwaltet werden, sind im [zentralen Maven-Repository](https://central.sonatype.com/artifact/software.amazon.awssdk/bom) aufgeführt. **Anmerkung** Sie können die Datei `pom.xml` anhand eines Codebeispiels betrachten, um zu ermitteln, welche Abhängigkeiten Sie für Ihr Projekt benötigen. Wenn Sie beispielsweise an den Abhängigkeiten für den DynamoDB-Dienst interessiert sind, sehen Sie sich [dieses Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/dynamodb/pom.xml) aus dem [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2) unter an. GitHub (Suchen Sie unter [/javav2/example\$1code/dynamodb](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/dynamodb) nach der `pom.xml` Datei.) ### Aufnehmen des gesamten SDK in Ihr Projekt Zur Optimierung Ihrer Anwendung empfehlen wir dringend, nur die benötigten Komponenten abzurufen, und nicht das gesamte SDK. Um jedoch die gesamte Datei AWS SDK für Java in Ihr Projekt einzubauen, deklarieren Sie sie wie folgt in Ihrer Datei. `pom.xml` ``` software.amazon.awssdk aws-sdk-java 2.X.X ``` ## Erstellen Ihres Projekts Nachdem Sie die Datei `pom.xml` konfiguriert haben, können Sie Ihr Projekt mithilfe von Maven erstellen. Um ein Maven-Projekt über die Befehlszeile zu erstellen, öffnen Sie ein Terminal- oder Eingabeaufforderungsfenster, navigieren Sie zu Ihrem Projektverzeichnis (z. B. `myapp`), geben oder fügen Sie den folgenden Befehl ein und drücken Sie dann die Eingabe. ``` mvn package ``` Dadurch wird eine einzelne `.jar`-Datei (JAR) im Verzeichnis `target` erstellt (z. B. `myapp/target`). Diese JAR enthält alle SDK-Module, die Sie als Abhängigkeiten in Ihrer Datei `pom.xml` angegeben haben. # Richten Sie ein Gradle-Projekt ein, das AWS SDK for Java 2.x Sie können [Gradle](https://gradle.org/) verwenden, um Projekte einzurichten und zu erstellen AWS SDK for Java 2.x . Die ersten Schritte im folgenden Beispiel stammen aus dem [Handbuch Erste Schritte von Gradle](https://docs.gradle.org/current/samples/sample_building_java_applications.html) für Version 8.4. Wenn Sie eine andere Version verwenden, können Ihre Ergebnisse geringfügig abweichen. **Um eine Java-Anwendung mit Gradle (Befehlszeile) zu erstellen** 1. Erstellen Sie ein Verzeichnis für Ihr Projekt. In diesem Beispiel `demo` ist das der Verzeichnisname. 1. Führen Sie innerhalb des `demo` Verzeichnisses den `gradle init` Befehl aus und geben Sie die rot markierten Werte ein, wie in der folgenden Befehlszeilenausgabe gezeigt. Für die Einführung wählen wir Kotlin als DSL-Sprache für das Build-Skript. Ein vollständiges Beispiel für Groovy finden Sie am Ende dieses Themas. ``` > gradle init Starting a Gradle Daemon (subsequent builds will be faster) Select type of project to generate: 1: basic 2: application 3: library 4: Gradle plugin Enter selection (default: basic) [1..4] 2 Select implementation language: 1: C++ 2: Groovy 3: Java 4: Kotlin 5: Scala 6: Swift Enter selection (default: Java) [1..6] 3 Generate multiple subprojects for application? (default: no) [yes, no] no Select build script DSL: 1: Kotlin 2: Groovy Enter selection (default: Kotlin) [1..2] Select test framework: 1: JUnit 4 2: TestNG 3: Spock 4: JUnit Jupiter Enter selection (default: JUnit Jupiter) [1..4] 4 Project name (default: demo): Source package (default: demo): Enter target version of Java (min. 7) (default: 11): Generate build using new APIs and behavior (some features may change in the next minor release)? (default: no) [yes, no] > Task :init To learn more about Gradle by exploring our Samples at https://docs.gradle.org/8.4/samples/sample_building_java_applications.html BUILD SUCCESSFUL in 3m 43s 2 actionable tasks: 2 executed ``` 1. Nach Abschluss der `init` Aufgabe enthält das `demo` Verzeichnis die folgende Baumstruktur. Im nächsten Abschnitt werfen wir einen genaueren Blick auf die Haupt-Build-Datei `build.gradle.kts` (rot hervorgehoben). ``` ├── app │   ├── build.gradle.kts │   └── src │   ├── main │   │   ├── java │   │   │   └── demo │   │   │   └── App.java │   │   └── resources │   └── test │   ├── java │   │   └── demo │   │   └── AppTest.java │   └── resources ├── gradle │   └── wrapper │   ├── gradle-wrapper.jar │   └── gradle-wrapper.properties ├── gradlew ├── gradlew.bat └── settings.gradle.kts ``` Die `build.gradle.kts` Datei enthält den folgenden gerüsteten Inhalt. ``` /* * This file was generated by the Gradle 'init' task. * * This generated file contains a sample Java application project to get you started. * For more details on building Java & JVM projects, please refer to https://docs.gradle.org/8.4/userguide/building_java_projects.html in the Gradle documentation. */ plugins { // Apply the application plugin to add support for building a CLI application in Java. application } repositories { // Use Maven Central for resolving dependencies. mavenCentral() } dependencies { // Use JUnit Jupiter for testing. testImplementation("org.junit.jupiter:junit-jupiter:5.9.3") testRuntimeOnly("org.junit.platform:junit-platform-launcher") // This dependency is used by the application. implementation("com.google.guava:guava:33.3.0-jre") } // Apply a specific Java toolchain to ease working on different environments. java { toolchain { languageVersion.set(JavaLanguageVersion.of(11)) } } application { // Define the main class for the application. mainClass.set("demo.App") } tasks.named("test") { // Use JUnit Platform for unit tests. useJUnitPlatform() } ``` 1. Verwenden Sie die Gradle-Build-Datei mit Gerüsten als Grundlage für Ihr Projekt. AWS 1. Um die SDK-Abhängigkeiten für Ihr Gradle-Projekt zu verwalten, fügen Sie dem Abschnitt der Datei die Maven-Stückliste (BOM) hinzu. AWS SDK for Java 2.x `dependencies` `build.gradle.kts` ``` ... dependencies { implementation(platform("software.amazon.awssdk:bom:2.27.21")) // With the bom declared, you specify individual SDK dependencies without a version. ... } ... ``` **Anmerkung** Ersetzen Sie in dieser Beispiel-Builddatei *2.27.21* durch die neueste Version des SDK for Java 2.x. Finden Sie die neueste Version, die im zentralen [Maven-Repository](https://central.sonatype.com/artifact/software.amazon.awssdk/bom/versions) verfügbar ist. 1. Geben Sie im `dependencies` Abschnitt die SDK-Module an, die Ihre Anwendung benötigt. Im Folgenden wird beispielsweise eine Abhängigkeit von Amazon Simple Storage Service hinzugefügt. ``` ... dependencies { implementation(platform("software.amazon.awssdk:bom:2.27.21")) implementation("software.amazon.awssdk:s3") ... } ... ``` Gradle löst automatisch die richtige Version der deklarierten Abhängigkeiten auf, indem es die Informationen aus der Stückliste verwendet. Die folgenden Beispiele zeigen komplette Gradle-Build-Dateien sowohl in Kotlin als auch in Groovy. DSLs Die Build-Datei enthält Abhängigkeiten für Amazon S3, Authentifizierung, Protokollierung und Tests. Die Quell- und Zielversion von Java ist Version 11. ------ #### [ Kotlin DSL (build.gradle.kts) ] ``` /* * This file was generated by the Gradle 'init' task. * * This generated file contains a sample Java application project to get you started. * For more details on building Java & JVM projects, please refer to https://docs.gradle.org/8.4/userguide/building_java_projects.html in the Gradle documentation. */ plugins { // Apply the application plugin to add support for building a CLI application in Java. application } repositories { // Use Maven Central for resolving dependencies. mavenCentral() } dependencies { implementation(platform("software.amazon.awssdk:bom:2.20.56")) implementation("software.amazon.awssdk:s3") implementation("software.amazon.awssdk:sso") implementation("software.amazon.awssdk:ssooidc") implementation(platform("org.apache.logging.log4j:log4j-bom:2.20.0")) implementation("org.apache.logging.log4j:log4j-slf4j2-impl") implementation("org.apache.logging.log4j:log4j-1.2-api") testImplementation(platform("org.junit:junit-bom:5.10.0")) testImplementation("org.junit.jupiter:junit-jupiter") } // Apply a specific Java toolchain to ease working on different environments. java { toolchain { languageVersion.set(JavaLanguageVersion.of(11)) } } application { // Define the main class for the application. mainClass.set("demo.App") } tasks.named("test") { // Use JUnit Platform for unit tests. useJUnitPlatform() } ``` ------ #### [ Groovy DSL (build.gradle) ] ``` /* * This file was generated by the Gradle 'init' task. * * This generated file contains a sample Java application project to get you started. * For more details on building Java & JVM projects, please refer to https://docs.gradle.org/8.4/userguide/building_java_projects.html in the Gradle documentation. */ plugins { // Apply the application plugin to add support for building a CLI application in Java. id 'application' } repositories { // Use Maven Central for resolving dependencies. mavenCentral() } dependencies { implementation platform('software.amazon.awssdk:bom:2.27.21') implementation 'software.amazon.awssdk:s3' implementation 'software.amazon.awssdk:sso' implementation 'software.amazon.awssdk:ssooidc' implementation platform('org.apache.logging.log4j:log4j-bom:2.20.0') implementation 'org.apache.logging.log4j:log4j-slf4j2-impl' implementation 'org.apache.logging.log4j:log4j-1.2-api' testImplementation platform('org.junit:junit-bom:5.10.0') testImplementation 'org.junit.jupiter:junit-jupiter' } // Apply a specific Java toolchain to ease working on different environments. java { toolchain { languageVersion = JavaLanguageVersion.of(11) } } application { // Define the main class for the application. mainClass = 'demo_groovy.App' } tasks.named('test') { // Use JUnit Platform for unit tests. useJUnitPlatform() } ``` ------ Die nächsten Schritte finden Sie im Handbuch Erste Schritte auf der Gradle-Website mit Anweisungen zum [Erstellen und Ausführen einer Gradle-Anwendung](https://docs.gradle.org/current/samples/sample_building_java_applications.html#run_the_application). # Richten Sie ein GraalVM Native Image-Projekt ein, das den AWS SDK for Java 2.x Mit den Versionen 2.16.1 und höher AWS SDK for Java 2.x bietet das out-of-the-box Unterstützung für GraalVM Native Image-Anwendungen. Verwenden Sie den `archetype-app-quickstart` Maven-Archetyp, um ein Projekt mit integrierter Native-Image-Unterstützung einzurichten. ## Voraussetzungen + Führen Sie die Schritte unter 2.x [einrichten aus. AWS SDK für Java](setup.md) + Installieren Sie [GraalVM Native Image](https://www.graalvm.org/reference-manual/native-image/#install-native-image). ## Erstellen Sie ein Projekt mit dem Archetyp Verwenden Sie den folgenden Befehl, um ein Maven-Projekt mit integrierter systemeigener Image-Unterstützung in einem Terminal- oder Befehlszeilenfenster zu erstellen. **Anmerkung** `com.example.mynativeimageapp`Ersetzen Sie es durch den vollständigen Paket-Namespace Ihrer Anwendung. Ersetzen Sie es auch `mynativeimageapp` durch Ihren Projektnamen. Dies wird der Name des Verzeichnisses für Ihr Projekt. ``` mvn archetype:generate \ -DarchetypeGroupId=software.amazon.awssdk \ -DarchetypeArtifactId=archetype-app-quickstart \ -DarchetypeVersion=2.27.21\ -DnativeImage=true \ -DhttpClient=apache-client \ -Dservice=s3 \ -DgroupId=com.example.mynativeimageapp \ -DartifactId=mynativeimageapp \ -DinteractiveMode=false ``` Dieser Befehl erstellt ein Maven-Projekt, das mit Abhängigkeiten für den AWS SDK für Java Amazon S3, und den `ApacheHttpClient` HTTP-Client konfiguriert ist. Es enthält auch eine Abhängigkeit für das [GraalVM Native Image Maven-Plugin, sodass Sie mit Maven](https://graalvm.github.io/native-build-tools/latest/index.html) native Images erstellen können. Um Abhängigkeiten für einen anderen Dienst einzubeziehen Amazon Web Services, setzen Sie den Wert des `-Dservice` Parameters auf die Artefakt-ID dieses Dienstes. Beispiele hierfür sind `dynamodb`, `comprehend` und `pinpoint`. Eine vollständige Liste der IDs Artefakte finden Sie in der Liste der verwalteten Abhängigkeiten für [software.amazon.awssdk](https://mvnrepository.com/artifact/software.amazon.awssdk/bom/latest) auf Maven Central. Um einen asynchronen HTTP-Client zu verwenden, setzen Sie den Parameter auf. `-DhttpClient` `netty-nio-client` Um ihn stattdessen `UrlConnectionHttpClient` als synchronen HTTP-Client zu verwenden`apache-client`, setzen Sie den `-DhttpClient` Parameter auf. `url-connection-client` ## Erstellen Sie ein systemeigenes Image Nachdem Sie das Projekt erstellt haben, führen Sie den folgenden Befehl in Ihrem Projektverzeichnis aus, z. B.`mynativeimageapp`: ``` mvn package -P native-image ``` Dadurch wird eine native Image-Anwendung in dem `target` Verzeichnis erstellt, `target/mynativeimageapp` z. B. # Authentifizierung AWS mit dem AWS SDK for Java 2.x Sie müssen bei der Entwicklung mit AWS Diensten festlegen AWS , wie sich das AWS SDK for Java 2.x authentifiziert. Das SDK verwaltet die Erkennung von Anmeldeinformationen, die Erstellung von Signaturen und die Aktualisierung der Anmeldeinformationen vollständig hinter den Kulissen, sodass Sie sich auf Ihre Anwendungslogik konzentrieren können. ## Für die Authentifizierung einrichten Im Thema [Authentifizierung und Zugriff](https://docs.aws.amazon.com/sdkref/latest/guide/access.html) im AWS SDKs Referenzhandbuch zu Tools werden die verschiedenen Authentifizierungsansätze beschrieben. Für die lokale Entwicklung wird empfohlen, kurzfristige Anmeldeinformationen zu verwenden, indem Sie sich mit Ihren Konsolen-Anmeldeinformationen bei der AWS CLI anmelden. Wird empfohlen, wenn Sie Root, IAM-Benutzer oder einen Verbund mit IAM für den AWS Kontozugriff verwenden. Folgen Sie den Anweisungen unter [Zugangsdaten für interaktive Entwicklungsarbeiten mit AWS SDK for Java 2.x](credentials-temporary.md). Nachdem Sie die Anweisungen in AWS SDKs und im Referenzhandbuch zu Tools befolgt haben, sollte Ihr System so eingerichtet sein, dass das SDK Anfragen signieren kann: ### 1. Lokale Entwicklung mit kurzfristigen Referenzen Für die lokale Entwicklung wird empfohlen, kurzfristige Anmeldeinformationen zu verwenden, indem Sie sich mit Ihren Konsolen-Anmeldeinformationen bei der AWS CLI anmelden. Wird empfohlen, wenn Sie Root, IAM-Benutzer oder einen Verbund mit IAM für den AWS Kontozugriff verwenden. Anweisungen finden Sie unter [Verwenden von Anmeldeinformationsanbietern in der](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/credentials-temporary.html). AWS SDK for Java 2.x ### 2. Einrichtung für den Single Sign-On-Zugriff für das SDK Nachdem Sie Schritt 2 im [Abschnitt „Programmatischer Zugriff“](https://docs.aws.amazon.com/sdkref/latest/guide/access-sso.html#idcGettingStarted) abgeschlossen haben, damit das SDK die IAM Identity Center-Authentifizierung verwenden kann, sollte Ihr System die folgenden Elemente enthalten. + Die AWS CLI, mit der Sie eine [AWS Access-Portal-Sitzung](#setup-login-sso) starten, bevor Sie Ihre Anwendung ausführen. + Eine `~/.aws/config` Datei, die ein [Standardprofil](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html#file-format-profile) enthält. Das SDK for Java verwendet die SSO-Token-Provider-Konfiguration des Profils, um Anmeldeinformationen abzurufen, bevor Anfragen an gesendet AWS werden. Der Wert `sso_role_name`, bei dem es sich um eine IAM-Rolle handelt, die mit einem Berechtigungssatz von IAM Identity Center verbunden ist, sollte den Zugriff auf die in Ihrer Anwendung verwendeten AWS-Services ermöglichen. Die folgende `config` Beispieldatei zeigt ein Standardprofil, das mit der Konfiguration des SSO-Token-Anbieters eingerichtet wurde. Die `sso_session`-Einstellung des Profils bezieht sich auf den benannten `sso-session`-Abschnitt. Der `sso-session`-Abschnitt enthält Einstellungen zum Initiieren einer AWS -Zugriffsportalsitzung. ``` [default] sso_session = my-sso sso_account_id = 111122223333 sso_role_name = SampleRole region = us-east-1 output = json [sso-session my-sso] sso_region = us-east-1 sso_start_url = https://provided-domain.awsapps.com/start sso_registration_scopes = sso:account:access ``` Weitere Informationen zu den in der Konfiguration des SSO-Token-Anbieters verwendeten Einstellungen finden Sie unter Konfiguration des [SSO-Token-Anbieters](https://docs.aws.amazon.com/sdkref/latest/guide/feature-sso-credentials.html#sso-token-config) im AWS SDKs Referenzhandbuch zu Tools. Wenn Ihre Entwicklungsumgebung nicht wie zuvor gezeigt für den programmatischen Zugriff eingerichtet ist, folgen Sie [Schritt 2 im SDKs Referenzhandbuch.](https://docs.aws.amazon.com/sdkref/latest/guide/access-sso.html#idcGettingStarted) ### 3. Melden Sie sich mit dem AWS CLI Bevor Sie eine Zugriffsanwendung ausführen AWS-Services, benötigen Sie eine aktive AWS Access-Portal-Sitzung, damit das SDK die IAM Identity Center-Authentifizierung zur Auflösung von Anmeldeinformationen verwenden kann. Führen Sie den folgenden Befehl im aus AWS CLI , um sich beim AWS Zugriffsportal anzumelden. ``` aws sso login ``` Da Sie ein Standardprofil eingerichtet haben, müssen Sie den Befehl nicht mit einer `--profile`-Option aufrufen. Wenn die Konfiguration Ihres SSO-Token-Anbieters ein benanntes Profil verwendet, lautet der Befehl `aws sso login --profile named-profile`. Führen Sie den folgenden AWS CLI -Befehl aus, um zu testen, ob Sie bereits eine aktive Sitzung haben. ``` aws sts get-caller-identity ``` In der Antwort auf diesen Befehl sollten das in der freigegebenen `config`-Datei konfigurierte IAM-Identity-Center-Konto und der Berechtigungssatz angegeben werden. **Anmerkung** Wenn Sie bereits über eine aktive AWS Access-Portal-Sitzung verfügen und diese ausführen`aws sso login`, müssen Sie keine Anmeldeinformationen angeben. Es wird jedoch ein Dialogfeld angezeigt, in dem Sie um die Erlaubnis `botocore` zum Zugriff auf Ihre Informationen gebeten werden. `botocore`ist die Grundlage für die AWS CLI . Wählen Sie **Zulassen** aus, um den Zugriff auf Ihre Informationen für das AWS CLI und SDK for Java zu autorisieren. ## Zusätzliche Authentifizierungsoptionen Weitere Optionen zur Authentifizierung für das SDK, wie z. B. die Verwendung von Profilen und Umgebungsvariablen, finden Sie im Kapitel [Konfiguration](https://docs.aws.amazon.com/sdkref/latest/guide/creds-config-files.html) im AWS SDKs Referenzhandbuch zu Tools. # Erstellen einer einfachen Anwendung mit dem AWS SDK for Java 2.x Dieses Tutorial zeigt Ihnen, wie Sie [Apache Maven](https://maven.apache.org/) verwenden, um Abhängigkeiten für das SDK for Java 2.x zu definieren und dann Code zu schreiben, der eine Verbindung herstellt, Amazon S3 um eine Datei hochzuladen. Folgen Sie diesen Schritten, um dieses Tutorial abzuschließen: + [Schritt 1: Richten Sie sich für dieses Tutorial ein](#get-started-setup) + [Schritt 2: Erstellen Sie das Projekt](#get-started-projectsetup) + [Schritt 3: Schreiben Sie den Code](#get-started-code) + [Schritt 4: Erstellen Sie die Anwendung und führen Sie sie aus](#get-started-run) ## Schritt 1: Einrichtung für dieses Tutorial Bevor Sie mit diesem Tutorial beginnen, brauchen Sie Folgendes: + Erlaubnis zum Zugriff Amazon S3 + Eine Java-Entwicklungsumgebung, die für den Zugriff AWS-Services per Single Sign-On auf die konfiguriert ist AWS IAM Identity Center Verwenden Sie die Anweisungen unter[Übersicht über die Einrichtung](setup.md#setup-overview), um sich auf dieses Tutorial vorzubereiten. Nachdem Sie [Ihre Entwicklungsumgebung mit Single Sign-On-Zugriff für das Java SDK konfiguriert](get-started-auth.md#setup-credentials) haben und eine [aktive AWS Access-Portal-Sitzung](get-started-auth.md#setup-login-sso) eingerichtet haben, fahren Sie mit Schritt 2 dieses Tutorials fort. ## Schritt 2: Erstellen des Projekts Um das Projekt für dieses Tutorial zu erstellen, führen Sie einen Maven-Befehl aus, der Sie zur Eingabe der Konfiguration des Projekts auffordert. Nachdem alle Eingaben eingegeben und bestätigt wurden, schließt Maven den Aufbau des Projekts ab, indem es `pom.xml` Java-Stub-Dateien erstellt und erstellt. 1. Öffnen Sie ein Terminal oder ein Befehlszeilenfenster und navigieren Sie zu einem Verzeichnis Ihrer Wahl, z. B. zu Ihrem Ordner `Desktop` oder `Home`. 1. Geben Sie den folgenden Befehl am Terminal ein und drücken Sie. `Enter` ``` mvn archetype:generate \ -DarchetypeGroupId=software.amazon.awssdk \ -DarchetypeArtifactId=archetype-app-quickstart \ -DarchetypeVersion=2.27.21 ``` 1. Geben Sie für jede Eingabeaufforderung den in der zweiten Spalte aufgeführten Wert ein. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/get-started-tutorial.html) 1. Nachdem der letzte Wert eingegeben wurde, listet Maven die von Ihnen getroffenen Entscheidungen auf. Bestätigen Sie, indem Sie Werte eingeben, *`Y`*oder geben Sie sie erneut ein, indem Sie sie eingeben. *`N`* Maven erstellt den Projektordner mit dem `getstarted` Namen, den Sie `artifactId` eingegeben haben. Suchen Sie im `getstarted` Ordner nach einer `README.md` Datei, die Sie überprüfen können, nach einer `pom.xml` Datei und einem `src` Verzeichnis. Maven erstellt den folgenden Verzeichnisbaum. ``` getstarted ├── README.md ├── pom.xml └── src ├── main │   ├── java │   │   └── org │   │   └── example │   │   ├── App.java │   │   ├── DependencyFactory.java │   │   └── Handler.java │   └── resources │   └── simplelogger.properties └── test └── java └── org └── example └── HandlerTest.java 10 directories, 7 files ``` Unten sehen Sie die Inhalte der `pom.xml`-Projektdatei. ### `pom.xml` Der `dependencyManagement` Abschnitt enthält eine Abhängigkeit von AWS SDK for Java 2.x und der `dependencies` Abschnitt hat eine Abhängigkeit von Amazon S3. Das Projekt verwendet Java 1.8 aufgrund des `1.8`-Werts in den `maven.compiler.source`- und `maven.compiler.target`-Eigenschaften. ``` 4.0.0 org.example getstarted 1.0-SNAPSHOT jar UTF-8 1.8 1.8 3.2.1 3.6.1 1.6.0 2.27.21 <-------- SDK version picked up from archetype version. 1.7.28 5.8.1 software.amazon.awssdk bom ${aws.java.sdk.version} pom import software.amazon.awssdk s3 <-------- S3 dependency software.amazon.awssdk netty-nio-client software.amazon.awssdk apache-client software.amazon.awssdk sso <-------- Required for identity center authentication. software.amazon.awssdk ssooidc <-------- Required for identity center authentication. software.amazon.awssdk apache-client <-------- HTTP client specified. commons-logging commons-logging org.slf4j slf4j-api ${slf4j.version} org.slf4j slf4j-simple ${slf4j.version} org.slf4j jcl-over-slf4j ${slf4j.version} org.junit.jupiter junit-jupiter ${junit5.version} test org.apache.maven.plugins maven-compiler-plugin ${maven.compiler.plugin.version} ``` ## Schritt 3: Schreiben des Codes Der folgende Code zeigt die von Maven erstellte `App` Klasse. Die `main`-Methode ist der Einstiegspunkt in die Anwendung, die eine Instance der `Handler`-Klasse erstellt und dann ihre `sendRequest`-Methode aufruft. ### `App`-Klasse ``` package org.example; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class App { private static final Logger logger = LoggerFactory.getLogger(App.class); public static void main(String... args) { logger.info("Application starts"); Handler handler = new Handler(); handler.sendRequest(); logger.info("Application ends"); } } ``` Die von Maven erstellte `DependencyFactory` Klasse enthält die `s3Client` Factory-Methode, die eine [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html)Instanz erstellt und zurückgibt. Die `S3Client`-Instance verwendet eine Instance des Apache-basierten HTTP-Clients. Dies liegt daran, dass Sie `apache-client` angegeben haben, als Maven Sie nach dem zu verwendenden HTTP-Client gefragt hat. Das `DependencyFactory` wird im folgenden Code gezeigt. ### `DependencyFactory`-Klasse ``` package org.example; import software.amazon.awssdk.http.apache.ApacheHttpClient; import software.amazon.awssdk.services.s3.S3Client; /** * The module containing all dependencies required by the {@link Handler}. */ public class DependencyFactory { private DependencyFactory() {} /** * @return an instance of S3Client */ public static S3Client s3Client() { return S3Client.builder() .httpClientBuilder(ApacheHttpClient.builder()) .build(); } } ``` Die `Handler`-Klasse enthält die Hauptlogik Ihres Programms. Wenn eine Instance von `Handler` in der Klasse `App` erstellt wird, stellt `DependencyFactory` den Service-Client für `S3Client` bereit. Ihr Code verwendet die `S3Client` Instance, um den Amazon S3 S3-Service aufzurufen. Maven generiert die folgende `Handler`-Klasse mit einem `TODO`-Kommentar. Der nächste Schritt im Tutorial *`TODO`*ersetzt den With-Code. ### `Handler`-Klasse, von Maven generiert ``` package org.example; import software.amazon.awssdk.services.s3.S3Client; public class Handler { private final S3Client s3Client; public Handler() { s3Client = DependencyFactory.s3Client(); } public void sendRequest() { // TODO: invoking the api calls using s3Client. } } ``` Um die Logik zu ergänzen, ersetzen Sie den gesamten Inhalt der Klasse `Handler` durch den folgenden Code: Die Methode `sendRequest` ist vollständig implementiert, und die erforderlichen Importe werden hinzugefügt. ### `Handler`-Klasse, implementiert Der Code erstellt zunächst einen neuen S3-Bucket, wobei der letzte Teil des Namens generiert wird, um den Bucket-Namen eindeutig zu machen. `System.currentTimeMillis()` Nach dem Erstellen des Buckets in der `createBucket()` Methode lädt das Programm ein Objekt mit der [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html#putObject(software.amazon.awssdk.services.s3.model.PutObjectRequest,software.amazon.awssdk.core.sync.RequestBody)](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html#putObject(software.amazon.awssdk.services.s3.model.PutObjectRequest,software.amazon.awssdk.core.sync.RequestBody))Methode von `S3Client` hoch. Der Inhalt des Objekts ist eine einfache Zeichenfolge, die mit der `RequestBody.fromString` Methode erstellt wurde. Schließlich löscht das Programm das Objekt, gefolgt vom Bucket in der `cleanUp` Methode. ``` package org.example; import software.amazon.awssdk.core.sync.RequestBody; import software.amazon.awssdk.services.s3.S3Client; import software.amazon.awssdk.services.s3.model.CreateBucketRequest; import software.amazon.awssdk.services.s3.model.DeleteBucketRequest; import software.amazon.awssdk.services.s3.model.DeleteObjectRequest; import software.amazon.awssdk.services.s3.model.HeadBucketRequest; import software.amazon.awssdk.services.s3.model.PutObjectRequest; import software.amazon.awssdk.services.s3.model.S3Exception; public class Handler { private final S3Client s3Client; public Handler() { s3Client = DependencyFactory.s3Client(); } public void sendRequest() { String bucket = "bucket" + System.currentTimeMillis(); String key = "key"; createBucket(s3Client, bucket); System.out.println("Uploading object..."); s3Client.putObject(PutObjectRequest.builder().bucket(bucket).key(key) .build(), RequestBody.fromString("Testing with the {sdk-java}")); System.out.println("Upload complete"); System.out.printf("%n"); cleanUp(s3Client, bucket, key); System.out.println("Closing the connection to {S3}"); s3Client.close(); System.out.println("Connection closed"); System.out.println("Exiting..."); } public static void createBucket(S3Client s3Client, String bucketName) { try { s3Client.createBucket(CreateBucketRequest .builder() .bucket(bucketName) .build()); System.out.println("Creating bucket: " + bucketName); s3Client.waiter().waitUntilBucketExists(HeadBucketRequest.builder() .bucket(bucketName) .build()); System.out.println(bucketName + " is ready."); System.out.printf("%n"); } catch (S3Exception e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } } public static void cleanUp(S3Client s3Client, String bucketName, String keyName) { System.out.println("Cleaning up..."); try { System.out.println("Deleting object: " + keyName); DeleteObjectRequest deleteObjectRequest = DeleteObjectRequest.builder().bucket(bucketName).key(keyName).build(); s3Client.deleteObject(deleteObjectRequest); System.out.println(keyName + " has been deleted."); System.out.println("Deleting bucket: " + bucketName); DeleteBucketRequest deleteBucketRequest = DeleteBucketRequest.builder().bucket(bucketName).build(); s3Client.deleteBucket(deleteBucketRequest); System.out.println(bucketName + " has been deleted."); System.out.printf("%n"); } catch (S3Exception e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } System.out.println("Cleanup complete"); System.out.printf("%n"); } } ``` ## Schritt 4: Anwendung erstellen und ausführen Nachdem das Projekt erstellt wurde und die vollständige `Handler` Klasse enthält, erstellen Sie die Anwendung und führen Sie sie aus. 1. Stellen Sie sicher, dass Sie eine aktive IAM Identity Center-Sitzung haben. Führen Sie dazu den AWS Command Line Interface Befehl aus `aws sts get-caller-identity` und überprüfen Sie die Antwort. Wenn Sie keine aktive Sitzung haben, finden Sie in [diesem Abschnitt](get-started-auth.md#setup-login-sso) Anweisungen. 1. Öffnen Sie ein Terminal- oder ein Befehlszeilenfenster und navigieren Sie zu Ihrem Projektverzeichnis `getstarted`. 1. Verwenden Sie den folgenden Befehl, um Ihr Projekt zu erstellen: ``` mvn clean package ``` 1. Verwenden Sie den folgenden Befehl, um die Anwendung auszuführen. ``` mvn exec:java -Dexec.mainClass="org.example.App" ``` Gehen Sie wie folgt vor, um den neuen Bucket und das neue Objekt anzuzeigen, die das Programm erstellt. 1. Kommentieren Sie die Zeile `cleanUp(s3Client, bucket, key)` in der `sendRequest` Methode aus und speichern Sie die Datei. `Handler.java` 1. Erstellen Sie das Projekt neu, indem Sie es ausführen`mvn clean package`. 1. Führen Sie `mvn exec:java -Dexec.mainClass="org.example.App"` den Vorgang erneut aus, um das Textobjekt erneut hochzuladen. 1. Melden Sie sich bei [der S3-Konsole](https://console.aws.amazon.com/s3/) an, um das neue Objekt im neu erstellten Bucket anzuzeigen. Nachdem Sie die Datei angezeigt haben, löschen Sie das Objekt und anschließend den Bucket. ### Herzlichen Glückwunsch Wenn Ihr Maven-Projekt ohne Fehler erstellt und ausgeführt wurde, dann herzlichen Glückwunsch\$1 Sie haben erfolgreich Ihre erste Java-Anwendung mit dem SDK for Java 2.x erstellt. ### Bereinigen Gehen Sie wie folgt vor, um die Ressourcen zu bereinigen, die Sie in diesem Tutorial erstellt haben: + Falls Sie dies noch nicht getan haben, löschen Sie in [der S3-Konsole](https://console.aws.amazon.com/s3/) alle Objekte und Buckets, die beim Ausführen der Anwendung erstellt wurden. + Löschen Sie den Projektordner (`getstarted`). ## Nächste Schritte Nachdem Sie sich mit den Grundlagen vertraut gemacht haben, können Sie sich über Folgendes informieren: + [Arbeiten mit Amazon S3](examples-s3.md) + [Arbeiten mit anderen](work-with-services.md) Datenbankdiensten wie Amazon Web Services[DynamoDB[Amazon EC2](examples-ec2.md)](examples-dynamodb.md), und [verschiedenen Datenbankdiensten](examples-databases.md) + [Verwenden Sie das SDK](using.md) + [Sicherheit für die AWS SDK für Java](security.md) **