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.

# Erstellen einer einfachen Anwendung mit dem AWS SDK for Java 2.x
<a name="get-started-tutorial"></a>

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
<a name="get-started-setup"></a>

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
<a name="get-started-projectsetup"></a>

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`
<a name="projectsetup-collapse2"></a>

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.

```
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>getstarted</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <maven.shade.plugin.version>3.2.1</maven.shade.plugin.version>
        <maven.compiler.plugin.version>3.6.1</maven.compiler.plugin.version>
        <exec-maven-plugin.version>1.6.0</exec-maven-plugin.version>
        <aws.java.sdk.version>2.27.21</aws.java.sdk.version> <-------- SDK version picked up from archetype version.
        <slf4j.version>1.7.28</slf4j.version>
        <junit5.version>5.8.1</junit5.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>software.amazon.awssdk</groupId>
                <artifactId>bom</artifactId>
                <version>${aws.java.sdk.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>s3</artifactId>  <-------- S3 dependency
            <exclusions>
                <exclusion>
                    <groupId>software.amazon.awssdk</groupId>
                    <artifactId>netty-nio-client</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>software.amazon.awssdk</groupId>
                    <artifactId>apache-client</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>sso</artifactId> <-------- Required for identity center authentication.
        </dependency>

        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>ssooidc</artifactId> <-------- Required for identity center authentication.
        </dependency>

        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>apache-client</artifactId> <-------- HTTP client specified.
            <exclusions>
                <exclusion>
                    <groupId>commons-logging</groupId>
                    <artifactId>commons-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>${slf4j.version}</version>
        </dependency>

        <!-- Needed to adapt Apache Commons Logging used by Apache HTTP Client to Slf4j to avoid
        ClassNotFoundException: org.apache.commons.logging.impl.LogFactoryImpl during runtime -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>jcl-over-slf4j</artifactId>
            <version>${slf4j.version}</version>
        </dependency>

        <!-- Test Dependencies -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>${junit5.version}</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>${maven.compiler.plugin.version}</version>
            </plugin>
        </plugins>
    </build>

</project>
```

## Schritt 3: Schreiben des Codes
<a name="get-started-code"></a>

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
<a name="projectsetup-collapse2"></a>

```
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
<a name="code-collapse2"></a>

```
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
<a name="code-collapsible3"></a>

```
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
<a name="code-collapse4"></a>

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
<a name="get-started-run"></a>

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
<a name="get-started-success"></a>

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
<a name="cleanup"></a>

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
<a name="get-started-next"></a>

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) **