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à.
# Utilizzo dell'oggetto contestuale Lambda per recuperare le informazioni sulla funzione Go
Questo oggetto fornisce i metodi e le proprietà con informazioni sulla chiamata, sulla funzione e sull'ambiente di esecuzione. Quando Lambda esegue la funzione, passa un oggetto Context al [gestore](golang-handler.md). Per utilizzare l'oggetto context nel tuo handler, puoi facoltativamente dichiararlo come parametro di input per il tuo handler. L'oggetto contesto è necessario se desideri eseguire le operazioni indicate di seguito nell'handler:
+ È necessario accedere a tutte le [variabili, i metodi o le proprietà globali](#golang-context-library) offerti dall'oggetto context. Questi metodi e proprietà sono utili per attività come determinare l'entità che ha richiamato la funzione o misurare il tempo di invocazione della funzione, come illustrato in. [Accesso alle informazioni relative al contesto di invocazione](#golang-context-access)
+ È necessario utilizzare il per effettuare chiamate AWS SDK per Go verso altri servizi. L'oggetto context è un parametro di input importante per la maggior parte di queste chiamate. Per ulteriori informazioni, consulta [Utilizzo del contesto nelle inizializzazioni e nelle AWS chiamate dei client SDK](#golang-context-sdk).
**Topics**
+ [Variabili supportate, metodi e proprietà nell'oggetto contesto](#golang-context-library)
+ [Accesso alle informazioni relative al contesto di invocazione](#golang-context-access)
+ [Utilizzo del contesto nelle inizializzazioni e nelle AWS chiamate dei client SDK](#golang-context-sdk)
## Variabili supportate, metodi e proprietà nell'oggetto contesto
La libreria contesto Lambda offre le variabili globali, i metodi e le proprietà indicate di seguito.
**Variabili globali**
+ `FunctionName`: il nome della funzione Lambda.
+ `FunctionVersion`: la [versione](configuration-versions.md) della funzione.
+ `MemoryLimitInMB`: la quantità di memoria allocata per la funzione.
+ `LogGroupName`: il gruppo di log per la funzione.
+ `LogStreamName`: il flusso di log per l'istanza della funzione.
**Metodi del contesto**
+ `Deadline`: restituisce la data del timeout dell'esecuzione in millisecondi Unix.
**Proprietà del contesto**
+ `InvokedFunctionArn`: l'ARN (Amazon Resource Name) utilizzato per richiamare la funzione. Indica se l'invoker ha specificato un numero di versione o un alias.
+ `AwsRequestID`: l'identificatore della richiesta di invocazione.
+ `Identity`: (app per dispositivi mobili) Informazioni relative all'identità Amazon Cognito che ha autorizzato la richiesta.
+ `ClientContext`: (app per dispositivi mobili) Contesto client fornito a Lambda dall'applicazione client.
## Accesso alle informazioni relative al contesto di invocazione
Le funzioni Lambda hanno accesso ai metadata relativi al loro ambiente e alla richiesta di invocazione. È possibile accedervi mediante il [Package context](https://golang.org/pkg/context/). Qualora il gestore includa `context.Context` come parametro, Lambda inserirà le informazioni relative alla funzione nella proprietà `Value` del contesto. È necessario importare la libreria `lambdacontext` per accedere ai contenuti dell'oggetto `context.Context`.
```
package main
import (
"context"
"log"
"github.com/aws/aws-lambda-go/lambda"
"github.com/aws/aws-lambda-go/lambdacontext"
)
func CognitoHandler(ctx context.Context) {
lc, _ := lambdacontext.FromContext(ctx)
log.Print(lc.Identity.CognitoIdentityPoolID)
}
func main() {
lambda.Start(CognitoHandler)
}
```
Nell'esempio sopra riportato, `lc` è la variabile utilizzata per usufruire delle informazioni acquisite dall'oggetto contesto e `log.Print(lc.Identity.CognitoIdentityPoolID)` stampa le informazioni, in questo caso il CognitoPoolID.
L'esempio che segue illustra come utilizzare l'oggetto contesto per monitorare il tempo impiegato per il completamento della funzione Lambda. In tal modo è possibile analizzare le aspettative prestazionali e, se necessario modificare la funzione di conseguenza.
```
package main
import (
"context"
"log"
"time"
"github.com/aws/aws-lambda-go/lambda"
)
func LongRunningHandler(ctx context.Context) (string, error) {
deadline, _ := ctx.Deadline()
deadline = deadline.Add(-100 * time.Millisecond)
timeoutChannel := time.After(time.Until(deadline))
for {
select {
case <- timeoutChannel:
return "Finished before timing out.", nil
default:
log.Print("hello!")
time.Sleep(50 * time.Millisecond)
}
}
}
func main() {
lambda.Start(LongRunningHandler)
}
```
## Utilizzo del contesto nelle inizializzazioni e nelle AWS chiamate dei client SDK
Se l'handler deve utilizzare il per effettuare chiamate AWS SDK per Go ad altri servizi, includi l'oggetto context come input per l'handler. In AWS, è consigliabile passare l'oggetto del contesto nella maggior parte delle chiamate all'SDK AWS. Ad esempio, la `PutObject` chiamata Amazon S3 accetta l'oggetto context (`ctx`) come primo argomento:
```
// Upload an object to S3
_, err = s3Client.PutObject(ctx, &s3.PutObjectInput{
...
})
```
Per inizializzare correttamente i client SDK, puoi anche utilizzare l'oggetto del contesto per caricare la configurazione corretta prima di passare l'oggetto di configurazione al client:
```
// Load AWS SDK configuration using the default credential provider chain
cfg, err := config.LoadDefaultConfig(ctx)
...
s3Client = s3.NewFromConfig(cfg)
```
Se desideri inizializzare i client SDK al di fuori dell'handler principale (ad esempio durante la fase di inizializzazione), puoi passare un oggetto del contesto segnaposto:
```
func init() {
// Initialize the S3 client outside of the handler, during the init phase
cfg, err := config.LoadDefaultConfig(context.TODO())
...
s3Client = s3.NewFromConfig(cfg)
}
```
Se inizializzi i client in questo modo, assicurati di inserire l'oggetto contestuale corretto nelle chiamate SDK dall'handler principale.