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.

# Migrieren Sie auf die AWS SDK für Go Version 2
<a name="migrate-gosdk"></a>

## Minimale Go-Version
<a name="minimum-go-version"></a>

 Die AWS SDK für Go erfordert eine Mindestversion von Go 1.23. Die neueste Version von Go kann auf der [Download-Seite](https://go.dev/dl/) heruntergeladen werden. In der [Versionsübersicht](https://go.dev/doc/devel/release) finden Sie weitere Informationen zu den einzelnen Go-Versionen und die für das Upgrade erforderlichen Informationen. 

## Modularisierung
<a name="modularization"></a>

 Das AWS SDK für Go wurde aktualisiert, um die Vorteile der Go-Module zu nutzen, die in Go 1.13 zum Standard-Entwicklungsmodus wurden. Eine Reihe von Paketen, die vom SDK bereitgestellt werden, wurden modularisiert und werden unabhängig voneinander versioniert bzw. veröffentlicht. Diese Änderung ermöglicht eine verbesserte Modellierung von Anwendungsabhängigkeiten und ermöglicht es dem SDK, neue Features und Funktionen bereitzustellen, die der Versionierungsstrategie für Go-Module folgen. 

 In der folgenden Liste sind einige Go-Module aufgeführt, die vom SDK bereitgestellt werden: 


|  Modul  |  Description  | 
| --- | --- | 
|  github.com/aws/aws-sdk-go-v2  |  Der SDK-Kern  | 
|  github.com/aws/aws-sdk-go-v2/config  |  Gemeinsame Konfiguration wird geladen  | 
|  github.com/aws/aws-sdk-go-v2/credentials  |  AWS Anbieter von Anmeldeinformationen  | 
|  github.com/aws/aws-sdk-go-v2/feature/ec2/imds  |  Amazon EC2 Instance Metadata Service-Client  | 

 Die Service-Clients und übergeordneten Dienstprogramm-Module des SDK sind unter den folgenden Importpfaden verschachtelt: 


|  Root importieren  |  Description  | 
| --- | --- | 
|  github.com/aws/aws-sdk-go-v2/service/  |  Service-Client-Module  | 
|  github.com/aws/aws-sdk-go-v2/feature/  |  Hochrangige Dienstprogramme für Dienste wie den Amazon S3 Transfer Manager  | 

## Konfiguration wird geladen
<a name="configuration-loading"></a>

 Das [Sitzungspaket](https://docs.aws.amazon.com/sdk-for-go/api/aws/session/) und die zugehörige Funktionalität werden durch ein vereinfachtes Konfigurationssystem ersetzt, das im [Konfigurationspaket](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/config) bereitgestellt wird. Das `config` Paket ist ein separates Go-Modul und kann mit in die Abhängigkeiten Ihrer Anwendung aufgenommen werden`go get`. 

```
go get github.com/aws/aws-sdk-go-v2/config
```

 [Die [Session.new](https://docs.aws.amazon.com/sdk-for-go/api/aws/session/#New), Sitzung. ](https://docs.aws.amazon.com/sdk-for-go/api/aws/session/#NewSession)NewSession[NewSessionWithOptions](https://docs.aws.amazon.com/sdk-for-go/api/aws/session/#NewSessionWithOptions)[, und [Session.Must müssen](https://docs.aws.amazon.com/sdk-for-go/api/aws/session/#Must) zur Konfiguration migriert werden. LoadDefaultConfig](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/config#LoadDefaultConfig). 

 Das `config` Paket bietet mehrere Hilfsfunktionen, die dabei helfen, das programmgesteuerte Laden der gemeinsam genutzten Konfiguration zu überschreiben. Diesen Funktionsnamen wird ein Präfix vorangestellt, `With` gefolgt von einer Option, die sie überschreiben. Schauen wir uns einige Beispiele an, wie die Nutzung des `session` Pakets migriert werden kann. 

 Weitere Informationen zum Laden der gemeinsam genutzten Konfiguration finden Sie unter[Das SDKs konfigurieren](configure-gosdk.md). 

### Beispiele
<a name="examples"></a>

#### Migration von zu NewSession LoadDefaultConfig
<a name="migrating-from-newsession-to-loaddefaultconfig"></a>

 Das folgende Beispiel zeigt, wie die Verwendung von `session.NewSession` ohne zusätzliche Argumentparameter migriert wird. `config.LoadDefaultConfig` 

```
// V1 using NewSession

import "github.com/aws/aws-sdk-go/aws/session"

// ...

sess, err := session.NewSession()
if err != nil {
    // handle error
}
```

```
// V2 using LoadDefaultConfig

import "context"
import "github.com/aws/aws-sdk-go-v2/config"

// ...

cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
    // handle error
}
```

#### Migration von NewSession mit AWS.config-Optionen
<a name="migrating-from-newsession-with-awsconfig-options"></a>

 Das Beispiel zeigt, wie das Überschreiben von `aws.Config` Werten beim Laden der Konfiguration migriert wird. Es können eine oder mehrere `config.With*` Hilfsfunktionen bereitgestellt werden, `config.LoadDefaultConfig` um die geladenen Konfigurationswerte zu überschreiben. [In diesem Beispiel wird die AWS Region überschrieben, sodass die Konfiguration `us-west-2` verwendet wird. WithRegion](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/config#WithRegion)Hilfsfunktion. 

```
// V1

import "github.com/aws/aws-sdk-go/aws"
import "github.com/aws/aws-sdk-go/aws/session"

// ...

sess, err := session.NewSession(aws.Config{
    Region: aws.String("us-west-2")
})
if err != nil {
    // handle error
}
```

```
// V2

import "context"
import "github.com/aws/aws-sdk-go-v2/config"

// ...

cfg, err := config.LoadDefaultConfig(context.TODO(),
    config.WithRegion("us-west-2"),
)
if err != nil {
    // handle error
}
```

#### Migration von NewSessionWithOptions
<a name="migrating-from-newsessionwithoptions"></a>

 Dieses Beispiel zeigt, wie überschreibende Werte beim Laden der Konfiguration migriert werden. Es können keine oder mehr `config.With*` Hilfsfunktionen bereitgestellt werden, `config.LoadDefaultConfig` um die geladenen Konfigurationswerte zu überschreiben. In diesem Beispiel zeigen wir, wie das Zielprofil überschrieben wird, das beim Laden der gemeinsam genutzten AWS SDK-Konfiguration verwendet wird. 

```
// V1

import "github.com/aws/aws-sdk-go/aws"
import "github.com/aws/aws-sdk-go/aws/session"

// ...

sess, err := session.NewSessionWithOptions(aws.Config{
    Profile: "my-application-profile"
})
if err != nil {
    // handle error
}
```

```
// V2

import "context"
import "github.com/aws/aws-sdk-go-v2/config"

// ...

cfg, err := config.LoadDefaultConfig(context.TODO(),
    config.WithSharedConfigProfile("my-application-profile"),
)
if err != nil {
    // handle error
}
```

## Spott und `*iface`
<a name="mocking-and-iface"></a>

 Die darin enthaltenen `*iface` Pakete und Schnittstellen (z. B. [s3iface.S3API](https://docs.aws.amazon.com/sdk-for-go/api/service/s3/s3iface/#S3API)) wurden entfernt. Diese Schnittstellendefinitionen sind nicht stabil, da sie jedes Mal kaputt gehen, wenn ein Dienst eine neue Operation hinzufügt. 

 Die Verwendung von `*iface` sollte durch vom Aufrufer definierte Schnittstellen mit Gültigkeitsbereich für die verwendeten Dienstoperationen ersetzt werden: 

```
// V1

import "io"

import "github.com/aws/aws-sdk-go/service/s3"
import "github.com/aws/aws-sdk-go/service/s3/s3iface"

func GetObjectBytes(client s3iface.S3API, bucket, key string) ([]byte, error) {
    object, err := client.GetObject(&s3.GetObjectInput{
        Bucket: &bucket,
        Key:    &key,
    })
    if err != nil {
        return nil, err
    }
    defer object.Body.Close()

    return io.ReadAll(object.Body)
}
```

```
// V2

import "context"
import "io"

import "github.com/aws/aws-sdk-go-v2/service/s3"

type GetObjectAPIClient interface {
    GetObject(context.Context, *s3.GetObjectInput, ...func(*s3.Options)) (*s3.GetObjectOutput, error)
}

func GetObjectBytes(ctx context.Context, client GetObjectAPIClient, bucket, key string) ([]byte, error) {
    object, err := client.GetObject(ctx, &s3.GetObjectInput{
        Bucket: &bucket,
        Key:    &key,
    })
    if err != nil {
        return nil, err
    }
    defer object.Body.Close()

    return io.ReadAll(object.Body)
}
```

 Weitere Informationen finden Sie unter [Unit-Tests mit dem AWS SDK für Go v2](unit-testing.md). 

## Anmeldeinformationen und Anbieter von Anmeldeinformationen
<a name="credentials--credential-providers"></a>

 [Das Paket [aws/credentials](https://docs.aws.amazon.com/sdk-for-go/api/aws/credentials/) und die zugehörigen Anmeldeinformationsanbieter wurden an den Speicherort für das Anmeldeinformationspaket verschoben.](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials) Das `credentials` Paket ist ein Go-Modul, mit dem Sie es abrufen können. `go get` 

```
go get github.com/aws/aws-sdk-go-v2/credentials
```

 In der Version AWS SDK für Go v2 werden die AWS Credential Providers aktualisiert, um eine konsistente Schnittstelle für das Abrufen von AWS Anmeldeinformationen bereitzustellen. [Jeder Anbieter implementiert die aws. CredentialsProvider](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws#CredentialsProvider)Schnittstelle, die eine `Retrieve` Methode definiert, die a zurückgibt`(aws.Credentials, error)`. [aws.Credentials](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws#Credentials)[, das dem Typ AWS SDK für Go v1 Credentials.Value entspricht.](https://docs.aws.amazon.com/sdk-for-go/api/aws/credentials/#Value) 

 [Sie müssen Objekte mit aws umschließen. `aws.CredentialsProvider` CredentialsCache](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws#CredentialsCache)um das Zwischenspeichern von Anmeldeinformationen zu ermöglichen. Sie verwenden, um ein [NewCredentialsCache](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws#NewCredentialsCache)`aws.CredentialsCache`Objekt zu konstruieren. Standardmäßig `config.LoadDefaultConfig` sind die von konfigurierten Anmeldeinformationen mit eingeschlossen`aws.CredentialsCache`. 

 In der folgenden Tabelle sind die Standortänderungen der AWS Anmeldeinformationsanbieter von AWS SDK für Go Version 1 zu Version 2 aufgeführt. 


|  Name  |  V1-Import  |  V2-Import  | 
| --- | --- | --- | 
|  Anmeldeinformationen für Amazon EC2 IAM-Rollen  |  github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds  |  github.com/aws/aws-sdk-go-v2/credentials/ec2rolecreds  | 
|  Anmeldeinformationen für Endgeräte  |  github.com/aws/aws-sdk-go/aws/credentials/endpointcreds  |  github.com/aws/aws-sdk-go-v2/credentials/endpointcreds  | 
|  Anmeldeinformationen verarbeiten  |  github.com/aws/aws-sdk-go/aws/credentials/processcreds  |  github.com/aws/aws-sdk-go-v2/credentials/processcreds  | 
|  AWS -Security-Token-Service  |  github.com/aws/aws-sdk-go/aws/credentials/stscreds  |  github.com/aws/aws-sdk-go-v2/credentials/stscreds  | 

### Statische Anmeldeinformationen
<a name="static-credentials"></a>

 Anwendungen, die [Anmeldeinformationen verwenden. ](https://docs.aws.amazon.com/sdk-for-go/api/aws/credentials//#NewStaticCredentials)NewStaticCredentials[um statische Anmeldeinformationen programmgesteuert zu erstellen, müssen Anmeldeinformationen verwendet werden. NewStaticCredentialsProvider](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials#NewStaticCredentialsProvider). 

#### Beispiel
<a name="example"></a>

```
// V1

import "github.com/aws/aws-sdk-go/aws/credentials"

// ...

appCreds := credentials.NewStaticCredentials(accessKey, secretKey, sessionToken)
value, err := appCreds.Get()
if err != nil {
    // handle error
}
```

```
// V2

import "context"
import "github.com/aws/aws-sdk-go-v2/aws"
import "github.com/aws/aws-sdk-go-v2/credentials"

// ...

appCreds := aws.NewCredentialsCache(credentials.NewStaticCredentialsProvider(accessKey, secretKey, sessionToken))
value, err := appCreds.Retrieve(context.TODO())
if err != nil {
    // handle error
}
```

### Anmeldeinformationen für Amazon EC2 IAM-Rollen
<a name="ec2-iam-role-credentials"></a>

 Sie müssen die Nutzung von [NewCredentials](https://docs.aws.amazon.com/sdk-for-go/api/aws/credentials/ec2rolecreds/#NewCredentials)und [NewCredentialsWithClient](https://docs.aws.amazon.com/sdk-for-go/api/aws/credentials/ec2rolecreds/#NewCredentialsWithClient)auf [New](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/ec2rolecreds#New) migrieren. 

 Das `ec2rolecreds` Paket verwendet funktionale Optionen von [ec2RoleCreds.Options](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/ec2rolecreds#Options) als Eingabe, sodass Sie den spezifischen Amazon EC2 Instance Metadata Service-Client, der verwendet werden soll, oder das Ablauffenster für Anmeldeinformationen überschreiben können. `ec2rolecreds.New` 

#### Beispiel
<a name="w2aac43c11c17b7"></a>

```
// V1

import "github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds"

// ...

appCreds := ec2rolecreds.NewCredentials(sess)
value, err := appCreds.Get()
if err != nil {
    // handle error
}
```

```
// V2

import "context"
import "github.com/aws/aws-sdk-go-v2/aws"
import "github.com/aws/aws-sdk-go-v2/credentials/ec2rolecreds"

// ...

// New returns an object of a type that satisfies the aws.CredentialProvider interface
appCreds := aws.NewCredentialsCache(ec2rolecreds.New())
value, err := appCreds.Retrieve(context.TODO())
if err != nil {
    // handle error
}
```

### Anmeldeinformationen für Endgeräte
<a name="endpoint-credentials"></a>

 Sie müssen die Verwendung von [NewCredentialsClient](https://docs.aws.amazon.com/sdk-for-go/api/aws/credentials/endpointcreds/#NewCredentialsClient)und [NewProviderClient](https://docs.aws.amazon.com/sdk-for-go/api/aws/credentials/endpointcreds/#NewProviderClient)zur Verwendung von [New](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/endpointcreds#New) migrieren. 

 Die `New` Funktion des `endpointcreds` Pakets verwendet ein Zeichenkettenargument, das die URL eines HTTP- oder HTTPS-Endpunkts enthält, von dem Anmeldeinformationen abgerufen werden sollen, sowie funktionale Optionen von [EndpointCreds.Options](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/endpointcreds#Options), um den Anbieter für Anmeldeinformationen zu ändern und bestimmte Konfigurationseinstellungen zu überschreiben. 

### Anmeldeinformationen verarbeiten
<a name="process-credentials"></a>

 Sie müssen die Verwendung von [NewCredentials](https://docs.aws.amazon.com/sdk-for-go/api/aws/credentials/processcreds/#NewCredentials), und migrieren [NewCredentialsCommand](https://docs.aws.amazon.com/sdk-for-go/api/aws/credentials/processcreds/#NewCredentialsCommand), [NewCredentialsTimeout](https://docs.aws.amazon.com/sdk-for-go/api/aws/credentials/processcreds/#NewCredentialsTimeout)um [NewProvider](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/processcreds#New)oder zu verwenden [NewProviderCommand](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/processcreds#NewProviderCommand). 

 Die `NewProvider` Funktion des `processcreds` Pakets verwendet ein Zeichenkettenargument, bei dem es sich um den Befehl handelt, der in der Shell der Host-Umgebung ausgeführt werden soll, sowie über die [Funktionsoptionen von Options](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/processcreds#Options), um den Anbieter für Anmeldeinformationen zu ändern und bestimmte Konfigurationseinstellungen zu überschreiben. 

 `NewProviderCommand`verwendet eine Implementierung der [NewCommandBuilder](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/processcreds#NewCommandBuilder)Schnittstelle, die komplexere Prozessbefehle definiert, die ein oder mehrere Befehlszeilenargumente benötigen oder bestimmte Anforderungen an die Ausführungsumgebung stellen können. [DefaultNewCommandBuilder](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/processcreds#DefaultNewCommandBuilder)implementiert diese Schnittstelle und definiert einen Befehlsgenerator für einen Prozess, der mehrere Befehlszeilenargumente erfordert. 

#### Beispiel
<a name="example-2"></a>

```
// V1

import "github.com/aws/aws-sdk-go/aws/credentials/processcreds"

// ...

appCreds := processcreds.NewCredentials("/path/to/command")
value, err := appCreds.Get()
if err != nil {
    // handle error
}
```

```
// V2

import "context"
import "github.com/aws/aws-sdk-go-v2/aws"
import "github.com/aws/aws-sdk-go-v2/credentials/processcreds"

// ...

appCreds := aws.NewCredentialsCache(processcreds.NewProvider("/path/to/command"))
value, err := appCreds.Retrieve(context.TODO())
if err != nil {
    // handle error
}
```

### AWS -Security-Token-Service Erweitern Sie im angezeigten Detailbereich die Option
<a name="stslong-credentials"></a>

#### AssumeRole
<a name="assumerole"></a>

 Sie müssen die Verwendung von [NewCredentials](https://docs.aws.amazon.com/sdk-for-go/api/aws/credentials/stscreds/#NewCredentials)und [NewCredentialsWithClient](https://docs.aws.amazon.com/sdk-for-go/api/aws/credentials/stscreds/#NewCredentialsWithClient)zur Verwendung migrieren. [NewAssumeRoleProvider](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/stscreds#NewAssumeRoleProvider) 

 Die `NewAssumeRoleProvider` Funktion des `stscreds` Pakets muss mit einem [STS.Client](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/sts#Client) aufgerufen werden, und der AWS Identity and Access Management Rollen-ARN muss aus den konfigurierten Anmeldeinformationen `sts.Client` des angegebenen Benutzers übernommen werden. Sie können auch eine Reihe von Funktionsoptionen angeben [AssumeRoleOptions](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/stscreds#AssumeRoleOptions), um andere optionale Einstellungen des Anbieters zu ändern. 

##### Beispiel
<a name="example-3"></a>

```
// V1

import "github.com/aws/aws-sdk-go/aws/credentials/stscreds"

// ...

appCreds := stscreds.NewCredentials(sess, "arn:aws:iam::123456789012:role/demo")
value, err := appCreds.Get()
if err != nil {
    // handle error
}
```

```
// V2

import "context"
import "github.com/aws/aws-sdk-go-v2/credentials/stscreds"
import "github.com/aws/aws-sdk-go-v2/service/sts"

// ...

client := sts.NewFromConfig(cfg)

appCreds := stscreds.NewAssumeRoleProvider(client, "arn:aws:iam::123456789012:role/demo")
value, err := appCreds.Retrieve(context.TODO())
if err != nil {
    // handle error
}
```

#### AssumeRoleWithWebIdentity
<a name="assumerolewithwebidentity"></a>

 Sie müssen die Verwendung von [NewWebIdentityCredentials](https://docs.aws.amazon.com/sdk-for-go/api/aws/credentials/stscreds/#NewWebIdentityCredentials), und migrieren [NewWebIdentityRoleProvider](https://docs.aws.amazon.com/sdk-for-go/api/aws/credentials/stscreds/#NewWebIdentityRoleProvider), [NewWebIdentityRoleProviderWithToken](https://docs.aws.amazon.com/sdk-for-go/api/aws/credentials/stscreds/#NewWebIdentityRoleProviderWithToken)um zu verwenden [NewWebIdentityRoleProvider](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/stscreds#NewWebIdentityRoleProvider). 

 Die `NewWebIdentityRoleProvider` Funktion des `stscreds` Pakets muss mit einem [STS.Client](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/sts#Client) aufgerufen werden, und der AWS Identity and Access Management Rollen-ARN muss unter Verwendung der konfigurierten Anmeldeinformationen `sts.Client` des angegebenen Benutzers und einer Implementierung von a [IdentityTokenRetriever](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/stscreds#IdentityTokenRetriever)zur Bereitstellung des OAuth 2.0- oder OpenID Connect-ID-Tokens übernommen werden. [IdentityTokenFile](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/stscreds#IdentityTokenFile)ist eine`IdentityTokenRetriever`, die verwendet werden kann, um das Web-Identitätstoken aus einer Datei bereitzustellen, die sich im Host-Dateisystem der Anwendung befindet. Sie können auch eine Reihe von Funktionsoptionen angeben, [WebIdentityRoleOptions](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/stscreds#WebIdentityRoleOptions)um andere optionale Einstellungen für den Anbieter zu ändern. 

##### Beispiel
<a name="example-4"></a>

```
// V1

import "github.com/aws/aws-sdk-go/aws/credentials/stscreds"

// ...

appCreds := stscreds.NewWebIdentityRoleProvider(sess, "arn:aws:iam::123456789012:role/demo", "sessionName", "/path/to/token")
value, err := appCreds.Get()
if err != nil {
    // handle error
}
```

```
// V2

import "context"
import "github.com/aws/aws-sdk-go-v2/aws"
import "github.com/aws/aws-sdk-go-v2/credentials/stscreds"
import "github.com/aws/aws-sdk-go-v2/service/sts"

// ...

client := sts.NewFromConfig(cfg)

appCreds := aws.NewCredentialsCache(stscreds.NewWebIdentityRoleProvider(
        client,
        "arn:aws:iam::123456789012:role/demo",
        stscreds.IdentityTokenFile("/path/to/file"),
        func(o *stscreds.WebIdentityRoleOptions) {
            o.RoleSessionName = "sessionName"
        }))
value, err := appCreds.Retrieve(context.TODO())
if err != nil {
    // handle error
}
```

## Kunden bedienen
<a name="service-clients"></a>

 AWS SDK für Go stellt Service-Client-Module bereit, die unter dem `github.com/aws/aws-sdk-go-v2/service` Importpfad verschachtelt sind. Jeder Service-Client ist in einem Go-Paket enthalten, wobei die eindeutige Kennung jedes Dienstes verwendet wird. Die folgende Tabelle enthält einige Beispiele für Service-Importpfade in der AWS SDK für Go. 


|  Service-Name  |  V1-Importpfad  |  V2-Importpfad  | 
| --- | --- | --- | 
|  Amazon S3  |  github.com/aws/aws-sdk-go/service/s3  |  github.com/aws/aws-sdk-go-v2/service/s3  | 
|  Amazon DynamoDB  |  github.com/aws/aws-sdk-go/service/dynamodb  |  github.com/aws/aws-sdk-go-v2/service/dynamodb  | 
|  CloudWatch Amazon-Protokolle  |  github.com/aws/aws-sdk-go/service/cloudwatchlogs  |  github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs  | 

 Jedes Service-Client-Paket ist ein unabhängig versioniertes Go-Modul. Um den Service-Client als Abhängigkeit von Ihrer Anwendung hinzuzufügen, verwenden Sie den `go get` Befehl mit dem Importpfad des Dienstes. Um beispielsweise den Amazon S3 S3-Client zu Ihren Abhängigkeiten hinzuzufügen, verwenden Sie 

```
go get github.com/aws/aws-sdk-go-v2/service/s3
```

### Aufbau eines Kunden
<a name="client-construction"></a>

 Sie können Clients erstellen, AWS SDK für Go indem Sie entweder die `New` oder die `NewFromConfig` Konstruktorfunktionen im Paket des Clients verwenden. Bei der Migration von AWS SDK für Go Version 1 empfehlen wir, die `NewFromConfig` Variante zu verwenden, die einen neuen Service-Client mit Werten aus einem zurückgibt. `aws.Config` Der `aws.Config` Wert wurde beim Laden der gemeinsam genutzten SDK-Konfiguration mit `config.LoadDefaultConfig` erstellt. Einzelheiten zum Erstellen von Service-Clients finden Sie unter[Verwenden Sie die AWS SDK für Go Version 2 mit AWS Diensten](use-services.md). 

#### Beispiel 1
<a name="w2aac43c13c11b5"></a>

```
// V1

import "github.com/aws/aws-sdk-go/aws/session"
import "github.com/aws/aws-sdk-go/service/s3"

// ...

sess, err := session.NewSession()
if err != nil {
    // handle error
}

client := s3.New(sess)
```

```
// V2

import "context"
import "github.com/aws/aws-sdk-go-v2/config"
import "github.com/aws/aws-sdk-go-v2/service/s3"

// ...

cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
    // handle error
}

client := s3.NewFromConfig(cfg)
```

#### Beispiel 2: Client-Einstellungen überschreiben
<a name="example-2-overriding-client-settings"></a>

```
// V1

import "github.com/aws/aws-sdk-go/aws"
import "github.com/aws/aws-sdk-go/aws/session"
import "github.com/aws/aws-sdk-go/service/s3"

// ...

sess, err := session.NewSession()
if err != nil {
    // handle error
}

client := s3.New(sess, &aws.Config{
    Region: aws.String("us-west-2"),
})
```

```
// V2

import "context"
import "github.com/aws/aws-sdk-go-v2/config"
import "github.com/aws/aws-sdk-go-v2/service/s3"

// ...

cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
    // handle error
}

client := s3.NewFromConfig(cfg, func(o *s3.Options) {
    o.Region = "us-west-2"
})
```

### Endpunkte
<a name="endpoints"></a>

 Das [Endpoints-Paket](https://docs.aws.amazon.com/sdk-for-go/api/aws/endpoints/) ist nicht mehr in der vorhanden. AWS SDK für Go Jeder Service-Client bettet jetzt seine erforderlichen AWS Endpunkt-Metadaten in das Client-Paket ein. Dadurch wird die gesamte Binärgröße kompilierter Anwendungen reduziert, da keine Endpunktmetadaten für Dienste mehr enthalten sind, die von Ihrer Anwendung nicht verwendet werden. 

 Darüber hinaus bietet jeder Dienst jetzt seine eigene Schnittstelle für die Endpunktauflösung in`EndpointResolverV2`. Jede API verwendet einen eindeutigen Satz von Parametern für einen Dienst`EndpointParameters`, dessen Werte vom SDK beim Aufrufen eines Vorgangs von verschiedenen Orten abgerufen werden. 

 Standardmäßig verwenden Service-Clients ihre konfigurierte AWS Region, um den Service-Endpunkt für die Zielregion aufzulösen. Wenn für Ihre Anwendung ein benutzerdefinierter Endpunkt erforderlich ist, können Sie ein benutzerdefiniertes Verhalten für das `EndpointResolverV2` Feld in der `aws.Config` Struktur angeben. Wenn Ihre Anwendung einen benutzerdefinierten [Endpoints.Resolver](https://docs.aws.amazon.com/sdk-for-go/api/aws/endpoints/#Resolver) implementiert, müssen Sie ihn migrieren, damit er dieser neuen Schnittstelle für jeden Dienst entspricht. 

 Weitere Informationen zu Endpunkten und zur Implementierung eines benutzerdefinierten Resolvers finden Sie unter. [Client-Endpunkte konfigurieren](configure-endpoints.md) 

### Authentifizierung
<a name="authentication"></a>

 Das AWS SDK für Go unterstützt ein erweitertes Authentifizierungsverhalten, das die Verwendung neuerer AWS Servicefunktionen wie Codecatalyst und S3 Express One Zone ermöglicht. Darüber hinaus kann dieses Verhalten für jeden einzelnen Client angepasst werden. 

### API-Operationen aufrufen
<a name="invoking-api-operations"></a>

 Die Anzahl der Betriebsmethoden für Service-Clients wurde erheblich reduziert. Die `<OperationName>` Methoden `<OperationName>Request``<OperationName>WithContext`, und wurden alle zu einer einzigen Betriebsmethode zusammengefasst`<OperationName>`. 

#### Beispiel
<a name="example-5"></a>

 Das folgende Beispiel zeigt, wie Aufrufe des Amazon S3 PutObject S3-Vorgangs von AWS SDK für Go Version 1 auf Version 2 migriert würden. 

```
// V1

import "context"
import "github.com/aws/aws-sdk-go/service/s3"

// ...

client := s3.New(sess)

// Pattern 1
output, err := client.PutObject(&s3.PutObjectInput{
    // input parameters
})

// Pattern 2
output, err := client.PutObjectWithContext(context.TODO(), &s3.PutObjectInput{
    // input parameters
})

// Pattern 3
req, output := client.PutObjectRequest(context.TODO(), &s3.PutObjectInput{
    // input parameters
})
err := req.Send()
```

```
// V2

import "context"
import "github.com/aws/aws-sdk-go-v2/service/s3"

// ...

client := s3.NewFromConfig(cfg)

output, err := client.PutObject(context.TODO(), &s3.PutObjectInput{
    // input parameters
})
```

### Service-Datentypen
<a name="service-data-types"></a>

 Die Eingabe- und Ausgabetypen der obersten Ebene eines Vorgangs finden Sie im Service-Client-Paket. Der Eingabe- und Ausgabetyp für eine bestimmte Operation folgt dem Muster von `<OperationName>Input` und`<OperationName>Output`, wobei der Name der Operation `OperationName` ist, die Sie aufrufen. Beispielsweise sind die Eingabe- und Ausgabeform für den Amazon S3 PutObject S3-Vorgang [PutObjectOutput](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/s3#PutObjectOutput)jeweils [PutObjectInput](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/s3#PutObjectInput)und. 

 Alle anderen Servicedatentypen, mit Ausnahme der Eingabe- und Ausgabetypen, wurden in das `types` Paket migriert, das sich unter der Hierarchie des Importpfads für Service-Client-Pakete befindet. Zum Beispiel der [S3. AccessControlPolicy](https://docs.aws.amazon.com/sdk-for-go/api/service/s3/#AccessControlPolicy)Der Typ befindet sich jetzt unter [Typen. AccessControlPolicy](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/s3/types#AccessControlPolicy). 

#### Aufzählungswerte
<a name="enumeration-values"></a>

 Das SDK bietet jetzt eine typisierte Oberfläche für alle API-Aufzählungsfelder. Anstatt einen Zeichenkettenliteralwert zu verwenden, der aus der Referenzdokumentation der Service-API kopiert wurde, können Sie jetzt einen der konkreten Typen verwenden, die im Paket des Service-Clients enthalten sind. `types` Beispielsweise können Sie für den Amazon S3 PutObjectInput S3-Vorgang eine ACL bereitstellen, die auf ein Objekt angewendet wird. In AWS SDK für Go Version 1 war dieser Parameter ein `*string` Typ. In der AWS SDK für Go ist dieser Parameter jetzt ein [Typ. ObjectCannedACL](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/s3/types#ObjectCannedACL). Das `types` Paket stellt generierte Konstanten für die gültigen Aufzählungswerte bereit, die diesem Feld zugewiesen werden können. [Zum Beispiel Typen. ObjectCannedACLPrivate](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/s3/types#ObjectCannedACLPrivate)ist die Konstante für den gespeicherten ACL-Wert „privat“. Dieser Wert kann anstelle der Verwaltung von Zeichenkettenkonstanten in Ihrer Anwendung verwendet werden. 

### Zeiger-Parameter
<a name="pointer-parameters"></a>

 In AWS SDK für Go Version 1 mussten Zeigerreferenzen für alle Eingabeparameter an Serviceoperationen übergeben werden. AWS SDK für Go Version 2 hat die Erfahrung mit den meisten Diensten vereinfacht, da die Notwendigkeit entfällt, Eingabewerte nach Möglichkeit als Zeiger zu übergeben. Diese Änderung bedeutet, dass Ihre Anwendung bei vielen Service-Client-Vorgängen nicht mehr Zeigerreferenzen für die folgenden Typen übergeben muss:`uint8`,`uint16`,`uint32`,`int8`,`int16`,,`int32`, `float32``float64`,`bool`. In ähnlicher Weise wurden die Elementtypen Slice und Map entsprechend aktualisiert, um zu berücksichtigen, ob ihre Elemente als Zeigerreferenzen übergeben werden müssen. 

 Das [aws-Paket](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws) enthält Hilfsfunktionen zum Erstellen von Zeigern für die integrierten Go-Typen. Diese Helfer sollten verwendet werden, um die Erstellung von Zeigertypen für diese Go-Typen einfacher zu handhaben. In ähnlicher Weise werden Hilfsmethoden bereitgestellt, mit denen Zeigerwerte für diese Typen sicher dereferenziert werden können. Die [AWS.String-Funktion](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws#String) konvertiert beispielsweise aus ⇒. `string` `*string` [Umgekehrt die aws. ToString](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws#ToString)konvertiert von `*string` ⇒`string`. Wenn Sie Ihre Anwendung von Version AWS SDK für Go 1 auf Version 2 aktualisieren, müssen Sie die Verwendung der Hilfsprogramme für die Konvertierung von Zeigertypen auf Varianten ohne Zeiger migrieren. Zum Beispiel [aws. StringValue](https://docs.aws.amazon.com/sdk-for-go/api/aws/#StringValue)muss aktualisiert werden auf`aws.ToString`. 

### Arten von Fehlern
<a name="errors-types"></a>

 Das AWS SDK für Go nutzt die [in Go 1.13 eingeführte](https://go.dev/blog/go1.13-errors) Funktion zum Umschließen von Fehlern voll aus. Dienste, die Fehlerantworten modellieren, verfügen im `types` Paket ihres Clients über generierte Typen, mit denen getestet werden kann, ob ein Client-Betriebsfehler durch einen dieser Typen verursacht wurde. Beispielsweise kann der Amazon S3 `GetObject` S3-Vorgang einen `NoSuchKey` Fehler zurückgeben, wenn versucht wird, einen Objektschlüssel abzurufen, der nicht existiert. [Sie können [Errors.as](https://pkg.go.dev/errors#As) verwenden, um zu testen, ob es sich bei dem zurückgegebenen Operationsfehler um einen Typ handelt. NoSuchKey](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/s3/types#NoSuchKey)Fehler. Falls ein Dienst keinen bestimmten Typ für einen Fehler modelliert, können Sie den [Smithy verwenden. APIError](https://pkg.go.dev/github.com/aws/smithy-go#APIError)Schnittstellentyp zur Überprüfung des zurückgegebenen Fehlercodes und der vom Dienst zurückgegebenen Meldung. Diese Funktionalität ersetzt [awserr.Error](https://docs.aws.amazon.com/sdk-for-go/api/aws/awserr//#Error) und die anderen [awserr-Funktionen](https://docs.aws.amazon.com/sdk-for-go/api/aws/awserr/) aus Version 1. AWS SDK für Go Weitere Informationen zur Behandlung von Fehlern finden Sie unter. [Umgang mit Fehlern in der AWS SDK für Go V2](handle-errors.md) 

#### Beispiel
<a name="example-6"></a>

```
// V1

import "github.com/aws/aws-sdk-go/aws/awserr"
import "github.com/aws/aws-sdk-go/service/s3"

// ...

client := s3.New(sess)

output, err := s3.GetObject(&s3.GetObjectInput{
    // input parameters
})
if err != nil {
    if awsErr, ok := err.(awserr.Error); ok {
        if awsErr.Code() == "NoSuchKey" {
            // handle NoSuchKey
        } else {
            // handle other codes
        }
        return
    }
    // handle a error
}
```

```
// V2

import "context"
import "github.com/aws/aws-sdk-go-v2/service/s3"
import "github.com/aws/aws-sdk-go-v2/service/s3/types"
import "github.com/aws/smithy-go"

// ...

client := s3.NewFromConfig(cfg)

output, err := client.GetObject(context.TODO(), &s3.GetObjectInput{
    // input parameters
})
if err != nil {
    var nsk *types.NoSuchKey
    if errors.As(err, &nsk) {
        // handle NoSuchKey error
        return
    }
    var apiErr smithy.APIError
    if errors.As(err, &apiErr) {
        code := apiErr.ErrorCode()
        message := apiErr.ErrorMessage()
        // handle error code
        return
    }
    // handle error
    return
}
```

### Paginatoren
<a name="paginators"></a>

 Paginatoren für Dienstoperationen werden nicht mehr als Methoden auf dem Service-Client aufgerufen. Um einen Paginator für eine Operation zu verwenden, müssen Sie mit einer der Paginator-Konstruktormethoden einen Paginator für eine Operation erstellen. [Um beispielsweise Paginate über die Amazon S3 `ListObjectsV2` S3-Operation zu verwenden, müssen Sie den zugehörigen Paginator mithilfe der S3 erstellen. NewListObjectsV2-Paginator.](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/s3#NewListObjectsV2Paginator) Dieser Konstruktor gibt einen [ListObjectsV2Paginator](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/s3#ListObjectsV2Paginator) zurück, der die Methoden bereitstellt und bestimmt`HasMorePages`, ob weitere Seiten abgerufen werden müssen, und `NextPage` der die Operation zum Abrufen der nächsten Seite aufruft. Weitere Informationen zur Verwendung der SDK-Paginatoren finden Sie unter. [Verwendung von Operation Paginators](using.md#using-operation-paginators) 

 Schauen wir uns ein Beispiel für die Migration von einem AWS SDK für Go v1-Paginator zum v2-Äquivalent an. AWS SDK für Go 

#### Beispiel
<a name="example-7"></a>

```
// V1

import "fmt"
import "github.com/aws/aws-sdk-go/service/s3"

// ...

client := s3.New(sess)

params := &s3.ListObjectsV2Input{
    // input parameters
}

totalObjects := 0
err := client.ListObjectsV2Pages(params, func(output *s3.ListObjectsV2Output, lastPage bool) bool {
    totalObjects += len(output.Contents)
    return !lastPage
})
if err != nil {
    // handle error
}
fmt.Println("total objects:", totalObjects)
```

```
// V2

import "context"
import "fmt"
import "github.com/aws/aws-sdk-go-v2/service/s3"

// ...

client := s3.NewFromConfig(cfg)

params := &s3.ListObjectsV2Input{
    // input parameters
}

totalObjects := 0
paginator := s3.NewListObjectsV2Paginator(client, params)
for paginator.HasMorePages() {
    output, err := paginator.NextPage(context.TODO())
    if err != nil {
        // handle error
    }
    totalObjects += len(output.Contents)
}
fmt.Println("total objects:", totalObjects)
```

### Waiter
<a name="waiters"></a>

 Service Operations Waiters werden nicht mehr als Methoden auf dem Service-Client aufgerufen. Um einen Kellner zu verwenden, erstellen Sie zunächst den gewünschten Kellnertyp und rufen dann die Methode wait auf. Um beispielsweise darauf zu warten, dass ein Amazon S3 S3-Bucket existiert, müssen Sie einen `BucketExists` Kellner einrichten. Verwenden Sie den [S3. NewBucketExistsWaiter](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/s3#NewBucketExistsWaiter)Konstruktor, um ein [S3 zu erstellen. BucketExistsWaiter](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/s3#BucketExistsWaiter). Das `s3.BucketExistsWaiter` bietet eine `Wait` Methode, mit der Sie warten können, bis ein Bucket verfügbar ist. 

### Vorsignierte Anfragen
<a name="presigned-requests"></a>

 Das V1-SDK unterstützte technisch gesehen die Vorsignierung *aller* AWS SDK-Operationen, dies entspricht jedoch nicht genau dem, was tatsächlich auf der Serviceebene unterstützt wird (und in der Realität unterstützen die meisten AWS Dienstoperationen das Vorsignieren nicht). 

 AWS SDK für Go behebt dieses Problem, indem es spezifische `PresignClient` Implementierungen in Servicepaketen mit spezifischen APIs , für die unterstützten vorsignierbaren Vorgängen verfügbar macht. 

 **[Hinweis: Wenn bei einem Dienst die Unterstützung für die Vorsignierung eines Vorgangs fehlt, den Sie erfolgreich in SDK v1 verwendet haben, teilen Sie uns dies bitte mit, indem Sie ein Problem unter melden. GitHub](https://github.com/aws/aws-sdk-go-v2/issues)** 

 Wird von [Presign](https://docs.aws.amazon.com/sdk-for-go/api/aws/request/#Request.Presign) verwendet und [PresignRequest](https://docs.aws.amazon.com/sdk-for-go/api/aws/request/#Request.PresignRequest)muss auf die Verwendung von dienstspezifischen Presigning-Clients umgestellt werden. 

 Das folgende Beispiel zeigt, wie die Vorsignierung einer S3-Anfrage migriert wird: GetObject 

```
// V1

import (
    "fmt"
    "time"

    "github.com/aws/aws-sdk-go/aws"
    "github.com/aws/aws-sdk-go/aws/session"
    "github.com/aws/aws-sdk-go/service/s3"
)

func main() {
    sess := session.Must(session.NewSessionWithOptions(session.Options{
        SharedConfigState: session.SharedConfigEnable,
    }))

    svc := s3.New(sess)
    req, _ := svc.GetObjectRequest(&s3.GetObjectInput{
        Bucket: aws.String("{{amzn-s3-demo-bucket}}"),
        Key:    aws.String("{{key}}"),
    })

    // pattern 1
    url1, err := req.Presign(20 * time.Minute)
    if err != nil {
        panic(err)
    }
    fmt.Println(url1)

    // pattern 2
    url2, header, err := req.PresignRequest(20 * time.Minute)
    if err != nil {
        panic(err)
    }
    fmt.Println(url2, header)
}
```

```
// V2

import (
    "context"
    "fmt"
    "time"

    "github.com/aws/aws-sdk-go-v2/aws"
    "github.com/aws/aws-sdk-go-v2/config"
    "github.com/aws/aws-sdk-go-v2/service/s3"
)

func main() {
    cfg, err := config.LoadDefaultConfig(context.Background())
    if err != nil {
        panic(err)
    }

    svc := s3.NewPresignClient(s3.NewFromConfig(cfg))
    req, err := svc.PresignGetObject(context.Background(), &s3.GetObjectInput{
        Bucket: aws.String("{{amzn-s3-demo-bucket}}"),
        Key:    aws.String("{{key}}"),
    }, func(o *s3.PresignOptions) {
        o.Expires = 20 * time.Minute
    })
    if err != nil {
        panic(err)
    }

    fmt.Println(req.Method, req.URL, req.SignedHeader)
}
```

## Anpassung anfordern
<a name="request-customization"></a>

 Die monolithische [Request.Request-API](https://docs.aws.amazon.com/sdk-for-go/api/aws/request/#Request) wurde neu unterteilt. 

### Operation Eingabe/Ausgabe
<a name="operation-inputoutput"></a>

 Die undurchsichtigen `Request` Felder `Params` und`Data`, die die Eingabe- bzw. Ausgabestrukturen der Operation enthalten, sind nun innerhalb bestimmter Middleware-Phasen als Eingabe/Ausgabe zugänglich: 

 Anforderungshandler, die auf Middleware verweisen `Request.Params` und `Request.Data` zu dieser migriert werden müssen. 

#### migrieren `Params`
<a name="migrating-params"></a>

```
// V1

import (
    "github.com/aws/aws-sdk-go/aws"
    "github.com/aws/aws-sdk-go/aws/request"
    "github.com/aws/aws-sdk-go/aws/session"
    "github.com/aws/aws-sdk-go/service/s3"
)

func withPutObjectDefaultACL(acl string) request.Option {
    return func(r *request.Request) {
        in, ok := r.Params.(*s3.PutObjectInput)
        if !ok {
            return
        }

        if in.ACL == nil {
            in.ACL = aws.String(acl)
        }
        r.Params = in
    }
}

func main() {
    sess := session.Must(session.NewSession())
    sess.Handlers.Validate.PushBack(withPutObjectDefaultACL(s3.ObjectCannedACLBucketOwnerFullControl))

    // ...
}
```

```
// V2

import (
    "context"

    "github.com/aws/aws-sdk-go-v2/service/s3"
    "github.com/aws/aws-sdk-go-v2/service/s3/types"
    "github.com/aws/smithy-go/middleware"
    smithyhttp "github.com/aws/smithy-go/transport/http"
)

type withPutObjectDefaultACL struct {
    acl types.ObjectCannedACL
}

// implements middleware.InitializeMiddleware, which runs BEFORE a request has
// been serialized and can act on the operation input
var _ middleware.InitializeMiddleware = (*withPutObjectDefaultACL)(nil)

func (*withPutObjectDefaultACL) ID() string {
    return "withPutObjectDefaultACL"
}

func (m *withPutObjectDefaultACL) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
    out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
    input, ok := in.Parameters.(*s3.PutObjectInput)
    if !ok {
        return next.HandleInitialize(ctx, in)
    }

    if len(input.ACL) == 0 {
        input.ACL = m.acl
    }
    in.Parameters = input
    return next.HandleInitialize(ctx, in)
}

// create a helper function to simplify instrumentation of our middleware
func WithPutObjectDefaultACL(acl types.ObjectCannedACL) func (*s3.Options) {
    return func(o *s3.Options) {
        o.APIOptions = append(o.APIOptions, func (s *middleware.Stack) error {
            return s.Initialize.Add(&withPutObjectDefaultACL{acl: acl}, middleware.After)
        })
    }
}

func main() {
    cfg, err := config.LoadDefaultConfig(context.Background())
    if err != nil {
        // ...
    }

    svc := s3.NewFromConfig(cfg, WithPutObjectDefaultACL(types.ObjectCannedACLBucketOwnerFullControl))
    // ...
}
```

#### migrieren `Data`
<a name="migrating-data"></a>

```
// V1

import (
    "github.com/aws/aws-sdk-go/aws"
    "github.com/aws/aws-sdk-go/aws/request"
    "github.com/aws/aws-sdk-go/aws/session"
    "github.com/aws/aws-sdk-go/service/s3"
)

func readPutObjectOutput(r *request.Request) {
        output, ok := r.Data.(*s3.PutObjectOutput)
        if !ok {
            return
        }

        // ...
    }
}

func main() {
    sess := session.Must(session.NewSession())
    sess.Handlers.Unmarshal.PushBack(readPutObjectOutput)

    svc := s3.New(sess)
    // ...
}
```

```
// V2

import (
    "context"

    "github.com/aws/aws-sdk-go-v2/config"
    "github.com/aws/aws-sdk-go-v2/service/s3"
    "github.com/aws/smithy-go/middleware"
    smithyhttp "github.com/aws/smithy-go/transport/http"
)

type readPutObjectOutput struct{}

var _ middleware.DeserializeMiddleware = (*readPutObjectOutput)(nil)

func (*readPutObjectOutput) ID() string {
    return "readPutObjectOutput"
}

func (*readPutObjectOutput) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
    out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
    out, metadata, err = next.HandleDeserialize(ctx, in)
    if err != nil {
        // ...
    }

    output, ok := in.Parameters.(*s3.PutObjectOutput)
    if !ok {
        return out, metadata, err
    }

    // inspect output...

    return out, metadata, err
}

func WithReadPutObjectOutput(o *s3.Options) {
    o.APIOptions = append(o.APIOptions, func (s *middleware.Stack) error {
        return s.Initialize.Add(&withReadPutObjectOutput{}, middleware.Before)
    })
}

func main() {
    cfg, err := config.LoadDefaultConfig(context.Background())
    if err != nil {
        // ...
    }

    svc := s3.NewFromConfig(cfg, WithReadPutObjectOutput)
    // ...
}
```

### HTTP-Anfrage/Antwort
<a name="http-requestresponse"></a>

 Die `HTTPResponse` Felder `HTTPRequest` und von `Request` werden jetzt in bestimmten Middleware-Phasen verfügbar gemacht. Da Middleware transportunabhängig ist, müssen Sie eine Typzusicherung für die Middleware-Eingabe oder -Ausgabe durchführen, um die zugrunde liegende HTTP-Anfrage oder -Antwort aufzudecken. 

 Anforderungshandler, die auf Middleware verweisen und zu dieser migriert werden müssen. `Request.HTTPRequest` `Request.HTTPResponse` 

#### migrieren `HTTPRequest`
<a name="migrating-httprequest"></a>

```
// V1

import (
    "github.com/aws/aws-sdk-go/aws/request"
    "github.com/aws/aws-sdk-go/aws/session"
)

func withHeader(header, val string) request.Option {
    return func(r *request.Request) {
        request.HTTPRequest.Header.Set(header, val)
    }
}

func main() {
    sess := session.Must(session.NewSession())
    sess.Handlers.Build.PushBack(withHeader("x-user-header", "..."))

    svc := s3.New(sess)
    // ...
}
```

```
// V2

import (
    "context"
    "fmt"

    "github.com/aws/aws-sdk-go-v2/config"
    "github.com/aws/aws-sdk-go-v2/service/s3"
    "github.com/aws/smithy-go/middleware"
    smithyhttp "github.com/aws/smithy-go/transport/http"
)

type withHeader struct {
    header, val string
}

// implements middleware.BuildMiddleware, which runs AFTER a request has been
// serialized and can operate on the transport request
var _ middleware.BuildMiddleware = (*withHeader)(nil)

func (*withHeader) ID() string {
    return "withHeader"
}

func (m *withHeader) HandleBuild(ctx context.Context, in middleware.BuildInput, next middleware.BuildHandler) (
    out middleware.BuildOutput, metadata middleware.Metadata, err error,
) {
    req, ok := in.Request.(*smithyhttp.Request)
    if !ok {
        return out, metadata, fmt.Errorf("unrecognized transport type %T", in.Request)
    }

    req.Header.Set(m.header, m.val)
    return next.HandleBuild(ctx, in)
}

func WithHeader(header, val string) func (*s3.Options) {
    return func(o *s3.Options) {
        o.APIOptions = append(o.APIOptions, func (s *middleware.Stack) error {
            return s.Build.Add(&withHeader{
                header: header,
                val: val,
            }, middleware.After)
        })
    }
}

func main() {
    cfg, err := config.LoadDefaultConfig(context.Background())
    if err != nil {
        // ...
    }

    svc := s3.NewFromConfig(cfg, WithHeader("x-user-header", "..."))
    // ...
}
```

### Handler-Phasen
<a name="handler-phases"></a>

 SDK v2-Middleware-Phasen sind der Nachfolger der v1-Handler-Phasen. 

 Die folgende Tabelle enthält eine grobe Zuordnung der v1-Handler-Phasen zu ihrer entsprechenden Position innerhalb des V2-Middleware-Stacks: 


|  Name des v1-Handlers  |  v2-Middleware-Phase  | 
| --- | --- | 
|  Validieren  |  Initialisieren  | 
|  Entwicklung  |  Serialisieren  | 
|  Sign  |  Finalisieren  | 
|  Senden  |  n/a (1)  | 
|  ValidateResponse  |  Deserialisieren  | 
|  Unmarschall  |  Deserialisieren  | 
|  UnmarshalMetadata  |  Deserialisieren  | 
|  UnmarshalError  |  Deserialisieren  | 
|  Erneut versuchen  |  Finalisieren, nach "Retry" Middleware (2)  | 
|  AfterRetry  |  Finalisieren, vor der "Retry" Middleware, nach- (2,3) next.HandleFinalize()  | 
|  CompleteAttempt  |  Finalisieren, Ende des Schritts  | 
|  Complete  |  Initialisieren, Beginn des Schritts, Post- next.HandleInitialize() (3)  | 

 (1) Die `Send` Phase in Version 1 ist praktisch der umschlossene HTTP-Client-Round-Trip in Version 2. Dieses Verhalten wird durch das `HTTPClient` Feld in den Client-Optionen gesteuert. 

 (2) Jede Middleware, die nach der `"Retry"` Middleware im Finalize-Schritt folgt, wird Teil der Wiederholungsschleife. 

 (3) Der Middleware-"Stack“ ist während des Betriebs in eine mehrfach dekorierte Handler-Funktion integriert. Jeder Handler ist dafür verantwortlich, den nächsten in der Kette aufzurufen. Dies bedeutet implizit, dass ein Middleware-Schritt auch Maßnahmen ergreifen kann, NACHDEM sein nächster Schritt aufgerufen wurde. 

 Für den Schritt Initialisieren, der sich ganz oben im Stack befindet, bedeutet dies, dass Middlewares initialisieren, die nach dem Aufrufen des nächsten Handlers eine Aktion ausführen, effektiv am Ende der Anfrage ausgeführt werden: 

```
// V2

import (
    "context"

    "github.com/aws/smithy-go/middleware"
)

type onComplete struct{}

var _ middleware.InitializeMiddleware = (*onComplete)(nil)

func (*onComplete) ID() string {
    return "onComplete"
}

func (*onComplete) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
    out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
    out, metadata, err = next.HandleInitialize(ctx, in)

    // the entire operation was invoked above - the deserialized response is
    // available opaquely in out.Result, run post-op actions here...

    return out, metadata, err
}
```

## Features
<a name="features"></a>

### Metadatenservice für EC2 Amazon-Instances
<a name="ec2-instance-metadata-service"></a>

 Der AWS SDK für Go stellt einen Amazon EC2 Instance Metadata Service (IMDS) -Client bereit, mit dem Sie das lokale IMDS abfragen können, wenn Sie Ihre Anwendung auf einer EC2 Amazon-Instance ausführen. Der IMDS-Client ist ein separates Go-Modul, das Ihrer Anwendung hinzugefügt werden kann, indem Sie 

```
go get github.com/aws/aws-sdk-go-v2/feature/ec2/imds
```

 Der Client-Konstruktor und die Methodenoperationen wurden aktualisiert, sodass sie dem Design der anderen SDK-Dienstclients entsprechen. 

#### Beispiel
<a name="example-8"></a>

```
// V1

import "github.com/aws/aws-sdk-go/aws/ec2metadata"

// ...

client := ec2metadata.New(sess)

region, err := client.Region()
if err != nil {
    // handle error
}
```

```
// V2

import "context"
import "github.com/aws/aws-sdk-go-v2/feature/ec2/imds"

// ...

client := imds.NewFromConfig(cfg)

region, err := client.GetRegion(context.TODO())
if err != nil {
    // handle error
}
```

### Amazon S3 Transfer-Manager
<a name="s3-transfer-manager"></a>

 Der Amazon S3 S3-Transfermanager ist für die gleichzeitige Verwaltung von Uploads und Downloads von Objekten verfügbar. Dieses Paket befindet sich in einem Go-Modul außerhalb des Importpfads des Service-Clients. Dieses Modul kann abgerufen werden, indem Sie`go get github.com/aws/aws-sdk-go-v2/feature/s3/manager`. 

 [s3. NewUploader](https://docs.aws.amazon.com/sdk-for-go/api/service/s3/s3manager/#NewUploader)und [s3. NewUploaderWithClient](https://docs.aws.amazon.com/sdk-for-go/api/service/s3/s3manager/#NewUploaderWithClient)wurden durch den [Konstruktor-Methodenmanager ersetzt. NewUploader](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/feature/s3/manager#)zum Erstellen eines Upload-Manager-Clients. 

 [s3. NewDownloader](https://docs.aws.amazon.com/sdk-for-go/api/service/s3/s3manager/#NewDownloader)und [s3. NewDownloaderWithClient](https://docs.aws.amazon.com/sdk-for-go/api/service/s3/s3manager/#NewDownloaderWithClient)wurden durch einen einzigen [Konstruktor-Methodenmanager ersetzt. NewDownloader](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/feature/s3/manager#NewDownloader)zum Erstellen eines Download-Manager-Clients. 

### Amazon CloudFront Signing Utilities
<a name="cflong-signing-utilities"></a>

 Das AWS SDK für Go stellt CloudFront Amazon-Signaturdienstprogramme in einem Go-Modul außerhalb des Importpfads des Service-Clients bereit. Dieses Modul kann abgerufen werden, indem Sie `go get` 

```
go get github.com/aws/aws-sdk-go-v2/feature/cloudfront/sign
```

### Amazon S3 Encryption Client
<a name="s3-encryption-client"></a>

 Ab sofort AWS SDK für Go ist der Amazon S3 S3-Verschlüsselungsclient ein separates Modul unter [AWS Crypto Tools](https://docs.aws.amazon.com/aws-crypto-tools). Die neueste Version des S3-Verschlüsselungsclients für Go, 3.x, ist jetzt unter [GitHub](https://github.com/aws/amazon-s3-encryption-client-go)verfügbar. Dieses Modul kann wie folgt abgerufen werden: `go get` 

```
go get github.com/aws/amazon-s3-encryption-client-go/v3
```

 Die separaten Versionen `EncryptionClient` ([v1](https://docs.aws.amazon.com/sdk-for-go/api/service/s3/s3crypto/#EncryptionClient), [v2](https://docs.aws.amazon.com/sdk-for-go/api/service/s3/s3crypto/#EncryptionClientV2)) und `DecryptionClient` ([v1](https://docs.aws.amazon.com/sdk-for-go/api/service/s3/s3crypto/#DecryptionClient), [v2](https://docs.aws.amazon.com/sdk-for-go/api/service/s3/s3crypto/#DecryptionClientV2)) APIs wurden durch einen einzigen Client, [S3 EncryptionClient V3](https://pkg.go.dev/github.com/aws/amazon-s3-encryption-client-go/v3/client#S3EncryptionClientV3), ersetzt, der sowohl Verschlüsselungs- als auch Entschlüsselungsfunktionen bietet. 

 Wie bei anderen Service-Clients wurde AWS SDK für Go der Vorgang zusammengefasst APIs : 
+  Die `GetObject``GetObjectRequest`, und die `GetObjectWithContext` Entschlüsselung APIs werden durch [GetObject](https://pkg.go.dev/github.com/aws/amazon-s3-encryption-client-go/v3/client#S3EncryptionClientV3.GetObject)ersetzt. 
+  Die `PutObjectWithContext` Verschlüsselung `PutObject``PutObjectRequest`, und APIs werden durch [PutObject](https://pkg.go.dev/github.com/aws/amazon-s3-encryption-client-go/v3/client#S3EncryptionClientV3.PutObject)ersetzt. 

 Informationen zur Migration auf die 3.x-Hauptversion des Verschlüsselungsclients finden Sie in [diesem Handbuch](https://docs.aws.amazon.com/amazon-s3-encryption-client/latest/developerguide/go-v3-migration.html). 

## Änderungen an den Serviceanpassungen
<a name="service-customizations-changes"></a>

### Amazon S3
<a name="s3"></a>

 Eine wichtige Änderung, die Sie bei der Migration von Version AWS SDK für Go 1 auf Version 2 beachten sollten, betrifft den Umgang mit der serverseitigen Verschlüsselung mit vom Kunden bereitgestellten Schlüsseln (SSE-C). `SSECustomerKey` In AWS SDK für Go Version 1 wurde die Kodierung von `SSECustomerKey` zu Base64 intern vom SDK übernommen. In SDK v2 wurde diese automatische Kodierung entfernt, und es ist nun erforderlich, die Kodierung manuell nach Base64 zu codieren`SSECustomerKey`, bevor sie an das SDK übergeben wird. 

 Beispiel für eine Anpassung: 

```
// V1

import (
  "context"
  "encoding/base64"
  "github.com/aws/aws-sdk-go-v2/config"
  "github.com/aws/aws-sdk-go-v2/service/s3"
)
// ... more code

plainTextKey := "12345678901234567890123456789012" // 32 bytes in length

// calculate md5..

_, err = client.PutObjectWithContext(context.Background(), &s3.PutObjectInput{
    Bucket: aws.String("{{amzn-s3-demo-bucket}}"),
    Key:    aws.String("{{your-object-key}}"),
    Body:                 strings.NewReader("hello-world"),
    SSECustomerKey:       &plainTextKey,
    SSECustomerKeyMD5:    &base64Md5,
    SSECustomerAlgorithm: aws.String("AES256"),
})

// ... more code
```

```
// V2

import (
  "github.com/aws/aws-sdk-go/aws"
  "github.com/aws/aws-sdk-go/aws/session"
  "github.com/aws/aws-sdk-go/service/s3"
)

// ... more code

plainTextKey := "12345678901234567890123456789012" // 32 bytes in length
base64EncodedKey := base64.StdEncoding.EncodeToString([]byte(plainTextKey))

// calculate md5..

_, err = client.PutObject(context.Background(), &s3.PutObjectInput{
    Bucket: aws.String("{{amzn-s3-demo-bucket}}"),
    Key:    aws.String("{{your-object-key}}"),
    Body:                 strings.NewReader("hello-world"),
    SSECustomerKey:       &base64EncodedKey,
    SSECustomerKeyMD5:    &base64Md5,
    SSECustomerAlgorithm: aws.String("AES256"),
})

// ... more code
```