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à.

# Compilazione di funzioni Lambda con Go
<a name="lambda-golang"></a>

Go è implementato in modo diverso rispetto ad altri runtime gestiti. Poiché Go viene compilato nativamente in un file binario eseguibile, non richiede un runtime linguistico dedicato. Usa un [runtime solo per il sistema operativo](runtimes-provided.md) (la famiglia di runtime `provided`) per distribuire le funzioni Go in Lambda.

**Topics**
+ [

## Supporto per il runtime Go
](#golang-al1)
+ [

## Strumenti e librerie
](#golang-libraries)
+ [

# Definisci i gestori di funzioni Lambda in Go
](golang-handler.md)
+ [

# Utilizzo dell'oggetto contestuale Lambda per recuperare le informazioni sulla funzione Go
](golang-context.md)
+ [

# Distribuisci funzioni Lambda per Go con gli archivi di file .zip
](golang-package.md)
+ [

# Distribuzione delle funzioni Go Lambda con immagini di container
](go-image.md)
+ [

# Utilizzo dei livelli per le funzioni Lambda in Go
](golang-layers.md)
+ [

# Registrare e monitorare le funzioni Lambda con Go
](golang-logging.md)
+ [

# Strumentazione del codice Go in AWS Lambda
](golang-tracing.md)

## Supporto per il runtime Go
<a name="golang-al1"></a>

Il runtime gestito Go 1.x per Lambda è [obsoleto](lambda-runtimes.md#runtime-support-policy). Se hai funzioni che utilizzano il runtime Go 1.x, devi eseguire la migrazione delle tue funzioni a `provided.al2023` o `provided.al2`. I `provided.al2` runtime `provided.al2023` and offrono diversi vantaggi`go1.x`, tra cui il supporto per l'architettura arm64 (processori AWS Graviton2), binari più piccoli e tempi di invoke leggermente più rapidi.

Per questa migrazione, non sono necessarie modifiche al codice. Le uniche modifiche richieste riguardano la modalità di creazione del pacchetto di implementazione e il runtime utilizzato per creare la funzione. *Per ulteriori informazioni, consulta la sezione [Migrazione AWS Lambda delle funzioni dal runtime Go1.x al runtime personalizzato su Amazon Linux 2](https://aws.amazon.com/blogs/compute/migrating-aws-lambda-functions-from-the-go1-x-runtime-to-the-custom-runtime-on-amazon-linux-2/) sul blog di Compute AWS .*


| Name | Identificatore | Sistema operativo | Data di ritiro | Blocco creazione funzioni | Blocco aggiornamento funzioni | 
| --- | --- | --- | --- | --- | --- | 
|  Runtime solo per il sistema operativo  |  `provided.al2023`  |  Amazon Linux 2023  |   30 giugno 2029   |   31 luglio 2029   |   31 agosto 2029   | 
|  Runtime solo per il sistema operativo  |  `provided.al2`  |  Amazon Linux 2  |   31 luglio 2026   |   31 agosto 2026   |   30 settembre 2026   | 

## Strumenti e librerie
<a name="golang-libraries"></a>

Lambda fornisce i seguenti strumenti e librerie per il runtime Go:
+ [AWS SDK per Go v2](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2): L' AWS SDK ufficiale per il linguaggio di programmazione Go.
+ [github. com/aws/aws-lambda-go/lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda): L'implementazione del modello di programmazione Lambda per Go. [Questo pacchetto viene utilizzato da AWS Lambda per richiamare il gestore.](golang-handler.md)
+ [github. ](https://github.com/aws/aws-lambda-go/tree/master/lambdacontext)com/aws/aws-lambda-go/lambdacontext[: Aiutanti per accedere alle informazioni di contesto dall'oggetto context.](golang-context.md)
+ [github. com/aws/aws-lambda-go/events](https://github.com/aws/aws-lambda-go/tree/master/events): Questa libreria fornisce definizioni dei tipi per le integrazioni di sorgenti di eventi comuni.
+ [github. com/aws/aws-lambda-go/cmd/build-lambda-zip](https://github.com/aws/aws-lambda-go/tree/master/cmd/build-lambda-zip): questo strumento può essere utilizzato per creare un archivio di file.zip su Windows.

Per ulteriori informazioni, vedere on. [aws-lambda-go](https://github.com/aws/aws-lambda-go) GitHub

Lambda fornisce le seguenti applicazioni di esempio per il runtime di Go:

**Applicazioni Lambda di esempio in Go**
+ [go-al2](https://github.com/aws-samples/sessions-with-aws-sam/tree/master/go-al2): una funzione hello world che restituisce l'indirizzo IP pubblico. Questa app utilizza il runtime personalizzato `provided.al2`.
+ [blank-go](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-go) — Una funzione Go che mostra l'uso delle librerie Go di Lambda, la registrazione, le variabili di ambiente e l'SDK. AWS Questa app utilizza il runtime `go1.x`.

# Definisci i gestori di funzioni Lambda in Go
<a name="golang-handler"></a>

Il *gestore* di funzioni Lambda è il metodo nel codice della funzione che elabora gli eventi. Quando viene richiamata la funzione, Lambda esegue il metodo del gestore. La funzione viene eseguita fino a quando il gestore non restituisce una risposta, termina o scade.

Questa pagina descrive come lavorare con i gestori di funzioni Lambda in Go, inclusa la configurazione del progetto, le convenzioni di denominazione e le migliori pratiche. Questa pagina include anche un esempio di funzione Go Lambda che raccoglie informazioni su un ordine, produce una ricevuta in un file di testo e inserisce questo file in un bucket Amazon Simple Storage Service (S3). Per informazioni su come distribuire una funzione dopo averla scritta, consulta o. [Distribuisci funzioni Lambda per Go con gli archivi di file .zip](golang-package.md) [Distribuzione delle funzioni Go Lambda con immagini di container](go-image.md)

**Topics**
+ [

## Configurazione di Go Handler
](#golang-handler-setup)
+ [

## Esempio di codice della funzione Lambda
](#golang-example-code)
+ [

## Convenzioni di denominazione dei gestori
](#golang-handler-naming)
+ [

## Definizione e accesso all'oggetto evento di input
](#golang-example-input)
+ [

## Accesso e utilizzo dell'oggetto contestuale Lambda
](#golang-example-context)
+ [

## Firme dell'handler valide per gli handler Go
](#golang-handler-signatures)
+ [

## Utilizzo della AWS SDK per Go versione v2 nell'handler
](#golang-example-sdk-usage)
+ [

## Accesso alle variabili d'ambiente
](#golang-example-envvars)
+ [

## Utilizzo dello stato globale
](#golang-handler-state)
+ [

## Procedure consigliate di codice per le funzioni Go Lambda
](#go-best-practices)

## Configurazione di Go Handler
<a name="golang-handler-setup"></a>

Una funzione Lambda scritta in [Go](https://golang.org/) viene creata come eseguibile di Go. È possibile inizializzare un progetto di funzione Go Lambda nello stesso modo in cui inizializzi qualsiasi altro progetto Go utilizzando il seguente comando: `go mod init`

```
go mod init example-go
```

Ecco il nome del `example-go` modulo. Puoi sostituire con un valore qualsiasi. Questo comando inizializza il progetto e genera il `go.mod` file che elenca le dipendenze del progetto.

Utilizzate il `go get` comando per aggiungere eventuali dipendenze esterne al progetto. Nel codice della funzione Lambda è necessario includere il pacchetto [github.com/aws/aws-lambda-go/lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda) che implementa il modello di programmazione Lambda per Go. Installa il pacchetto con il seguente comando `go get`:

```
go get github.com/aws/aws-lambda-go
```

Il codice della funzione dovrebbe risiedere in un file Go. In questo esempio viene assegnato un nome a questo file`main.go`. In questo file, implementa la logica della funzione principale in un metodo di gestione, oltre a una funzione `main()` che chiama questo handler.

## Esempio di codice della funzione Lambda
<a name="golang-example-code"></a>

Il seguente esempio di codice della funzione Go Lambda raccoglie le informazioni su un ordine, produce una ricevuta in un file di testo e inserisce questo file in un bucket Amazon S3.

**Example Funzione Lambda `main.go`**  

```
package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"os"
	"strings"

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

type Order struct {
	OrderID string  `json:"order_id"`
	Amount  float64 `json:"amount"`
	Item    string  `json:"item"`
}

var (
	s3Client *s3.Client
)

func init() {
	// Initialize the S3 client outside of the handler, during the init phase
	cfg, err := config.LoadDefaultConfig(context.TODO())
	if err != nil {
		log.Fatalf("unable to load SDK config, %v", err)
	}

	s3Client = s3.NewFromConfig(cfg)
}

func uploadReceiptToS3(ctx context.Context, bucketName, key, receiptContent string) error {
	_, err := s3Client.PutObject(ctx, &s3.PutObjectInput{
		Bucket: &bucketName,
		Key:    &key,
		Body:   strings.NewReader(receiptContent),
	})
	if err != nil {
		log.Printf("Failed to upload receipt to S3: %v", err)
		return err
	}
	return nil
}

func handleRequest(ctx context.Context, event json.RawMessage) error {
	// Parse the input event
	var order Order
	if err := json.Unmarshal(event, &order); err != nil {
		log.Printf("Failed to unmarshal event: %v", err)
		return err
	}

	// Access environment variables
	bucketName := os.Getenv("RECEIPT_BUCKET")
	if bucketName == "" {
		log.Printf("RECEIPT_BUCKET environment variable is not set")
		return fmt.Errorf("missing required environment variable RECEIPT_BUCKET")
	}

	// Create the receipt content and key destination
	receiptContent := fmt.Sprintf("OrderID: %s\nAmount: $%.2f\nItem: %s",
		order.OrderID, order.Amount, order.Item)
	key := "receipts/" + order.OrderID + ".txt"

	// Upload the receipt to S3 using the helper method
	if err := uploadReceiptToS3(ctx, bucketName, key, receiptContent); err != nil {
		return err
	}

	log.Printf("Successfully processed order %s and stored receipt in S3 bucket %s", order.OrderID, bucketName)
	return nil
}

func main() {
	lambda.Start(handleRequest)
}
```

Questo file `main.go` contiene le sezioni seguenti:
+ `package main`: in Go, il pacchetto contenente la funzione `func main()` deve essere sempre denominato `main`.
+ Blocco `import`: utilizza questo blocco per includere le librerie richieste dalla funzione Lambda.
+ `type Order struct {}`block: definisce la forma dell'evento di input previsto in questa struttura Go.
+ `var ()`block: usa questo blocco per definire tutte le variabili globali che utilizzerai nella tua funzione Lambda.
+ `func init() {}`: includi in questo metodo qualsiasi codice che desideri che Lambda esegua durante la [fase di inizializzazione](lambda-runtime-environment.md#runtimes-lifecycle-ib). `init()`
+ `func uploadReceiptToS3(...) {}`: questo è un metodo helper a cui fa riferimento il metodo dell'handler principale `handleRequest`.
+ `func handleRequest(ctx context.Context, event json.RawMessage) error {}`: questo è il **metodo dell'handler principale**, che contiene la logica principale dell'applicazione.
+ `func main() {}`: questo è un punto di ingresso obbligatorio per il tuo handler Lambda. L'argomento del metodo `lambda.Start()` è il metodo principale dell'handler.

Affinché questa funzione funzioni correttamente, il suo [ruolo di esecuzione](lambda-intro-execution-role.md) deve consentire l'`s3:PutObject`azione. Inoltre, assicuratevi di definire la variabile di `RECEIPT_BUCKET` ambiente. Dopo una chiamata riuscita, il bucket Amazon S3 dovrebbe contenere un file di ricevuta.

## Convenzioni di denominazione dei gestori
<a name="golang-handler-naming"></a>

Per le funzioni Lambda in Go, puoi usare qualsiasi nome per l'handler. In questo esempio, il nome del metodo dell'handler è `handleRequest`. Per fare riferimento al valore del gestore nel codice, puoi usare la variabile di ambiente `_HANDLER`.

Per le funzioni Go implementate mediante un [pacchetto di implementazione .zip](golang-package.md), il file eseguibile che contiene il codice della funzione deve essere denominato `bootstrap`. Il file `bootstrap` deve trovarsi nella posizione root del file .zip. Per le funzioni Go implementate mediante una [immagine del container](go-image.md#go-image-provided), per il file eseguibile è possibile usare qualsiasi nome.

## Definizione e accesso all'oggetto evento di input
<a name="golang-example-input"></a>

JSON è il formato di input più comune e standard per le funzioni Lambda. In questo esempio, la funzione prevede un input simile a quanto segue:

```
{
    "order_id": "12345",
    "amount": 199.99,
    "item": "Wireless Headphones"
}
```

Quando si utilizzano le funzioni Lambda in Go, è possibile definire la forma dell'evento di input previsto come struttura Go. In questo esempio, definiamo una struttura per rappresentare un`Order`:

```
type Order struct {
    OrderID string  `json:"order_id"`
    Amount  float64 `json:"amount"`
    Item    string  `json:"item"`
}
```

Questa struttura corrisponde alla forma di input prevista. Dopo aver definito la struttura, puoi scrivere una firma dell'handler che includa un tipo JSON generico compatibile con la libreria standard [encoding/json](https://pkg.go.dev/encoding/json). [Puoi quindi deserializzarlo nella tua struttura usando la funzione func Unmarshal.](https://golang.org/pkg/encoding/json/#Unmarshal) Ciò è illustrato nelle prime righe dell'handler:

```
func handleRequest(ctx context.Context, event json.RawMessage) error {
    // Parse the input event
    var order Order
    if err := json.Unmarshal(event, &order); err != nil {
        log.Printf("Failed to unmarshal event: %v", err)
        return err
    ...
}
```

Dopo questa deserializzazione, è possibile accedere ai campi della variabile. `order` Ad esempio, `order.OrderID` recupera il valore di `"order_id"` dall'input originale.

**Nota**  
Il `encoding/json` pacchetto può accedere solo ai campi esportati. Affinché siano esportati, i nomi dei campi nella struttura dell'evento devono avere l'iniziale maiuscola.

## Accesso e utilizzo dell'oggetto contestuale Lambda
<a name="golang-example-context"></a>

L'[oggetto contesto](golang-context.md): contiene informazioni sulla chiamata, sulla funzione e sull'ambiente di esecuzione. In questo esempio, abbiamo dichiarato questa variabile come `ctx` nella firma dell'handler:

```
func handleRequest(ctx context.Context, event json.RawMessage) error {
    ...
}
```

L'input `ctx context.Context` è un argomento facoltativo nell'handler della funzione. Per ulteriori informazioni sulle firme dell'handler accettate, consulta [Firme dell'handler valide per gli handler Go](#golang-handler-signatures).

Se si effettuano chiamate ad altri servizi utilizzando l'AWSSDK, l'oggetto context è necessario in alcune aree chiave. Ad esempio, per inizializzare correttamente i client SDK, è possibile caricare la configurazione AWS SDK corretta utilizzando l'oggetto di contesto come segue:

```
// Load AWS SDK configuration using the default credential provider chain
    cfg, err := config.LoadDefaultConfig(ctx)
```

Le stesse chiamate SDK possono richiedere l'oggetto context come input. Ad esempio, la `s3Client.PutObject` chiamata accetta l'oggetto context come primo argomento:

```
// Upload the receipt to S3
    _, err = s3Client.PutObject(ctx, &s3.PutObjectInput{
        ...
    })
```

Oltre alle richieste AWS SDK, puoi anche utilizzare l'oggetto context per il monitoraggio delle funzioni. Per ulteriori informazioni sulla copia di oggetti, consulta la sezione [Utilizzo dell'oggetto contestuale Lambda per recuperare le informazioni sulla funzione Go](golang-context.md).

## Firme dell'handler valide per gli handler Go
<a name="golang-handler-signatures"></a>

Durante la creazione di un gestore della funzione Lambda in Go sono disponibili diverse opzioni, ma è necessario attenersi alle seguenti regole:
+ Il gestore deve essere una funzione.
+ Il gestore può richiedere da 0 a 2 argomenti. Nel caso di due argomenti, il primo argomento deve implementare `context.Context`.
+ Il gestore può restituire da 0 a 2 argomenti. Nel caso di un singolo valore restituito, deve implementare `error`. Nel caso di due valori restituiti, il secondo valore deve implementare `error`.

Di seguito sono elencate le firme del gestore valide. `TIn` e `TOut` rappresentano le tipologie compatibili con la libreria standard *encoding/json*. Per ulteriori informazioni su come deserializzare queste tipologie, consultare [func Unmarshal](https://golang.org/pkg/encoding/json/#Unmarshal).
+ 

  ```
  func ()
  ```
+ 

  ```
  func () error
  ```
+ 

  ```
  func () (TOut, error)
  ```
+ 

  ```
  func (TIn) error
  ```
+ 

  ```
  func (TIn) (TOut, error)
  ```
+ 

  ```
  func (context.Context) error
  ```
+ 

  ```
  func (context.Context) (TOut, error)
  ```
+ 

  ```
  func (context.Context, TIn) error
  ```
+ 

  ```
  func (context.Context, TIn) (TOut, error)
  ```

## Utilizzo della AWS SDK per Go versione v2 nell'handler
<a name="golang-example-sdk-usage"></a>

Spesso, utilizzerai le funzioni Lambda per interagire o aggiornare altre AWS risorse. Il modo più semplice per interfacciarsi con queste risorse è usare la AWS SDK per Go v2.

**Nota**  
La AWS SDK per Go (v1) è in modalità manutenzione e terminerà il supporto il 31 luglio 2025. In futuro, si consiglia di utilizzare solo la AWS SDK per Go v2.

Per aggiungere dipendenze SDK alla tua funzione, usa il `go get` comando per i client SDK specifici di cui hai bisogno. Nel codice di esempio precedente, abbiamo usato la `config` libreria e la libreria. `s3` Aggiungi queste dipendenze eseguendo i seguenti comandi nella directory che contiene i file `go.mod` e `main.go `:

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

Quindi, importa le dipendenze di conseguenza nel blocco di importazione della tua funzione:

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

Quando utilizzi l'SDK nel tuo handler, configura i tuoi client con le impostazioni corrette. Il modo più semplice per farlo è utilizzare la catena di provider di [credenziali predefinita](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html#credentialProviderChain). Questo esempio illustra un modo per caricare questa configurazione:

```
// Load AWS SDK configuration using the default credential provider chain
    cfg, err := config.LoadDefaultConfig(ctx)
    if err != nil {
        log.Printf("Failed to load AWS SDK config: %v", err)
        return err
    }
```

Dopo aver caricato questa configurazione nella variabile `cfg`, è possibile passare la variabile nelle istanze del client. Il codice di esempio crea un'istanza di un client Amazon S3 come segue:

```
// Create an S3 client
    s3Client := s3.NewFromConfig(cfg)
```

In questo esempio, abbiamo inizializzato il nostro client Amazon S3 nella `init()` funzione per evitare di doverlo inizializzare ogni volta che richiamiamo la nostra funzione. Il problema è che nella `init()` funzione, Lambda non ha accesso all'oggetto context. Come soluzione alternativa, puoi inserire un segnaposto come `context.TODO()` durante la fase di inizializzazione. Successivamente, quando effettui una chiamata utilizzando il client, inserisci l'oggetto contestuale completo. Questa soluzione alternativa è descritta anche in[Utilizzo del contesto nelle inizializzazioni e nelle AWS chiamate dei client SDK](golang-context.md#golang-context-sdk).

Dopo aver configurato e inizializzato il client SDK, puoi utilizzarlo per interagire con altri servizi. AWS Il codice di esempio richiama l'`PutObject`API Amazon S3 nel modo seguente:

```
_, err = s3Client.PutObject(ctx, &s3.PutObjectInput{
    Bucket: &bucketName,
    Key:    &key,
    Body:   strings.NewReader(receiptContent),
})
```

## Accesso alle variabili d'ambiente
<a name="golang-example-envvars"></a>

Nel codice dell'handler, puoi fare riferimento a qualsiasi [variabile di ambiente](configuration-envvars.md) utilizzando il metodo `os.Getenv()`. In questo esempio, facciamo riferimento alla variabile di `RECEIPT_BUCKET` ambiente definita utilizzando la seguente riga di codice:

```
// Access environment variables
    bucketName := os.Getenv("RECEIPT_BUCKET")
    if bucketName == "" {
        log.Printf("RECEIPT_BUCKET environment variable is not set")
        return fmt.Errorf("missing required environment variable RECEIPT_BUCKET")
    }
```

## Utilizzo dello stato globale
<a name="golang-handler-state"></a>

Per evitare di creare nuove risorse ogni volta che richiami la funzione, puoi dichiarare e modificare le variabili globali all'esterno del codice dell'handler della funzione Lambda. Queste variabili globali vengono definite in un blocco o in un'`var`istruzione. Inoltre, l'handler può dichiarare una funzione `init()` che viene eseguita durante la fase di [inizializzazione](lambda-runtime-environment.md#runtimes-lifecycle-ib). Il metodo `init` si comporta allo stesso modo in AWS Lambda come nei programmi Go standard.

## Procedure consigliate di codice per le funzioni Go Lambda
<a name="go-best-practices"></a>

Segui le linee guida riportate nell'elenco seguente per utilizzare le best practice di codifica durante la creazione delle funzioni Lambda:
+ **Separare il gestore Lambda dalla logica principale.** In questo modo è possibile creare una funzione di cui è più semplice eseguire l'unit test.
+ **Ridurre la complessità delle dipendenze.** Preferire framework più semplici che si caricano velocemente all'avvio del [contesto di esecuzione](lambda-runtime-environment.md).
+ **Ridurre al minimo le dimensioni del pacchetto di implementazione al fine di soddisfare le esigenze di runtime.** In questo modo viene ridotta la quantità di tempo necessaria per il download del pacchetto e per la relativa decompressione prima dell'invocazione.

**Sfruttare il riutilizzo del contesto di esecuzione per migliorare le prestazioni della funzione.** Inizializzare i client SDK e le connessioni al database all'esterno del gestore di funzioni e memorizzare localmente nella cache gli asset statici nella directory `/tmp`. Le chiamate successive elaborate dalla stessa istanza della funzione possono riutilizzare queste risorse. Ciò consente di risparmiare sui costi riducendo i tempi di esecuzione delle funzioni.

Per evitare potenziali perdite di dati tra le chiamate, non utilizzare il contesto di esecuzione per archiviare dati utente, eventi o altre informazioni con implicazioni di sicurezza. Se la funzione si basa su uno stato mutabile che non può essere archiviato in memoria all'interno del gestore, considerare la possibilità di creare una funzione separata o versioni separate di una funzione per ogni utente.

**Utilizzare una direttiva keep-alive per mantenere le connessioni persistenti.** Lambda elimina le connessioni inattive nel tempo. Se si tenta di riutilizzare una connessione inattiva quando si richiama una funzione, si verificherà un errore di connessione. Per mantenere la connessione persistente, utilizzare la direttiva keep-alive associata al runtime. Per un esempio, vedere [Riutilizzo delle connessioni con Keep-Alive in Node.js](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-reusing-connections.html).

**Utilizzare [le variabili di ambiente](configuration-envvars.md) per passare i parametri operativi alla funzione.** Se ad esempio si scrive in un bucket Amazon S3 anziché impostare come hard-coded il nome del bucket in cui si esegue la scrittura, configurare tale nome come una variabile di ambiente.

**Evita di usare invocazioni ricorsive** nella tua funzione Lambda, in cui la funzione si richiama da sola o avvia un processo che potrebbe richiamare nuovamente la funzione. Ciò potrebbe provocare un volume non desiderato di invocazioni della funzione e un aumento dei costi. Se noti un volume indesiderato di invocazioni, imposta immediatamente la simultaneità riservata della funzione su `0` per interrompere tutte le invocazioni della funzione mentre si aggiorna il codice.

**Non utilizzare API non documentate e non pubbliche** nel codice della funzione Lambda. Per i tempi di esecuzione gestiti AWS Lambda, Lambda applica periodicamente aggiornamenti di sicurezza e funzionalità alle API interne di Lambda. Questi aggiornamenti API interni potrebbero essere incompatibili con le versioni precedenti, causando conseguenze indesiderate come errori di chiamata se la funzione ha una dipendenza su queste API non pubbliche. Consulta il [riferimento all'API](https://docs.aws.amazon.com/lambda/latest/api/welcome.html) per un elenco di API disponibili pubblicamente.

**Scrivi un codice idempotente.** La scrittura di un codice idempotente per le tue funzioni garantisce che gli eventi duplicati vengano gestiti allo stesso modo. Il tuo codice dovrebbe convalidare correttamente gli eventi e gestire con garbo gli eventi duplicati. Per ulteriori informazioni, consulta [Come posso rendere idempotente la mia funzione Lambda?](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-function-idempotent/).

# Utilizzo dell'oggetto contestuale Lambda per recuperare le informazioni sulla funzione Go
<a name="golang-context"></a>

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
<a name="golang-context-library"></a>

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
<a name="golang-context-access"></a>

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
<a name="golang-context-sdk"></a>

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.

# Distribuisci funzioni Lambda per Go con gli archivi di file .zip
<a name="golang-package"></a>

Il codice della AWS Lambda funzione è costituito da script o programmi compilati e dalle relative dipendenze. Utilizza un *pacchetto di implementazione* per distribuire il codice della funzione a Lambda. Lambda supporta due tipi di pacchetti di implementazione: immagini di container e archivi di file .zip. 

Questa pagina descrive come creare un file.zip come pacchetto di distribuzione per il runtime Go, quindi utilizzare il file.zip per distribuire il codice della funzione su Console di gestione AWS, AWS Command Line Interface (AWS CLI) e (). AWS Lambda AWS Serverless Application Model AWS SAM

Nota che Lambda utilizza le autorizzazioni dei file POSIX, quindi potresti aver bisogno di [impostare le autorizzazioni per la cartella del pacchetto di implementazione](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-deployment-package-errors/) prima di creare l'archivio di file .zip.

**Topics**
+ [

## Creazione di un file .zip su macOS e Linux
](#golang-package-mac-linux)
+ [

## Creazione di un file .zip su Windows
](#golang-package-windows)
+ [

## Creazione e aggiornamento delle funzioni Lambda di Go utilizzando file .zip
](#golang-package-create-function)

## Creazione di un file .zip su macOS e Linux
<a name="golang-package-mac-linux"></a>

I passaggi seguenti mostrano come compilare il file eseguibile utilizzando il comando `go build` e creare un pacchetto di implementazione con file .zip per Lambda. [Prima di compilare il codice, assicurati di aver installato il pacchetto lambda da.](https://github.com/aws/aws-lambda-go/tree/master/lambda) GitHub Questo modulo fornisce un'implementazione dell'interfaccia di runtime, che gestisce l'interazione tra Lambda e il codice della funzione. Per scaricare questa libreria, esegui il comando seguente.

```
go get github.com/aws/aws-lambda-go/lambda
```

Se la tua funzione utilizza il AWS SDK per Go, scarica il set standard di moduli SDK, insieme a tutti i client API AWS di servizio richiesti dall'applicazione. Per informazioni su come installare l'SDK for Go, [consulta Guida introduttiva AWS SDK per Go alla versione 2](https://github.com/aws/aws-sdk-go-v2?tab=readme-ov-file#getting-started).

### Utilizzo della famiglia di runtime forniti
<a name="golang-package-mac-linux-al2"></a>

Go è implementato in modo diverso rispetto ad altri runtime gestiti. Poiché Go viene compilato nativamente in un file binario eseguibile, non richiede un runtime linguistico dedicato. Usa un [runtime solo per il sistema operativo](runtimes-provided.md) (la famiglia di runtime `provided`) per distribuire le funzioni Go in Lambda.

**Creazione di un pacchetto di implementazione .zip (macOS/Linux)**

1. Nella directory del progetto contenente il file `main.go` dell'applicazione, compila il tuo eseguibile. Tenere presente quanto segue:
   + L'eseguibile deve essere denominato `bootstrap`. Per ulteriori informazioni, consulta [Convenzioni di denominazione dei gestori](golang-handler.md#golang-handler-naming).
   + Imposta l'[architettura del set di istruzioni](foundation-arch.md) di destinazione. I runtime del sistema operativo supportano sia arm64 sia x86\$164.
   + Puoi usare il tag facoltativo `lambda.norpc` per escludere il componente Remote Procedure Call (RPC) della libreria [lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda). Il componente RPC è richiesto solo quando si utilizza il runtime Go 1.x obsoleto. L'esclusione dell'RPC riduce le dimensioni del pacchetto di implementazione.

   Per l'architettura arm64:

   ```
   GOOS=linux GOARCH=arm64 go build -tags lambda.norpc -o bootstrap main.go
   ```

   Per l'architettura x86\$164:

   ```
   GOOS=linux GOARCH=amd64 go build -tags lambda.norpc -o bootstrap main.go
   ```

1. (Opzionale) Potrebbe essere necessario compilare pacchetti con `CGO_ENABLED=0` impostato su Linux:

   ```
   GOOS=linux GOARCH=arm64 CGO_ENABLED=0 go build -o bootstrap -tags lambda.norpc main.go
   ```

   Questo comando crea un pacchetto binario stabile per le versioni standard della libreria C (`libc`) che possono essere diverse su Lambda e su altri dispositivi.

1. Crea un pacchetto di distribuzione comprimendo l'eseguibile in un file .zip.

   ```
   zip myFunction.zip bootstrap
   ```
**Nota**  
Il file `bootstrap` deve trovarsi nella posizione root del file .zip.

1. Crea la funzione . Tenere presente quanto segue:
   + Il file binario deve essere denominato `bootstrap` ma il nome del gestore può essere qualsiasi cosa. Per ulteriori informazioni, consulta [Convenzioni di denominazione dei gestori](golang-handler.md#golang-handler-naming).
   + L'opzione `--architectures` è necessaria solo se si utilizza arm64. Il valore predefinito è x86\$164.
   + Per `--role`, specifica il nome della risorsa Amazon (ARN) del [ruolo di esecuzione](lambda-intro-execution-role.md).

   ```
   aws lambda create-function --function-name myFunction \
   --runtime provided.al2023 --handler bootstrap \
   --architectures arm64 \
   --role arn:aws:iam::111122223333:role/lambda-ex \
   --zip-file fileb://myFunction.zip
   ```

## Creazione di un file .zip su Windows
<a name="golang-package-windows"></a>

I passaggi seguenti mostrano come scaricare [build-lambda-zip](https://github.com/aws/aws-lambda-go/tree/main/cmd/build-lambda-zip)lo strumento per Windows da GitHub, compilare il file eseguibile e creare un pacchetto di distribuzione.zip.

**Nota**  
Se non è già presente, è necessario installare [git](https://git-scm.com/) e quindi aggiungere il percorso dell'eseguibile `git` alla variabile di ambiente di Windows `%PATH%`.

Prima di compilare il codice, assicurati di aver installato la libreria [lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda) da. GitHub Per scaricare questa libreria, esegui il comando seguente.

```
go get github.com/aws/aws-lambda-go/lambda
```

Se la tua funzione utilizza il AWS SDK per Go, scarica il set standard di moduli SDK, insieme a tutti i client API AWS di servizio richiesti dall'applicazione. Per informazioni su come installare l'SDK for Go, [consulta Guida introduttiva AWS SDK per Go alla versione 2](https://aws.github.io/aws-sdk-go-v2/docs/getting-started/).

### Utilizzo della famiglia di runtime forniti
<a name="golang-package-windows-al2"></a>

Go è implementato in modo diverso rispetto ad altri runtime gestiti. Poiché Go viene compilato nativamente in un file binario eseguibile, non richiede un runtime linguistico dedicato. Usa un [runtime solo per il sistema operativo](runtimes-provided.md) (la famiglia di runtime `provided`) per distribuire le funzioni Go in Lambda.

**Creazione di un pacchetto di implementazione .zip (Windows)**

1. Scarica lo **build-lambda-zip**strumento da. GitHub

   ```
   go install github.com/aws/aws-lambda-go/cmd/build-lambda-zip@latest
   ```

1. Utilizza lo strumento dal tuo `GOPATH` per creare un file .zip. Se si dispone di un'installazione predefinita di Go, lo strumento si trova solitamente in `%USERPROFILE%\Go\bin`. Altrimenti, vai alla posizione in cui è stato installato il runtime Go ed esegui una delle seguenti operazioni:

------
#### [ cmd.exe ]

   In cmd.exe, esegui una delle operazioni riportate, a seconda della tua [architettura del set di istruzioni](foundation-arch.md) di destinazione. I runtime del sistema operativo supportano sia arm64 sia x86\$164.

   Puoi usare il tag facoltativo `lambda.norpc` per escludere il componente Remote Procedure Call (RPC) della libreria [lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda). Il componente RPC è richiesto solo quando si utilizza il runtime Go 1.x obsoleto. L'esclusione dell'RPC riduce le dimensioni del pacchetto di implementazione.

**Example - Per l'architettura x86\$164**  

   ```
   set GOOS=linux
   set GOARCH=amd64
   set CGO_ENABLED=0
   go build -tags lambda.norpc -o bootstrap main.go
   %USERPROFILE%\Go\bin\build-lambda-zip.exe -o myFunction.zip bootstrap
   ```

**Example - Per l'architettura arm64**  

   ```
   set GOOS=linux
   set GOARCH=arm64
   set CGO_ENABLED=0
   go build -tags lambda.norpc -o bootstrap main.go
   %USERPROFILE%\Go\bin\build-lambda-zip.exe -o myFunction.zip bootstrap
   ```

------
#### [ PowerShell ]

   In PowerShell, esegui una delle seguenti operazioni, a seconda dell'[architettura del set di istruzioni](foundation-arch.md) di destinazione. I runtime del sistema operativo supportano sia arm64 sia x86\$164.

   Puoi usare il tag facoltativo `lambda.norpc` per escludere il componente Remote Procedure Call (RPC) della libreria [lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda). Il componente RPC è richiesto solo quando si utilizza il runtime Go 1.x obsoleto. L'esclusione dell'RPC riduce le dimensioni del pacchetto di implementazione.

   Per l'architettura x86\$164:

   ```
   $env:GOOS = "linux"
   $env:GOARCH = "amd64"
   $env:CGO_ENABLED = "0"
   go build -tags lambda.norpc -o bootstrap main.go
   ~\Go\Bin\build-lambda-zip.exe -o myFunction.zip bootstrap
   ```

   Per l'architettura arm64:

   ```
   $env:GOOS = "linux"
   $env:GOARCH = "arm64"
   $env:CGO_ENABLED = "0"
   go build -tags lambda.norpc -o bootstrap main.go
   ~\Go\Bin\build-lambda-zip.exe -o myFunction.zip bootstrap
   ```

------

1. Crea la funzione . Tenere presente quanto segue:
   + Il file binario deve essere denominato `bootstrap` ma il nome del gestore può essere qualsiasi cosa. Per ulteriori informazioni, consulta [Convenzioni di denominazione dei gestori](golang-handler.md#golang-handler-naming).
   + L'opzione `--architectures` è necessaria solo se si utilizza arm64. Il valore predefinito è x86\$164.
   + Per `--role`, specifica il nome della risorsa Amazon (ARN) del [ruolo di esecuzione](lambda-intro-execution-role.md).

   ```
   aws lambda create-function --function-name myFunction \
   --runtime provided.al2023 --handler bootstrap \
   --architectures arm64 \
   --role arn:aws:iam::111122223333:role/lambda-ex \
   --zip-file fileb://myFunction.zip
   ```

## Creazione e aggiornamento delle funzioni Lambda di Go utilizzando file .zip
<a name="golang-package-create-function"></a>

 Dopo aver creato il pacchetto di implementazione .zip, puoi utilizzarlo per creare una nuova funzione Lambda o aggiornarne una esistente. Puoi distribuire il tuo pacchetto.zip utilizzando la console Lambda, l'API Lambda AWS Command Line Interface e l'API Lambda. Puoi anche creare e aggiornare le funzioni Lambda usando AWS Serverless Application Model (AWS SAM) e CloudFormation. 

La dimensione massima per un pacchetto di implementazione .zip per Lambda è di 250 MB (dopo l'estrazione). Nota che questo limite si applica alla dimensione combinata di tutti i file caricati, inclusi eventuali livelli Lambda.

Il runtime Lambda necessita dell'autorizzazione per leggere i file nel pacchetto di distribuzione. Nella notazione ottale delle autorizzazioni Linux, Lambda richiede 644 permessi per i file non eseguibili (rw-r--r--) e 755 permessi () per le directory e i file eseguibili. rwxr-xr-x

In Linux e macOS, utilizza il comando `chmod` per modificare le autorizzazioni file su file e directory nel pacchetto di implementazione. Ad esempio, per assegnare a un file non eseguibile le autorizzazioni corrette, utilizza il comando seguente.

```
chmod 644 <filepath>
```

Per modificare le autorizzazioni file in Windows, consulta [Set, View, Change, or Remove Permissions on an Object](https://learn.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc731667(v=ws.10)) nella documentazione di Microsoft Windows.

**Nota**  
Se non concedi a Lambda le autorizzazioni necessarie per accedere alle directory nel pacchetto di distribuzione, Lambda imposta le autorizzazioni per tali directory su 755 (). rwxr-xr-x

### Creazione e aggiornamento delle funzioni con file .zip utilizzando la console
<a name="golang-package-create-console"></a>

 Per creare una nuova funzione, devi prima creare la funzione nella console, quindi devi caricare il tuo archivio .zip. Per aggiornare una funzione esistente, apri la pagina relativa alla funzione, quindi segui la stessa procedura per aggiungere il file .zip aggiornato. 

 Se il file .zip ha dimensioni inferiori a 50 MB, è possibile creare o aggiornare una funzione caricando il file direttamente dal computer locale. Per i file .zip di dimensioni superiori a 50 MB, prima è necessario caricare il pacchetto in un bucket Amazon S3. Per istruzioni su come caricare un file in un bucket Amazon S3 utilizzando Console di gestione AWS, consulta la [Guida introduttiva ad Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html). *Per caricare file utilizzando la AWS CLI, consulta [Move objects](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) nella Guida per l'AWS CLI utente.* 

**Nota**  
Non è possibile convertire una funzione di immagine di container esistente per utilizzare un archivio .zip. È necessario creare una nuova funzione.

**Creazione di una nuova funzione (console)**

1. Apri la [pagina Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda e scegli **Crea funzione**.

1. Scegli **Author from scratch** (Crea da zero).

1. In **Basic information (Informazioni di base)** eseguire queste operazioni:

   1. In **Nome funzione**, inserisci il nome della funzione.

   1. In **Runtime**, selezionare `provided.al2023`.

1. (Opzionale) In **Autorizzazioni** espandere **Modifica ruolo di esecuzione predefinito**. Puoi creare un nuovo **ruolo di esecuzione** o utilizzare un ruolo esistente.

1. Scegli **Crea funzione**. Lambda crea una funzione di base "Hello world" utilizzando il runtime scelto.

**Caricamento di un archivio .zip dal computer locale (console)**

1. Nella [pagina Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda, scegli la funzione per cui vuoi caricare il file .zip.

1. Scegli la scheda **Codice**.

1. Nel riquadro **Origine del codice**, scegli **Carica da**.

1. Scegli **File .zip**.

1. Per caricare il file .zip, procedi come segue:

   1. Seleziona **Carica**, quindi seleziona il tuo file .zip nel selettore di file.

   1. Seleziona **Apri**.

   1. Scegli **Save** (Salva).

**Caricamento di un archivio .zip da un bucket Amazon S3 (console)**

1. Nella [pagina Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda, scegli la funzione per cui vuoi caricare un nuovo file .zip.

1. Scegli la scheda **Codice**.

1. Nel riquadro **Origine del codice**, scegli **Carica da**.

1. Scegli **Posizione Amazon S3**.

1. Incolla l'URL del link Amazon S3 del tuo file .zip e scegli **Salva**.

### Creazione e aggiornamento di funzioni con file.zip utilizzando il AWS CLI
<a name="golang-package-create-cli"></a>

 È possibile utilizzare la [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) per creare una nuova funzione o aggiornare una funzione esistente mediante un file .zip. Usa la funzione [create-function](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html) e [update-function-code](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html)i comandi per distribuire il tuo pacchetto .zip. Se il file .zip ha dimensioni inferiori a 50 MB, è possibile caricare il pacchetto .zip da una posizione di file nella macchina di compilazione locale. Per i file di dimensioni maggiori, è necessario caricare il pacchetto .zip da un bucket Amazon S3. *Per istruzioni su come caricare un file su un bucket Amazon S3 utilizzando AWS CLI, consulta [Move objects](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) nella User Guide.AWS CLI * 

**Nota**  
Se carichi il tuo file.zip da un bucket Amazon S3 utilizzando AWS CLI il, il bucket deve trovarsi nella stessa posizione della Regione AWS tua funzione.

 Per creare una nuova funzione utilizzando un file.zip con AWS CLI, devi specificare quanto segue: 
+ Il nome della funzione (`--function-name`)
+ Il runtime della tua funzione (`--runtime`)
+ Il nome della risorsa Amazon (ARN) del [ruolo di esecuzione](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) della funzione (`--role`)
+ Il nome del metodo del gestore nel codice della funzione (`--handler`)

 È inoltre necessario specificare la posizione del file .zip. Se il file .zip si trova in una cartella sulla macchina di compilazione locale, utilizza l'opzione `--zip-file` per specificare il percorso del file, come mostrato nel seguente comando di esempio. 

```
aws lambda create-function --function-name myFunction \
--runtime provided.al2023 --handler bootstrap \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--zip-file fileb://myFunction.zip
```

 Per specificare la posizione del file .zip in un bucket Amazon S3, utilizza l'opzione `--code` illustrata nel seguente comando di esempio. È necessario utilizzare il parametro `S3ObjectVersion` solo per gli oggetti con controllo delle versioni. 

```
aws lambda create-function --function-name myFunction \
--runtime provided.al2023 --handler bootstrap \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--code S3Bucket=amzn-s3-demo-bucket,S3Key=myFileName.zip,S3ObjectVersion=myObjectVersion
```

 Per aggiornare una funzione esistente mediante la CLI, specifica il nome della funzione utilizzando il parametro `--function-name`. È inoltre necessario specificare la posizione del file .zip che desideri utilizzare per aggiornare il codice della funzione. Se il file .zip si trova in una cartella sulla macchina di compilazione locale, utilizza l'opzione `--zip-file` per specificare il percorso del file, come mostrato nel seguente comando di esempio. 

```
aws lambda update-function-code --function-name myFunction \
--zip-file fileb://myFunction.zip
```

 Per specificare la posizione del file .zip in un bucket Amazon S3, utilizza le opzioni `--s3-bucket` e `--s3-key` come illustrato nel seguente comando di esempio. È necessario utilizzare il parametro `--s3-object-version` solo per gli oggetti con controllo delle versioni. 

```
aws lambda update-function-code --function-name myFunction \
--s3-bucket amzn-s3-demo-bucket --s3-key myFileName.zip --s3-object-version myObject Version
```

### Creazione e aggiornamento delle funzioni con file .zip utilizzando l'API Lambda
<a name="golang-package-create-api"></a>

 Per creare e aggiornare le funzioni mediante un archivio di file .zip, utilizza le seguenti operazioni API: 
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)
+ [UpdateFunctionCode](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionCode.html)

### Creazione e aggiornamento di funzioni con file.zip utilizzando AWS SAM
<a name="golang-package-create-sam"></a>

 Il AWS Serverless Application Model (AWS SAM) è un toolkit che aiuta a semplificare il processo di creazione ed esecuzione di applicazioni serverless su. AWS Definisci le risorse per la tua applicazione in un modello YAML o JSON e utilizzi l'interfaccia a riga di AWS SAM comando (AWS SAM CLI) per creare, impacchettare e distribuire le tue applicazioni. Quando crei una funzione Lambda da un AWS SAM modello, crea AWS SAM automaticamente un pacchetto di distribuzione.zip o un'immagine del contenitore con il codice della funzione e le eventuali dipendenze specificate. Per ulteriori informazioni sull'utilizzo AWS SAM per creare e distribuire funzioni Lambda, [consulta la Guida introduttiva AWS Serverless Application Model](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-getting-started.html) *alla AWS SAM* Developer Guide.

È inoltre possibile utilizzare AWS SAM per creare una funzione Lambda utilizzando un archivio di file.zip esistente. Per creare una funzione Lambda utilizzando AWS SAM, puoi salvare il tuo file.zip in un bucket Amazon S3 o in una cartella locale sulla tua macchina di compilazione. *Per istruzioni su come caricare un file su un bucket Amazon S3 utilizzando AWS CLI, consulta [Move objects](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) nella User Guide.AWS CLI * 

 Nel AWS SAM modello, la `AWS::Serverless::Function` risorsa specifica la funzione Lambda. In questa risorsa, imposta le seguenti proprietà per creare una funzione utilizzando un archivio di file .zip: 
+ `PackageType`: imposta il valore su `Zip`
+ `CodeUri`- impostato sull'URI Amazon S3 del codice della funzione, sul percorso della cartella locale o sull'oggetto [FunctionCode](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-function-functioncode.html)
+ `Runtime`: imposta il runtime prescelto

 Inoltre AWS SAM, se il tuo file.zip è più grande di 50 MB, non è necessario caricarlo prima in un bucket Amazon S3. AWS SAM puoi caricare pacchetti.zip fino alla dimensione massima consentita di 250 MB (decompressi) da una posizione sulla macchina di compilazione locale. 

 *Per ulteriori informazioni sulla distribuzione delle funzioni utilizzando il file.zip in AWS SAM, consulta la Guida per gli sviluppatori. [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)AWS SAM * 

**Esempio: utilizzo AWS SAM per creare una funzione Go con provided.al2023**

1. Crea un AWS SAM modello con le seguenti proprietà:
   + **BuildMethod**: specifica il compilatore per l'applicazione. Utilizza `go1.x`.
   + **Runtime**: utilizza `provided.al2023`.
   + **CodeUri**: inserisci il percorso del codice.
   + **Architetture**: usa `[arm64]` per l'architettura arm64. Per l'architettura del set di istruzioni x86\$164, utilizza `[amd64]` oppure rimuovi la proprietà `Architectures`.  
**Example template.yaml**  

   ```
   AWSTemplateFormatVersion: '2010-09-09'
   Transform: 'AWS::Serverless-2016-10-31'
   Resources:
     HelloWorldFunction:
       Type: AWS::Serverless::Function
       Metadata:
         BuildMethod: go1.x
       Properties:
         CodeUri: hello-world/ # folder where your main program resides
         Handler: bootstrap
         Runtime: provided.al2023
         Architectures: [arm64]
   ```

1. Usa il comando [sam build](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-build.html) per compilare l'eseguibile.

   ```
   sam build
   ```

1. Utilizza il comando [sam deploy](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html) per implementare la funzione su Lambda.

   ```
   sam deploy --guided
   ```

### Creazione e aggiornamento di funzioni con file.zip utilizzando CloudFormation
<a name="golang-package-create-cfn"></a>

 È possibile utilizzare CloudFormation per creare una funzione Lambda utilizzando un archivio di file.zip. Per creare una funzione Lambda da un file .zip, devi prima caricare il file su un bucket Amazon S3. *Per istruzioni su come caricare un file su un bucket Amazon S3 utilizzando AWS CLI, consulta [Move objects](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) nella User Guide.AWS CLI *

Nel CloudFormation modello, la `AWS::Lambda::Function` risorsa specifica la funzione Lambda. In questa risorsa, imposta le seguenti proprietà per creare una funzione utilizzando un archivio di file .zip:
+ `PackageType`: imposta il valore su `Zip`
+ `Code`: inserisci il nome del bucket Amazon S3 e il nome del file .zip nei campi `S3Bucket` e `S3Key`
+ `Runtime`: imposta il runtime prescelto

 Il file.zip che CloudFormation genera non può superare i 4 MB. *Per ulteriori informazioni sulla distribuzione delle funzioni utilizzando il file.zip in CloudFormation, [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)consultate la Guida per l'utente.CloudFormation * 

# Distribuzione delle funzioni Go Lambda con immagini di container
<a name="go-image"></a>

Esistono due modi per creare un'immagine di container per una funzione Lambda in Go:
+ [Utilizzo di un'immagine di AWS base solo per il sistema operativo](#go-image-provided)

  Go è implementato in modo diverso rispetto ad altri runtime gestiti. Poiché Go viene compilato nativamente in un file binario eseguibile, non richiede un runtime linguistico dedicato. Usa un'[immagine di base solo per il sistema operativo](images-create.md#runtimes-images-provided) per creare immagini Go per Lambda. Per rendere l'immagine compatibile con Lambda, devi includere il pacchetto `aws-lambda-go/lambda` nell'immagine.
+ [Utilizzo di un'immagine non di base AWS](#go-image-other)

  È possibile utilizzare un'immagine di base alternativa da un altro registro del container, come ad esempio Alpine Linux o Debian. Puoi anche utilizzare un'immagine personalizzata creata dalla tua organizzazione. Per rendere l'immagine compatibile con Lambda, devi includere il pacchetto `aws-lambda-go/lambda` nell'immagine.

**Suggerimento**  
Per ridurre il tempo necessario all'attivazione delle funzioni del container Lambda, consulta [Utilizzo di compilazioni a più fasi](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#use-multi-stage-builds) nella documentazione Docker. Per creare immagini di container efficienti, segui le [best practice per scrivere file Docker](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/).

Questa pagina spiega come creare, testare e implementare le immagini di container per Lambda.

## AWS immagini di base per l'implementazione delle funzioni Go
<a name="go-image-base"></a>

Go è implementato in modo diverso rispetto ad altri runtime gestiti. Poiché Go viene compilato nativamente in un file binario eseguibile, non richiede un runtime linguistico dedicato. Usa un'[immagine di base solo per il sistema operativo](images-create.md#runtimes-images-provided) per distribuire le funzioni Go su Lambda.


| Name | Identificatore | Sistema operativo | Data di ritiro | Blocco creazione funzioni | Blocco aggiornamento funzioni | 
| --- | --- | --- | --- | --- | --- | 
|  Runtime solo per il sistema operativo  |  `provided.al2023`  |  Amazon Linux 2023  |   30 giugno 2029   |   31 luglio 2029   |   31 agosto 2029   | 
|  Runtime solo per il sistema operativo  |  `provided.al2`  |  Amazon Linux 2  |   31 luglio 2026   |   31 agosto 2026   |   30 settembre 2026   | 

Galleria pubblica di Amazon Elastic Container Registry: [gallery.ecr. aws/lambda/provided](https://gallery.ecr.aws/lambda/provided)

## Client di interfaccia di runtime per Go
<a name="go-image-clients"></a>

Il pacchetto `aws-lambda-go/lambda` include un'implementazione dell'interfaccia di runtime. Per esempi di come utilizzare `aws-lambda-go/lambda` nell'immagine, consulta le sezioni [Utilizzo di un'immagine di AWS base solo per il sistema operativo](#go-image-provided) o [Utilizzo di un'immagine non di base AWS](#go-image-other).

## Utilizzo di un'immagine di AWS base solo per il sistema operativo
<a name="go-image-provided"></a>

Go è implementato in modo diverso rispetto ad altri runtime gestiti. Poiché Go viene compilato nativamente in un file binario eseguibile, non richiede un runtime linguistico dedicato. Utilizza un'[immagine di base solo per il sistema operativo](images-create.md#runtimes-images-provided) per creare immagini di container per le funzioni Go.


| Tag | Runtime | Sistema operativo | Dockerfile | Raggiunta obsolescenza | 
| --- | --- | --- | --- | --- | 
| al2023 | Runtime solo per il sistema operativo | Amazon Linux 2023 | [Dockerfile per Runtime solo per sistema operativo su GitHub](https://github.com/aws/aws-lambda-base-images/blob/provided.al2023/Dockerfile.provided.al2023) |   30 giugno 2029   | 
| al2 | Runtime solo per il sistema operativo | Amazon Linux 2 | [Dockerfile per Runtime solo per sistema operativo su GitHub](https://github.com/aws/aws-lambda-base-images/blob/provided.al2/Dockerfile.provided.al2) |   31 luglio 2026   | 

Per ulteriori informazioni su queste immagini di base, consulta la documentazione [fornita](https://gallery.ecr.aws/lambda/provided) nella galleria pubblica di Amazon ECR.

È necessario includere il pacchetto [aws-lambda-go/lambda](https://github.com/aws/aws-lambda-go) nel gestore Go. Questo pacchetto implementa il modello di programmazione per Go, inclusa l'interfaccia di runtime.

### Prerequisiti
<a name="go-custom-prerequisites"></a>

Per completare le fasi riportate in questa sezione, è necessario:
+ [AWS CLI versione 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Docker](https://docs.docker.com/get-docker) (versione minima 25.0.0)
+ Il [plugin buildx](https://github.com/docker/buildx/blob/master/README.md) di Docker.
+ Go

### Creazione di un'immagine dall'immagine di base provided.al2023
<a name="go-custom-create"></a>

**Creazione e implementazione di una funzione Go con l'immagine di base `provided.al2023`**

1. Crea una directory per il progetto, quindi passa a quella directory.

   ```
   mkdir hello
   cd hello
   ```

1. Inizializza un nuovo modulo Go.

   ```
   go mod init example.com/hello-world
   ```

1. Aggiungi la libreria **lambda** come dipendenza del nuovo modulo.

   ```
   go get github.com/aws/aws-lambda-go/lambda
   ```

1. Crea un file denominato `main.go`, quindi aprilo in un editor di testo. Questo è il codice per la funzione Lambda. A fini di test, puoi utilizzare il codice di esempio seguente o sostituirlo con il tuo codice personalizzato.

   ```
   package main
   
   import (
   	"context"
   	"github.com/aws/aws-lambda-go/events"
   	"github.com/aws/aws-lambda-go/lambda"
   )
   
   func handler(ctx context.Context, event events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
   	response := events.APIGatewayProxyResponse{
   		StatusCode: 200,
   		Body:       "\"Hello from Lambda!\"",
   	}
   	return response, nil
   }
   
   func main() {
   	lambda.Start(handler)
   }
   ```

1. Utilizza un editor di testo per creare un file Dockerfile nella directory del progetto.
   + Il seguente Dockerfile di esempio utilizza una [build multi-fase](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#use-multi-stage-builds). Ciò consente di utilizzare un'immagine di base diversa in ogni passaggio. Puoi utilizzare un'immagine, ad esempio un'[immagine di base Go](https://hub.docker.com/_/golang), per compilare il codice e creare il file binario eseguibile. È quindi possibile utilizzare un'immagine diversa, ad esempio `provided.al2023`, nell'istruzione `FROM` finale per definire l'immagine da implementare in Lambda. Il processo di compilazione è separato dall'immagine di implementazione finale, quindi l'immagine finale contiene solo i file necessari per eseguire l'applicazione.
   + Puoi usare il tag facoltativo `lambda.norpc` per escludere il componente Remote Procedure Call (RPC) della libreria [lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda). Il componente RPC è richiesto solo quando si utilizza il runtime Go 1.x obsoleto. L'esclusione dell'RPC riduce le dimensioni del pacchetto di implementazione.
   + Nota che l'esempio Dockerfile non include un'[istruzione USER](https://docs.docker.com/reference/dockerfile/#user). Quando implementi un'immagine di container su Lambda, Lambda definisce automaticamente un utente Linux predefinito con autorizzazioni con privilegi minimi. Questo è diverso dal comportamento standard di Docker, che per impostazione predefinita è l'utente `root` quando non viene fornita alcuna istruzione `USER`.  
**Example - Dockerfile di compilazione multi-fase**  
**Nota**  
Assicurati che la versione di Go specificata nel tuo Dockerfile (ad esempio `golang:1.20`) sia la stessa versione di Go che hai usato per creare l'applicazione.

   ```
   FROM golang:1.20 as build
   WORKDIR /helloworld
   # Copy dependencies list
   COPY go.mod go.sum ./
   # Build with optional lambda.norpc tag
   COPY main.go .
   RUN go build -tags lambda.norpc -o main main.go
   # Copy artifacts to a clean image
   FROM public.ecr.aws/lambda/provided:al2023
   COPY --from=build /helloworld/main ./main
   ENTRYPOINT [ "./main" ]
   ```

1. Crea l'immagine Docker con il comando [docker build](https://docs.docker.com/engine/reference/commandline/build/). L'esempio seguente assegna un nome all'immagine `docker-image` e le assegna il [tag](https://docs.docker.com/engine/reference/commandline/build/#tag) `test`. Per rendere l'immagine compatibile con Lambda, è necessario utilizzare l'`--provenance=false`opzione.

   ```
   docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
   ```
**Nota**  
Il comando specifica l’opzione `--platform linux/amd64` per garantire che il container sia compatibile con l'ambiente di esecuzione di Lambda, indipendentemente dall'architettura della macchina di sviluppo. Se intendi creare una funzione Lambda utilizzando l'architettura del set di ARM64 istruzioni, assicurati di modificare il comando per utilizzare invece l'`--platform linux/arm64`opzione.

### (Facoltativo) Test dell'immagine in locale
<a name="go-custom-test"></a>

Usa il [simulatore dell'interfaccia di runtime](https://github.com/aws/aws-lambda-runtime-interface-emulator/) per testare l'immagine in locale. Il simulatore dell'interfaccia di runtime è incluso nell'immagine di base `provided.al2023`.

**Esecuzione del simulatore dell'interfaccia di runtime sul computer locale**

1. Avvia l'immagine Docker con il comando **docker run**. Tenere presente quanto segue:
   + `docker-image` è il nome dell'immagine e `test` è il tag.
   + `./main` è l'`ENTRYPOINT` del Dockerfile.

   ```
   docker run -d -p 9000:8080 \
   --entrypoint /usr/local/bin/aws-lambda-rie \
   docker-image:test ./main
   ```

   Questo comando esegue l'immagine come container e crea un endpoint locale in `localhost:9000/2015-03-31/functions/function/invocations`.

1. Da una nuova finestra di terminale, invia un evento al seguente endpoint utilizzando un comando **curl**:

   ```
   curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
   ```

   Questo comando richiama la funzione con un evento vuoto e restituisce una risposta. Alcune funzioni potrebbero richiedere un payload JSON. Esempio:

   ```
   curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
   ```

1. Ottieni l'ID del container.

   ```
   docker ps
   ```

1. Utilizza il comando [docker kill](https://docs.docker.com/engine/reference/commandline/kill/) per arrestare il container. In questo comando, sostituisci `3766c4ab331c` con l'ID del container del passaggio precedente.

   ```
   docker kill 3766c4ab331c
   ```

### Implementazione dell'immagine
<a name="go-custom-deploy"></a>

**Caricamento dell'immagine su Amazon ECR e creazione della funzione Lambda**

1. Esegui il [get-login-password](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/get-login-password.html)comando per autenticare la CLI Docker nel tuo registro Amazon ECR.
   + Imposta il `--region` valore nel Regione AWS punto in cui desideri creare il repository Amazon ECR.
   + Sostituiscilo `111122223333` con il tuo ID. Account AWS 

   ```
   aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
   ```

1. Crea un repository in Amazon ECR utilizzando il commando [create-repository](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/create-repository.html).

   ```
   aws ecr create-repository --repository-name hello-world --region us-east-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE
   ```
**Nota**  
Il repository Amazon ECR deve corrispondere alla funzione Lambda. Regione AWS 

   In caso di esito positivo, dovresti ottenere una risposta simile a questa:

   ```
   {
       "repository": {
           "repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world",
           "registryId": "111122223333",
           "repositoryName": "hello-world",
           "repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world",
           "createdAt": "2023-03-09T10:39:01+00:00",
           "imageTagMutability": "MUTABLE",
           "imageScanningConfiguration": {
               "scanOnPush": true
           },
           "encryptionConfiguration": {
               "encryptionType": "AES256"
           }
       }
   }
   ```

1. Copia il `repositoryUri` dall'output del passaggio precedente.

1. Esegui il comando [docker tag](https://docs.docker.com/engine/reference/commandline/tag/) per etichettare l'immagine locale nel repository Amazon ECR come versione più recente. In questo comando:
   + `docker-image:test` è il nome e [tag](https://docs.docker.com/engine/reference/commandline/build/#tag) dell'immagine Docker. Si tratta del nome e del tag dell'immagine specificati nel comando `docker build`.
   + Sostituisci l’`<ECRrepositoryUri>` con l’`repositoryUri` copiato. Assicurati di includere `:latest` alla fine dell'URI.

   ```
   docker tag docker-image:test <ECRrepositoryUri>:latest
   ```

   Esempio:

   ```
   docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
   ```

1. Esegui il comando [docker push](https://docs.docker.com/engine/reference/commandline/push/) per implementare la tua immagine locale sul repository Amazon ECR. Assicurati di includere `:latest` alla fine dell'URI del repository.

   ```
   docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
   ```

1. [Crea un ruolo di esecuzione](lambda-intro-execution-role.md#permissions-executionrole-api) per la funzione, se non lo hai già fatto. Il nome della risorsa Amazon (ARN) del ruolo ti occorrerà nel passaggio successivo.

1. Creazione della funzione Lambda Per `ImageUri`, specifica l'URI del repository creato in precedenza. Assicurati di includere `:latest` alla fine dell'URI.

   ```
   aws lambda create-function \
     --function-name hello-world \
     --package-type Image \
     --code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
     --role arn:aws:iam::111122223333:role/lambda-ex
   ```
**Nota**  
È possibile creare una funzione utilizzando un'immagine in un AWS account diverso, purché l'immagine si trovi nella stessa regione della funzione Lambda. Per ulteriori informazioni, consulta [Autorizzazioni multiaccount Amazon ECR](images-create.md#configuration-images-xaccount-permissions).

1. Richiama la funzione.

   ```
   aws lambda invoke --function-name hello-world response.json
   ```

   Dovresti ottenere una risposta simile a questa:

   ```
   {
     "ExecutedVersion": "$LATEST", 
     "StatusCode": 200
   }
   ```

1. Per vedere l'output della funzione, controlla il file `response.json`.

Per aggiornare il codice della funzione, devi creare nuovamente l'immagine, caricare la nuova immagine nell'archivio Amazon ECR e quindi utilizzare il [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)comando per distribuire l'immagine nella funzione Lambda.

Lambda risolve il tag dell'immagine in un digest di immagine specifico. Ciò significa che se punti il tag immagine utilizzato per implementare la funzione su una nuova immagine in Amazon ECR, Lambda non aggiorna automaticamente la funzione per utilizzare la nuova immagine.

Per distribuire la nuova immagine nella stessa funzione Lambda, è necessario utilizzare [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)il comando, anche se il tag dell'immagine in Amazon ECR rimane lo stesso. Nell'esempio seguente, l'opzione `--publish` crea una nuova versione della funzione utilizzando l'immagine del container aggiornata.

```
aws lambda update-function-code \
  --function-name hello-world \
  --image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
  --publish
```

## Utilizzo di un'immagine non di base AWS
<a name="go-image-other"></a>

Puoi creare un'immagine contenitore per Go da un'immagine non di AWS base. Nei passaggi di esempio che seguono, Dockerfile utilizza un'[immagine di base Alpine](https://hub.docker.com/_/golang/).

È necessario includere il pacchetto [aws-lambda-go/lambda](https://github.com/aws/aws-lambda-go) nel gestore Go. Questo pacchetto implementa il modello di programmazione per Go, inclusa l'interfaccia di runtime.

### Prerequisiti
<a name="go-alt-prerequisites"></a>

Per completare le fasi riportate in questa sezione, è necessario:
+ [AWS CLI versione 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Docker](https://docs.docker.com/get-docker) (versione minima 25.0.0)
+ Il [plugin buildx](https://github.com/docker/buildx/blob/master/README.md) di Docker.
+ Go

### Creazione di un'immagine da un'immagine di base alternativa
<a name="go-alt-create"></a>

**Creazione e implementazione di una funzione Go con un'immagine di base Alpine**

1. Crea una directory per il progetto, quindi passa a quella directory.

   ```
   mkdir hello
   cd hello
   ```

1. Inizializza un nuovo modulo Go.

   ```
   go mod init example.com/hello-world
   ```

1. Aggiungi la libreria **lambda** come dipendenza del nuovo modulo.

   ```
   go get github.com/aws/aws-lambda-go/lambda
   ```

1. Crea un file denominato `main.go`, quindi aprilo in un editor di testo. Questo è il codice per la funzione Lambda. A fini di test, puoi utilizzare il codice di esempio seguente o sostituirlo con il tuo codice personalizzato.

   ```
   package main
   
   import (
   	"context"
   	"github.com/aws/aws-lambda-go/events"
   	"github.com/aws/aws-lambda-go/lambda"
   )
   
   func handler(ctx context.Context, event events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
   	response := events.APIGatewayProxyResponse{
   		StatusCode: 200,
   		Body:       "\"Hello from Lambda!\"",
   	}
   	return response, nil
   }
   
   func main() {
   	lambda.Start(handler)
   }
   ```

1. Utilizza un editor di testo per creare un file Dockerfile nella directory del progetto. Nell'esempio che segue, Dockerfile utilizza un'[immagine di base Alpine](https://hub.docker.com/_/golang/). Nota che l'esempio Dockerfile non include un'[istruzione USER](https://docs.docker.com/reference/dockerfile/#user). Quando implementi un'immagine di container su Lambda, Lambda definisce automaticamente un utente Linux predefinito con autorizzazioni con privilegi minimi. Questo è diverso dal comportamento standard di Docker, che per impostazione predefinita è l'utente `root` quando non viene fornita alcuna istruzione `USER`.  
**Example Dockerfile**  
**Nota**  
Assicurati che la versione di Go specificata nel tuo Dockerfile (ad esempio `golang:1.20`) sia la stessa versione di Go che hai usato per creare l'applicazione.

   ```
   FROM golang:1.20.2-alpine3.16 as build
   WORKDIR /helloworld
   # Copy dependencies list
   COPY go.mod go.sum ./
   # Build
   COPY main.go .
   RUN go build -o main main.go
   # Copy artifacts to a clean image
   FROM alpine:3.16
   COPY --from=build /helloworld/main /main
   ENTRYPOINT [ "/main" ]
   ```

1. Crea l'immagine Docker con il comando [docker build](https://docs.docker.com/engine/reference/commandline/build/). L'esempio seguente assegna un nome all'immagine `docker-image` e le assegna il [tag](https://docs.docker.com/engine/reference/commandline/build/#tag) `test`. Per rendere l'immagine compatibile con Lambda, è necessario utilizzare l'`--provenance=false`opzione.

   ```
   docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
   ```
**Nota**  
Il comando specifica l’opzione `--platform linux/amd64` per garantire che il container sia compatibile con l'ambiente di esecuzione di Lambda, indipendentemente dall'architettura della macchina di sviluppo. Se intendi creare una funzione Lambda utilizzando l'architettura del set di ARM64 istruzioni, assicurati di modificare il comando per utilizzare invece l'`--platform linux/arm64`opzione.

### (Facoltativo) Test dell'immagine in locale
<a name="go-alt-test"></a>

Usa il [simulatore dell'interfaccia di runtime](https://github.com/aws/aws-lambda-runtime-interface-emulator/) per testare l'immagine in locale. Puoi [creare l'emulatore nella tua immagine](https://github.com/aws/aws-lambda-runtime-interface-emulator/?tab=readme-ov-file#build-rie-into-your-base-image) o seguire la procedura riportata e installarlo sul tuo computer locale.

**Installazione ed esecuzione dell'emulatore di interfaccia di runtime sul computer locale**

1. Dalla directory del progetto, esegui il comando seguente per scaricare l'emulatore di interfaccia di runtime (architettura x86-64) GitHub e installarlo sul computer locale.

------
#### [ Linux/macOS ]

   ```
   mkdir -p ~/.aws-lambda-rie && \
       curl -Lo ~/.aws-lambda-rie/aws-lambda-rie https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie && \
       chmod +x ~/.aws-lambda-rie/aws-lambda-rie
   ```

   Per installare l'emulatore arm64, sostituisci l'URL del GitHub repository nel comando precedente con il seguente:

   ```
   https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64
   ```

------
#### [ PowerShell ]

   ```
   $dirPath = "$HOME\.aws-lambda-rie"
   if (-not (Test-Path $dirPath)) {
       New-Item -Path $dirPath -ItemType Directory
   }
         
   $downloadLink = "https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie"
   $destinationPath = "$HOME\.aws-lambda-rie\aws-lambda-rie"
   Invoke-WebRequest -Uri $downloadLink -OutFile $destinationPath
   ```

   Per installare l'emulatore arm64, sostituisci `$downloadLink` con quanto segue:

   ```
   https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64
   ```

------

1. Avvia l'immagine Docker con il comando **docker run**. Tenere presente quanto segue:
   + `docker-image` è il nome dell'immagine e `test` è il tag.
   + `/main` è l'`ENTRYPOINT` del Dockerfile.

------
#### [ Linux/macOS ]

   ```
   docker run --platform linux/amd64 -d -v ~/.aws-lambda-rie:/aws-lambda -p 9000:8080 \
       --entrypoint /aws-lambda/aws-lambda-rie \
       docker-image:test \
           /main
   ```

------
#### [ PowerShell ]

   ```
   docker run --platform linux/amd64 -d -v "$HOME\.aws-lambda-rie:/aws-lambda" -p 9000:8080 `
   --entrypoint /aws-lambda/aws-lambda-rie `
   docker-image:test `
       /main
   ```

------

   Questo comando esegue l'immagine come container e crea un endpoint locale in `localhost:9000/2015-03-31/functions/function/invocations`.
**Nota**  
Se hai creato l'immagine Docker per l'architettura del set di ARM64 istruzioni, assicurati di utilizzare l'`--platform linux/arm64`opzione invece di. `--platform linux/amd64`

1. Pubblica un evento nell'endpoint locale.

------
#### [ Linux/macOS ]

   Su MacOS o Linux, esegui il comando seguente `curl`:

   ```
   curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
   ```

   Questo comando richiama la funzione con un evento vuoto e restituisce una risposta. Se stai utilizzando il tuo codice della funzione anziché quello di esempio, potresti voler richiamare la funzione con un payload JSON. Esempio:

   ```
   curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
   ```

------
#### [ PowerShell ]

   In PowerShell, esegui il seguente `Invoke-WebRequest` comando:

   ```
   Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{}' -ContentType "application/json"
   ```

   Questo comando richiama la funzione con un evento vuoto e restituisce una risposta. Se stai utilizzando il tuo codice della funzione anziché quello di esempio, potresti voler richiamare la funzione con un payload JSON. Esempio:

   ```
   Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{"payload":"hello world!"}' -ContentType "application/json"
   ```

------

1. Ottieni l'ID del container.

   ```
   docker ps
   ```

1. Utilizza il comando [docker kill](https://docs.docker.com/engine/reference/commandline/kill/) per arrestare il container. In questo comando, sostituisci `3766c4ab331c` con l'ID del container del passaggio precedente.

   ```
   docker kill 3766c4ab331c
   ```

### Implementazione dell'immagine
<a name="go-alt-deploy"></a>

**Caricamento dell'immagine su Amazon ECR e creazione della funzione Lambda**

1. Esegui il [get-login-password](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/get-login-password.html)comando per autenticare la CLI Docker nel tuo registro Amazon ECR.
   + Imposta il `--region` valore nel Regione AWS punto in cui desideri creare il repository Amazon ECR.
   + Sostituiscilo `111122223333` con il tuo ID. Account AWS 

   ```
   aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
   ```

1. Crea un repository in Amazon ECR utilizzando il commando [create-repository](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/create-repository.html).

   ```
   aws ecr create-repository --repository-name hello-world --region us-east-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE
   ```
**Nota**  
Il repository Amazon ECR deve corrispondere alla funzione Lambda. Regione AWS 

   In caso di esito positivo, dovresti ottenere una risposta simile a questa:

   ```
   {
       "repository": {
           "repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world",
           "registryId": "111122223333",
           "repositoryName": "hello-world",
           "repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world",
           "createdAt": "2023-03-09T10:39:01+00:00",
           "imageTagMutability": "MUTABLE",
           "imageScanningConfiguration": {
               "scanOnPush": true
           },
           "encryptionConfiguration": {
               "encryptionType": "AES256"
           }
       }
   }
   ```

1. Copia il `repositoryUri` dall'output del passaggio precedente.

1. Esegui il comando [docker tag](https://docs.docker.com/engine/reference/commandline/tag/) per etichettare l'immagine locale nel repository Amazon ECR come versione più recente. In questo comando:
   + `docker-image:test` è il nome e [tag](https://docs.docker.com/engine/reference/commandline/build/#tag) dell'immagine Docker. Si tratta del nome e del tag dell'immagine specificati nel comando `docker build`.
   + Sostituisci l’`<ECRrepositoryUri>` con l’`repositoryUri` copiato. Assicurati di includere `:latest` alla fine dell'URI.

   ```
   docker tag docker-image:test <ECRrepositoryUri>:latest
   ```

   Esempio:

   ```
   docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
   ```

1. Esegui il comando [docker push](https://docs.docker.com/engine/reference/commandline/push/) per implementare la tua immagine locale sul repository Amazon ECR. Assicurati di includere `:latest` alla fine dell'URI del repository.

   ```
   docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
   ```

1. [Crea un ruolo di esecuzione](lambda-intro-execution-role.md#permissions-executionrole-api) per la funzione, se non lo hai già fatto. Il nome della risorsa Amazon (ARN) del ruolo ti occorrerà nel passaggio successivo.

1. Creazione della funzione Lambda Per `ImageUri`, specifica l'URI del repository creato in precedenza. Assicurati di includere `:latest` alla fine dell'URI.

   ```
   aws lambda create-function \
     --function-name hello-world \
     --package-type Image \
     --code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
     --role arn:aws:iam::111122223333:role/lambda-ex
   ```
**Nota**  
È possibile creare una funzione utilizzando un'immagine in un AWS account diverso, purché l'immagine si trovi nella stessa regione della funzione Lambda. Per ulteriori informazioni, consulta [Autorizzazioni multiaccount Amazon ECR](images-create.md#configuration-images-xaccount-permissions).

1. Richiama la funzione.

   ```
   aws lambda invoke --function-name hello-world response.json
   ```

   Dovresti ottenere una risposta simile a questa:

   ```
   {
     "ExecutedVersion": "$LATEST", 
     "StatusCode": 200
   }
   ```

1. Per vedere l'output della funzione, controlla il file `response.json`.

Per aggiornare il codice della funzione, devi creare nuovamente l'immagine, caricare la nuova immagine nell'archivio Amazon ECR e quindi utilizzare il [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)comando per distribuire l'immagine nella funzione Lambda.

Lambda risolve il tag dell'immagine in un digest di immagine specifico. Ciò significa che se punti il tag immagine utilizzato per implementare la funzione su una nuova immagine in Amazon ECR, Lambda non aggiorna automaticamente la funzione per utilizzare la nuova immagine.

Per distribuire la nuova immagine nella stessa funzione Lambda, è necessario utilizzare [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)il comando, anche se il tag dell'immagine in Amazon ECR rimane lo stesso. Nell'esempio seguente, l'opzione `--publish` crea una nuova versione della funzione utilizzando l'immagine del container aggiornata.

```
aws lambda update-function-code \
  --function-name hello-world \
  --image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
  --publish
```

# Utilizzo dei livelli per le funzioni Lambda in Go
<a name="golang-layers"></a>

Consigliamo di non utilizzare i livelli per gestire le dipendenze per le funzioni Lambda scritte in Go. Questo perché le funzioni Lambda in Go vengono compilate in un unico eseguibile, che viene fornito a Lambda quando si distribuisce la funzione. Questo eseguibile contiene il codice di funzione compilato, insieme a tutte le sue dipendenze. L'uso dei livelli non solo complica questo processo, ma comporta anche un aumento dei tempi di avvio a freddo, poiché le funzioni devono caricare manualmente assiemi aggiuntivi in memoria durante la fase di inizializzazione.

Per utilizzare dipendenze esterne con i gestori Go, includile direttamente nel pacchetto di implementazione. In questo modo, semplifichi il processo di implementazione e sfrutti anche le ottimizzazioni integrate del compilatore Go. Per un esempio di come importare e utilizzare una dipendenza come l'SDK AWS per Go nella tua funzione, consulta [Definisci i gestori di funzioni Lambda in Go](golang-handler.md).

# Registrare e monitorare le funzioni Lambda con Go
<a name="golang-logging"></a>

AWS Lambda monitora automaticamente le funzioni Lambda per tuo conto e invia i log ad Amazon. CloudWatch La funzione Lambda include un gruppo di log CloudWatch Logs e un flusso di log per ogni istanza della funzione. L'ambiente del runtime Lambda invia i dettagli su ogni richiamo al flusso di log e inoltra i log e l'output del codice della funzione. Per ulteriori informazioni, consulta [Lambda invia automaticamente i log delle funzioni a CloudWatch Logs.](monitoring-cloudwatchlogs.md).

Questa pagina descrive come produrre un output di registro dal codice della funzione Lambda e accedere ai log utilizzando AWS Command Line Interface la console Lambda o la console. CloudWatch 

**Topics**
+ [

## Creazione di una funzione che restituisce i registri
](#golang-logging-output)
+ [

## Visualizzazione dei log nella console Lambda
](#golang-logging-console)
+ [

## Visualizzazione dei log nella console CloudWatch
](#golang-logging-cwconsole)
+ [

## Visualizzazione dei log utilizzando () AWS Command Line Interface AWS CLI
](#golang-logging-cli)
+ [

## Eliminazione dei log
](#golang-logging-delete)

## Creazione di una funzione che restituisce i registri
<a name="golang-logging-output"></a>

Per i log di output del codice della funzione, puoi usare i metodi del [pacchetto fmt](https://golang.org/pkg/fmt/) o qualsiasi libreria di registrazione che scriva in `stdout` o `stderr`. Nell'esempio seguente viene utilizzato [il pacchetto log](https://golang.org/pkg/log/).

**Example [main.go](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-go/function/main.go) – Registrazione**  

```
func handleRequest(ctx context.Context, event events.SQSEvent) (string, error) {
  // event
  eventJson, _ := json.MarshalIndent(event, "", "  ")
  log.Printf("EVENT: %s", eventJson)
  // environment variables
  log.Printf("REGION: %s", os.Getenv("AWS_REGION"))
  log.Println("ALL ENV VARS:")
  for _, element := range os.Environ() {
    log.Println(element)
  }
```

**Example Formato dei log**  

```
START RequestId: dbda340c-xmpl-4031-8810-11bb609b4c71 Version: $LATEST
2020/03/27 03:40:05 EVENT: {
  "Records": [
    {
      "messageId": "19dd0b57-b21e-4ac1-bd88-01bbb068cb78",
      "receiptHandle": "MessageReceiptHandle",
      "body": "Hello from SQS!",
      "md5OfBody": "7b27xmplb47ff90a553787216d55d91d",
      "md5OfMessageAttributes": "",
      "attributes": {
        "ApproximateFirstReceiveTimestamp": "1523232000001",
        "ApproximateReceiveCount": "1",
        "SenderId": "123456789012",
        "SentTimestamp": "1523232000000"
      },
      ...
2020/03/27 03:40:05 AWS_LAMBDA_LOG_STREAM_NAME=2020/03/27/[$LATEST]569cxmplc3c34c7489e6a97ad08b4419
2020/03/27 03:40:05 AWS_LAMBDA_FUNCTION_NAME=blank-go-function-9DV3XMPL6XBC
2020/03/27 03:40:05 AWS_LAMBDA_FUNCTION_MEMORY_SIZE=128
2020/03/27 03:40:05 AWS_LAMBDA_FUNCTION_VERSION=$LATEST
2020/03/27 03:40:05 AWS_EXECUTION_ENV=AWS_Lambda_go1.x
END RequestId: dbda340c-xmpl-4031-8810-11bb609b4c71
REPORT RequestId: dbda340c-xmpl-4031-8810-11bb609b4c71	Duration: 38.66 ms	Billed Duration: 243 ms	Memory Size: 128 MB	Max Memory Used: 54 MB	Init Duration: 203.69 ms	
XRAY TraceId: 1-5e7d7595-212fxmpl9ee07c4884191322	SegmentId: 42ffxmpl0645f474	Sampled: true
```

Il runtime di Go registra `START`, `END` e `REPORT` per ogni chiamata. La riga del report fornisce i seguenti dettagli.

**Campi dati della riga REPORT**
+ **RequestId**— L'ID univoco della richiesta per la chiamata.
+ **Durata** – La quantità di tempo che il metodo del gestore della funzione impiega durante l'elaborazione dell'evento.
+ **Durata fatturata** – La quantità di tempo fatturata per la chiamata.
+ **Dimensioni memoria** – La quantità di memoria allocata per la funzione.
+ **Quantità max utilizzata** – La quantità di memoria utilizzata dalla funzione. Quando le invocazioni condividono un ambiente di esecuzione, Lambda riporta la memoria massima utilizzata in tutte le invocazioni. Questo comportamento potrebbe comportare un valore riportato superiore al previsto.
+ **Durata Init** – Per la prima richiesta servita, la quantità di tempo impiegato dal runtime per caricare la funzione ed eseguire il codice al di fuori del metodo del gestore.
+ **XRAY TraceId** [— Per le richieste tracciate, l'ID di traccia.AWS X-Ray](services-xray.md)
+ **SegmentId**— Per le richieste tracciate, l'ID del segmento X-Ray.
+ **Campionato** – Per le richieste tracciate, il risultato del campionamento.

## Visualizzazione dei log nella console Lambda
<a name="golang-logging-console"></a>

È possibile utilizzare la console Lambda per visualizzare l'output del log dopo aver richiamato una funzione Lambda.

Se il codice può essere testato dall'editor del **codice** incorporato, troverai i log nei **risultati dell’esecuzione**. Quando utilizzi la funzionalità di test della console per richiamare una funzione, troverai l’**output del log** nella sezione **Dettagli**.

## Visualizzazione dei log nella console CloudWatch
<a name="golang-logging-cwconsole"></a>

Puoi utilizzare la CloudWatch console Amazon per visualizzare i log di tutte le chiamate di funzioni Lambda.

**Per visualizzare i log sulla console CloudWatch**

1. Apri la [pagina Registra gruppi](https://console.aws.amazon.com/cloudwatch/home?#logs:) sulla CloudWatch console.

1. Scegli il gruppo di log per la tua funzione (***your-function-name*/aws/lambda/**).

1. Creare un flusso di log.

Ogni flusso di log corrisponde a un'[istanza della funzione](lambda-runtime-environment.md). Viene visualizzato un flusso di log quando aggiorni la funzione Lambda e quando vengono create istanze aggiuntive per gestire le chiamate simultanee. Per trovare i log per una chiamata specifica, consigliamo di strumentare la funzione con. AWS X-Ray X-Ray registra i dettagli sulla richiesta e il flusso di log nella traccia.

## Visualizzazione dei log utilizzando () AWS Command Line Interface AWS CLI
<a name="golang-logging-cli"></a>

 AWS CLI È uno strumento open source che consente di interagire con i AWS servizi utilizzando i comandi nella shell della riga di comando. Per completare le fasi riportate in questa sezione, è necessario disporre della [AWS CLI versione 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).

È possibile utilizzare [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) per recuperare i log per una chiamata utilizzando l'opzione di comando `--log-type`. La risposta include un campo `LogResult` che contiene fino a 4 KB di log con codifica base64 del richiamo.

**Example recuperare un ID di log**  
Nell'esempio seguente viene illustrato come recuperare un *ID di log* dal `LogResult` campo per una funzione denominata `my-function`.  

```
aws lambda invoke --function-name my-function out --log-type Tail
```
Verrà visualizzato l’output seguente:  

```
{
    "StatusCode": 200,
    "LogResult": "U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb...",
    "ExecutedVersion": "$LATEST"
}
```

**Example decodificare i log**  
Nello stesso prompt dei comandi, utilizzare l'`base64` utilità per decodificare i log. Nell'esempio seguente viene illustrato come recuperare i log codificati in base64 per `my-function`.  

```
aws lambda invoke --function-name my-function out --log-type Tail \
--query 'LogResult' --output text --cli-binary-format raw-in-base64-out | base64 --decode
```
L'**cli-binary-format**opzione è obbligatoria se si utilizza la AWS CLI versione 2. Per rendere questa impostazione come predefinita, esegui `aws configure set cli-binary-format raw-in-base64-out`. Per ulteriori informazioni, consulta la pagina [AWS CLI supported global command line options](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) nella *Guida per l'utente di AWS Command Line Interface versione 2*.  
Verrà visualizzato l’output seguente:  

```
START RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Version: $LATEST
"AWS_SESSION_TOKEN": "AgoJb3JpZ2luX2VjELj...", "_X_AMZN_TRACE_ID": "Root=1-5d02e5ca-f5792818b6fe8368e5b51d50;Parent=191db58857df8395;Sampled=0"",ask/lib:/opt/lib",
END RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8
REPORT RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8  Duration: 79.67 ms      Billed Duration: 80 ms         Memory Size: 128 MB     Max Memory Used: 73 MB
```
L'utilità `base64` è disponibile su Linux, macOS e [Ubuntu su Windows](https://docs.microsoft.com/en-us/windows/wsl/install-win10). Gli utenti macOS potrebbero dover utilizzare `base64 -D`.

**Example Script get-logs.sh**  
Nello stesso prompt dei comandi, utilizzare lo script seguente per scaricare gli ultimi cinque eventi di log. Lo script utilizza `sed` per rimuovere le virgolette dal file di output e rimane in sospensione per 15 secondi in attesa che i log diventino disponibili. L'output include la risposta di Lambda e l'output del comando `get-log-events`.   
Copiare il contenuto del seguente esempio di codice e salvare nella directory del progetto Lambda come `get-logs.sh`.  
L'**cli-binary-format**opzione è obbligatoria se utilizzi la AWS CLI versione 2. Per rendere questa impostazione come predefinita, esegui `aws configure set cli-binary-format raw-in-base64-out`. Per ulteriori informazioni, consulta la pagina [AWS CLI supported global command line options](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) nella *Guida per l'utente di AWS Command Line Interface versione 2*.  

```
#!/bin/bash
aws lambda invoke --function-name my-function --cli-binary-format raw-in-base64-out --payload '{"key": "value"}' out
sed -i'' -e 's/"//g' out
sleep 15
aws logs get-log-events --log-group-name /aws/lambda/my-function --log-stream-name stream1 --limit 5
```

**Example (solo) macOS e Linux**  
Nello stesso prompt dei comandi, gli utenti macOS e Linux potrebbero dover eseguire il seguente comando per assicurarsi che lo script sia eseguibile.  

```
chmod -R 755 get-logs.sh
```

**Example recuperare gli ultimi cinque eventi di log**  
Nello stesso prompt dei comandi, eseguire lo script seguente per ottenere gli ultimi cinque eventi di log.  

```
./get-logs.sh
```
Verrà visualizzato l’output seguente:  

```
{
    "StatusCode": 200,
    "ExecutedVersion": "$LATEST"
}
{
    "events": [
        {
            "timestamp": 1559763003171,
            "message": "START RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf Version: $LATEST\n",
            "ingestionTime": 1559763003309
        },
        {
            "timestamp": 1559763003173,
            "message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tENVIRONMENT VARIABLES\r{\r  \"AWS_LAMBDA_FUNCTION_VERSION\": \"$LATEST\",\r ...",
            "ingestionTime": 1559763018353
        },
        {
            "timestamp": 1559763003173,
            "message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tEVENT\r{\r  \"key\": \"value\"\r}\n",
            "ingestionTime": 1559763018353
        },
        {
            "timestamp": 1559763003218,
            "message": "END RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\n",
            "ingestionTime": 1559763018353
        },
        {
            "timestamp": 1559763003218,
            "message": "REPORT RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\tDuration: 26.73 ms\tBilled Duration: 27 ms \tMemory Size: 128 MB\tMax Memory Used: 75 MB\t\n",
            "ingestionTime": 1559763018353
        }
    ],
    "nextForwardToken": "f/34783877304859518393868359594929986069206639495374241795",
    "nextBackwardToken": "b/34783877303811383369537420289090800615709599058929582080"
}
```

## Eliminazione dei log
<a name="golang-logging-delete"></a>

I gruppi di log non vengono eliminati automaticamente quando si elimina una funzione. Per evitare di archiviare i log a tempo indeterminato, eliminare il gruppo di log o [configurare un periodo di conservazione](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#SettingLogRetention) trascorso il quale i log vengono eliminati automaticamente.

# Strumentazione del codice Go in AWS Lambda
<a name="golang-tracing"></a>

Lambda si integra con AWS X-Ray per aiutarti a tracciare, eseguire il debug e ottimizzare le applicazioni Lambda. Puoi utilizzare X-Ray per tracciare una richiesta mentre attraversa le risorse nell'applicazione, che possono includere funzioni Lambda e altri servizi AWS .

Per inviare dati di tracciamento a X-Ray, è possibile utilizzare una delle due librerie SDK:
+ [AWS Distro for OpenTelemetry (ADOT)](https://aws.amazon.com/otel): una distribuzione sicura, pronta per la produzione e supportata dell'SDK (). AWS OpenTelemetry OTel
+ [AWS X-Ray SDK for Go: un SDK per la](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-go.html) generazione e l'invio di dati di traccia a X-Ray.

Ciascuno di essi SDKs offre modi per inviare i dati di telemetria al servizio X-Ray. Puoi quindi utilizzare X-Ray per visualizzare, filtrare e analizzare le metriche delle prestazioni dell'applicazione per identificare i problemi e le opportunità di ottimizzazione.

**Importante**  
X-Ray e Powertools per AWS Lambda SDKs fanno parte di una soluzione di strumentazione strettamente integrata offerta da. AWS I livelli Lambda ADOT fanno parte di uno standard di settore per la strumentazione di tracciamento che in generale raccoglie più dati, ma potrebbero non essere adatti a tutti i casi d'uso. È possibile implementare il end-to-end tracciamento in X-Ray utilizzando entrambe le soluzioni. Per saperne di più sulla scelta tra di esse, consulta [Scelta tra AWS Distro for Open Telemetry](https://docs.aws.amazon.com/xray/latest/devguide/xray-instrumenting-your-app.html#xray-instrumenting-choosing) e X-Ray. SDKs

**Topics**
+ [

## Utilizzo di ADOT per strumentare le funzioni Go
](#golang-adot)
+ [

## Utilizzo dell'SDK X-Ray per strumentare le funzioni Go
](#golang-xray-sdk)
+ [

## Attivazione del tracciamento con la console Lambda
](#golang-tracing-console)
+ [

## Attivazione del tracciamento con l'API Lambda
](#golang-tracing-api)
+ [

## Attivazione del tracciamento con CloudFormation
](#golang-tracing-cloudformation)
+ [

## Interpretazione di una traccia X-Ray
](#golang-tracing-interpretation)

## Utilizzo di ADOT per strumentare le funzioni Go
<a name="golang-adot"></a>

ADOT fornisce layer [Lambda](chapter-layers.md) completamente gestiti che racchiudono tutto il necessario per raccogliere dati di telemetria utilizzando l'SDK. OTel Usando questo livello, è possibile strumentare le funzioni Lambda senza dover modificare alcun codice funzione. Puoi anche configurare il tuo layer per eseguire l'inizializzazione personalizzata di. OTel Per ulteriori informazioni, consulta la sezione relativa alla [configurazione personalizzata per ADOT Collector su Lambda](https://aws-otel.github.io/docs/getting-started/lambda#custom-configuration-for-the-adot-collector-on-lambda) nella documentazione di ADOT.

Per i runtime Go, puoi aggiungere il **livello Lambda gestito da AWS per ADOT Go** per strumentare automaticamente le tue funzioni. Per istruzioni dettagliate su come aggiungere questo layer, consulta [AWS Distro for OpenTelemetry Lambda Support for](https://aws-otel.github.io/docs/getting-started/lambda/lambda-go) Go nella documentazione ADOT.

## Utilizzo dell'SDK X-Ray per strumentare le funzioni Go
<a name="golang-xray-sdk"></a>

Per registrare i dettagli sulle chiamate che la funzione Lambda effettua ad altre risorse dell'applicazione, puoi anche utilizzare l' AWS X-Ray SDK for Go. [Per scaricare l'SDK, scarica l'SDK dal suo repository con: GitHub ](https://github.com/aws/aws-xray-sdk-go) `go get`

```
go get github.com/aws/aws-xray-sdk-go
```

Per utilizzare i client AWS SDK di Instrument, passate il client al metodo. `xray.AWS()` Quindi potrai tracciare le chiamate utilizzando la versione `WithContext` del metodo.

```
svc := s3.New(session.New())
xray.AWS(svc.Client)
...
svc.ListBucketsWithContext(ctx aws.Context, input *ListBucketsInput)
```

Dopo aver aggiunto le dipendenze corrette e aver apportato le modifiche necessarie al codice, attivare il tracciamento nella configurazione della funzione tramite la console Lambda o l'API.

## Attivazione del tracciamento con la console Lambda
<a name="golang-tracing-console"></a>

Per attivare il tracciamento attivo sulla funzione Lambda con la console, attenersi alla seguente procedura:

**Per attivare il tracciamento attivo**

1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.

1. Scegliere una funzione.

1. Scegliere **Configuration** (Configurazione) e quindi **Monitoring and operations tools** (Strumenti di monitoraggio e operazioni).

1. In **Strumenti di monitoraggio aggiuntivi** scegli **Modifica**.

1. In **CloudWatch Application Signals e AWS X-Ray**, scegli **Enable** for **Lambda service trace**.

1. Scegli **Save** (Salva).

## Attivazione del tracciamento con l'API Lambda
<a name="golang-tracing-api"></a>

Configura il tracciamento sulla tua funzione Lambda con AWS o SDK, utilizza AWS CLI le seguenti operazioni API:
+ [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html)
+ [GetFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunctionConfiguration.html)
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)

**Il AWS CLI comando di esempio seguente abilita il tracciamento attivo su una funzione denominata my-function.**

```
aws lambda update-function-configuration --function-name my-function \
--tracing-config Mode=Active
```

La modalità di tracciamento fa parte della configurazione specifica della versione quando si pubblica una versione della funzione. Non è possibile modificare la modalità di tracciamento in una versione pubblicata.

## Attivazione del tracciamento con CloudFormation
<a name="golang-tracing-cloudformation"></a>

Per attivare il tracciamento su una `AWS::Lambda::Function` risorsa in un CloudFormation modello, utilizzate la proprietà. `TracingConfig`

**Example [function-inline.yml](https://github.com/awsdocs/aws-lambda-developer-guide/blob/master/templates/function-inline.yml) – Configurazione del tracciamento**  

```
Resources:
  function:
    Type: [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)
    Properties:
      TracingConfig:
        Mode: Active
      ...
```

Per una `AWS::Serverless::Function` risorsa AWS Serverless Application Model (AWS SAM), utilizzate la `Tracing` proprietà.

**Example [template.yml](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-nodejs/template.yml) – Configurazione del tracciamento**  

```
Resources:
  function:
    Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)
    Properties:
      Tracing: Active
      ...
```

## Interpretazione di una traccia X-Ray
<a name="golang-tracing-interpretation"></a>

La funzione ha bisogno dell'autorizzazione per caricare i dati di traccia su X-Ray. Quando si attiva il tracciamento nella console Lambda, Lambda aggiunge le autorizzazioni necessarie al [ruolo di esecuzione](lambda-intro-execution-role.md) della funzione. Altrimenti, aggiungete la [AWSXRayDaemonWriteAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AWSXRayDaemonWriteAccess)politica al ruolo di esecuzione.

Dopo aver configurato il tracciamento attivo, è possibile osservare richieste specifiche tramite l'applicazione. Il [grafico dei servizi X-Ray](https://docs.aws.amazon.com/xray/latest/devguide/aws-xray.html#xray-concepts-servicegraph) mostra informazioni sull'applicazione e tutti i suoi componenti. Il seguente esempio mostra un'applicazione con due funzioni. La funzione principale elabora gli eventi e talvolta restituisce errori. La seconda funzione in alto elabora gli errori che compaiono nel gruppo di log della prima e utilizza l' AWS SDK per chiamare X-Ray, Amazon Simple Storage Service (Amazon S3) e Amazon Logs. CloudWatch 

![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/sample-errorprocessor-servicemap.png)


X-Ray non traccia tutte le richieste nell'applicazione. X-Ray applica un algoritmo di campionamento per garantire che il tracciamento avvenga in modo efficiente, continuando allo stesso tempo a fornire un campione rappresentativo di tutte le richieste. La frequenza di campionamento è di una richiesta al secondo e del 5% delle altre richieste. Non è possibile configurare la frequenza di campionamento di X-Ray per le funzioni.

In X-Ray, una *traccia* registra informazioni su una richiesta elaborata da uno o più *servizi*. Lambda registra 2 segmenti per traccia, che creano due nodi sul grafico del servizio. L'immagine seguente evidenzia questi due nodi:

![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/xray-servicemap-function.png)


Il primo nodo a sinistra rappresenta il servizio Lambda che riceve la richiesta di chiamata. Il secondo nodo rappresenta la specifica funzione Lambda. L'esempio seguente mostra una traccia con questi 2 segmenti. Entrambi sono nominati **my-function**, ma uno ha l'origine `AWS::Lambda` e l'altro ha l'origine `AWS::Lambda::Function`. Se il segmento `AWS::Lambda` mostra un errore, il servizio Lambda ha avuto un problema. Se il `AWS::Lambda::Function` segmento mostra un errore, la funzione ha avuto un problema.

![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/V2_sandbox_images/my-function-2-v1.png)


Questo esempio espande il segmento `AWS::Lambda::Function` per visualizzare i relativi tre sottosegmenti.

**Nota**  
AWS sta attualmente implementando modifiche al servizio Lambda. A causa di queste modifiche, potresti notare piccole differenze tra la struttura e il contenuto dei messaggi di log di sistema e dei segmenti di traccia emessi da diverse funzioni Lambda nel tuo Account AWS.  
La traccia di esempio mostrata qui illustra il segmento di funzione vecchio stile. Le differenze tra i segmenti vecchio e nuovo stile sono descritte nei paragrafi seguenti.  
Queste modifiche verranno implementate nelle prossime settimane e tutte le funzioni, Regioni AWS ad eccezione della Cina e delle GovCloud regioni, passeranno all'utilizzo dei messaggi di registro e dei segmenti di traccia di nuovo formato.

Il segmento di funzioni vecchio stile contiene i seguenti sottosegmenti:
+ **Inizializzazione** – Rappresenta il tempo trascorso a caricare la funzione e ad eseguire il [codice di inizializzazione](foundation-progmodel.md). Questo sottosegmento viene visualizzato solo per il primo evento che viene elaborato da ogni istanza della funzione.
+ **Chiamata**: rappresenta il tempo impiegato per eseguire il codice del gestore.
+ **Overhead**: rappresenta il tempo impiegato dal runtime Lambda per prepararsi a gestire l'evento successivo.

Il segmento di funzione di nuovo stile non contiene un sottosegmento `Invocation`. I sottosegmenti dei clienti sono invece collegati direttamente al segmento di funzioni. Per ulteriori informazioni sulla struttura dei segmenti di funzioni vecchio e nuovo stile, consulta [Informazioni sui monitoraggi di X-Ray](services-xray.md#services-xray-traces).

È inoltre possibile strumentare i client HTTP, registrare query SQL e creare segmenti secondari personalizzati con annotazioni e metadati. Per ulteriori informazioni, consulta [SDK AWS X-Ray per Go](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-python.html) nella *Guida per gli sviluppatori di AWS X-Ray *.

**Prezzi**  
Puoi utilizzare il tracciamento X-Ray gratuitamente ogni mese fino a un determinato limite come parte del AWS piano gratuito. Oltre la soglia, X-Ray addebita lo storage di traccia e il recupero. Per ulteriori informazioni, consultare [Prezzi di AWS X-Ray](https://aws.amazon.com/xray/pricing/).