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.
# Das SDKs konfigurieren
In der AWS SDK für Go V2 können Sie allgemeine Einstellungen für Service-Clients konfigurieren, z. B. die Logger-, Log Level- und Wiederholungskonfiguration. Die meisten Einstellungen sind optional. Für jeden Service-Client müssen Sie jedoch eine AWS Region und Ihre Anmeldeinformationen angeben. Das SDK verwendet diese Werte, um Anfragen an die richtige Region zu senden und Anfragen mit den richtigen Anmeldeinformationen zu signieren. Sie können diese Werte programmgesteuert im Code oder über die Ausführungsumgebung angeben.
## AWS Gemeinsam genutzte Konfigurationsdateien werden geladen
Es gibt eine Reihe von Möglichkeiten, einen Service-API-Client zu initialisieren, aber das folgende Muster wird Benutzern am häufigsten empfohlen.
Verwenden Sie den folgenden Code, um das SDK für die Verwendung der AWS gemeinsam genutzten Konfigurationsdateien zu konfigurieren:
```
import (
"context"
"log"
"github.com/aws/aws-sdk-go-v2/config"
)
// ...
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
log.Fatalf("failed to load configuration, %v", err)
}
```
`config.LoadDefaultConfig(context.TODO())`erstellt mithilfe der AWS gemeinsam genutzten [Konfigurationsquellen eine AWS.Config](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws#Config). Dazu gehören die Konfiguration eines Anmeldeinformationsanbieters, die Konfiguration der AWS Region und das Laden der dienstspezifischen Konfiguration. Dienstclients können mithilfe der geladenen Datei erstellt werden`aws.Config`, wodurch ein konsistentes Muster für die Erstellung von Clients bereitgestellt wird.
Weitere Informationen zu AWS gemeinsam genutzten Konfigurationsdateien finden Sie unter [Konfiguration](https://docs.aws.amazon.com/sdkref/latest/guide/creds-config-files.html) im Referenzhandbuch AWS SDKs und im Tools-Referenzhandbuch.
## Angabe der AWS Region
Wenn Sie die Region angeben, geben Sie an, wohin Anfragen gesendet werden sollen, z. B. `us-west-2` oder`us-east-2`. Eine Liste der Regionen für jeden Dienst finden Sie unter [Dienstendpunkte und Kontingente](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) in der Allgemeine Amazon Web Services-Referenz.
Das SDK hat keine Standardregion. Um eine Region anzugeben:
+ Setzen Sie die `AWS_REGION` Umgebungsvariable auf die Standardregion.
+ Stellen Sie die Region explizit mit [config ein. WithRegion](https://github.com/aws/aws-sdk-go-v2/blob/config/v0.2.2/config/provider.go#L127)als Argument für `config.LoadDefaultConfig` beim Laden der Konfiguration.
RÜCKBLICK: Wenn Sie eine Region mit all diesen Techniken festlegen, verwendet das SDK die Region, die Sie explizit angegeben haben.
### Region mit Umgebungsvariable konfigurieren
#### Linux, macOS oder Unix
```
export AWS_REGION=us-west-2
```
#### Windows
```
set AWS_REGION=us-west-2
```
### Region programmgesteuert angeben
```
cfg, err := config.LoadDefaultConfig(context.TODO(), config.WithRegion("us-west-2"))
```
## Festlegen von Anmeldeinformationen
AWS SDK für Go Für das Signieren von Anfragen sind Anmeldeinformationen (ein Zugriffsschlüssel und ein geheimer Zugriffsschlüssel) erforderlich. AWS Sie können Ihre Anmeldeinformationen je nach Ihrem speziellen Anwendungsfall an verschiedenen Stellen angeben. Informationen zum Abrufen von Anmeldeinformationen finden Sie unter[Fangen Sie an mit AWS SDK für Go](getting-started.md).
Wenn Sie eine `aws.Config` Instanz mithilfe initialisieren`config.LoadDefaultConfig`, verwendet das SDK seine standardmäßige Anmeldeinformationskette, um Anmeldeinformationen zu finden AWS . Diese standardmäßige Anmeldeinformationskette sucht in der folgenden Reihenfolge nach Anmeldeinformationen:
1. Umgebungsvariablen.
1. Statische Anmeldeinformationen (`AWS_ACCESS_KEY_ID`,`AWS_SECRET_ACCESS_KEY`,`AWS_SESSION_TOKEN`)
1. Web-Identitätstoken (`AWS_WEB_IDENTITY_TOKEN_FILE`)
1. Gemeinsam genutzte Konfigurationsdateien.
1. SDK verwendet standardmäßig den Ordner `credentials` Datei unter dem `.aws` Ordner, der sich im Home-Ordner auf Ihrem Computer befindet.
1. SDK verwendet standardmäßig den Ordner `config` File unter dem `.aws` Ordner, der sich im Home-Ordner auf Ihrem Computer befindet.
1. Wenn Ihre Anwendung eine Amazon ECS-Aufgabendefinition oder einen RunTask API-Vorgang verwendet, IAM-Rolle für Aufgaben.
1. Wenn Ihre Anwendung auf einer Amazon EC2-Instance ausgeführt wird, IAM-Rolle für Amazon EC2.
Das SDK erkennt und verwendet die integrierten Anbieter automatisch, ohne dass manuelle Konfigurationen erforderlich sind. Wenn Sie beispielsweise IAM-Rollen für Amazon EC2 EC2-Instances verwenden, verwenden Ihre Anwendungen automatisch die Anmeldeinformationen der Instance. Sie müssen die Anmeldeinformationen in Ihrer Anwendung nicht manuell konfigurieren.
Als bewährte Methode AWS empfiehlt es sich, die Anmeldeinformationen in der folgenden Reihenfolge anzugeben:
1. Verwenden Sie IAM-Rollen für Aufgaben, wenn Ihre Anwendung eine Amazon ECS-Aufgabendefinition oder einen RunTask API-Vorgang verwendet.
1. Verwenden Sie IAM-Rollen für Amazon EC2 (wenn Ihre Anwendung auf einer Amazon EC2 EC2-Instance läuft).
IAM-Rollen stellen Anwendungen auf der Instance temporäre Sicherheitsanmeldedaten zur Verfügung, um Aufrufe zu tätigen. AWS IAM-Rollen bieten eine einfache Möglichkeit, Anmeldeinformationen auf mehreren Amazon EC2 EC2-Instances zu verteilen und zu verwalten.
1. Verwenden Sie gemeinsam genutzte Anmeldeinformationen oder Konfigurationsdateien.
Die Anmeldeinformationen und Konfigurationsdateien werden von anderen AWS SDKs und gemeinsam genutzt AWS CLI. Aus Sicherheitsgründen empfehlen wir, die Anmeldeinformationsdatei für die Festlegung sensibler Werte wie Zugriffsschlüssel IDs und geheime Schlüssel zu verwenden. Hier sind die [Formatierungsanforderungen](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) für jede dieser Dateien.
1. Umgebungsvariablen verwenden.
Das Setzen von Umgebungsvariablen ist nützlich, wenn Sie Entwicklungsarbeiten auf einem anderen Computer als einer Amazon EC2 EC2-Instance durchführen.
### IAM-Rollen für Aufgaben
Wenn Ihre Anwendung eine Amazon ECS-Aufgabendefinition oder einen `RunTask` Vorgang verwendet, verwenden Sie [IAM-Rollen für Aufgaben](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html), um eine IAM-Rolle anzugeben, die von den Containern in einer Aufgabe verwendet werden kann.
### IAM-Rollen für Amazon EC2 EC2-Instances
Wenn Sie Ihre Anwendung auf einer Amazon EC2 EC2-Instance ausführen, verwenden Sie die [IAM-Rolle](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html) der Instance, um temporäre Sicherheitsanmeldeinformationen für Aufrufe abzurufen. AWS
Wenn Sie Ihre Instance für die Verwendung von IAM-Rollen konfiguriert haben, verwendet das SDK diese Anmeldeinformationen automatisch für Ihre Anwendung. Sie müssen diese Anmeldeinformationen nicht manuell angeben.
### Gemeinsame Anmeldeinformationen und Konfiguration
Die gemeinsamen Anmeldeinformationen und Konfigurationsdateien können verwendet werden, um gemeinsame Konfigurationen AWS SDKs und andere Tools gemeinsam zu nutzen. Wenn Sie für unterschiedliche Tools und Anwendungen verschiedene Anmeldeinformationen verwenden, können Sie mithilfe von *Profilen* mehrere Zugriffsschlüssel innerhalb ein und derselben Konfigurationsdatei konfigurieren.
Sie können mehrere Speicherorte für Anmelde- oder Konfigurationsdateien angeben. Standardmäßig lädt das SDK Dateien`config.LoadOptions`, die an den in der [Festlegen von Anmeldeinformationen](#specifying-credentials) genannten Standardspeicherorten gespeichert sind.
```
import (
"context"
"github.com/aws/aws-sdk-go-v2/config"
)
// ...
cfg , err := config.LoadDefaultConfig(context.TODO(),
config.WithSharedCredentialsFiles(
[]string{"test/credentials", "data/credentials"},
),
config.WithSharedConfigFiles(
[]string{"test/config", "data/config"},
)
)
```
Wenn Sie mit gemeinsam genutzten Anmeldeinformationen und Konfigurationsdateien arbeiten und doppelte Profile angegeben werden, werden diese zusammengeführt, um ein Profil aufzulösen. Im Falle eines Zusammenführungskonflikts
1. Wenn in derselben credentials/config Datei doppelte Profile angegeben werden, haben die im letzteren Profil angegebenen Profileigenschaften Vorrang.
1. Wenn doppelte Profile entweder für mehrere Anmeldeinformationsdateien oder für mehrere Konfigurationsdateien angegeben werden, werden die Profileigenschaften gemäß der Reihenfolge der Dateieingabe in die `config.LoadOptions` aufgelöst. Die Profileigenschaften in den letztgenannten Dateien haben Vorrang.
1. Wenn ein Profil sowohl in der Anmeldeinformationsdatei als auch in der Konfigurationsdatei vorhanden ist, haben die Eigenschaften der Anmeldeinformationsdatei Vorrang.
Bei Bedarf können Sie die Schritte `LogConfigurationWarnings` zur Profilauflösung aktivieren `config.LoadOptions` und protokollieren.
#### Die Datei mit den Anmeldeinformationen wird erstellt
Wenn Sie keine gemeinsame Anmeldeinformationsdatei (`.aws/credentials`) haben, können Sie einen beliebigen Texteditor verwenden, um eine Datei in Ihrem Home-Verzeichnis zu erstellen. Fügen Sie Ihrer Anmeldeinformationsdatei den folgenden Inhalt hinzu {{}} und {{}} ersetzen Sie dabei Ihre Anmeldeinformationen.
```
[default]
aws_access_key_id = {{}}
aws_secret_access_key = {{}}
```
In der `[default]` Überschrift werden die Anmeldeinformationen für das Standardprofil definiert, die das SDK verwendet, sofern Sie es nicht für die Verwendung eines anderen Profils konfigurieren.
Sie können auch temporäre Sicherheitsanmeldedaten verwenden, indem Sie die Sitzungstoken zu Ihrem Profil hinzufügen, wie im folgenden Beispiel gezeigt:
```
[temp]
aws_access_key_id = {{}}
aws_secret_access_key = {{}}
aws_session_token = {{}}
```
Der Abschnittsname für ein nicht standardmäßiges Profil in einer Anmeldeinformationsdatei darf nicht mit dem Wort `profile` beginnen. Weitere Informationen finden Sie im [AWS SDKs Referenzhandbuch zu Tools.](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html#file-format-creds)
#### Die Config erstellen
Wenn Sie keine gemeinsame Anmeldeinformationsdatei (`.aws/config`) haben, können Sie einen beliebigen Texteditor verwenden, um eine Datei in Ihrem Home-Verzeichnis zu erstellen. Fügen Sie Ihrer Konfigurationsdatei den folgenden Inhalt hinzu und {{}} ersetzen Sie ihn durch die gewünschte Region.
```
[default]
region = {{}}
```
Die `[default]` Überschrift definiert die Konfiguration für das Standardprofil, das das SDK verwendet, sofern Sie es nicht für die Verwendung eines anderen Profils konfigurieren.
Sie können benannte Profile verwenden, wie im folgenden Beispiel gezeigt:
```
[profile named-profile]
region = {{}}
```
Der Abschnittsname für ein nicht standardmäßiges Profil in einer Konfigurationsdatei muss immer mit dem Wort beginnen`profile`, gefolgt vom beabsichtigten Profilnamen. Weitere Informationen finden Sie im Referenzhandbuch [AWS SDKs und im Tools-Referenzhandbuch.](https://docs.aws.amazon.com/credref/latest/refdocs/file-format.html#file-format-config)
#### Profile angeben
Sie können mehrere Zugriffsschlüssel in dieselbe Konfigurationsdatei aufnehmen, indem Sie jeden Satz von Zugriffsschlüsseln einem Profil zuordnen. In Ihrer Anmeldeinformationsdatei können Sie beispielsweise mehrere Profile wie folgt deklarieren.
```
[default]
aws_access_key_id =
aws_secret_access_key =
[test-account]
aws_access_key_id =
aws_secret_access_key =
[prod-account]
; work profile
aws_access_key_id =
aws_secret_access_key =
```
Standardmäßig prüft das SDK die Umgebungsvariable `AWS_PROFILE`, um zu bestimmen, welches Profil verwendet werden soll. Wenn keine `AWS_PROFILE` Variable festgelegt ist, verwendet das SDK das `default` Profil.
Manchmal möchten Sie vielleicht ein anderes Profil für Ihre Anwendung verwenden. Sie möchten beispielsweise die `test-account` Anmeldeinformationen mit Ihrer `myapp` Anwendung verwenden. Sie können dieses Profil mit dem folgenden Befehl verwenden:
```
$ AWS_PROFILE=test-account myapp
```
Sie können das SDK auch anweisen, ein Profil auszuwählen`config.LoadDefaultConfig`, indem Sie es entweder `os.Setenv("AWS_PROFILE", "test-account")` vor dem Aufruf aufrufen oder indem Sie ein explizites Profil als Argument übergeben, wie im folgenden Beispiel gezeigt:
```
cfg, err := config.LoadDefaultConfig(context.TODO(),
config.WithSharedConfigProfile("test-account"))
```
**Anmerkung**
Wenn Sie Anmeldeinformationen in Umgebungsvariablen angeben, verwendet das SDK immer diese Anmeldeinformationen, unabhängig davon, welches Profil Sie angeben.
### Umgebungsvariablen
Standardmäßig erkennt das SDK die in Ihrer Umgebung festgelegten AWS Anmeldeinformationen und verwendet sie zum Signieren von Anfragen AWS. Auf diese Weise müssen Sie die Anmeldeinformationen in Ihren Anwendungen nicht verwalten.
Das SDK sucht in den folgenden Umgebungsvariablen nach Anmeldeinformationen:
+ `AWS_ACCESS_KEY_ID`
+ `AWS_SECRET_ACCESS_KEY`
+ `AWS_SESSION_TOKEN` (optional)
Die folgenden Beispiele zeigen, wie Sie die Umgebungsvariablen konfigurieren.
#### Linux, OS X oder Unix
```
$ export AWS_ACCESS_KEY_ID=YOUR_AKID
$ export AWS_SECRET_ACCESS_KEY=YOUR_SECRET_KEY
$ export AWS_SESSION_TOKEN=TOKEN
```
#### Windows
```
> set AWS_ACCESS_KEY_ID=YOUR_AKID
> set AWS_SECRET_ACCESS_KEY=YOUR_SECRET_KEY
> set AWS_SESSION_TOKEN=TOKEN
```
### Geben Sie Anmeldeinformationen programmgesteuert an
`config.LoadDefaultConfig`[ermöglicht es Ihnen, eine explizite AWS anzugeben. CredentialProvider](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws#CredentialsProvider)beim Laden der gemeinsam genutzten Konfigurationsquellen. Verwenden Sie [config, um beim Laden der gemeinsam genutzten Konfiguration einen expliziten Anbieter für Anmeldeinformationen zu übergeben. WithCredentialsProvider](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/config#WithCredentialsProvider). Wenn beispielsweise `customProvider` auf eine `aws.CredentialProvider` Implementierungsinstanz verwiesen wird, kann sie beim Laden der Konfiguration wie folgt übergeben werden:
```
cfg, err := config.LoadDefaultConfig(context.TODO(),
config.WithCredentialsProvider(customProvider))
```
Wenn Sie wie in diesem Beispiel explizit Anmeldeinformationen angeben, verwendet das SDK nur diese Anmeldeinformationen.
**Anmerkung**
Alle Anmeldeinformationsanbieter, die an übergeben oder von zurückgegeben wurden, `LoadDefaultConfig` werden [CredentialsCache](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws#CredentialsCache)automatisch in eine eingebunden. Dies ermöglicht das Zwischenspeichern und die Rotation von Anmeldeinformationen, wodurch Parallelität gewährleistet ist. Wenn Sie einen Anbieter explizit `aws.Config` direkt konfigurieren, müssen Sie den Anbieter auch explizit mit diesem Typ umschließen, indem Sie. [NewCredentialsCache](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws#NewCredentialsCache)
#### Statische Anmeldeinformationen
Sie können Anmeldeinformationen in Ihrer Anwendung fest codieren, indem Sie die [Anmeldeinformationen verwenden. NewStaticCredentialsProvider](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials#NewStaticCredentialsProvider)Anmeldeinformationsanbieter, um die zu verwendenden Zugriffsschlüssel explizit festzulegen. Beispiel:
```
cfg, err := config.LoadDefaultConfig(context.TODO(),
config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider("AKID", "SECRET_KEY", "TOKEN")),
)
```
**Warnung**
Betten Sie keine Anmeldeinformationen in eine Anwendung ein. Verwenden Sie diese Methode nur zu Testzwecken.
#### Anmeldeinformationen für Single Sign-On
Das SDK bietet einen Anbieter für Anmeldeinformationen zum Abrufen temporärer AWS Anmeldeinformationen mithilfe von. AWS IAM Identity Center Mit dem AWS CLI authentifizieren Sie sich beim AWS Zugriffsportal und autorisieren den Zugriff auf temporäre Anmeldeinformationen. AWS Anschließend konfigurieren Sie Ihre Anwendung so, dass das Single Sign-On (SSO) -Profil geladen wird, und das SDK verwendet Ihre SSO-Anmeldeinformationen, um temporäre AWS Anmeldeinformationen abzurufen, die bei Ablauf automatisch erneuert werden. Wenn Ihre SSO-Anmeldeinformationen ablaufen, müssen Sie sie ausdrücklich erneuern, indem Sie sich erneut mit dem bei Ihrem IAM Identity Center-Konto anmelden. AWS CLI
Sie können beispielsweise ein Profil erstellen`dev-profile`, dieses Profil mit dem authentifizieren und autorisieren und Ihre Anwendung wie unten gezeigt konfigurieren. AWS CLI
1. Erstellen Sie zuerst das und `profile` `sso-session`
```
[profile dev-profile]
sso_session = dev-session
sso_account_id = 012345678901
sso_role_name = Developer
region = us-east-1
[sso-session dev-session]
sso_region = us-west-2
sso_start_url = https://company-sso-portal.awsapps.com/start
sso_registration_scopes = sso:account:access
```
1. Melden Sie sich mit dem AWS CLI an, um das SSO-Profil zu authentifizieren und zu autorisieren.
```
$ aws --profile dev-profile sso login
Attempting to automatically open the SSO authorization page in your default browser.
If the browser does not open or you wish to use a different device to authorize this request, open the following URL:
https://device.sso.us-west-2.amazonaws.com/
Then enter the code:
ABCD-EFGH
Successully logged into Start URL: https://company-sso-portal.awsapps.com/start
```
1. Als Nächstes konfigurieren Sie Ihre Anwendung so, dass sie das SSO-Profil verwendet.
```
import "github.com/aws/aws-sdk-go-v2/config"
// ...
cfg, err := config.LoadDefaultConfig(
context.Background(),
config.WithSharedConfigProfile("dev-profile"),
)
if err != nil {
return err
}
```
Weitere Informationen zur Konfiguration von SSO-Profilen und zur Authentifizierung mithilfe des AWS CLI finden Sie unter [Konfiguration der AWS CLI zu AWS IAM Identity Center verwendenden](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sso.html) Profile im AWS CLI Benutzerhandbuch. [Weitere Informationen zur programmgesteuerten Erstellung des SSO-Anmeldeinformationsanbieters finden Sie in der Referenzdokumentation zur ssocreds-API.](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/ssocreds)
#### Anmeldeinformationen
Sie können Ihre vorhandenen Anmeldedaten für die AWS Management Console für den programmgesteuerten Zugriff AWS auf Dienste verwenden. AWS Generiert nach einem browserbasierten Authentifizierungsablauf temporäre Anmeldeinformationen, die in allen lokalen Entwicklungstools wie der AWS CLI AWS -Tools für PowerShell und AWS SDKs funktionieren. Diese Funktion vereinfacht die Konfiguration und Verwaltung von AWS CLI-Anmeldeinformationen, insbesondere wenn Sie die interaktive Authentifizierung der Verwaltung von langfristigen Zugriffsschlüsseln vorziehen.
1. Initiieren Sie den Anmeldevorgang mit der AWS CLI und folgen Sie den Anweisungen des Browsers. In diesem Beispiel speichern wir die Anmeldesitzung in einem neuen Profil**dev-profile**, dies ist jedoch optional.
```
$ aws --profile dev-profile login
```
1. (Optional) Überprüfen Sie Ihre AWS gemeinsam genutzte Konfigurationsdatei, um sicherzustellen, dass die Sitzung eingerichtet wurde.
```
[profile dev-profile]
login_session = arn:aws:sts::{{account id>}}:{{role}}
```
1. Als Nächstes konfigurieren Sie Ihre Anwendung so, dass sie das Anmeldeprofil verwendet.
```
import "github.com/aws/aws-sdk-go-v2/config"
// ...
cfg, err := config.LoadDefaultConfig(
context.Background(),
// only necessary if login session is saved to a non-default profile
config.WithSharedConfigProfile("dev-profile"),
)
if err != nil {
return err
}
```
Weitere Informationen zur Konfiguration von Anmeldeprofilen und zur Authentifizierung mit der AWS CLI finden Sie unter [Anmeldung für die AWS lokale Entwicklung mit Konsolenanmeldedaten](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sign-in.html).
#### Andere Anbieter von Anmeldeinformationen
Das SDK bietet andere Methoden zum Abrufen von Anmeldeinformationen im Modul für [Anmeldeinformationen](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials). Sie können beispielsweise temporäre Sicherheitsanmeldedaten aus AWS -Security-Token-Service oder Anmeldeinformationen aus einem verschlüsselten Speicher abrufen.
**Verfügbare Anbieter von Anmeldeinformationen**:
+ [ec2rolecreds](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/ec2rolecreds) — Rufen Sie Anmeldeinformationen von Amazon EC2-Instance-Rollen über Amazon EC2 IMDS ab.
+ [endpointcreds — Ruft Anmeldeinformationen von einem beliebigen HTTP-Endpunkt ab](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/endpointcreds).
+ [processcreds](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/processcreds) — Ruft Anmeldeinformationen von einem externen Prozess ab, der von der Shell der Host-Umgebung aufgerufen wird.
+ [stscreds](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/stscreds) — Ruft Anmeldeinformationen ab von AWS STS