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 Ruby
Puoi eseguire il codice Ruby in AWS Lambda. Lambda fornisce [Runtime](lambda-runtimes.md) per Ruby che eseguono il tuo codice per elaborare gli eventi. Il codice viene eseguito in un ambiente che include AWS SDK per Ruby, con le credenziali di un ruolo AWS Identity and Access Management (IAM) che gestisci. Per saperne di più sulle versioni degli SDK incluse nei runtime di Ruby, consulta [Versioni SDK incluse nel runtime](#ruby-sdk-included).
Lambda supporta i seguenti runtime di Ruby.
| Name | Identificatore | Sistema operativo | Data di ritiro | Blocco creazione funzioni | Blocco aggiornamento funzioni |
| --- | --- | --- | --- | --- | --- |
| Ruby 3.4 | `ruby3.4` | Amazon Linux 2023 | 31 marzo 2028 | 30 aprile 2028 | 31 maggio 2028 |
| Ruby 3.3 | `ruby3.3` | Amazon Linux 2023 | 31 marzo 2027 | 30 aprile 2027 | 31 maggio 2027 |
| Ruby 3.2 | `ruby3.2` | Amazon Linux 2 | 31 marzo 2026 | 31 agosto 2026 | 30 settembre 2026 |
**Per creare una funzione Ruby**
1. Aprire la [console Lambda](https://console.aws.amazon.com/lambda).
1. Scegli **Crea funzione**.
1. Configura le impostazioni seguenti:
+ **Nome della funzione**: inserisci il nome della funzione.
+ **Runtime**: scegli **Ruby 3.4**.
1. Scegli **Crea funzione**.
La console crea una funzione Lambda con un singolo file di origine denominato `lambda_function.rb`. È possibile modificare questo file e aggiungere altri file nell'editor di codice predefinito. Nella sezione **DEPLOY**, scegli **Implementa** per aggiornare il codice della tua funzione. Quindi, per eseguire il codice, scegli **Crea evento di test** nella sezione **EVENTI DI TEST**.
Il file `lambda_function.rb` esporta una funzione denominata `lambda_handler` che richiede un oggetto evento e un oggetto contesto. Questa è la [funzione del gestore](ruby-handler.md) chiamata da Lambda quando la funzione viene richiamata. Il runtime della funzione Ruby riceve gli eventi di chiamata da Lambda e li passa al gestore. Nella configurazione della funzione il valore del gestore è `lambda_function.lambda_handler`.
Quando si salva il codice funzione, la console Lambda crea un pacchetto di implementazione dell'archivio di file .zip. Quando sviluppi il codice funzione al di fuori della console (utilizzando un IDE) devi [creare un pacchetto di implementazione](ruby-package.md) per caricare il codice nella funzione Lambda.
Il runtime della funzione passa un oggetto contesto al gestore, oltre all'evento di chiamata. L'[oggetto contesto](ruby-context.md) contiene ulteriori informazioni sulla chiamata, sulla funzione e sull'ambiente di esecuzione. Altre informazioni sono disponibili con le variabili di ambiente.
La funzione Lambda include un gruppo di CloudWatch log Logs. Il runtime della funzione invia i dettagli su ogni chiamata a Logs. CloudWatch Si trasmette qualsiasi [log che la tua funzione emette](ruby-logging.md) durante la chiamata. Se la funzione restituisce un errore, Lambda formatta l'errore e lo restituisce al chiamante.
**Topics**
+ [Versioni SDK incluse nel runtime](#ruby-sdk-included)
+ [Abilitazione di Yet Another Ruby JIT (YJIT)](#ruby-yjit)
+ [Definire l'handler di funzioni Lambda in Ruby](ruby-handler.md)
+ [Distribuire le funzioni Ruby Lambda con gli archivi di file .zip](ruby-package.md)
+ [Distribuisci funzioni Lambda per Ruby con immagini di container](ruby-image.md)
+ [Utilizzo dei livelli per le funzioni Lamba di Ruby](ruby-layers.md)
+ [Utilizzo dell'oggetto del contesto Lambda per recuperare le informazioni sulla funzione Ruby](ruby-context.md)
+ [Registrare e monitorare le funzioni Lambda con Ruby](ruby-logging.md)
+ [Strumentazione del codice Ruby in AWS Lambda](ruby-tracing.md)
## Versioni SDK incluse nel runtime
La versione dell' AWS SDK inclusa nel runtime di Ruby dipende dalla versione di runtime e dalla tua. Regione AWS L' AWS SDK for Ruby è progettato per essere modulare ed è separato da. Servizio AWS Per trovare la versione di una determinata gemma di servizio inclusa nel runtime che stai utilizzando, crea una funzione Lambda con il codice nel seguente formato. Sostituisci `aws-sdk-s3` e `Aws::S3` con il nome delle gemme di servizio utilizzate dal tuo codice.
```
require 'aws-sdk-s3'
def lambda_handler(event:, context:)
puts "Service gem version: #{Aws::S3::GEM_VERSION}"
puts "Core version: #{Aws::CORE_GEM_VERSION}"
end
```
## Abilitazione di Yet Another Ruby JIT (YJIT)
I runtime Ruby supportano [YJIT, un compilatore Ruby JIT](https://docs.ruby-lang.org/en/master/jit/yjit_md.html) leggero e minimalista. YJIT offre prestazioni significativamente più elevate, ma utilizza anche più memoria rispetto all'interprete Ruby. YJIT è consigliato per i carichi di lavoro Ruby on Rails.
YJIT non è abilitato per impostazione predefinita. Per abilitare YJIT per una funzione Ruby, imposta la variabile di ambiente su. `RUBY_YJIT_ENABLE` `1` Per verificare che YJIT sia abilitato, stampa il risultato del metodo `RubyVM::YJIT.enabled?`.
**Example - Conferma che YJIT è abilitato**
```
puts(RubyVM::YJIT.enabled?())
# => true
```
# Definire l'handler di funzioni Lambda in Ruby
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.
**Topics**
+ [Nozioni di base sull'handler Ruby](#ruby-handler-basics)
+ [Best practice di codice per le funzioni Lambda con Ruby](#ruby-best-practices)
## Nozioni di base sull'handler Ruby
In questo esempio il file `function.rb` definisce un metodo del gestore denominato `handler`. La funzione del gestore richiede due oggetti come input e restituisce un documento JSON.
**Example function.rb**
```
require 'json'
def handler(event:, context:)
{ event: JSON.generate(event), context: JSON.generate(context.inspect) }
end
```
Nella configurazione della funzione, l'impostazione `handler` indica a Lambda dove trovare il gestore. Nell'esempio precedente, il valore corretto per questa impostazione è **function.handler**. Include due nomi separati da un punto: il nome del file e il nome del metodo del gestore.
È inoltre possibile definire il metodo del gestore in una classe. L'esempio seguente definisce il metodo del gestore `process` nella classe `Handler` nel modulo `LambdaFunctions`.
**Example source.rb**
```
module LambdaFunctions
class Handler
def self.process(event:,context:)
"Hello!"
end
end
end
```
In questo caso, l'impostazione del gestore è **source.LambdaFunctions::Handler.process**.
I due oggetti che il gestore accetta sono il contesto e l'evento di chiamata. L'evento è un oggetto Ruby che contiene il payload fornito dal chiamante. Se il payload è un documento JSON, l'oggetto evento è un hash Ruby. In caso contrario, è una stringa. L'[oggetto contesto](ruby-context.md) include i metodi e le proprietà che forniscono le informazioni sulla chiamata, sulla funzione e sull'ambiente di esecuzione.
Il gestore della funzione viene eseguito ogni volta che la funzione Lambda viene richiamata. Il codice statico all'esterno del gestore viene eseguito una volta per istanza della funzione. Se il gestore utilizza risorse come client SDK e connessioni database, puoi crearle al di fuori del metodo del gestore per riutilizzarle per più chiamate.
Ogni istanza della funzione può elaborare più eventi di chiamata, ma elabora un solo evento alla volta. Il numero di istanze che elaborano un evento in un dato momento costituisce la *simultaneità* della funzione. Per ulteriori informazioni sull'ambiente di esecuzione Lambda, consulta [Comprendere il ciclo di vita dell’ambiente di esecuzione Lambda](lambda-runtime-environment.md).
## Best practice di codice per le funzioni Lambda con Ruby
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. Ad esempio, in Ruby, l'aspetto è analogo al seguente:
```
def lambda_handler(event:, context:)
foo = event['foo']
bar = event['bar']
result = my_lambda_function(foo:, bar:)
end
def my_lambda_function(foo:, bar:)
// MyLambdaFunction logic here
end
```
+ **Controllare le dipendenze nel pacchetto di distribuzione della funzione. ** L'ambiente di esecuzione AWS Lambda contiene diverse librerie. Per il runtime Ruby, queste includono l'SDK AWS. Per abilitare il set di caratteristiche e aggiornamenti della sicurezza più recenti, Lambda aggiorna periodicamente tali librerie. Tali aggiornamenti possono introdurre lievi modifiche al comportamento della funzione Lambda. Per mantenere il controllo completo delle dipendenze utilizzate dalla funzione, inserire tutte le dipendenze nel pacchetto di implementazione.
+ **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. Per le funzioni create in Ruby, evitare di caricare l'intera libreria dell'SDK AWS come parte del pacchetto di implementazione. Dipendono invece in modo selettivo dalle gemme che prelevano i componenti dell'SDK necessari (ad esempio le gemme SDK DynamoDB e Amazon S3).
**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/).
# Distribuire le funzioni Ruby Lambda con gli archivi di file .zip
Il codice della funzione AWS Lambda comprende un file .rb contenente il codice del gestore della funzione, insieme a tutti i moduli aggiuntivi (gemme) da cui dipende il codice. Per implementare questo codice della funzione in Lambda, utilizza un *pacchetto di implementazione*. Questo pacchetto può essere un archivio di file .zip o un'immagine di container. Per ulteriori informazioni sull'uso delle immagini di container con Ruby, consulta la pagina [Implementazione di funzioni Lambda in Ruby con immagini di container](https://docs.aws.amazon.com/lambda/latest/dg/ruby-image.html).
Per creare un pacchetto di implementazione come archivio di file .zip, puoi utilizzare l'utilità di archiviazione di file .zip incorporata del tuo strumento della linea di comando o qualsiasi altra utilità file .zip, come ad esempio [7zip](https://www.7-zip.org/download.html). Gli esempi mostrati nelle sezioni seguenti presuppongono che tu stia utilizzando uno strumento della linea di comando `zip` in un ambiente Linux o MacOS. Per utilizzare gli stessi comandi in Windows, puoi [installare il sottosistema Windows per Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10) per ottenere una versione di Ubuntu e Bash integrata con Windows.
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.
I comandi di esempio nelle sezioni seguenti utilizzano l'utilità [Creatore di bundle](https://bundler.io/) per aggiungere dipendenze al pacchetto di implementazione. Per installare il creatore di bundle, esegui il comando sotto riportato.
```
gem install bundler
```
**Topics**
+ [Dipendenze in Ruby](#ruby-package-runtime-dependencies)
+ [Creazione di un pacchetto di implementazione .zip senza dipendenze](#ruby-package-codeonly)
+ [Creazione di un pacchetto di implementazione .zip con dipendenze](#ruby-package-dependencies)
+ [Creazione di un livello Ruby per dipendenze](#ruby-package-dependencies-layers)
+ [Creazione di un pacchetto di implementazione .zip con librerie native](#ruby-package-native)
+ [Creazione e aggiornamento delle funzioni Lambda di Ruby utilizzando file .zip](#ruby-package-create-functions)
## Dipendenze in Ruby
Per le funzioni Lambda che utilizzano il runtime di Ruby, una dipendenza può essere una qualsiasi gemma Ruby. Se implementi la funzione utilizzando un archivio .zip, puoi aggiungere queste dipendenze al file .zip con il tuo codice della funzione o utilizzare un livello Lambda. Un livello è un file .zip separato che può contenere codice aggiuntivo o altri contenuti. Per maggiori informazioni sull'uso dei livelli Lambda, consulta [Gestione delle dipendenze Lambda con i livelli](chapter-layers.md).
Il runtime di Ruby include AWS SDK per Ruby. Se la tua funzione utilizza l'SDK, non è necessario raggrupparla con il codice. Tuttavia, per mantenere il pieno controllo delle tue dipendenze o per utilizzare una versione specifica dell'SDK, puoi aggiungerlo al pacchetto di implementazione della tua funzione. Puoi includere l'SDK nel tuo file .zip o aggiungerlo utilizzando un livello Lambda. Le dipendenze nel file .zip o nei livelli Lambda hanno la precedenza sulle versioni incluse nel runtime. Per vedere quale versione dell'SDK per Ruby è inclusa nella tua versione di runtime, consulta [Versioni SDK incluse nel runtime](lambda-ruby.md#ruby-sdk-included).
In base al [modello di responsabilità condivisa di AWS](lambda-runtimes.md#runtimes-shared-responsibility), è tua responsabilità gestire eventuali dipendenze nei pacchetti di implementazione delle tue funzioni. Ciò include l'applicazione di aggiornamenti e patch di sicurezza. Per aggiornare le dipendenze nel pacchetto di implementazione della funzione, crea prima un nuovo file .zip e poi caricalo su Lambda. Per ulteriori informazioni, consulta [Creazione di un pacchetto di implementazione .zip con dipendenze](#ruby-package-dependencies) e [Creazione e aggiornamento delle funzioni Lambda di Ruby utilizzando file .zip](#ruby-package-create-functions).
## Creazione di un pacchetto di implementazione .zip senza dipendenze
Se il codice della funzione non ha dipendenze, il file .zip contiene solo il file .rb con il codice del gestore della funzione. Utilizza il tuo strumento di compressione preferito per creare un file .zip con il file .rb nella directory principale. Se il file .rb non si trova nella directory principale del file .zip, Lambda non sarà in grado di eseguire il codice.
Per informazioni su come implementare il file .zip per creare una nuova funzione Lambda o aggiornarne una esistente, consulta la sezione [Creazione e aggiornamento delle funzioni Lambda di Ruby utilizzando file .zip](#ruby-package-create-functions).
## Creazione di un pacchetto di implementazione .zip con dipendenze
Se il codice della funzione dipende da gem Ruby aggiuntivi, puoi aggiungere queste dipendenze al file .zip con il codice della funzione o utilizzare un [livello Lambda](chapter-layers.md). Le istruzioni in questa sezione mostrano come includere le dipendenze nel pacchetto di implementazione .zip. Per istruzioni sull’inclusione di dipendenze in un livello, consulta [Creazione di un livello Ruby per dipendenze](#ruby-package-dependencies-layers).
Supponiamo che il codice della funzione sia salvato in un file denominato `lambda_function.rb` nella directory del progetto. I seguenti comandi della CLI di esempio creano un file .zip denominato `my_deployment_package.zip` contenente il codice della funzione e le relative dipendenze.
**Per creare il pacchetto di implementazione**
1. Nella directory del progetto, crea un `Gemfile` in cui specificare le tue dipendenze.
```
bundle init
```
1. Utilizzando il tuo editor di testo preferito, modifica il `Gemfile` per specificare le dipendenze della tua funzione. Ad esempio, per utilizzare la gemma TZInfo, modifica il tuo `Gemfile` in modo che assomigli a quanto segue.
```
source "https://rubygems.org"
gem "tzinfo"
```
1. Esegui il comando sotto riportato per installare le gemme specificate nel `Gemfile` nella tua directory del progetto. Questo comando imposta `vendor/bundle` come percorso predefinito per le installazioni delle gemme.
```
bundle config set --local path 'vendor/bundle' && bundle install
```
Verrà visualizzato un output simile al seguente.
```
Fetching gem metadata from https://rubygems.org/...........
Resolving dependencies...
Using bundler 2.4.13
Fetching tzinfo 2.0.6
Installing tzinfo 2.0.6
...
```
**Nota**
Per installare nuovamente le gemme a livello globale in un secondo momento, esegui il comando sotto riportato.
```
bundle config set --local system 'true'
```
1. Crea un archivio di file .zip contenente il file `lambda_function.rb` con il codice del gestore della funzione e le dipendenze che hai installato nel passaggio precedente.
```
zip -r my_deployment_package.zip lambda_function.rb vendor
```
Verrà visualizzato un output simile al seguente.
```
adding: lambda_function.rb (deflated 37%)
adding: vendor/ (stored 0%)
adding: vendor/bundle/ (stored 0%)
adding: vendor/bundle/ruby/ (stored 0%)
adding: vendor/bundle/ruby/3.2.0/ (stored 0%)
adding: vendor/bundle/ruby/3.2.0/build_info/ (stored 0%)
adding: vendor/bundle/ruby/3.2.0/cache/ (stored 0%)
adding: vendor/bundle/ruby/3.2.0/cache/aws-eventstream-1.0.1.gem (deflated 36%)
...
```
## Creazione di un livello Ruby per dipendenze
Per informazioni su come impacchettare le dipendenze di Ruby in un livello Lambda, consulta [Utilizzo dei livelli per le funzioni Lamba di Ruby](ruby-layers.md).
## Creazione di un pacchetto di implementazione .zip con librerie native
Molte gemme Ruby comuni, come `nokogiri`, `nio4r` e `mysql`, contengono estensioni native scritte in C. Quando aggiungi librerie contenenti codice C al pacchetto di implementazione, devi creare il pacchetto correttamente per assicurarti che sia compatibile con l'ambiente di esecuzione Lambda.
Per le applicazioni di produzione, consigliamo di creare e implementare il codice utilizzando AWS Serverless Application Model (AWS SAM). In AWS SAM, usa l'opzione `sam build --use-container` per creare la tua funzione all'interno di un container Docker simile a Lambda. Per ulteriori informazioni sull'utilizzo di AWS SAM per implementare il codice della funzione, consulta la pagina [Creazione di applicazioni](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-using-build.html) nella *Guida per gli sviluppatori di AWS SAM*.
In alternativa, per creare un pacchetto di implementazione .zip contenente gemme con estensioni native senza utilizzare AWS SAM, puoi usare un container per raggruppare le tue dipendenze nello stesso ambiente del runtime Lambda di Ruby. Per completare questi passaggi, Docker deve essere installato sulla tua macchina di compilazione. Per ulteriori informazioni sull'installazione di Docker, consulta la pagina [Install Docker Engine](https://docs.docker.com/engine/install/).
**Creazione di un pacchetto di implementazione .zip in un container Docker**
1. Sulla tua macchina di compilazione locale, crea una cartella in cui salvare il container. All'interno di quella cartella, crea un file denominato `dockerfile` e incolla il seguente codice.
```
FROM public.ecr.aws/sam/build-ruby3.2:latest-x86_64
RUN gem update bundler
CMD "/bin/bash"
```
1. All'interno della cartella in cui hai creato il tuo `dockerfile`, esegui il comando sotto riportato per creare il container Docker.
```
docker build -t awsruby32 .
```
1. Accedi alla directory del progetto contenente il file `.rb` con il codice del gestore della funzione e il `Gemfile` specificato nelle dipendenze della funzione. Dall'interno di quella directory, esegui il comando sotto riportato per avviare il container Lambda Ruby.
------
#### [ Linux/MacOS ]
```
docker run --rm -it -v $PWD:/var/task -w /var/task awsruby32
```
**Nota**
In MacOS, potresti visualizzare un avviso che ti informa che la piattaforma dell'immagine richiesta non corrisponde alla piattaforma host rilevata. Ignora questo avviso.
------
#### [ Windows PowerShell ]
```
docker run --rm -it -v ${pwd}:var/task -w /var/task awsruby32
```
------
All'avvio del container, dovresti vedere un prompt bash.
```
bash-4.2#
```
1. Configura l'utilità di creazione di bundle per installare le gemme specificate nel `Gemfile` in una directory `vendor/bundle` locale e installare le tue dipendenze.
```
bash-4.2# bundle config set --local path 'vendor/bundle' && bundle install
```
1. Crea il pacchetto di implementazione .zip con il codice della funzione e le relative dipendenze. In questo esempio, il file contenente il codice del gestore della funzione è denominato `lambda_function.rb`.
```
bash-4.2# zip -r my_deployment_package.zip lambda_function.rb vendor
```
1. Esci dal container e torna alla directory del progetto locale.
```
bash-4.2# exit
```
Ora puoi usare il pacchetto di implementazione di file .zip per creare o aggiornare la tua funzione Lambda. Per informazioni, consultare [Creazione e aggiornamento delle funzioni Lambda di Ruby utilizzando file .zip](#ruby-package-create-functions)
## Creazione e aggiornamento delle funzioni Lambda di Ruby utilizzando file .zip
Dopo aver creato il pacchetto di implementazione .zip, puoi utilizzarlo per creare una nuova funzione Lambda o aggiornarne una esistente. È possibile caricare il pacchetto .zip utilizzando la console Lambda, l'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 di Linux, Lambda richiede 644 autorizzazioni per i file non eseguibili (rw-r--r--) e 755 autorizzazioni (rwxr-xr-x) per le directory e i file eseguibili.
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
```
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 del pacchetto di implementazione, Lambda imposta le autorizzazioni per tali directory su 755 (rwxr-xr-x).
### Creazione e aggiornamento delle funzioni con file .zip utilizzando la console
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 la Console di gestione AWS, consulta la sezione [Nozioni di base su Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html). Per caricare file utilizzando la AWS CLI, consulta la sezione [Spostamento di oggetti](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) nella *Guida per l'utente di AWS CLI*.
**Nota**
Non è possibile modificare il [tipo di pacchetto di implementazione](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#lambda-CreateFunction-request-PackageType) (.zip o immagine di container) per una funzione esistente. Ad esempio, non è possibile convertire una funzione di immagine di container esistente per utilizzare un archivio di file .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. Per **Runtime**, seleziona il runtime che desideri utilizzare.
1. (Facoltativo) Per **Architettura**, scegli l'architettura del set di istruzioni per la funzione. L'architettura predefinita è x86\$164. Assicurati che il pacchetto di implementazione per la tua funzione sia compatibile con l'architettura del set di istruzioni scelta.
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. Selezionare **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**.
### Aggiornamento delle funzioni dei file .zip tramite l'editor di codice della console
Per alcune funzioni con pacchetti di implementazione .zip, puoi utilizzare l'editor di codice integrato nella console Lambda per aggiornare direttamente il codice della funzione. Per utilizzare questa funzione, la funzione deve soddisfare i seguenti criteri:
+ La funzione deve utilizzare uno dei runtime del linguaggio interpretato (Python, Node.js o Ruby)
+ Il pacchetto di implementazione della funzione deve avere dimensioni inferiori a 50 MB (non compresso).
Il codice della funzione per le funzioni con pacchetti di implementazione di immagini di container non può essere modificato direttamente nella console.
**Aggiornamento del codice della funzione utilizzando l'editor di codice della console**
1. Apri la [pagina Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda e scegli la tua funzione.
1. Scegli la scheda **Codice**.
1. Nel riquadro **Origine del codice**, seleziona il tuo file di codice sorgente e modificalo nell'editor di codice integrato.
1. Nella sezione **DEPLOY**, scegli **Implementa** per aggiornare il codice della tua funzione:
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
### Creazione e aggiornamento delle funzioni con file .zip utilizzando la AWS CLI
È 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. Utilizza i comandi [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) per implementare 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 in un bucket Amazon S3 utilizzando la AWS CLI, consulta la sezione [Spostamento di oggetti](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) nella *Guida per l'utente di AWS CLI*.
**Nota**
Se carichi il file .zip da un bucket Amazon S3 utilizzando la AWS CLI, il bucket deve trovarsi nella stessa Regione AWS della funzione.
Per creare una nuova funzione mediante un file .zip con la AWS CLI, è necessario 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 ruby3.2 --handler lambda_function.lambda_handler \
--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 ruby3.2 --handler lambda_function.lambda_handler \
--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
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 delle funzioni con file .zip utilizzando AWS SAM
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 usa l'interfaccia della linea di comando AWS SAM (AWS SAM CLI) per compilare, creare pacchetti e implementare le tue applicazioni. Quando crei una funzione Lambda da un modello AWS SAM, AWS SAM crea automaticamente un pacchetto di implementazione .zip o un'immagine di container con il codice della funzione e le dipendenze specificate. Per ulteriori informazioni sull'utilizzo di AWS SAM per creare e implementare funzioni Lambda, consulta la pagina [Nozioni di base su AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-getting-started.html) nella *Guida introduttiva per gli sviluppatori di AWS Serverless Application Model*.
Puoi anche utilizzare AWS SAM per creare una funzione Lambda mediante 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 sul tuo computer di compilazione. Per istruzioni su come caricare un file in un bucket Amazon S3 utilizzando la AWS CLI, consulta la sezione [Spostamento di oggetti](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) nella *Guida per l'utente di AWS CLI*.
Nel modello AWS SAM, la risorsa `AWS::Serverless::Function` 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`: imposta il valore sull'URI Amazon S3, sul percorso della cartella locale o sull'oggetto [FunctionCode](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-function-functioncode.html) del codice della funzione
+ `Runtime`: imposta il runtime prescelto
Con AWS SAM, se il file .zip è superiore a 50 MB, non è necessario caricarlo prima in un bucket Amazon S3. AWS SAM può caricare pacchetti .zip fino alla dimensione massima consentita di 250 MB (dopo l'estrazione) da una posizione sulla macchina di compilazione locale.
Per ulteriori informazioni sull'implementazione di funzioni mediante il file .zip in AWS SAM, consulta la sezione [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html) nella *Guida per gli sviluppatori di AWS SAM*.
### Creazione e aggiornamento delle funzioni con file .zip utilizzando CloudFormation
È possibile utilizzare CloudFormation per creare una funzione Lambda mediante 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 in un bucket Amazon S3 utilizzando la AWS CLI, consulta la sezione [Spostamento di oggetti](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) nella *Guida per l'utente di AWS CLI*.
Nel modello CloudFormation, la risorsa `AWS::Lambda::Function` 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 sull'implementazione di funzioni mediante un file .zip in CloudFormation, consulta la sezione [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html) nella *Guida per gli sviluppatori di CloudFormation*.
# Distribuisci funzioni Lambda per Ruby con immagini di container
Esistono tre modi per creare un'immagine di container per una funzione Lambda in Ruby:
+ [Usare un'immagine AWS di base per Ruby](#ruby-image-instructions)
[Le immagini di base AWS](images-create.md#runtimes-images-lp) sono precaricate con un runtime in linguaggio, un client di interfaccia di runtime per gestire l'interazione tra Lambda e il codice della funzione e un emulatore di interfaccia di runtime per i test locali.
+ [Utilizzo di un'immagine di AWS base solo per il sistema operativo](images-create.md#runtimes-images-provided)
[AWS Le immagini di base solo](https://gallery.ecr.aws/lambda/provided) per il sistema operativo contengono una distribuzione Amazon Linux e l'emulatore [di interfaccia di runtime](https://github.com/aws/aws-lambda-runtime-interface-emulator/). Queste immagini vengono comunemente utilizzate per creare immagini di container per linguaggi compilati, come [Go](go-image.md#go-image-provided) e [Rust](lambda-rust.md), e per un linguaggio o una versione di linguaggio per cui Lambda non fornisce un'immagine di base, come Node.js 19. Puoi anche utilizzare immagini di base solo per il sistema operativo per implementare un [runtime personalizzato](runtimes-custom.md). Per rendere l'immagine compatibile con Lambda, devi includere il [client di interfaccia di runtime per Ruby](#ruby-image-clients) nell'immagine.
+ [Utilizzo di un'immagine non di base AWS ](#ruby-image-clients)
È 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 [client di interfaccia di runtime per Ruby](#ruby-image-clients) 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/build/building/multi-stage/) 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.
**Topics**
+ [AWS immagini di base per Ruby](#ruby-image-base)
+ [Usare un'immagine AWS di base per Ruby](#ruby-image-instructions)
+ [Utilizzo di un'immagine di base alternativa con il client di interfaccia di runtime](#ruby-image-clients)
## AWS immagini di base per Ruby
AWS fornisce le seguenti immagini di base per Ruby:
| Tag | Runtime | Sistema operativo | Dockerfile | Raggiunta obsolescenza |
| --- | --- | --- | --- | --- |
| 3.4 | Ruby 3.4 | Amazon Linux 2023 | [Dockerfile per Ruby 3.4 e versioni successive GitHub](https://github.com/aws/aws-lambda-base-images/blob/ruby3.4/Dockerfile.ruby3.4) | 31 marzo 2028 |
| 3.3 | Ruby 3.3 | Amazon Linux 2023 | [Dockerfile per Ruby 3.3 su GitHub](https://github.com/aws/aws-lambda-base-images/blob/ruby3.3/Dockerfile.ruby3.3) | 31 marzo 2027 |
| 3.2 | Ruby 3.2 | Amazon Linux 2 | [Dockerfile per Ruby 3.2 su GitHub](https://github.com/aws/aws-lambda-base-images/blob/ruby3.2/Dockerfile.ruby3.2) | 31 marzo 2026 |
[Archivio Amazon ECR: gallery.ecr. aws/lambda/ruby](https://gallery.ecr.aws/lambda/ruby)
## Usare un'immagine AWS di base per Ruby
### Prerequisiti
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.
+ Ruby
### Creazione di un'immagine da un'immagine di base
**Creazione di un'immagine di container per Ruby**
1. Crea una directory per il progetto, quindi passa a quella directory.
```
mkdir example
cd example
```
1. Crea un nuovo file denominato `Gemfile`. Qui è possibile elencare i RubyGems pacchetti richiesti dall'applicazione. AWS SDK per Ruby È disponibile da RubyGems. Dovresti scegliere AWS service gem specifici da installare. Ad esempio, per usare la [gemma Ruby per Lambda](https://rubygems.org/gems/aws-sdk-lambda/), il tuo Gemfile dovrebbe avere questo aspetto:
```
source 'https://rubygems.org'
gem 'aws-sdk-lambda'
```
In alternativa, la gemma [aws-sdk](https://rubygems.org/gems/aws-sdk/) contiene tutte le gem di servizio disponibili. AWS Questa gemma è molto grande. Ti consigliamo di utilizzarlo solo se dipendi da molti servizi. AWS
1. Installa le dipendenze specificate nel Gemfile utilizzando l'[installazione in bundle](https://bundler.io/v2.4/man/bundle-install.1.html).
```
bundle install
```
1. Crea un nuovo file denominato `lambda_function.rb`. A fini di test, puoi utilizzare il codice della funzione di esempio seguente o sostituirlo con il tuo codice personalizzato.
**Example Funzione Ruby**
```
module LambdaFunction
class Handler
def self.process(event:,context:)
"Hello from Lambda!"
end
end
end
```
1. Crea un nuovo Dockerfile. Il Dockerfile di esempio seguente utilizza l'[immagine di base AWS](images-create.md#runtimes-images-lp). Il Dockerfile utilizza la seguente configurazione:
+ Imposta la proprietà `FROM` sull'URI dell'immagine di base.
+ Utilizza il comando COPY per copiare il codice della funzione e le dipendenze di runtime in `{LAMBDA_TASK_ROOT}`, una [variabile d'ambiente definita da Lambda](configuration-envvars.md#configuration-envvars-runtime).
+ Imposta l'argomento `CMD` specificando il gestore della funzione Lambda.
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**
```
FROM public.ecr.aws/lambda/ruby:3.4
# Copy Gemfile and Gemfile.lock
COPY Gemfile Gemfile.lock ${LAMBDA_TASK_ROOT}/
# Install Bundler and the specified gems
RUN gem install bundler:2.4.20 && \
bundle config set --local path 'vendor/bundle' && \
bundle install
# Copy function code
COPY lambda_function.rb ${LAMBDA_TASK_ROOT}/
# Set the CMD to your handler (could also be done as a parameter override outside of the Dockerfile)
CMD [ "lambda_function.LambdaFunction::Handler.process" ]
```
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
1. Avvia l'immagine Docker con il comando **docker run**. In questo esempio, `docker-image` è il nome dell'immagine e `test` è il tag.
```
docker run --platform linux/amd64 -p 9000:8080 docker-image:test
```
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. Da una nuova finestra di terminale, invia un evento all'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
**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’`` con l’`repositoryUri` copiato. Assicurati di includere `:latest` alla fine dell'URI.
```
docker tag docker-image:test :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 di base alternativa con il client di interfaccia di runtime
Se utilizzi un'[immagine di base solo per il sistema operativo](images-create.md#runtimes-images-provided) o un'immagine di base alternativa, devi includere il client dell'interfaccia di runtime nell'immagine. Il client dell'interfaccia di runtime estende l'[API Runtime](runtimes-api.md), che gestisce l'interazione tra Lambda e il codice della funzione.
Installa il [client dell'interfaccia di runtime Lambda per Ruby utilizzando il gestore di RubyGems pacchetti.org](https://rubygems.org/gems/aws_lambda_ric):
```
gem install aws_lambda_ric
```
Puoi anche scaricare il client dell'[interfaccia di runtime Ruby da](https://github.com/aws/aws-lambda-ruby-runtime-interface-client). GitHub
L'esempio seguente mostra come creare un'immagine contenitore per Ruby utilizzando un'immagine non di base.AWS Il Dockerfile di esempio utilizza un'immagine di base Ruby ufficiale. Il Dockerfile include il client di interfaccia di runtime.
### Prerequisiti
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.
+ Ruby
### Creazione di un'immagine da un'immagine di base alternativa
**Creazione di un'immagine di container per Ruby utilizzando un'immagine di base alternativa**
1. Crea una directory per il progetto, quindi passa a quella directory.
```
mkdir example
cd example
```
1. Crea un nuovo file denominato `Gemfile`. Qui è possibile elencare i RubyGems pacchetti richiesti dall'applicazione. AWS SDK per Ruby È disponibile da RubyGems. Dovresti scegliere AWS service gem specifici da installare. Ad esempio, per usare la [gemma Ruby per Lambda](https://rubygems.org/gems/aws-sdk-lambda/), il tuo Gemfile dovrebbe avere questo aspetto:
```
source 'https://rubygems.org'
gem 'aws-sdk-lambda'
```
In alternativa, la gemma [aws-sdk](https://rubygems.org/gems/aws-sdk/) contiene tutte le gem di servizio disponibili. AWS Questa gemma è molto grande. Ti consigliamo di utilizzarlo solo se dipendi da molti servizi. AWS
1. Installa le dipendenze specificate nel Gemfile utilizzando l'[installazione in bundle](https://bundler.io/v2.4/man/bundle-install.1.html).
```
bundle install
```
1. Crea un nuovo file denominato `lambda_function.rb`. A fini di test, puoi utilizzare il codice della funzione di esempio seguente o sostituirlo con il tuo codice personalizzato.
**Example Funzione Ruby**
```
module LambdaFunction
class Handler
def self.process(event:,context:)
"Hello from Lambda!"
end
end
end
```
1. Crea un nuovo Dockerfile. Il seguente Dockerfile utilizza un'immagine di base Ruby anziché un'[immagine di base AWS](images-create.md#runtimes-images-lp). Il Dockerfile include il [client di interfaccia di runtime per Ruby](https://github.com/aws/aws-lambda-ruby-runtime-interface-client), che rende l'immagine compatibile con Lambda. In alternativa, puoi aggiungere il client di interfaccia di runtime al Gemfile dell'applicazione.
+ Imposta la proprietà `FROM` sull'immagine di base Ruby.
+ Crea una directory per il codice della funzione e una variabile di ambiente che punti a quella directory. In questo esempio, la directory è `/var/task`, che rispecchia l'ambiente di esecuzione Lambda. Tuttavia, puoi scegliere qualsiasi directory per il codice della funzione perché il Dockerfile non utilizza un'immagine di AWS base.
+ Imposta l'`ENTRYPOINT` sul modulo su cui desideri che il container Docker venga eseguito all'avvio. In questo caso, il modulo è il client di interfaccia di runtime.
+ Imposta l'argomento `CMD` specificando il gestore della funzione Lambda.
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**
```
FROM ruby:2.7
# Install the runtime interface client for Ruby
RUN gem install aws_lambda_ric
# Add the runtime interface client to the PATH
ENV PATH="/usr/local/bundle/bin:${PATH}"
# Create a directory for the Lambda function
ENV LAMBDA_TASK_ROOT=/var/task
RUN mkdir -p ${LAMBDA_TASK_ROOT}
WORKDIR ${LAMBDA_TASK_ROOT}
# Copy Gemfile and Gemfile.lock
COPY Gemfile Gemfile.lock ${LAMBDA_TASK_ROOT}/
# Install Bundler and the specified gems
RUN gem install bundler:2.4.20 && \
bundle config set --local path 'vendor/bundle' && \
bundle install
# Copy function code
COPY lambda_function.rb ${LAMBDA_TASK_ROOT}/
# Set runtime interface client as default command for the container runtime
ENTRYPOINT [ "aws_lambda_ric" ]
# Set the CMD to your handler (could also be done as a parameter override outside of the Dockerfile)
CMD [ "lambda_function.LambdaFunction::Handler.process" ]
```
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
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.
+ `aws_lambda_ric lambda_function.LambdaFunction::Handler.process` è l'`ENTRYPOINT` seguito dal `CMD` 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 \
aws_lambda_ric lambda_function.LambdaFunction::Handler.process
```
------
#### [ 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 `
aws_lambda_ric lambda_function.LambdaFunction::Handler.process
```
------
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
**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’`` con l’`repositoryUri` copiato. Assicurati di includere `:latest` alla fine dell'URI.
```
docker tag docker-image:test :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 Lamba di Ruby
Usa i [livelli Lambda](chapter-layers.md) per impacchettare codice e dipendenze che desideri riutilizzare in più funzioni. I livelli di solito contengono dipendenze dalla libreria, un [runtime personalizzato](runtimes-custom.md) o file di configurazione. La creazione di un livello prevede tre passaggi generali:
1. Crea un pacchetto per il contenuto del livello. Ciò significa creare un archivio di file con estensione .zip che contiene le dipendenze che desideri utilizzare nelle funzioni.
1. Crea il livello in Lambda.
1. Aggiungi il livello alle tue funzioni.
**Topics**
+ [Crea un pacchetto per il contenuto del livello](#ruby-layers-package)
+ [Crea il livello in Lambda.](#publishing-layer)
+ [Usare le gemme dei livelli in una funzione](#ruby-layers-bundler-limitations)
+ [Aggiungi il livello alla tua funzione.](#ruby-layer-adding)
+ [app di esempio](#ruby-layer-sample-app)
## Crea un pacchetto per il contenuto del livello
Per creare un livello, raggruppa i pacchetti in un archivio di file con estensione zip che soddisfi i seguenti requisiti:
+ Create il livello utilizzando la stessa versione di Ruby che intendete utilizzare per la funzione Lambda. Ad esempio, se create il vostro layer per Ruby 3.4, usate il runtime Ruby 3.4 per la vostra funzione.
+ Il file.zip del livello deve utilizzare una di queste strutture di directory:
+ `ruby/gems/x.x.x`(dove *x.x.x* è la vostra versione di Ruby, ad esempio) `3.4.0`
+ `ruby/lib`
Per ulteriori informazioni, consulta [Percorsi dei livelli per ciascun runtime Lambda](packaging-layers.md#packaging-layers-paths).
+ I pacchetti del livello devono essere compatibili con Linux. Le funzioni Lambda vengono eseguite su Amazon Linux.
Puoi creare livelli che contengono gemme Ruby di terze parti o moduli e classi Ruby personalizzati. Molte gemme Ruby popolari contengono estensioni native (codice C) che devono essere compilate per l'ambiente Lambda Linux.
### Gemme di ruby puro
Le gemme Pure Ruby contengono solo codice Ruby e non richiedono la compilazione. Queste gemme sono più semplici da impacchettare e funzionano su piattaforme diverse.
**Creazione di un livello utilizzando gemme di Ruby puri**
1. Crea uno `Gemfile` per specificare le gemme Ruby pure che desideri includere nel tuo livello:
**Example Gemfile**
```
source 'https://rubygems.org'
gem 'tzinfo'
```
1. Installa le gemme nella `vendor/bundle` directory usando Bundler:
```
bundle config set --local path vendor/bundle
bundle install
```
1. Copia le gemme installate nella struttura di directory richiesta da Lambda`ruby/gems/3.4.0`):
```
mkdir -p ruby/gems/3.4.0
cp -r vendor/bundle/ruby/3.4.0*/* ruby/gems/3.4.0/
```
1. Comprimi il contenuto dei livelli:
------
#### [ Linux/macOS ]
```
zip -r layer.zip ruby/
```
------
#### [ PowerShell ]
```
Compress-Archive -Path .\ruby -DestinationPath .\layer.zip
```
------
L'aspetto della struttura di directory dovrebbe essere simile al seguente:
```
ruby/
└── gems/
└── 3.4.0/
├── gems/
│ ├── concurrent-ruby-1.3.5/
│ └── tzinfo-2.0.6/
├── specifications/
├── cache/
├── build_info/
└── (other bundler directories)
```
**Nota**
È necessario richiedere ogni gemma singolarmente nel codice della funzione. Non è possibile utilizzare `bundler/setup` con `Bundler.require`. Per ulteriori informazioni, consulta [Usare le gemme dei livelli in una funzione](#ruby-layers-bundler-limitations).
### Gems con estensioni native
Molte gemme Ruby popolari contengono estensioni native (codice C) che devono essere compilate per la piattaforma di destinazione. [https://rubygems.org/gems/sqlite3/](https://rubygems.org/gems/sqlite3/) Queste gemme devono essere create in un ambiente Linux compatibile con il runtime Lambda.
**Creazione di un livello utilizzando gemme con estensioni native**
1. Creazione di un del `Gemfile`.
**Example Gemfile**
```
source 'https://rubygems.org'
gem 'nokogiri'
gem 'httparty'
```
1. Usa Docker per creare le gemme in un ambiente Linux compatibile con Lambda. Specificate un'[immagine di AWS base](ruby-image.md#ruby-image-base) nel vostro Dockerfile:
**Example Dockerfile per Ruby 3.4**
```
FROM public.ecr.aws/lambda/ruby:3.4
# Copy Gemfile
COPY Gemfile ./
# Install system dependencies for native extensions
RUN dnf update -y && \
dnf install -y gcc gcc-c++ make
# Configure bundler and install gems
RUN bundle config set --local path vendor/bundle && \
bundle install
# Create the layer structure
RUN mkdir -p ruby/gems/3.4.0 && \
cp -r vendor/bundle/ruby/3.4.0*/* ruby/gems/3.4.0/
# Create the layer zip file
RUN zip -r layer.zip ruby/
```
1. Costruisci l'immagine ed estrai il livello:
```
docker build -t ruby-layer-builder .
docker run --rm -v $(pwd):/output --entrypoint cp ruby-layer-builder layer.zip /output/
```
Questo crea le gemme nell'ambiente Linux corretto e copia il `layer.zip` file nella directory locale. L'aspetto della struttura di directory dovrebbe essere simile al seguente:
```
ruby/
└── gems/
└── 3.4.0/
├── gems/
│ ├── bigdecimal-3.2.2/
│ ├── csv-3.3.5/
│ ├── httparty-0.23.1/
│ ├── mini_mime-1.1.5/
│ ├── multi_xml-0.7.2/
│ ├── nokogiri-1.18.8-x86_64-linux-gnu/
│ └── racc-1.8.1/
├── build_info/
├── cache/
├── specifications/
└── (other bundler directories)
```
**Nota**
È necessario richiedere ogni gem singolarmente nel codice della funzione. Non è possibile utilizzare `bundler/setup` con `Bundler.require`. Per ulteriori informazioni, consulta [Usare le gemme dei livelli in una funzione](#ruby-layers-bundler-limitations).
### Moduli di Ruby personalizzati
**Creazione di un livello utilizzando il tuo codice**
1. Crea la struttura di directory richiesta per il tuo livello:
```
mkdir -p ruby/lib
```
1. Crea i tuoi moduli Ruby nella `ruby/lib` directory. Il seguente modulo di esempio convalida gli ordini confermando che contengono le informazioni richieste.
**Example ruby/lib/order\$1validator.rb**
```
require 'json'
module OrderValidator
class ValidationError < StandardError; end
def self.validate_order(order_data)
# Validates an order and returns formatted data
required_fields = %w[product_id quantity]
# Check required fields
missing_fields = required_fields.reject { |field| order_data.key?(field) }
unless missing_fields.empty?
raise ValidationError, "Missing required fields: #{missing_fields.join(', ')}"
end
# Validate quantity
quantity = order_data['quantity']
unless quantity.is_a?(Integer) && quantity > 0
raise ValidationError, 'Quantity must be a positive integer'
end
# Format and return the validated data
{
'product_id' => order_data['product_id'].to_s,
'quantity' => quantity,
'shipping_priority' => order_data.fetch('priority', 'standard')
}
end
def self.format_response(status_code, body)
# Formats the API response
{
statusCode: status_code,
body: JSON.generate(body)
}
end
end
```
1. Comprimi il contenuto dei livelli:
------
#### [ Linux/macOS ]
```
zip -r layer.zip ruby/
```
------
#### [ PowerShell ]
```
Compress-Archive -Path .\ruby -DestinationPath .\layer.zip
```
------
L'aspetto della struttura di directory dovrebbe essere simile al seguente:
```
ruby/
└── lib/
└── order_validator.rb
```
1. Nella tua funzione, richiedi e usa i moduli. È necessario richiedere ogni gemma singolarmente nel codice della funzione. Non è possibile utilizzare `bundler/setup` con `Bundler.require`. Per ulteriori informazioni, consulta [Usare le gemme dei livelli in una funzione](#ruby-layers-bundler-limitations). Esempio:
```
require 'json'
require 'order_validator'
def lambda_handler(event:, context:)
begin
# Parse the order data from the event body
order_data = JSON.parse(event['body'] || '{}')
# Validate and format the order
validated_order = OrderValidator.validate_order(order_data)
OrderValidator.format_response(200, {
message: 'Order validated successfully',
order: validated_order
})
rescue OrderValidator::ValidationError => e
OrderValidator.format_response(400, {
error: e.message
})
rescue => e
OrderValidator.format_response(500, {
error: 'Internal server error'
})
end
end
```
È possibile utilizzare i seguenti dati evento per [invocare la funzione](testing-functions.md#invoke-with-event):
```
{
"body": "{\"product_id\": \"ABC123\", \"quantity\": 2, \"priority\": \"express\"}"
}
```
Risposta prevista:
```
{
"statusCode": 200,
"body": "{\"message\":\"Order validated successfully\",\"order\":{\"product_id\":\"ABC123\",\"quantity\":2,\"shipping_priority\":\"express\"}}"
}
```
## Crea il livello in Lambda.
È possibile creare la funzione Lambda mediante la AWS CLI o la console Lambda.
------
#### [ AWS CLI ]
Esegui il AWS CLI comando [publish-layer-version](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/publish-layer-version.html) per creare il livello Lambda:
```
aws lambda publish-layer-version --layer-name my-layer --zip-file fileb://layer.zip --compatible-runtimes ruby3.4
```
Il parametro [compatible runtimes è facoltativo](https://docs.aws.amazon.com/lambda/latest/api/API_PublishLayerVersion.html#lambda-PublishLayerVersion-request-CompatibleRuntimes). Quando specificato, Lambda utilizza questo parametro per filtrare i livelli nella console Lambda.
------
#### [ Console ]
**Creazione di un livello (console)**
1. Apri la [pagina Layers](https://console.aws.amazon.com/lambda/home#/layers) (Livelli) nella console Lambda.
1. Scegli **Create layer** (Crea livello).
1. Scegli **Carica un file.zip**, quindi carica l'archivio.zip che hai creato in precedenza.
1. (Facoltativo) Per i **runtime compatibili**, scegli il runtime di Ruby che corrisponde alla versione di Ruby che hai usato per creare il tuo layer.
1. Seleziona **Create** (Crea).
------
## Usare le gemme dei livelli in una funzione
Nel codice della funzione, è necessario richiedere esplicitamente ogni gemma che si desidera utilizzare. I comandi Bundler come `bundler/setup` e non `Bundler.require` sono supportati. Ecco come usare correttamente le gemme di un livello in una funzione Lambda:
```
# Correct: Use explicit requires for each gem
require 'nokogiri'
require 'httparty'
def lambda_handler(event:, context:)
# Use the gems directly
doc = Nokogiri::HTML(event['html'])
response = HTTParty.get(event['url'])
# ... rest of your function
end
# Incorrect: These Bundler commands will not work
# require 'bundler/setup'
# Bundler.require
```
## Aggiungi il livello alla tua funzione.
------
#### [ AWS CLI ]
Per collegare il layer alla tua funzione, esegui il comando [AWS CLIupdate-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html). Usa l'attività ARN per il parametro `--layers`. L'ARN deve specificare la versione (ad esempio,`arn:aws:lambda:us-east-1:123456789012:layer:my-layer:1`). Per ulteriori informazioni, consulta [Livelli e versioni di livelli](chapter-layers.md#lambda-layer-versions).
```
aws lambda update-function-configuration --function-name my-function --cli-binary-format raw-in-base64-out --layers "arn:aws:lambda:us-east-1:123456789012:layer:my-layer:1"
```
L'opzione **cli-binary-format** è necessaria se si utilizza la versione 2 della AWS CLI. 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*.
------
#### [ Console ]
**Aggiunta di un livello a una funzione**
1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Scegli la funzione ().
1. Scorri verso il basso fino alla sezione **Livelli**, quindi scegli **Aggiungi un livello**.
1. In **Scegli un livello**, seleziona **Livelli personalizzati**, quindi scegli il tuo livello.
**Nota**
Se non hai aggiunto un [runtime compatibile](https://docs.aws.amazon.com/lambda/latest/api/API_PublishLayerVersion.html#lambda-PublishLayerVersion-request-CompatibleRuntimes) quando hai creato il layer, il tuo layer non verrà elencato qui. È possibile specificare invece il livello ARN.
1. Scegli **Aggiungi**.
------
## app di esempio
Per altri esempi di utilizzo dei layer Lambda, consulta l'applicazione di esempio [layer-ruby nel repository](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/layer-ruby) GitHub della Developer AWS Lambda Guide. [Questa applicazione include un livello che contiene la libreria tzinfo.](https://rubygems.org/gems/tzinfo) Dopo aver creato un livello, puoi implementare e richiamare la funzione corrispondente per verificare che tutto funzioni.
# Utilizzo dell'oggetto del contesto Lambda per recuperare le informazioni sulla funzione Ruby
Quando Lambda esegue la funzione, passa un oggetto Context al [gestore](ruby-handler.md). Questo oggetto fornisce i metodi e le proprietà che forniscono le informazioni sulla chiamata, sulla funzione e sull'ambiente di esecuzione.
**Metodi del contesto**
+ `get_remaining_time_in_millis`: restituisce il numero di millisecondi rimasti prima del timeout dell'esecuzione.
**Proprietà del contesto**
+ `function_name`: il nome della funzione Lambda.
+ `function_version`: la [versione](configuration-versions.md) della funzione.
+ `invoked_function_arn`: l'Amazon Resource Name (ARN) utilizzato per richiamare la funzione. Indica se l'invoker ha specificato un numero di versione o un alias.
+ `memory_limit_in_mb`: la quantità di memoria allocata per la funzione.
+ `aws_request_id`: l'identificatore della richiesta di invocazione.
+ `log_group_name`: il gruppo di log per la funzione.
+ `log_stream_name`: il flusso di log per l'istanza della funzione.
+ `deadline_ms`: la data del timeout dell'esecuzione in millisecondi Unix.
+ `identity`: (app per dispositivi mobili) Informazioni relative all'identità Amazon Cognito che ha autorizzato la richiesta.
+ `client_context`: (app per dispositivi mobili) Contesto client fornito a Lambda dall'applicazione client.
# Registrare e monitorare le funzioni Lambda con Ruby
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](#ruby-logging-output)
+ [Visualizzazione dei log nella console Lambda](#ruby-logging-console)
+ [Visualizzazione dei log nella console CloudWatch](#ruby-logging-cwconsole)
+ [Visualizzazione dei log utilizzando () AWS Command Line Interface AWS CLI](#ruby-logging-cli)
+ [Eliminazione dei log](#ruby-logging-delete)
+ [Utilizzo della libreria dei logger Ruby](#ruby-logging-lib)
## Creazione di una funzione che restituisce i registri
Per i log di output del codice della funzione, puoi usare le istruzioni `puts` o qualsiasi libreria di registrazione che scriva in `stdout` o `stderr`. L'esempio seguente registra i valori delle variabili di ambiente e l'oggetto evento.
**Example lambda\$1function.rb**
```
# lambda_function.rb
def handler(event:, context:)
puts "## ENVIRONMENT VARIABLES"
puts ENV.to_a
puts "## EVENT"
puts event.to_a
end
```
**Example Formato dei log**
```
START RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95 Version: $LATEST
## ENVIRONMENT VARIABLES
environ({'AWS_LAMBDA_LOG_GROUP_NAME': '/aws/lambda/my-function', 'AWS_LAMBDA_LOG_STREAM_NAME': '2020/01/31/[$LATEST]3893xmpl7fac4485b47bb75b671a283c', 'AWS_LAMBDA_FUNCTION_NAME': 'my-function', ...})
## EVENT
{'key': 'value'}
END RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95
REPORT RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95 Duration: 15.74 ms Billed Duration: 147 ms Memory Size: 128 MB Max Memory Used: 56 MB Init Duration: 130.49 ms
XRAY TraceId: 1-5e34a614-10bdxmplf1fb44f07bc535a1 SegmentId: 07f5xmpl2d1f6f85 Sampled: true
```
Il runtime di Ruby 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.
Per ottenere log più dettagliati, utilizza la [Utilizzo della libreria dei logger Ruby](#ruby-logging-lib).
## Visualizzazione dei log nella console Lambda
È 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
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
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
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.
## Utilizzo della libreria dei logger Ruby
La [libreria di registrazione](https://ruby-doc.org/stdlib-2.7.0/libdoc/logger/rdoc/index.html) Ruby restituisce log semplificati e facilmente leggibili. Utilizza l'utilità di registrazione per generare informazioni dettagliate, messaggi e codici di errore relativi alla tua funzione.
```
# lambda_function.rb
require 'logger'
def handler(event:, context:)
logger = Logger.new($stdout)
logger.info('## ENVIRONMENT VARIABLES')
logger.info(ENV.to_a)
logger.info('## EVENT')
logger.info(event)
event.to_a
end
```
L'output di `logger` include il livello del log, il timestamp e l'ID della richiesta.
```
START RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125 Version: $LATEST
[INFO] 2020-01-31T22:12:58.534Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 ## ENVIRONMENT VARIABLES
[INFO] 2020-01-31T22:12:58.534Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 environ({'AWS_LAMBDA_LOG_GROUP_NAME': '/aws/lambda/my-function', 'AWS_LAMBDA_LOG_STREAM_NAME': '2020/01/31/[$LATEST]1bbe51xmplb34a2788dbaa7433b0aa4d', 'AWS_LAMBDA_FUNCTION_NAME': 'my-function', ...})
[INFO] 2020-01-31T22:12:58.535Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 ## EVENT
[INFO] 2020-01-31T22:12:58.535Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 {'key': 'value'}
END RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125
REPORT RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125 Duration: 2.75 ms Billed Duration: 117 ms Memory Size: 128 MB Max Memory Used: 56 MB Init Duration: 113.51 ms
XRAY TraceId: 1-5e34a66a-474xmpl7c2534a87870b4370 SegmentId: 073cxmpl3e442861 Sampled: true
```
# Strumentazione del codice Ruby in AWS Lambda
Lambda si integra con AWS X-Ray per consentirti di tracciare, eseguire il debug e ottimizzare le applicazioni Lambda. Puoi utilizzare X-Ray per tracciare una richiesta mentre attraversa le risorse nell'applicazione, dall'API di frontend allo storage e al database di backend. Aggiungendo semplicemente la libreria X-Ray SDK alla configurazione di build, è possibile registrare errori e latenza per ogni chiamata effettuata dalla funzione a un servizio. AWS
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)
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).
**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/).
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, aggiungi la [AWSXRayDaemonWriteAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AWSXRayDaemonWriteAccess)policy al ruolo di esecuzione.
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).
È possibile strumentare il codice del gestore per registrare i metadati e tracciare le chiamate a valle. Per registrare dettagli sulle chiamate effettuate dal gestore ad altre risorse e servizi, utilizzare l'SDK for Ruby X-Ray. Per ottenere l'SDK, aggiungere il pacchetto `aws-xray-sdk` alle dipendenze dell'applicazione.
**Example [vuoto- ruby/function/Gemfile](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-ruby/function/Gemfile)**
```
# Gemfile
source 'https://rubygems.org'
gem 'aws-xray-sdk', '0.11.4'
gem 'aws-sdk-lambda', '1.39.0'
gem 'test-unit', '3.3.5'
```
Per i client Instrument AWS SDK, richiedi il `aws-xray-sdk/lambda` modulo dopo aver creato un client nel codice di inizializzazione.
**Example [blank- ruby/function/lambda \$1function.rb](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-ruby/function/lambda_function.rb) — Tracciamento di un client SDK AWS**
```
# lambda_function.rb
require 'logger'
require 'json'
require 'aws-sdk-lambda'
$client = Aws::Lambda::Client.new()
$client.get_account_settings()
require 'aws-xray-sdk/lambda'
def lambda_handler(event:, context:)
logger = Logger.new($stdout)
...
```
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 [X-Ray SDK for Ruby](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-ruby.html) nella Developer Guide. AWS X-Ray
**Topics**
+ [Abilitazione del tracciamento attivo con l'API Lambda](#ruby-tracing-api)
+ [Abilitazione del tracciamento attivo con CloudFormation](#ruby-tracing-cloudformation)
+ [Memorizzazione delle dipendenze di runtime in un layer](#ruby-tracing-layers)
## Abilitazione del tracciamento attivo con l'API Lambda
Per gestire la configurazione di tracciamento con AWS CLI o AWS SDK, utilizza 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.
## Abilitazione del tracciamento attivo con CloudFormation
Per attivare il tracciamento su una `AWS::Lambda::Function` risorsa in un CloudFormation modello, utilizzate la `TracingConfig` proprietà.
**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
...
```
## Memorizzazione delle dipendenze di runtime in un layer
Se utilizzi X-Ray SDK per strumentare i client AWS SDK del codice della funzione, il pacchetto di distribuzione può diventare piuttosto grande. Per evitare di caricare dipendenze di runtime ogni volta che si aggiorna il codice della funzione, includere l'SDK X-Ray in un [livello Lambda](chapter-layers.md).
L'esempio seguente mostra una risorsa `AWS::Serverless::LayerVersion` che memorizza l'SDK for Ruby X-Ray.
**Example [template.yml](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-ruby/template.yml) – Livello delle dipendenze**
```
Resources:
function:
Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)
Properties:
CodeUri: function/.
Tracing: Active
Layers:
- !Ref libs
...
libs:
Type: [AWS::Serverless::LayerVersion](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-layerversion.html)
Properties:
LayerName: blank-ruby-lib
Description: Dependencies for the blank-ruby sample app.
ContentUri: lib/.
CompatibleRuntimes:
- ruby2.5
```
Con questa configurazione, si aggiorna il livello della libreria solo se si modificano le dipendenze di runtime. Poiché il pacchetto di implementazione della funzione contiene solo il codice, questo può contribuire a ridurre i tempi di caricamento.
La creazione di un layer per le dipendenze richiede modifiche alla compilazione per generare l'archivio dei layer prima della distribuzione. Per un esempio funzionante, vedere l'applicazione di esempio [blank-ruby](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-ruby) .