Utilizzo dei livelli per le funzioni Lamba di Ruby - AWS Lambda

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

Utilizzo dei livelli per le funzioni Lamba di Ruby

Un livello Lambda è un archivio di file .zip che può contenere codice o dati aggiuntivi. I livelli di solito contengono dipendenze dalla libreria, un runtime personalizzato 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.

  2. Crea il livello in Lambda.

  3. Aggiungi il livello alle tue funzioni.

Questo argomento contiene passaggi e indicazioni su come creare un pacchetto e un livello Lambda per Ruby con dipendenze di librerie esterne.

Prerequisiti

Per completare le fasi riportate in questa sezione, è necessario:

In questo argomento, facciamo riferimento all'applicazione di esempio layer-ruby nel repository GitHub di awsdocs. Questa applicazione contiene script che scaricano le dipendenze e generano i livelli. L'applicazione contiene anche le funzioni corrispondenti che utilizzano la dipendenza dai livelli. Dopo aver creato un livello, puoi implementare e richiamare la funzione corrispondente per verificare che tutto funzioni correttamente. Poiché si utilizza il runtime Ruby 3.3 per le funzioni, i livelli devono essere compatibili anche con Ruby 3.3.

Nell'applicazione layer-ruby di esempio, la libreria tzinfo viene impacchettata in un livello Lambda. La directory layer/ contiene gli script per generare il livello. La directory function/ contiene una funzione di esempio per verificare il funzionamento del livello. Nella maggior parte di questo tutorial viene spiegato come creare e impacchettare questo livello.

Compatibilità dei livelli Ruby con l'ambiente di runtime Lambda

Quando si impacchetta il codice in un livello Ruby, si specificano gli ambienti di runtime Lambda con cui il codice è compatibile. Per valutare la compatibilità del codice con un runtime, considera le versioni di Ruby, i sistemi operativi e le architetture di set di istruzioni per cui è progettato il codice.

I runtime Lambda Ruby specificano la versione di Ruby e il sistema operativo. In questo documento, utilizzerai il runtime Ruby 3.3, basato su AL2023. Per ulteriori informazioni sulle versioni di runtime, consulta Runtime supportati. Quando crei una funzione Lambda, puoi specificare l'architettura del set di istruzioni. In questo documento, utilizzerai l'architettura x86_64. Per ulteriori informazioni sulle architetture in Lambda, consulta Selezione e configurazione di un'architettura di set di istruzioni per la funzione Lambda.

Quando si utilizza il codice fornito in un pacchetto, ogni manutentore del pacchetto definisce in modo indipendente la propria compatibilità. La maggior parte delle gemme sono scritte completamente in Ruby e sono compatibili con qualsiasi runtime che utilizza una versione compatibile in linguaggio Ruby.

A volte, le gemme usano una funzionalità di Ruby chiamata estensioni per compilare il codice o includono codice precompilato come parte del processo di installazione. Se dipendi da una gemma con un'estensione nativa, devi valutare la compatibilità del sistema operativo e dell'architettura del set di istruzioni. Per valutare la compatibilità tra le gemme e il runtime di Ruby, è necessario ispezionare le gemme e consultare la loro documentazione. Puoi capire se la tua gemma utilizza estensioni controllando se extensions è definita nella sua specifica Gem. Ruby identifica la piattaforma su cui è in esecuzione attraverso la costante globale RUBY_PLATFORM. Il runtime Ruby di Lambda definisce la piattaforma aarch64-linux quando viene eseguita sull'architettura arm64 o x86_64-linux quando viene eseguita sull'architettura x86_64. Non esiste un modo garantito per verificare se una gemma è compatibile con queste piattaforme, ma alcune gemme dichiarano le piattaforme supportate tramite l'attributo di specifica Gem platform.

Percorsi dei livelli per i runtime Ruby

