Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Migrazione alla v2 AWS SDK per Go
<a name="migrate-gosdk"></a>

## Versione minima Go
<a name="minimum-go-version"></a>

 AWS SDK per Go Richiede una versione minima di Go 1.23. L'ultima versione di Go può essere scaricata dalla pagina [Download](https://go.dev/dl/). Consulta la [Cronologia](https://go.dev/doc/devel/release) delle versioni per ulteriori informazioni su ogni versione di Go e sulle informazioni pertinenti necessarie per l'aggiornamento. 

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

 AWS SDK per Go È stato aggiornato per sfruttare i moduli Go, che sono diventati la modalità di sviluppo predefinita in Go 1.13. Alcuni pacchetti forniti dall'SDK sono stati modularizzati e sono rispettivamente distribuiti e rilasciati in modo indipendente. Questa modifica consente una migliore modellazione delle dipendenze delle applicazioni e consente all'SDK di fornire nuove caratteristiche e funzionalità che seguono la strategia di controllo delle versioni del modulo Go. 

 Di seguito sono elencati alcuni moduli Go forniti dall'SDK: 


|  Modulo  |  Description  | 
| --- | --- | 
|  github.com/aws/aws-sdk-go-v2  |  Il core dell'SDK  | 
|  github.com/aws/aws-sdk-go-v2/config  |  Caricamento della configurazione condivisa  | 
|  github.com/aws/aws-sdk-go-v2/credentials  |  AWS Fornitori di credenziali  | 
|  github.com/aws/aws-sdk-go-v2/feature/ec2/imds  |  Client del servizio di metadati di Amazon EC2 Instance  | 

 I client di servizio e i moduli di utilità di livello superiore dell'SDK sono annidati nei seguenti percorsi di importazione: 


|  Importa root  |  Description  | 
| --- | --- | 
|  github.com/aws/aws-sdk-go-v2/service/  |  Moduli Service Client  | 
|  github.com/aws/aws-sdk-go-v2/feature/  |  Utilità di alto livello per servizi come Amazon S3 Transfer Manager  | 

