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.

# Richten Sie das ein AWS SDK für Kotlin
<a name="setup"></a>

Um Anfragen zur AWS-Services Verwendung von zu stellen AWS SDK für Kotlin, benötigen Sie Folgendes:
+ Die Möglichkeit, sich beim AWS Zugangsportal anzumelden
+ Erlaubnis zur Nutzung der AWS Ressourcen, die Ihre Anwendung benötigt
+ 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 Einstellungen für die IAM Identity Center-Anmeldeinformationen, sodass das SDK Anmeldeinformationen abrufen AWS kann
    + Die `credentials` Datei enthält temporäre Anmeldeinformationen
  + [Ein Tool zur Build-Automatisierung wie [Gradle oder Maven](https://gradle.org/install/)](https://maven.apache.org/download.cgi) 
+ Eine aktive AWS Access-Portal-Sitzung, wenn Sie bereit sind, Ihre Anwendung auszuführen

**Topics**
+ [Grundlegende Einrichtung](setup-basic-onetime-setup.md)
+ [Erstellen Sie Projekt-Build-Dateien](setup-create-project-file.md)
+ [Codieren Sie Ihr Kotlin-Projekt mit dem SDK für Kotlin](code-project.md)

# Grundlegende Einrichtung
<a name="setup-basic-onetime-setup"></a>

## -Übersicht
<a name="setup-overview"></a>

Um erfolgreich Anwendungen entwickeln zu können, die AWS-Services über das zugreifen AWS SDK für Kotlin, müssen die folgenden Anforderungen erfüllt sein.
+ Sie müssen sich [bei dem AWS Zugriffsportal anmelden können, das](#setup-awsaccount) im verfügbar ist AWS IAM Identity Center.
+ 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 AWS-Services , die Ihre Anwendung benötigt, ermöglichen. 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](#setup-sso-access), sodass das SDK Anmeldeinformationen abrufen AWS kann.
    + Die `credentials` Datei enthält temporäre Anmeldeinformationen.
  + Eine [Installation von Java 8 oder höher](#setup-envtools).
  + Ein [Tool zur Build-Automatisierung](#setup-envtools) 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) oder Eclipse.](https://www.eclipse.org/ide/)

    Wenn Sie eine IDE verwenden, können Sie AWS Toolkit s auch integrieren, um einfacher damit zu arbeiten. AWS-Services Die [AWS Toolkit for IntelliJ](https://docs.aws.amazon.com/toolkit-for-jetbrains/latest/userguide/welcome.html)und [AWS Toolkit for Eclipse](https://docs.aws.amazon.com/toolkit-for-eclipse/v1/user-guide/welcome.html)sind zwei Toolkits, die Sie verwenden können.
+ Eine aktive AWS Access-Portal-Sitzung, 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](#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 für Kotlin erhalten können. Folgen Sie diesen Anweisungen, um der Datei temporäre Anmeldeinformationen hinzuzufügen. `~/.aws/credentials`  
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.

## Anmeldemöglichkeit beim AWS Zugriffsportal
<a name="setup-awsaccount"></a>

Das AWS Zugriffsportal ist die Webadresse, über die Sie sich manuell beim IAM Identity Center anmelden. Das Format der URL ist `d-xxxxxxxxxx.awsapps.com/start` oder`your_subdomain.awsapps.com/start`. 

Wenn Sie mit dem AWS Zugriffsportal nicht vertraut sind, folgen Sie den Anleitungen für den Kontozugriff im Thema [IAM Identity Center-Authentifizierung](https://docs.aws.amazon.com/sdkref/latest/guide/access-sso.html) im Referenzhandbuch AWS SDKs und im Tools-Referenzhandbuch.

## Richten Sie den Single Sign-On-Zugriff für das SDK ein
<a name="setup-sso-access"></a>

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 für Kotlin verwendet die SSO-Token-Provider-Konfiguration des Profils, um Anmeldeinformationen abzurufen, bevor Anfragen an AWS gesendet 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 Access-Portal-Sitzung.

  ```
  [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 Referenzhandbuch AWS SDKs und im Tools-Referenzhandbuch.

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)

## Melden Sie sich mit dem AWS CLI
<a name="setup-login-sso"></a>

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 Access-Portal anzumelden.

```
aws sso login
```

Da Sie ein Standardprofil eingerichtet haben, müssen Sie den Befehl nicht mit einer `--profile` Option aufrufen. Wenn Ihre SSO-Token-Provider-Konfiguration 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 -Zugriffsportalsitzung verfügen und `aws sso login` ausführen, müssen Sie keine Anmeldeinformationen angeben.   
Es wird jedoch ein Dialogfeld angezeigt, in dem Sie um 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 für Kotlin zu autorisieren.

## Installieren Sie Java und ein Build-Tool
<a name="setup-envtools"></a>

Ihre Entwicklungsumgebung benötigt Folgendes:
+ JDK 8 oder höher. [Das AWS SDK für Kotlin funktioniert mit dem [Oracle Java SE Development Kit](https://www.oracle.com/java/technologies/javase-downloads.html) und mit Distributionen von Open Java Development Kit (OpenJDK) wie [Amazon Corretto](https://aws.amazon.com/corretto/)[Red Hat OpenJDK und JDK](https://developers.redhat.com/products/openjdk). AdoptOpen](https://adoptopenjdk.net/)
+ Ein Build-Tool oder eine IDE, die Maven Central wie Apache Maven, Gradle oder IntelliJ unterstützt.
  + [Informationen zur Installation und Verwendung von Maven finden Sie unter http://maven.apache.org/.](http://maven.apache.org/)
  + [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/)

## Verwenden temporärer Anmeldeinformationen
<a name="setup-use-temporary-creds"></a>

Als Alternative zur [Konfiguration des IAM Identity Center Single Sign-On-Zugriffs](#setup-sso-access) für das SDK können Sie Ihre Entwicklungsumgebung mit temporären Anmeldeinformationen konfigurieren.

**Richten Sie eine lokale Anmeldeinformationsdatei für temporäre Anmeldeinformationen ein**

1. [Erstellen Sie eine gemeinsame Anmeldeinformationsdatei](https://docs.aws.amazon.com/sdkref/latest/guide/file-location.html)

1. Fügen Sie in die Anmeldeinformationsdatei den folgenden Platzhaltertext ein, bis Sie funktionierende temporäre Anmeldeinformationen einfügen:

   ```
   [default]
   aws_access_key_id=<value from AWS access portal>
   aws_secret_access_key=<value from AWS access portal>
   aws_session_token=<value from AWS access portal>
   ```

1. Speichern Sie die Datei. Die Datei `~/.aws/credentials` sollte jetzt auf Ihrem lokalen Entwicklungssystem vorhanden sein. Diese Datei enthält das [[Standard-] Profil](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html#file-format-profile), das das SDK für Kotlin verwendet, wenn kein bestimmtes benanntes Profil angegeben ist. 

1. [Melden Sie sich beim AWS Zugangsportal an](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtosignin.html)

1. Folgen Sie diesen Anweisungen unter der Überschrift [Manuelle Aktualisierung der Anmeldeinformationen](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtogetcredentials.html#how-to-get-temp-credentials), um die Anmeldeinformationen für die IAM-Rolle aus dem AWS Zugriffsportal zu kopieren.

   1. Wählen Sie für Schritt 4 der verlinkten Anleitung den IAM-Rollennamen aus, der den Zugriff für Ihre Entwicklungsanforderungen gewährt. Diese Rolle hat normalerweise einen Namen wie **PowerUserAccess**oder **Developer**.

   1. Wählen Sie für Schritt 7 die Option **Manuelles Hinzufügen eines Profils zu Ihrer AWS Anmeldeinformationsdatei** und kopieren Sie den Inhalt.

1. Fügen Sie die kopierten Anmeldeinformationen in Ihre lokale `credentials` Datei ein und entfernen Sie den generierten Profilnamen. Ihre Datei sollte wie folgt aussehen:

   ```
   [default]
   aws_access_key_id=AKIAIOSFODNN7EXAMPLE
   aws_secret_access_key=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
   aws_session_token=IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZVERYLONGSTRINGEXAMPLE
   ```

1. Speichern Sie die `credentials` Datei

Das SDK für Kotlin greift auf diese temporären Anmeldeinformationen zu, wenn es einen Service-Client erstellt, und verwendet sie für jede Anfrage. Die in Schritt 5a ausgewählten Einstellungen für die IAM-Rolle bestimmen, [wie lange die temporären Anmeldeinformationen gültig sind](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtosessionduration.html). Die maximale Dauer beträgt zwölf Stunden.

Wenn die temporären Anmeldeinformationen abgelaufen sind, wiederholen Sie die Schritte 4 bis 7.

# Erstellen Sie Projekt-Build-Dateien
<a name="setup-create-project-file"></a>

Nachdem Sie den Single Sign-On-Zugriff und Ihre Entwicklungsumgebung konfiguriert haben, erstellen Sie ein Kotlin-Projekt mit Ihrem bevorzugten Build-Tool. Geben Sie in der Build-Datei die Abhängigkeiten für die an AWS-Services , auf die Ihre Anwendung zugreifen muss.

Eine Liste aller möglichen Namen von Maven-Artefakten finden Sie in der [API-Referenzdokumentation.](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/index.html) Die neueste Version des SDK finden Sie in der [neuesten Version unter](https://github.com/awslabs/aws-sdk-kotlin/releases/latest). GitHub

Die folgenden Beispiel-Build-Dateien enthalten die notwendigen Elemente, um mit der Codierung eines Projekts mit sieben zu beginnen AWS-Services. 

------
#### [ Gradle ]

The AWS SDK für Kotlin veröffentlicht einen [Gradle-Versionskatalog](https://docs.gradle.org/current/userguide/version_catalogs.html) und eine Stückliste (BOM), mit deren Hilfe Sie die Namen von Abhängigkeiten ermitteln und Versionsnummern für mehrere Artefakte synchronisieren können. 

Beachten Sie, dass Versionskataloge eine Vorschaufunktion von Gradle vor Version 8 sind. [Abhängig von der Version von Gradle, die Sie verwenden, müssen Sie sich möglicherweise über die Feature Preview API anmelden.](https://docs.gradle.org/current/userguide/feature_lifecycle.html#feature_preview)

**Um einen Gradle-Versionskatalog zu verwenden**

1. Fügen Sie in Ihrer `settings.gradle.kts` Datei einen `versionCatalogs` Block innerhalb des `dependencyResolutionManagement` Blocks hinzu.

   Die folgende Beispieldatei konfiguriert den AWS SDK für Kotlin Versionskatalog. Sie können zu dem *X.Y.Z* Link navigieren, um die neueste verfügbare Version zu sehen.

   ```
   plugins {
       id("org.gradle.toolchains.foojay-resolver-convention") version "[https://plugins.gradle.org/plugin/org.gradle.toolchains.foojay-resolver-convention](https://plugins.gradle.org/plugin/org.gradle.toolchains.foojay-resolver-convention)"
   }
   rootProject.name = "your-project-name"
   
   dependencyResolutionManagement {
       repositories {
           mavenCentral()
       }
   
       versionCatalogs {
           create("awssdk") {
               from("aws.sdk.kotlin:version-catalog:[https://github.com/awslabs/aws-sdk-kotlin/releases/latest](https://github.com/awslabs/aws-sdk-kotlin/releases/latest)")
           }
       }
   }
   ```

1. Deklarieren Sie Abhängigkeiten `build.gradle.kts` mithilfe der typsicheren Bezeichner, die im Versionskatalog verfügbar sind.

   Die folgende Beispieldatei deklariert Abhängigkeiten für sieben. AWS-Services

   ```
   plugins {
       kotlin("jvm") version "[X.Y.Z](https://plugins.gradle.org/plugin/org.jetbrains.kotlin.jvm)"
       application
   }
   
   group = "org.example"
   version = "1.0-SNAPSHOT"
   
   repositories {
       mavenCentral()
   }
   
   dependencies {
       implementation(platform(awssdk.bom))
       implementation(platform("org.apache.logging.log4j:log4j-bom:[https://search.maven.org/#search|gav|1|g:org.apache.logging.log4j%20AND%20a:log4j-bom](https://search.maven.org/#search|gav|1|g:org.apache.logging.log4j%20AND%20a:log4j-bom)"))
   
       implementation(awssdk.services.s3)
       implementation(awssdk.services.dynamodb)
       implementation(awssdk.services.iam)
       implementation(awssdk.services.cloudwatch)
       implementation(awssdk.services.cognitoidentityprovider)
       implementation(awssdk.services.sns)
       implementation(awssdk.services.pinpoint)
       implementation("org.apache.logging.log4j:log4j-slf4j2-impl")
   
       // Test dependency.
       testImplementation(kotlin("test"))
   }
   
   tasks.test {
       useJUnitPlatform()
   }
   
   java {
       toolchain {
           languageVersion = JavaLanguageVersion.of(X*)
       }
   }
   
   application {
       mainClass = "org.example.AppKt"
   }
   ```

   \$1 Java-Version, zum Beispiel `17` oder`21`.

------
#### [ Maven ]

Die folgende `pom.xml` Beispieldatei hat Abhängigkeiten für sieben AWS-Services. Sie können zu dem *X.Y.Z* Link navigieren, um die neueste verfügbare Version zu sehen.

```
<?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/maven-v4_0_0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>setup</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <aws.sdk.kotlin.version>[https://github.com/awslabs/aws-sdk-kotlin/releases/latest](https://github.com/awslabs/aws-sdk-kotlin/releases/latest)</aws.sdk.kotlin.version>
        <kotlin.version>[X.Y.Z](https://kotlinlang.org/docs/releases.html#release-details)</kotlin.version>
        <log4j.version>[https://search.maven.org/#search|gav|1|g:org.apache.logging.log4j%20AND%20a:log4j-bom](https://search.maven.org/#search|gav|1|g:org.apache.logging.log4j%20AND%20a:log4j-bom)</log4j.version>
        <junit.jupiter.version>[https://search.maven.org/#search|gav|1|g:org.junit.jupiter%20AND%20a:junit-jupiter](https://search.maven.org/#search|gav|1|g:org.junit.jupiter%20AND%20a:junit-jupiter)</junit.jupiter.version>
        <jvm.version>X*</jvm.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>aws.sdk.kotlin</groupId>
                <artifactId>bom</artifactId>
                <version>${aws.sdk.kotlin.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>org.apache.logging.log4j</groupId>
                <artifactId>log4j-bom</artifactId>
                <version>${log4j.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

        </dependencies>
    </dependencyManagement>

    <dependencies>
        <dependency>
            <groupId>aws.sdk.kotlin</groupId>
            <artifactId>s3-jvm</artifactId>
        </dependency>
        <dependency>
            <groupId>aws.sdk.kotlin</groupId>
            <artifactId>dynamodb-jvm</artifactId>
        </dependency>
        <dependency>
            <groupId>aws.sdk.kotlin</groupId>
            <artifactId>iam-jvm</artifactId>
        </dependency>
        <dependency>
            <groupId>aws.sdk.kotlin</groupId>
            <artifactId>cloudwatch-jvm</artifactId>
        </dependency>
        <dependency>
            <groupId>aws.sdk.kotlin</groupId>
            <artifactId>cognitoidentityprovider-jvm</artifactId>
        </dependency>
        <dependency>
            <groupId>aws.sdk.kotlin</groupId>
            <artifactId>sns-jvm</artifactId>
        </dependency>
        <dependency>
            <groupId>aws.sdk.kotlin</groupId>
            <artifactId>pinpoint-jvm</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j2-impl</artifactId>
        </dependency>

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

    <build>
        <sourceDirectory>src/main/kotlin</sourceDirectory>
        <testSourceDirectory>src/test/kotlin</testSourceDirectory>

        <plugins>
            <plugin>
                <groupId>org.jetbrains.kotlin</groupId>
                <artifactId>kotlin-maven-plugin</artifactId>
                <version>${kotlin.version}</version>
                <executions>
                    <execution>
                        <id>compile</id>
                        <phase>compile</phase>
                        <goals>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                    <execution>
                        <id>test-compile</id>
                        <phase>test-compile</phase>
                        <goals>
                            <goal>test-compile</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <jvmTarget>${jvm.version}</jvmTarget>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>
```

\$1 Java-Version, zum Beispiel `17` oder`21`.

------

# Codieren Sie Ihr Kotlin-Projekt mit dem SDK für Kotlin
<a name="code-project"></a>

Jetzt beginnt der Spaß. Bei der Entwicklung Ihrer Anwendung finden Sie in der [AWS SDK für Kotlin API-Referenz](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/index.html) vollständige Informationen zu den API-Vorgängen. Verwenden Sie die folgenden Links für allgemeine Kotlin-API-Informationen:
+ [API-Referenz für die Standardbibliothek](https://kotlinlang.org/api/latest/jvm/stdlib/)
+ [Überblick über Coroutines](https://kotlinlang.org/docs/coroutines-overview.html)
+ [Coroutinen-API](https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/)

## Loggen Sie sich mit dem ein AWS CLI
<a name="code-project-login-cli"></a>

Immer wenn Sie ein Programm ausführen, das zugreift AWS-Services, benötigen Sie eine aktive AWS Access-Portal-Sitzung. Sie erreichen dies mit dem folgenden -Befehl.

```
aws sso login
```

Da Sie ein Standardprofil eingerichtet haben, müssen Sie den Befehl nicht mit einer `--profile`-Option aufrufen. Wenn Ihre IAM Identity Center Single Sign-On-Konfiguration 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.