Quando si aggiunge un livello a una funzione, Lambda carica il contenuto del livello nella directory /opt di quell'ambiente di esecuzione. Per ogni runtime Lambda, la variabile PATH include percorsi di cartelle specifici nella directory /opt. Per garantire che la variabile PATH raccolga il contenuto del livello, il file .zip del livello dovrebbe avere le sue dipendenze nei seguenti percorsi di cartella:

  • ruby/gems/x, dove x è la versione di Ruby sul runtime, ad esempio 3.3.0.

  • ruby/lib/

In questo documento, usa il percorso ruby/gems/x. Lambda si aspetta che il contenuto di questa directory corrisponda alla struttura di una directory di installazione di Bundler. Memorizza le tue dipendenze delle gemme nella sottodirectory /gems del percorso del livello, insieme ad altre sottodirectory di metadati. Ad esempio, il file .zip del livello risultante creato in questo tutorial ha la seguente struttura di directory:

layer_content.zip └ ruby └ gems └ 3.3.0 └ gems └ tzinfo-2.0.6 └ <other_dependencies> (i.e. dependencies of the tzinfo package) └ ... └ <metadata generated by bundle>

La libreria tzinfo è posizionata correttamente nella directory ruby/gems/3.3.0/. Ciò garantisce che Lambda possa localizzare la libreria durante l'invocazione delle funzioni.

Impacchettamento del contenuto dei livelli

In questo esempio, impacchetti la libreria tzinfo Ruby in un file .zip di livelli. Per installare e creare il pacchetto del contenuto del livello, completa i seguenti passaggi.