## Caricamento della configurazione
<a name="configuration-loading"></a>

 Il pacchetto di [sessione](https://docs.aws.amazon.com/sdk-for-go/api/aws/session/) e le funzionalità associate vengono sostituiti con un sistema di configurazione semplificato fornito dal pacchetto [config.](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/config) Il `config` pacchetto è un modulo Go separato e può essere incluso nelle dipendenze dell'applicazione con. `go get` 

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

 [La [sessione. NEW, session.](https://docs.aws.amazon.com/sdk-for-go/api/aws/session/#New)](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)[, e [Session.must deve essere](https://docs.aws.amazon.com/sdk-for-go/api/aws/session/#Must) migrato a config. LoadDefaultConfig](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/config#LoadDefaultConfig). 

 Il `config` pacchetto fornisce diverse funzioni di supporto che aiutano a sovrascrivere il caricamento della configurazione condivisa a livello di codice. I nomi di queste funzioni sono preceduti da un'opzione `With` seguita da un'opzione che sostituiscono. Diamo un'occhiata ad alcuni esempi di come migrare l'utilizzo del pacchetto. `session` 

 Per ulteriori informazioni sul caricamento della configurazione condivisa, consulta[Configurare l'SDK](configure-gosdk.md). 

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

#### Migrazione da a NewSession LoadDefaultConfig
<a name="migrating-from-newsession-to-loaddefaultconfig"></a>

 L'esempio seguente mostra come viene migrato l'utilizzo di parametri `session.NewSession` senza argomenti aggiuntivi. `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
}
```

#### Migrazione da NewSession con le opzioni AWS.config
<a name="migrating-from-newsession-with-awsconfig-options"></a>

 L'esempio mostra come migrare l'override dei valori durante il caricamento della configurazione. `aws.Config` È possibile fornire una o più funzioni di `config.With*` supporto per `config.LoadDefaultConfig` sovrascrivere i valori di configurazione caricati. [In questo esempio la AWS regione viene sostituita dall'utilizzo della configurazione. `us-west-2` WithRegion](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/config#WithRegion)funzione di supporto. 

```
// 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
}
```

#### Migrazione da NewSessionWithOptions
<a name="migrating-from-newsessionwithoptions"></a>

 Questo esempio mostra come migrare i valori di override durante il caricamento della configurazione. È possibile fornire zero o più funzioni di `config.With*` supporto per `config.LoadDefaultConfig` sovrascrivere i valori di configurazione caricati. In questo esempio mostriamo come sovrascrivere il profilo di destinazione utilizzato durante il caricamento della configurazione condivisa dell' AWS SDK. 

```
// 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
}
```

## Mocking e `*iface`
<a name="mocking-and-iface"></a>

 I `*iface` pacchetti e le interfacce in esso contenuti (ad esempio [S3iFace.S3api](https://docs.aws.amazon.com/sdk-for-go/api/service/s3/s3iface/#S3API)) sono stati rimossi. Queste definizioni di interfaccia non sono stabili poiché vengono interrotte ogni volta che un servizio aggiunge una nuova operazione. 

 L'utilizzo di `*iface` deve essere sostituito da interfacce definite dal chiamante con ambito per le operazioni di servizio utilizzate: 

```
// 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)
}
```

 Per ulteriori informazioni, consulta [Test unitario con la AWS SDK per Go v2](unit-testing.md). 

## Credenziali e fornitori di credenziali
<a name="credentials--credential-providers"></a>

 [Il pacchetto [aws/credentials](https://docs.aws.amazon.com/sdk-for-go/api/aws/credentials/) e i provider di credenziali associati sono stati trasferiti nella posizione del pacchetto delle credenziali.](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials) Il `credentials` pacchetto è un modulo Go che si recupera utilizzando. `go get` 

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

 La versione AWS SDK per Go v2 aggiorna i AWS Credential Provider per fornire un'interfaccia coerente per il recupero delle credenziali. AWS [Ogni provider implementa aws. CredentialsProvider](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws#CredentialsProvider)interfaccia, che definisce un `Retrieve` metodo che restituisce un`(aws.Credentials, error)`. [aws.Credentials](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws#Credentials) [che è analogo al tipo v1 Credentials.value. AWS SDK per Go](https://docs.aws.amazon.com/sdk-for-go/api/aws/credentials/#Value) 

 È necessario `aws.CredentialsProvider` avvolgere [gli oggetti con aws. CredentialsCache](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws#CredentialsCache)per consentire la memorizzazione nella cache delle credenziali. Si usa [NewCredentialsCache](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws#NewCredentialsCache)per costruire un oggetto. `aws.CredentialsCache` Per impostazione predefinita, le credenziali configurate da `config.LoadDefaultConfig` sono racchiuse con. `aws.CredentialsCache` 

 La tabella seguente elenca le modifiche alla posizione dei provider di AWS credenziali dalla AWS SDK per Go v1 alla v2. 


|  Name  |  Importazione V1  |  Importazione V2  | 
| --- | --- | --- | 
|  Credenziali del ruolo Amazon EC2 IAM  |  github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds  |  github.com/aws/aws-sdk-go-v2/credentials/ec2rolecreds  | 
|  Credenziali degli endpoint  |  github.com/aws/aws-sdk-go/aws/credentials/endpointcreds  |  github.com/aws/aws-sdk-go-v2/credentials/endpointcreds  | 
|  Credenziali di processo  |  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  | 

### Credenziali statiche
<a name="static-credentials"></a>

 Applicazioni che utilizzano [credenziali. ](https://docs.aws.amazon.com/sdk-for-go/api/aws/credentials//#NewStaticCredentials)NewStaticCredentials[per costruire credenziali statiche a livello di codice devono utilizzare credenziali. NewStaticCredentialsProvider](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials#NewStaticCredentialsProvider). 

#### Esempio
<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
}
```

### Credenziali del ruolo Amazon EC2 IAM
<a name="ec2-iam-role-credentials"></a>

 [È necessario migrare l'utilizzo [NewCredentials](https://docs.aws.amazon.com/sdk-for-go/api/aws/credentials/ec2rolecreds/#NewCredentials)e l'utilizzo di [NewCredentialsWithClient](https://docs.aws.amazon.com/sdk-for-go/api/aws/credentials/ec2rolecreds/#NewCredentialsWithClient)New.](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/ec2rolecreds#New) 

 Il `ec2rolecreds` pacchetto utilizza le opzioni funzionali `ec2rolecreds.New` di [EC2RoleCreds.options come input, consentendoti](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/ec2rolecreds#Options) di sovrascrivere lo specifico client Amazon EC2 Instance Metadata Service da utilizzare o di sovrascrivere la finestra di scadenza delle credenziali. 

#### Esempio
<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
}
```

### Credenziali degli endpoint
<a name="endpoint-credentials"></a>

 [È necessario migrare l'utilizzo [NewCredentialsClient](https://docs.aws.amazon.com/sdk-for-go/api/aws/credentials/endpointcreds/#NewCredentialsClient)e l'utilizzo [NewProviderClient](https://docs.aws.amazon.com/sdk-for-go/api/aws/credentials/endpointcreds/#NewProviderClient)di New.](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/endpointcreds#New) 

 La `New` funzione del `endpointcreds` pacchetto accetta un argomento di tipo stringa contenente l'URL di un endpoint HTTP o HTTPS da cui recuperare le credenziali e le opzioni funzionali di [EndpointCreds.options per modificare il provider delle credenziali e sovrascrivere impostazioni](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/endpointcreds#Options) di configurazione specifiche. 

### Credenziali di processo
<a name="process-credentials"></a>

 È necessario migrare l'utilizzo di [NewCredentials[NewCredentialsCommand](https://docs.aws.amazon.com/sdk-for-go/api/aws/credentials/processcreds/#NewCredentialsCommand)](https://docs.aws.amazon.com/sdk-for-go/api/aws/credentials/processcreds/#NewCredentials), e [NewCredentialsTimeout](https://docs.aws.amazon.com/sdk-for-go/api/aws/credentials/processcreds/#NewCredentialsTimeout)utilizzare [NewProvider](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/processcreds#New)o. [NewProviderCommand](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/processcreds#NewProviderCommand) 

 La `NewProvider` funzione del `processcreds` pacchetto accetta un argomento di stringa che è il comando da eseguire nella shell dell'ambiente host e le opzioni funzionali di [Options](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/processcreds#Options) per modificare il provider delle credenziali e sovrascrivere impostazioni di configurazione specifiche. 

 `NewProviderCommand`richiede un'implementazione dell'[NewCommandBuilder](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/processcreds#NewCommandBuilder)interfaccia che definisce comandi di processo più complessi che potrebbero accettare uno o più argomenti della riga di comando o avere determinati requisiti dell'ambiente di esecuzione. [DefaultNewCommandBuilder](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/processcreds#DefaultNewCommandBuilder)implementa questa interfaccia e definisce un generatore di comandi per un processo che richiede più argomenti della riga di comando. 

#### Esempio
<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 Credenziali
<a name="stslong-credentials"></a>

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

 È necessario migrare l'utilizzo di [NewCredentials](https://docs.aws.amazon.com/sdk-for-go/api/aws/credentials/stscreds/#NewCredentials)e da utilizzare. [NewCredentialsWithClient[NewAssumeRoleProvider](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/stscreds#NewAssumeRoleProvider)](https://docs.aws.amazon.com/sdk-for-go/api/aws/credentials/stscreds/#NewCredentialsWithClient) 

 La `NewAssumeRoleProvider` funzione del `stscreds` pacchetto deve essere chiamata con un [STS.Client](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/sts#Client) e il AWS Identity and Access Management Role ARN deve essere assunto dalle credenziali configurate fornite`sts.Client`. È inoltre possibile fornire una serie di opzioni funzionali o [AssumeRoleOptions](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/stscreds#AssumeRoleOptions)modificare altre impostazioni opzionali del provider. 

##### Esempio
<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>

 È necessario migrare l'utilizzo di [NewWebIdentityCredentials[NewWebIdentityRoleProvider](https://docs.aws.amazon.com/sdk-for-go/api/aws/credentials/stscreds/#NewWebIdentityRoleProvider)](https://docs.aws.amazon.com/sdk-for-go/api/aws/credentials/stscreds/#NewWebIdentityCredentials), e [NewWebIdentityRoleProviderWithToken](https://docs.aws.amazon.com/sdk-for-go/api/aws/credentials/stscreds/#NewWebIdentityRoleProviderWithToken)da utilizzare [NewWebIdentityRoleProvider](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/stscreds#NewWebIdentityRoleProvider). 

 La `NewWebIdentityRoleProvider` funzione del `stscreds` pacchetto deve essere chiamata con un [STS.Client](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/sts#Client) e l' AWS Identity and Access Management ARN del ruolo deve essere assunto utilizzando le credenziali configurate fornite `sts.Client` e un'implementazione di a [IdentityTokenRetriever](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/stscreds#IdentityTokenRetriever)per fornire il token 2.0 o OAuth OpenID Connect ID. [IdentityTokenFile](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/stscreds#IdentityTokenFile)è un file `IdentityTokenRetriever` che può essere utilizzato per fornire il token di identità Web da un file che si trova nel file system host dell'applicazione. È inoltre possibile fornire una serie di opzioni funzionali [WebIdentityRoleOptions](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/stscreds#WebIdentityRoleOptions)per modificare altre impostazioni opzionali per il provider. 

##### Esempio
<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
}
```

## Client di servizio
<a name="service-clients"></a>

 AWS SDK per Go fornisce moduli client di servizio annidati nel percorso di `github.com/aws/aws-sdk-go-v2/service` importazione. Ogni client di servizio è contenuto in un pacchetto Go che utilizza l'identificatore univoco di ogni servizio. La tabella seguente fornisce alcuni esempi di percorsi di importazione dei servizi in. AWS SDK per Go


|  Nome del servizio  |  Percorso di importazione V1  |  Percorso di importazione V2  | 
| --- | --- | --- | 
|  Simple Storage Service (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 Registri Amazon  |  github.com/aws/aws-sdk-go/service/cloudwatchlogs  |  github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs  | 

 Ogni pacchetto client di servizio è un modulo Go con versione indipendente. Per aggiungere il client di servizio come dipendenza dell'applicazione, utilizzate il `go get` comando con il percorso di importazione del servizio. Ad esempio, per aggiungere il client Amazon S3 alle tue dipendenze, usa 

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

### Costruzione del cliente
<a name="client-construction"></a>

 È possibile creare client AWS SDK per Go utilizzando le funzioni `New` o il `NewFromConfig` costruttore nel pacchetto del client. Durante la migrazione dalla AWS SDK per Go v1, si consiglia di utilizzare la `NewFromConfig` variante, che restituirà un nuovo client di servizio utilizzando i valori di un. `aws.Config` Il `aws.Config` valore sarà stato creato durante il caricamento della configurazione condivisa dell'SDK utilizzando. `config.LoadDefaultConfig` Per i dettagli sulla creazione di client di servizio, consulta[Usa la AWS SDK per Go v2 con i servizi AWS](use-services.md). 

#### Esempio 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)
```

#### Esempio 2: sovrascrivere le impostazioni del client
<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"
})
```

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

 Il pacchetto [endpoints](https://docs.aws.amazon.com/sdk-for-go/api/aws/endpoints/) non esiste più in. AWS SDK per Go Ogni client di servizio ora incorpora i metadati AWS degli endpoint richiesti nel pacchetto client. Ciò riduce la dimensione binaria complessiva delle applicazioni compilate non includendo più i metadati degli endpoint per i servizi non utilizzati dall'applicazione. 

 Inoltre, ogni servizio ora espone la propria interfaccia per la risoluzione degli endpoint in. `EndpointResolverV2` Ogni API utilizza un set unico di parametri per un servizio`EndpointParameters`, i cui valori provengono dall'SDK da varie posizioni quando viene richiamata un'operazione. 

 Per impostazione predefinita, i client del servizio utilizzano la AWS regione configurata per risolvere l'endpoint del servizio per la regione di destinazione. Se l'applicazione richiede un endpoint personalizzato, è possibile specificare un comportamento personalizzato sul `EndpointResolverV2` campo della `aws.Config` struttura. Se la tua applicazione implementa un [EndPoints.resolver](https://docs.aws.amazon.com/sdk-for-go/api/aws/endpoints/#Resolver) personalizzato, devi migrarlo per renderlo conforme a questa nuova interfaccia per servizio. 

 Per ulteriori informazioni sugli endpoint e sull'implementazione di un resolver personalizzato, consulta. [Configurazione degli endpoint client](configure-endpoints.md) 

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

 AWS SDK per Go Supporta un comportamento di autenticazione più avanzato, che consente l'uso di nuove funzionalità di AWS servizio come codecatalyst e S3 Express One Zone. Inoltre, questo comportamento può essere personalizzato in base al cliente. 

### Richiamo delle operazioni API
<a name="invoking-api-operations"></a>

 Il numero di metodi operativi dei client di servizio è stato ridotto in modo significativo. I `<OperationName>` metodi `<OperationName>Request``<OperationName>WithContext`, e sono stati tutti consolidati in un unico metodo operativo,`<OperationName>`. 

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

 L'esempio seguente mostra come le chiamate all' PutObject operazione Amazon S3 verrebbero migrate dalla AWS SDK per Go v1 alla v2. 

```
// 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
})
```

### Tipi di dati di servizio
<a name="service-data-types"></a>

 I tipi di input e output di primo livello di un'operazione si trovano nel pacchetto client del servizio. I tipi di input e output per una determinata operazione seguono lo schema di `<OperationName>Input` e`<OperationName>Output`, where `OperationName` è il nome dell'operazione che si sta richiamando. Ad esempio, la forma di input e output per l' PutObject operazione Amazon S3 sono [PutObjectInput](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/s3#PutObjectInput)e [PutObjectOutput](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/s3#PutObjectOutput)rispettivamente. 

 Tutti gli altri tipi di dati di servizio, diversi dai tipi di input e output, sono stati migrati al `types` pacchetto situato nella gerarchia dei percorsi di importazione dei pacchetti del client di servizio. [Ad esempio, s3. AccessControlPolicy](https://docs.aws.amazon.com/sdk-for-go/api/service/s3/#AccessControlPolicy)type si trova ora in [types. AccessControlPolicy](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/s3/types#AccessControlPolicy). 

#### Valori di enumerazione
<a name="enumeration-values"></a>

 L'SDK ora offre un'esperienza digitata per tutti i campi di enumerazione delle API. Invece di utilizzare un valore letterale di stringa copiato dalla documentazione di riferimento dell'API di servizio, ora puoi utilizzare uno dei tipi concreti presenti nel pacchetto del client del servizio. `types` Ad esempio, puoi fornire all' PutObjectInput operazione Amazon S3 un ACL da applicare a un oggetto. Nella AWS SDK per Go v1, questo parametro era un tipo. `*string` Nel AWS SDK per Go, questo parametro è ora un [tipo. ObjectCannedACL.](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/s3/types#ObjectCannedACL) Il `types` pacchetto fornisce le costanti generate per i valori di enumerazione validi che possono essere assegnati a questo campo. [Ad esempio tipi. ObjectCannedACLPrivate](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/s3/types#ObjectCannedACLPrivate)è la costante per il valore ACL predefinito «privato». Questo valore può essere utilizzato al posto della gestione delle costanti di stringa all'interno dell'applicazione. 

### Parametri del puntatore
<a name="pointer-parameters"></a>

 La AWS SDK per Go v1 richiedeva che i riferimenti ai puntatori fossero passati per tutti i parametri di input alle operazioni di servizio. La AWS SDK per Go v2 ha semplificato l'esperienza con la maggior parte dei servizi eliminando la necessità di passare i valori di input come puntatori, ove possibile. Questa modifica significa che le operazioni di molti client di servizio non richiedono più che l'applicazione trasmetta riferimenti ai puntatori per i seguenti tipi:`uint8`,,,`uint16`,`uint32`,, `int8``int16`,`int32`. `float32` `float64` `bool` Allo stesso modo, i tipi di elementi slice e map sono stati aggiornati di conseguenza per indicare se i relativi elementi devono essere passati come riferimenti puntatori. 

 Il pacchetto [aws](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws) contiene funzioni di supporto per la creazione di puntatori per i tipi integrati di Go, questi helper dovrebbero essere usati per gestire più facilmente la creazione di tipi di puntatori per questi tipi di Go. Allo stesso modo, vengono forniti metodi di supporto per dereferenziare in modo sicuro i valori dei puntatori per questi tipi. Ad esempio, la funzione [AWS.String](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws#String) converte da ⇒. `string` `*string` [Al contrario, l'aws. ToString](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws#ToString)converte da `*string` ⇒. `string` Quando si aggiorna l'applicazione dalla AWS SDK per Go v1 alla v2, è necessario migrare l'utilizzo degli helper per la conversione dai tipi di puntatore alle varianti senza puntatore. [Ad esempio, aws. StringValue](https://docs.aws.amazon.com/sdk-for-go/api/aws/#StringValue)deve essere aggiornato a`aws.ToString`. 

### Tipi di errori
<a name="errors-types"></a>

 Sfrutta appieno la AWS SDK per Go funzionalità di risoluzione degli errori [introdotta in Go 1.13](https://go.dev/blog/go1.13-errors). I servizi che modellano le risposte agli errori hanno generato tipi disponibili nel `types` pacchetto del client che possono essere utilizzati per verificare se un errore operativo del client è stato causato da uno di questi tipi. Ad esempio, l'`GetObject`operazione Amazon S3 può restituire un `NoSuchKey` errore se si tenta di recuperare una chiave oggetto che non esiste. [Puoi utilizzare [Errors.as](https://pkg.go.dev/errors#As) per verificare se l'errore di operazione restituito è di tipo A. NoSuchKey](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/s3/types#NoSuchKey)errore. Se un servizio non modella un tipo specifico di errore, puoi utilizzare la [fucina. APIError](https://pkg.go.dev/github.com/aws/smithy-go#APIError)tipo di interfaccia per controllare il codice di errore e il messaggio restituiti dal servizio. Questa funzionalità sostituisce [awSerr.Error e l'altra funzionalità [awserr](https://docs.aws.amazon.com/sdk-for-go/api/aws/awserr/)](https://docs.aws.amazon.com/sdk-for-go/api/aws/awserr//#Error) della v1. AWS SDK per Go Per ulteriori informazioni sulla gestione degli errori, vedere. [Gestione degli errori nella AWS SDK per Go V2](handle-errors.md) 

#### Esempio
<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
}
```

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

 Gli impaginatori per le operazioni di servizio non vengono più richiamati come metodi sul client del servizio. Per utilizzare un paginatore per un'operazione, è necessario creare un impaginatore per un'operazione utilizzando uno dei metodi del costruttore del paginatore. [Ad esempio, per utilizzare paginate sull'operazione Amazon `ListObjectsV2` S3, è necessario creare il relativo impaginatore utilizzando s3. NewListObjectsPaginatore V2.](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/s3#NewListObjectsV2Paginator) Questo costruttore restituisce un [ListObjectsV2Paginator](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/s3#ListObjectsV2Paginator) che fornisce i metodi `HasMorePages` e `NextPage` per determinare se ci sono più pagine da recuperare e richiama l'operazione per recuperare rispettivamente la pagina successiva. Maggiori dettagli sull'utilizzo degli impaginatori SDK sono disponibili all'indirizzo. [Utilizzo di Operation Paginators](using.md#using-operation-paginators) 

 Diamo un'occhiata a un esempio di come migrare da un paginatore AWS SDK per Go v1 all'equivalente v2. AWS SDK per Go 

#### Esempio
<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>

 I camerieri addetti alle operazioni di servizio non vengono più richiamati come metodi sul client del servizio. Per utilizzare un cameriere devi prima creare il tipo di cameriere desiderato, quindi invocare il metodo di attesa. Ad esempio, per attendere che esista un Amazon S3 Bucket, devi creare un cameriere. `BucketExists` [Usa s3. ](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/s3#NewBucketExistsWaiter)NewBucketExistsWaiter[costruttore per creare un s3. BucketExistsWaiter](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/s3#BucketExistsWaiter). `s3.BucketExistsWaiter`Fornisce un `Wait` metodo che può essere utilizzato per attendere che un bucket diventi disponibile. 

### Richieste predefinite
<a name="presigned-requests"></a>

 L'SDK V1 supportava tecnicamente la preassegnazione di *qualsiasi* operazione AWS SDK, tuttavia, ciò non rappresenta con precisione ciò che è effettivamente supportato a livello di servizio (e in realtà la maggior parte delle AWS operazioni di servizio non supporta la prefirma). 

 AWS SDK per Go risolve questo problema esponendo `PresignClient` implementazioni specifiche nei pacchetti di servizi con operazioni presignabili specifiche per il supporto. APIs 

 **[Nota: se a un servizio manca il supporto di prefirma per un'operazione che stavi utilizzando con successo in SDK v1, faccelo sapere segnalando un problema su. GitHub](https://github.com/aws/aws-sdk-go-v2/issues)** 

 Utilizza [Presign](https://docs.aws.amazon.com/sdk-for-go/api/aws/request/#Request.Presign) e [PresignRequest](https://docs.aws.amazon.com/sdk-for-go/api/aws/request/#Request.PresignRequest)deve essere convertito per utilizzare client di prefirma specifici del servizio. 

 L'esempio seguente mostra come migrare la prefirma di una richiesta S3: 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)
}
```

## Richiedi la personalizzazione
<a name="request-customization"></a>

 L'API monolitica [Request.Request](https://docs.aws.amazon.com/sdk-for-go/api/aws/request/#Request) è stata ricompartimentalizzata. 

### Ingresso/uscita dell'operazione
<a name="operation-inputoutput"></a>

 I `Request` campi opachi `Params` e`Data`, che contengono rispettivamente le strutture di input e output dell'operazione, sono ora accessibili all'interno di specifiche fasi del middleware come input/output: 

 Gestori di richieste che fanno riferimento e devono essere migrati al middleware. `Request.Params` `Request.Data` 

#### migrando `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))
    // ...
}
```

#### migrando `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)
    // ...
}
```

### richiesta/risposta HTTP
<a name="http-requestresponse"></a>

 I `HTTPResponse` campi `HTTPRequest` e di `Request` sono ora esposti in fasi middleware specifiche. Poiché il middleware è indipendente dal trasporto, è necessario eseguire un'asserzione di tipo sull'input o sull'output del middleware per rivelare la richiesta o la risposta HTTP sottostante. 

 Gestori di richieste che fanno riferimento e che devono essere migrati al middleware. `Request.HTTPRequest` `Request.HTTPResponse` 

#### migrando `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", "..."))
    // ...
}
```

### fasi del gestore
<a name="handler-phases"></a>

 Le fasi del middleware SDK v2 sono le successive alle fasi del gestore v1. 

 La tabella seguente fornisce una mappatura approssimativa delle fasi del gestore v1 alla loro posizione equivalente all'interno dello stack di middleware V2: 


|  nome del gestore v1  |  fase middleware v2  | 
| --- | --- | 
|  Convalida  |  Inizializzazione  | 
|  Creazione  |  Serializza  | 
|  Sign  |  Finalizzare  | 
|  Invia  |  n/a (1)  | 
|  ValidateResponse  |  Deserializza  | 
|  Demolisci sceriffo  |  Deserializza  | 
|  UnmarshalMetadata  |  Deserializza  | 
|  UnmarshalError  |  Deserializza  | 
|  Riprova  |  Finalizza, dopo il "Retry" middleware (2)  | 
|  AfterRetry  |  Finalizza, prima del "Retry" middleware, post- (2,3) next.HandleFinalize()  | 
|  CompleteAttempt  |  Finalizzazione, fine del passaggio  | 
|  Completa  |  Inizializzazione, inizio del passaggio, post- next.HandleInitialize() (3)  | 

 (1) La `Send` fase in v1 è effettivamente il round-trip del client HTTP incluso nella v2. Questo comportamento è controllato dal campo sulle opzioni del `HTTPClient` client. 

 (2) Qualsiasi middleware dopo il `"Retry"` middleware nella fase Finalize farà parte del ciclo di riprova. 

 (3) Lo «stack» del middleware al momento dell'operazione è integrato in una funzione di gestione decorata ripetutamente. Ogni gestore è responsabile della chiamata a quello successivo nella catena. Ciò significa implicitamente che una fase del middleware può agire anche DOPO che è stata chiamata la fase successiva. 

 Ad esempio, per la fase di inizializzazione, che si trova in cima allo stack, ciò significa che i middleware di inizializzazione che agiscono dopo aver chiamato il gestore successivo operano effettivamente alla fine della richiesta: 

```
// 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
}
```

## Funzionalità
<a name="features"></a>

### Servizio di metadati Amazon EC2 Instance
<a name="ec2-instance-metadata-service"></a>

 AWS SDK per Go Fornisce un client Amazon EC2 Instance Metadata Service (IMDS) che puoi utilizzare per interrogare l'IMDS locale durante l'esecuzione della tua applicazione su un'istanza Amazon. EC2 Il client IMDS è un modulo Go separato che può essere aggiunto all'applicazione utilizzando 

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

 Il costruttore del client e le operazioni del metodo sono state aggiornate per corrispondere al design degli altri client di servizi SDK. 

#### Esempio
<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>

 Il gestore di trasferimenti Amazon S3 è disponibile per la gestione simultanea di caricamenti e download di oggetti. Questo pacchetto si trova in un modulo Go esterno al percorso di importazione del client di servizio. Questo modulo può essere recuperato utilizzando`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)e [s3. ](https://docs.aws.amazon.com/sdk-for-go/api/service/s3/s3manager/#NewUploaderWithClient)NewUploaderWithClient[sono stati sostituiti con il gestore dei metodi del costruttore. NewUploader](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/feature/s3/manager#)per creare un client Upload manager. 

 [s3. NewDownloader](https://docs.aws.amazon.com/sdk-for-go/api/service/s3/s3manager/#NewDownloader)e [s3. ](https://docs.aws.amazon.com/sdk-for-go/api/service/s3/s3manager/#NewDownloaderWithClient)NewDownloaderWithClient[sono stati sostituiti con un gestore di metodi a singolo costruttore. NewDownloader](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/feature/s3/manager#NewDownloader)per creare un client di gestione dei download. 

### Utilità di CloudFront firma Amazon
<a name="cflong-signing-utilities"></a>

 AWS SDK per Go Fornisce utilità di CloudFront firma Amazon in un modulo Go esterno al percorso di importazione del client di servizio. Questo modulo può essere recuperato utilizzando. `go get` 

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

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

 A partire da AWS SDK per Go, il client di crittografia Amazon S3 è un modulo separato in [AWS Crypto](https://docs.aws.amazon.com/aws-crypto-tools) Tools. L'ultima versione del client di crittografia S3 per Go, 3.x, è ora disponibile all'indirizzo. [GitHub](https://github.com/aws/amazon-s3-encryption-client-go) Questo modulo può essere recuperato utilizzando: `go get` 

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

 I due client separati `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)) e `DecryptionClient` ([v1, [v2](https://docs.aws.amazon.com/sdk-for-go/api/service/s3/s3crypto/#DecryptionClientV2)](https://docs.aws.amazon.com/sdk-for-go/api/service/s3/s3crypto/#DecryptionClient)) sono APIs stati sostituiti con un singolo client, [S3 EncryptionClient V3](https://pkg.go.dev/github.com/aws/amazon-s3-encryption-client-go/v3/client#S3EncryptionClientV3), che espone sia la funzionalità di crittografia che quella di decrittografia. 

 Come altri client di servizio, l'operazione è stata condensata: AWS SDK per Go APIs 
+  La `GetObject``GetObjectRequest`, e la `GetObjectWithContext` decrittografia APIs sono sostituite da. [GetObject](https://pkg.go.dev/github.com/aws/amazon-s3-encryption-client-go/v3/client#S3EncryptionClientV3.GetObject) 
+  La `PutObjectWithContext` crittografia `PutObject``PutObjectRequest`, e viene sostituita APIs da. [PutObject](https://pkg.go.dev/github.com/aws/amazon-s3-encryption-client-go/v3/client#S3EncryptionClientV3.PutObject) 

 Per informazioni su come migrare alla versione principale 3.x del client di crittografia, consulta [questa](https://docs.aws.amazon.com/amazon-s3-encryption-client/latest/developerguide/go-v3-migration.html) guida. 

## Modifiche alle personalizzazioni del servizio
<a name="service-customizations-changes"></a>

### Simple Storage Service (Amazon S3)
<a name="s3"></a>

 Durante la migrazione dalla AWS SDK per Go v1 alla v2, una modifica importante di cui tenere conto riguarda la gestione delle chiavi `SSECustomerKey` utilizzate per la crittografia lato server con chiavi fornite dal cliente (SSE-C). Nella AWS SDK per Go v1, la codifica di Base64 veniva gestita internamente dall'SDK. `SSECustomerKey` In SDK v2, questa codifica automatica è stata rimossa e ora è necessario codificarla manualmente in Base64 prima di passarla all'SDK. `SSECustomerKey` 

 Esempio di regolazione: 

```
// 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
```