Per installare e creare il pacchetto del contenuto dei livelli
  1. Clona il repository aws-lambda-developer-guide GitHub, che contiene il codice di esempio di cui hai bisogno nella directory sample-apps/layer-ruby.

    git clone https://github.com/awsdocs/aws-lambda-developer-guide.git
  2. Passa alla directory layer dell'app di esempio layer-ruby. Questa directory contiene gli script che usi per creare e impacchettare correttamente il livello.

    cd aws-lambda-developer-guide/sample-apps/layer-ruby/layer
  3. Esamina il Gemfile. Questo file definisce le dipendenze da includere nel livello, ovvero la libreria tzinfo. È possibile aggiornare questo file per includere tutte le dipendenze che si desidera nel livello.

    Esempio Gemfile
    source "https://rubygems.org" gem "tzinfo"
  4. Assicurati di disporre delle autorizzazioni per eseguire entrambi gli script.

    chmod 744 1-install.sh && chmod 744 2-package.sh
  5. Esegui lo script 1-install.sh utilizzando il comando seguente:

    ./1-install.sh

    Questo script configura il bundler per installare le dipendenze nella directory del progetto. Quindi installa tutte le dipendenze richieste nella directory vendor/bundle/.

    Esempio 1-install.sh
    bundle config set --local path 'vendor/bundle' bundle install
  6. Esegui lo script 2-package.sh utilizzando il comando seguente:

    ./2-package.sh

    Questo script copia il contenuto della directory vendor/bundle in una nuova directory denominata ruby. Comprime quindi il contenuto della directory ruby in un file denominato layer_content.zip. Questo è il file con estensione .zip per il livello. È possibile decomprimere il file e verificare che contenga la struttura di file corretta, come mostrato nella sezione Percorsi dei livelli per i runtime Ruby.

    Esempio 2-package.sh
    mkdir -p ruby/gems/3.3.0 cp -r vendor/bundle/ruby/3.3.0/* ruby/gems/3.3.0/ zip -r layer_content.zip ruby

Creazione del livello

In questa sezione, viene utilizzato il file layer_content.zip generato nella sezione precedente e viene caricato come livello Lambda. È possibile caricare un livello utilizzando la AWS Management Console o l'API Lambda tramite la AWS Command Line Interface (AWS CLI). Quando carichi il file .zip dei livelli, nel seguente comando AWS CLIPublishLayerVersion, specifica ruby3.3 come runtime compatibile e arm64 come architettura compatibile.

aws lambda publish-layer-version --layer-name ruby-requests-layer \ --zip-file fileb://layer_content.zip \ --compatible-runtimes ruby3.3 \ --compatible-architectures "arm64"

Dalla risposta, nota LayerVersionArn, che assomiglia a arn:aws:lambda:us-east-1:123456789012:layer:ruby-requests-layer:1. Avrai bisogno di questo nome della risorsa Amazon (ARN) nel passaggio successivo di questo tutorial, quando aggiungerai il livello alla tua funzione.

Aggiunta del livello alla tua funzione

In questa sezione, viene implementata una funzione Lambda di esempio che utilizza la libreria tzinfo nel suo codice funzione, quindi si collega il livello. Per implementare la funzione, è necessario un Definizione delle autorizzazioni della funzione Lambda con un ruolo di esecuzione. Se non disponi ancora di un ruolo di esecuzione, completa i passaggi nella sezione comprimibile.

Creazione di un ruolo di esecuzione
  1. Apri la pagina Ruoli nella console IAM.

  2. Scegliere Create role (Crea ruolo).

  3. Creare un ruolo con le seguenti proprietà.

    • Trusted entity (Entità attendibileLambda

    • Permissions (Autorizzazioni) AWSLambdaBasicExecutionRole.

    • Role name (Nome ruolo) – lambda-role.

    La policy AWSLambdaBasicExecutionRole dispone delle autorizzazioni delle quali la funzione necessita per scrivere i log in CloudWatch Logs.

Il codice della funzione Lambda importa la libreria tzinfo, quindi restituisce il codice di stato e una stringa di data localizzata.

require 'json' require 'tzinfo' def lambda_handler(event:, context:) tz = TZInfo::Timezone.get('America/New_York') { statusCode: 200, body: tz.to_local(Time.utc(2018, 2, 1, 12, 30, 0)) } end
Per implementare la funzione Lambda
  1. Passa alla directory function/. Se ti trovi attualmente nella directory layer/, esegui il seguente comando:

    cd ../function
  2. Crea un pacchetto di implementazione di file .zip utilizzando il seguente comando:

    zip my_deployment_package.zip lambda_function.rb
  3. Implementare la funzione. Nel comando AWS CLI seguente, sostituisci il parametro --role con l'ARN del tuo ruolo di esecuzione:

    aws lambda create-function --function-name ruby_function_with_layer \ --runtime ruby3.3 \ --architectures "arm64" \ --handler lambda_function.lambda_handler \ --role arn:aws:iam::123456789012:role/lambda-role \ --zip-file fileb://my_deployment_package.zip
  4. Quindi, collega il livello alla tua funzione. Nel comando AWS CLI seguente, sostituisci il parametro --layers con l'ARN della versione del livello notato in precedenza:

    aws lambda update-function-configuration --function-name ruby_function_with_layer \ --cli-binary-format raw-in-base64-out \ --layers "arn:aws:lambda:us-east-1:123456789012:layer:ruby-requests-layer:1"
  5. Infine, prova a richiamare la tua funzione usando il seguente comando AWS CLI:

    aws lambda invoke --function-name ruby_function_with_layer \ --cli-binary-format raw-in-base64-out \ --payload '{ "key": "value" }' response.json

    L'output visualizzato dovrebbe essere di questo tipo:

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

    Il file response.json di output contiene dettagli sulla risposta.

Ora è possibile eliminare le risorse create per questo tutorial, a meno che non si voglia conservarle. Eliminando le risorse AWS che non si utilizzano più, è possibile evitare addebiti superflui sul proprio account Account AWS.

Per eliminare il livello Lambda
  1. Apri la pagina Layers (Livelli) nella console Lambda.

  2. Seleziona il livello che hai creato.

  3. Seleziona Elimina, quindi scegli di nuovo Elimina.

Per eliminare la funzione Lambda
  1. Aprire la pagina Functions (Funzioni) della console Lambda.

  2. Selezionare la funzione creata.

  3. Scegliere Operazioni, Elimina.

  4. Digita delete nel campo di immissione testo e scegli Delete (Elimina).