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 di Lambda con l'infrastructure as code (IaC) Le funzioni Lambda raramente vengono eseguite in modo isolato. Spesso fanno invece parte di un'applicazione serverless con altre risorse come database, code e spazio di archiviazione. Con l'[infrastructure as code (IaC)](https://aws.amazon.com/what-is/iac/), è possibile automatizzare i processi di implementazione per implementare e aggiornare in modo rapido e ripetibile intere applicazioni serverless che coinvolgono molte risorse AWS separate. Questo approccio accelera il ciclo di sviluppo, semplifica la gestione della configurazione e garantisce che le risorse vengano implementate sempre allo stesso modo. ## Strumenti di IaC per Lambda **CloudFormation** CloudFormation è il servizio IaC fondamentale di AWS. Puoi utilizzare i [modelli YAML o JSON](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-guide.html) per modellare ed eseguire il provisioning dell'intera infrastruttura AWS, comprese le funzioni Lambda. CloudFormation gestisce le complessità legate alla creazione, all'aggiornamento e all'eliminazione delle risorse AWS. **AWS Serverless Application Model (AWS SAM)** AWS SAM è un framework open source basato su CloudFormation. Fornisce una sintassi semplificata per definire applicazioni serverless. Usa i [modelli AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-specification-template-anatomy.html) per effettuare rapidamente il provisioning di funzioni Lambda, API, database e origini eventi con poche righe di YAML. **AWS Cloud Development Kit (AWS CDK)** Il CDK è un approccio basato sul codice a IaC. Puoi definire la tua architettura basata su Lambda utilizzando TypeScript, JavaScript, Python, Java, C\$1/.NET o Go. Scegli il tuo linguaggio preferito e utilizza elementi di programmazione come parametri, condizionali, cicli, composizione ed ereditarietà per definire il risultato desiderato della tua infrastruttura. Il CDK genera quindi i modelli CloudFormation sottostanti per l'implementazione. Per un esempio di come utilizzare Lambda con CDK, consulta [Implementazione delle funzioni Lambda con AWS CDK](lambda-cdk-tutorial.md). ![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/IaC_tools.png) Inoltre, AWS fornisce un servizio chiamato AWS Infrastructure Composer per sviluppare modelli di IaC utilizzando una semplice interfaccia grafica. Con Infrastructure Composer, è possibile progettare un'architettura di applicazioni trascinando, raggruppando e connettendo i Servizi AWS in un canvas visivo. Infrastructure Composer crea quindi un modello AWS SAM oppure un modello CloudFormation a partire dal tuo progetto che puoi utilizzare per implementare l'applicazione. Nella sezione [Utilizzo delle funzioni Lambda in AWS SAM e Infrastructure Composer](foundation-iac-getting-started.md) seguente, Infrastructure Composer viene utilizzato per sviluppare un modello per un'applicazione serverless basata su una funzione Lambda esistente. # Utilizzo delle funzioni Lambda in AWS SAM e Infrastructure Composer In questo tutorial, puoi iniziare a utilizzare l'IaC con Lambda creando un modello AWS SAM da una funzione Lambda esistente e successivamente creando un'applicazione serverless in Infrastructure Composer mediante l'aggiunta di altre risorse AWS. Man mano che procedi in questo tutorial, imparerai alcuni concetti fondamentali, ad esempio come vengono specificate le risorse AWS in AWS SAM. Imparerai anche a utilizzare Infrastructure Composer per creare un'applicazione serverless che puoi implementare tramite AWS SAM oppure CloudFormation. Per completare questo tutorial, eseguirai le seguenti attività: + Creazione di una funzione Lambda di esempio + Utilizzo della console Lambda per visualizzare il modello AWS SAM della funzione + Esportazione della configurazione della funzione in AWS Infrastructure Composer e progettazione di una semplice applicazione serverless basata sulla configurazione della funzione + Salvataggio di un modello AWS SAM aggiornato che può essere utilizzato come base per implementare un'applicazione serverless ## Prerequisiti In questo tutorial, utilizzi la funzionalità di [sincronizzazione locale](https://docs.aws.amazon.com/application-composer/latest/dg/reference-features-local-sync.html) di Infrastructure Composer per salvare i file di modello e codice sul computer di compilazione locale. Per utilizzare questa funzionalità, è necessario un browser che supporti l'API File System Access, che consente alle applicazioni web di leggere, scrivere e salvare file nel file system locale. Ti consigliamo di utilizzare Google Chrome o Microsoft Edge. Per ulteriori informazioni sull'API File System Access, consulta la pagina [What is the File System Access API?](https://docs.aws.amazon.com/application-composer/latest/dg/reference-fsa.html#reference-fsa-api) ## Creazione di una funzione Lambda In questo primo passaggio, creerai una funzione Lambda da utilizzare nei passaggi successivi del tutorial. Per semplicità, utilizzerai la console Lambda per creare una funzione di base "Hello world" tramite il runtime Python 3.11. **Creazione di una funzione Lambda "Hello world" tramite la console** 1. Aprire la [console Lambda](https://console.aws.amazon.com/lambda). 1. Scegli **Crea funzione**. 1. Lascia selezionato **Crea da zero** e, in **Informazioni di base**, immetti **LambdaIaCDemo** come **Nome della funzione**. 1. In **Runtime**, scegli **Python 3.11**. 1. Scegli **Crea funzione**. ## Visualizzazione del modello AWS SAM per la funzione Prima di esportare la configurazione della funzione in Infrastructure Composer, utilizza la console Lambda per visualizzare la configurazione corrente della funzione come modello AWS SAM. Seguendo i passaggi di questa sezione, imparerai a conoscere la struttura di un modello AWS SAM e a definire risorse come le funzioni Lambda per iniziare a specificare un'applicazione serverless. **Visualizzazione del modello AWS SAM per la funzione** 1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda. 1. Scegli la funzione creata in precedenza (`LambdaIaCDemo`). 1. Nel riquadro **Panoramica della funzione**, scegli **Modello**. Al posto del diagramma che rappresenta la configurazione della funzione, vedrai un modello AWS SAM relativo alla funzione. Il modello avrà un aspetto simile al seguente. ``` # This AWS SAM template has been generated from your function's # configuration. If your function has one or more triggers, note # that the AWS resources associated with these triggers aren't fully # specified in this template and include placeholder values.Open this template # in AWS Application Composer or your favorite IDE and modify # it to specify a serverless application with other AWS resources. AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 Description: An AWS Serverless Specification template describing your function. Resources: LambdaIaCDemo: Type: AWS::Serverless::Function Properties: CodeUri: . Description: '' MemorySize: 128 Timeout: 3 Handler: lambda_function.lambda_handler Runtime: python3.11 Architectures: - x86_64 EventInvokeConfig: MaximumEventAgeInSeconds: 21600 MaximumRetryAttempts: 2 EphemeralStorage: Size: 512 RuntimeManagementConfig: UpdateRuntimeOn: Auto SnapStart: ApplyOn: None PackageType: Zip Policies: Statement: - Effect: Allow Action: - logs:CreateLogGroup Resource: arn:aws:logs:us-east-1:123456789012:* - Effect: Allow Action: - logs:CreateLogStream - logs:PutLogEvents Resource: - >- arn:aws:logs:us-east-1:123456789012:log-group:/aws/lambda/LambdaIaCDemo:* ``` Esaminiamo il modello YAML per la funzione in uso e apprendiamo alcuni concetti chiave. Il modello inizia con la dichiarazione `Transform: AWS::Serverless-2016-10-31`. Questa dichiarazione è obbligatoria perché, dietro le quinte, i modelli AWS SAM vengono implementati tramite CloudFormation. L'utilizzo dell'istruzione `Transform` identifica il modello come file di modello AWS SAM. Dopo la dichiarazione `Transform`, arriva la sezione `Resources`. Qui definisci le risorse AWS che desideri implementare con il modello AWS SAM. I modelli AWS SAM possono contenere una combinazione di risorse AWS SAM e risorse CloudFormation. Questo perché, durante l'implementazione, i modelli AWS SAM si espandono in modelli CloudFormation, quindi a un modello AWS SAM è possibile aggiungere qualsiasi sintassi CloudFormation valida. Al momento, nella sezione `Resources` del modello è presente soltanto una risorsa definita, la funzione Lambda `LambdaIaCDemo`. Per aggiungere una funzione Lambda a un modello AWS SAM, utilizzi il tipo di risorsa `AWS::Serverless::Function`. La risorsa `Properties` di una funzione Lambda definisce il runtime della funzione, il gestore delle funzioni e altre opzioni di configurazione. Qui viene definito anche il percorso del codice sorgente della funzione che AWS SAM deve utilizzare per implementare la funzione. Per ulteriori informazioni sulle risorse della funzione Lambda 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*. Oltre alle proprietà e alle configurazioni della funzione, il modello specifica anche una policy AWS Identity and Access Management (IAM) per la funzione. Questa policy autorizza la funzione a scrivere i log in Amazon CloudWatch Logs. Quando crei una funzione nella console Lambda, Lambda associa automaticamente questa policy alla tua funzione. Per ulteriori informazioni sulla definizione di una policy IAM per una funzione in un modello AWS SAM, consulta la proprietà `policies` nella pagina [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html) della *Guida per gli sviluppatori di AWS SAM*. Per ulteriori informazioni sulla struttura dei modelli AWS SAM, consulta la pagina [AWS SAM template anatomy](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-specification-template-anatomy.html). ## Utilizzo di AWS Infrastructure Composer per progettare un'applicazione serverless Per iniziare a creare una semplice applicazione serverless utilizzando il modello AWS SAM della funzione come punto di partenza, esporta la configurazione della funzione in Infrastructure Composer e attiva la modalità di sincronizzazione locale di Infrastructure Composer. La sincronizzazione locale salva automaticamente il codice della funzione e il modello AWS SAM sul computer di compilazione locale e mantiene sincronizzato il modello salvato man mano che si aggiungono altre risorse AWS a Infrastructure Composer. **Per esportare una funzione Lambda in Infrastructure Composer** 1. Nel riquadro **Panoramica della funzione**, scegli **Esporta in Strumento per la creazione di applicazioni**. Per esportare la configurazione e il codice della funzione in Infrastructure Composer, Lambda crea un bucket Amazon S3 nel tuo account in cui archiviare temporaneamente questi dati. 1. Nella finestra di dialogo, scegli **Conferma e crea progetto** per accettare il nome predefinito per questo bucket ed esportare la configurazione e il codice della funzione in Infrastructure Composer. 1. (Facoltativo) Per scegliere un altro nome per il bucket Amazon S3 creato da Lambda, immetti un nuovo nome e scegli **Conferma e crea progetto**. I nomi dei bucket Amazon S3 devono essere univoci a livello globale e seguire le [regole di denominazione dei bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html). Selezionando **Conferma e crea progetto** si apre la console Infrastructure Composer. Nel *canvas* vedrai la funzione Lambda. 1. Dal menu a discesa **Menu**, scegli **Attiva sincronizzazione locale**. 1. Nella finestra di dialogo che si apre, scegli **Seleziona cartella** e seleziona una cartella sul tuo computer di compilazione locale. 1. Scegli **Attiva** per attivare la sincronizzazione locale. Per esportare la funzione in Infrastructure Composer, è necessaria l'autorizzazione a utilizzare determinate operazioni API. Se non sei in grado di esportare la funzione, consulta [Autorizzazioni richieste](services-appcomposer.md#services-appcomposer-permissions) e assicurati di disporre delle autorizzazioni necessarie. **Nota** Il bucket che Lambda crea quando esporti una funzione in Infrastructure Composer è soggetto ai [prezzi di Amazon S3](https://aws.amazon.com/s3/pricing) standard. Gli oggetti che Lambda inserisce nel bucket vengono eliminati automaticamente dopo 10 giorni, ma il bucket in sé non viene eliminato. Per evitare l'addebito di costi aggiuntivi sul tuo Account AWS, segui le istruzioni in [Eliminazione di un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-bucket.html) dopo aver esportato la funzione in Infrastructure Composer. Per ulteriori informazioni sul bucket Amazon S3 creato da Lambda, consulta la pagina [Utilizzo AWS Lambda con AWS Infrastructure Composer](services-appcomposer.md). **Per progettare un'applicazione serverless in Infrastructure Composer** Dopo aver attivato la sincronizzazione locale, le modifiche apportate in Infrastructure Composer si rifletteranno nel modello AWS SAM salvato sul computer di compilazione locale. Ora puoi trascinare e rilasciare altre risorse AWS sul canvas di Infrastructure Composer per creare l'applicazione. In questo esempio, aggiungi una coda semplice Amazon SQS come trigger per la funzione Lambda e una tabella DynamoDB in cui la funzione può scrivere i dati. 1. Per aggiungere un trigger Amazon SQS alla funzione Lambda, effettua le seguenti operazioni: 1. Nel campo di ricerca della palette **Risorse**, immetti **SQS**. 1. Trascina la risorsa **Coda SQS** sul canvas e posizionala a sinistra della funzione Lambda. 1. Seleziona **Dettagli** e per **ID logico** immetti **LambdaIaCQueue**. 1. Selezionare **Salva**. 1. Connetti le tue risorse Amazon SQS e Lambda facendo clic sulla porta **Abbonamento** sulla scheda della coda SQS e trascinandola sulla porta sinistra della scheda della funzione Lambda. La comparsa di una linea tra le due risorse indica che la connessione è stabilita. Inoltre, nella parte inferiore del canvas, Infrastructure Composer visualizza un messaggio che indica che le due risorse sono state connesse correttamente. 1. Per aggiungere una tabella Amazon DynamoDB in cui la funzione Lambda può scrivere dati, effettua le seguenti operazioni: 1. Nel campo di ricerca della palette **Risorse**, immetti **DynamoDB**. 1. Trascina la risorsa **Tabella DynamoDB** sul canvas e posizionala a destra della funzione Lambda. 1. Seleziona **Dettagli** e per **ID logico** immetti **LambdaIaCTable**. 1. Selezionare **Salva**. 1. Connetti la tabella DynamoDB alla funzione Lambda facendo clic sulla porta destra della scheda della funzione Lambda e trascinandola sulla porta sinistra della scheda di DynamoDB. Ora che hai aggiunto queste nuove risorse, diamo un'occhiata al modello AWS SAM aggiornato creato da Infrastructure Composer. **Visualizzazione del modello AWS SAM aggiornato** + Nel canvas di Infrastructure Composer, scegli **Modello** per passare dalla visualizzazione del canvas alla visualizzazione del modello. Ora il modello AWS SAM dovrebbe contenere le seguenti risorse e proprietà aggiuntive: + Una coda Amazon SQS con l'identificativo `LambdaIaCQueue` ``` LambdaIaCQueue: Type: AWS::SQS::Queue Properties: MessageRetentionPeriod: 345600 ``` Quando aggiungi una coda Amazon SQS utilizzando Infrastructure Composer, questo imposta la proprietà `MessageRetentionPeriod`. Puoi anche impostare la proprietà `FifoQueue` selezionando **Dettagli** sulla scheda della coda SQS e selezionando o deselezionando **Coda Fifo**. Per impostare altre proprietà per la coda, puoi modificare manualmente il modello per aggiungerle. Per ulteriori informazioni sulla risorsa `AWS::SQS::Queue` e sulle sue proprietà disponibili, consulta la sezione [AWS::SQS::Queue](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-sqs-queue.html) nella *Guida per l'utente di CloudFormation*. + Una proprietà `Events` nella definizione della funzione Lambda che specifica la coda Amazon SQS come trigger per la funzione ``` Events: LambdaIaCQueue: Type: SQS Properties: Queue: !GetAtt LambdaIaCQueue.Arn BatchSize: 1 ``` La proprietà `Events` è composta da un tipo di evento e da un insieme di proprietà che dipendono dal tipo. Per ulteriori informazioni sui diversi Servizi AWS che puoi configurare per attivare una funzione Lambda e le proprietà che puoi impostare, consulta la sezione [EventSource](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-function-eventsource.html) nella *Guida per gli sviluppatori di AWS SAM*. + Una tabella DynamoDB con l'identificatore `LambdaIaCTable` ``` LambdaIaCTable: Type: AWS::DynamoDB::Table Properties: AttributeDefinitions: - AttributeName: id AttributeType: S BillingMode: PAY_PER_REQUEST KeySchema: - AttributeName: id KeyType: HASH StreamSpecification: StreamViewType: NEW_AND_OLD_IMAGES ``` Quando aggiungi una tabella DynamoDB utilizzando Infrastructure Composer, puoi impostare le chiavi della tabella scegliendo **Dettagli** nella scheda della tabella DynamoDB e modificando i valori delle chiavi. Infrastructure Composer imposta anche i valori predefiniti anche per una serie di altre proprietà, tra cui `BillingMode` e `StreamViewType`. Per ulteriori informazioni su queste proprietà e sulle altre proprietà che puoi aggiungere al tuo modello AWS SAM, consulta la sezione [AWS::DynamoDB::Table](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-dynamodb-table.html) nella *Guida per l'utente di CloudFormation*. + Una nuova policy IAM che autorizza la funzione a eseguire operazioni CRUD sulla tabella DynamoDB che hai aggiunto. ``` Policies: ... - DynamoDBCrudPolicy: TableName: !Ref LambdaIaCTable ``` Il modello AWS SAM finale completo avrà un aspetto simile al seguente. ``` AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 Description: An AWS Serverless Specification template describing your function. Resources: LambdaIaCDemo: Type: AWS::Serverless::Function Properties: CodeUri: . Description: '' MemorySize: 128 Timeout: 3 Handler: lambda_function.lambda_handler Runtime: python3.11 Architectures: - x86_64 EventInvokeConfig: MaximumEventAgeInSeconds: 21600 MaximumRetryAttempts: 2 EphemeralStorage: Size: 512 RuntimeManagementConfig: UpdateRuntimeOn: Auto SnapStart: ApplyOn: None PackageType: Zip Policies: - Statement: - Effect: Allow Action: - logs:CreateLogGroup Resource: arn:aws:logs:us-east-1:594035263019:* - Effect: Allow Action: - logs:CreateLogStream - logs:PutLogEvents Resource: - arn:aws:logs:us-east-1:594035263019:log-group:/aws/lambda/LambdaIaCDemo:* - DynamoDBCrudPolicy: TableName: !Ref LambdaIaCTable Events: LambdaIaCQueue: Type: SQS Properties: Queue: !GetAtt LambdaIaCQueue.Arn BatchSize: 1 Environment: Variables: LAMBDAIACTABLE_TABLE_NAME: !Ref LambdaIaCTable LAMBDAIACTABLE_TABLE_ARN: !GetAtt LambdaIaCTable.Arn LambdaIaCQueue: Type: AWS::SQS::Queue Properties: MessageRetentionPeriod: 345600 LambdaIaCTable: Type: AWS::DynamoDB::Table Properties: AttributeDefinitions: - AttributeName: id AttributeType: S BillingMode: PAY_PER_REQUEST KeySchema: - AttributeName: id KeyType: HASH StreamSpecification: StreamViewType: NEW_AND_OLD_IMAGES ``` ## Implementazione dell'applicazione serverless utilizzando AWS SAM (facoltativo) Se desideri utilizzare AWS SAM per implementare un'applicazione serverless mediante il modello appena creato in Infrastructure Composer, devi prima installare la CLI di AWS SAM. Per farlo, segui le istruzioni riportate nella pagina [Installing the AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html). Inoltre, prima di implementare l'applicazione devi aggiornare il codice della funzione che Infrastructure Composer ha salvato insieme al modello. Al momento, il file `lambda_function.py` salvato da Infrastructure Composer contiene solo il codice di base "Hello world" fornito da Lambda al momento della creazione della funzione. Per aggiornare il codice della funzione, copia il codice seguente e incollalo nel file `lambda_function.py` che Infrastructure Composer ha salvato sul computer di compilazione locale. Hai specificato la directory in cui Infrastructure Composer deve salvare questo file quando hai attivato la modalità di sincronizzazione locale. Questo codice accetta una coppia chiave-valore in un messaggio dalla coda Amazon SQS creata in Infrastructure Composer. Se sia la chiave sia il valore sono stringhe, il codice li utilizza per scrivere un elemento nella tabella DynamoDB definita nel modello. ### Codice della funzione Python aggiornato ``` import boto3 import os import json # define the DynamoDB table that Lambda will connect to tablename = os.environ['LAMBDAIACTABLE_TABLE_NAME'] # create the DynamoDB resource dynamo = boto3.client('dynamodb') def lambda_handler(event, context): # get the message out of the SQS event message = event['Records'][0]['body'] data = json.loads(message) # write event data to DDB table if check_message_format(data): key = next(iter(data)) value = data[key] dynamo.put_item( TableName=tablename, Item={ 'id': {'S': key}, 'Value': {'S': value} } ) else: raise ValueError("Input data not in the correct format") # check that the event object contains a single key value # pair that can be written to the database def check_message_format(message): if len(message) != 1: return False key, value = next(iter(message.items())) if not (isinstance(key, str) and isinstance(value, str)): return False else: return True ``` **Implementazione dell'applicazione serverless** Per implementare l'applicazione utilizzando la CLI di AWS SAM, effettua le seguenti operazioni. Affinché la funzione venga compilata e implementata correttamente, sul computer di compilazione e nel `PATH` deve essere installata la versione 3.11 di Python. 1. Esegui il seguente comando dalla directory in cui Infrastructure Composer ha salvato i tuoi file `template.yaml` e `lambda_function.py`. ``` sam build ``` Questo comando raccoglie gli artefatti di compilazione per l'applicazione e li colloca nel formato e nella posizione corretti per l'implementazione. 1. Per implementare l'applicazione e creare le risorse Lambda, Amazon SQS e DynamoDB specificate nel modello AWS SAM, esegui il comando seguente. ``` sam deploy --guided ``` L'utilizzo del flag `--guided` significa che AWS SAM mostrerà le istruzioni per guidarti attraverso il processo di implementazione. Per questa implementazione, accetta le opzioni predefinite premendo Invio. Durante il processo di implementazione, AWS SAM crea le seguenti risorse nel tuo Account AWS: + Uno [stack](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-whatis-concepts.html#cfn-concepts-stacks) CloudFormation denominato `sam-app` + Una funzione Lambda con il formato del nome `sam-app-LambdaIaCDemo-99VXPpYQVv1M` + Una coda Amazon SQS con il formato del nome `sam-app-LambdaIaCQueue-xL87VeKsGiIo` + Una tabella DynamoDB con il formato del nome `sam-app-LambdaIaCTable-CN0S66C0VLNV` AWS SAM crea anche i ruoli e le policy IAM necessari in modo che la funzione Lambda possa leggere i messaggi dalla coda Amazon SQS ed eseguire operazioni CRUD sulla tabella DynamoDB. ## Test dell'applicazione implementata (facoltativo) Per confermare che l'applicazione serverless sia stata implementata correttamente, invia un messaggio alla coda Amazon SQS contenente una coppia chiave-valore e verifica che Lambda scriva un elemento nella tabella DynamoDB utilizzando questi valori. **Test dell'applicazione serverless** 1. Apri la pagina [Code](https://console.aws.amazon.com/sqs/v2/home#/queues) della console Amazon SQS e seleziona la coda che AWS SAM ha creato dal modello. Il formato del nome è `sam-app-LambdaIaCQueue-xL87VeKsGiIo`. 1. Scegli **Invio e ricezione di messaggi** e incolla il seguente JSON nel **Corpo del messaggio** nella sezione **Invia messaggio**. ``` { "myKey": "myValue" } ``` 1. Scegliere **Invia messaggio**. L'invio del messaggio alla coda farà sì che Lambda chiami la funzione tramite lo strumento di mappatura dell'origine degli eventi definito nel modello AWS SAM. Per verificare che Lambda abbia chiamato la funzione come previsto, verifica che alla tabella DynamoDB sia stato aggiunto un elemento. 1. Apri la pagina [Tabelle](https://console.aws.amazon.com/dynamodbv2#tables) della console DynamoDB e scegli la tabella. Il formato del nome è `sam-app-LambdaIaCTable-CN0S66C0VLNV`. 1. Scegli **Explore table items** (Esplora elementi della tabella). Nel riquadro **Elementi restituiti**, dovresti vedere un elemento con l'**id** `myKey` e il **valore** `myValue`. # Implementazione delle funzioni Lambda con AWS CDK AWS Cloud Development Kit (AWS CDK) Si tratta di un framework Infrastructure as Code (IaC) che puoi utilizzare per definire l'infrastruttura AWS cloud utilizzando un linguaggio di programmazione di tua scelta. Per definire la tua infrastruttura cloud, devi innanzitutto scrivere un'app (in uno dei linguaggi supportati dal CDK) contenente uno o più stack. Quindi, lo sintetizzi in un CloudFormation modello e distribuisci le tue risorse sul tuo. Account AWS Segui i passaggi descritti in questo argomento per implementare una funzione Lambda che restituisce un evento da un endpoint Gateway Amazon API. La AWS Construct Library, inclusa nel CDK, fornisce moduli che è possibile utilizzare per modellare le risorse fornite. Servizi AWS Per i servizi più diffusi, la libreria fornisce costrutti curati con impostazioni predefinite intelligenti e best practice. Puoi utilizzare il modulo [aws\$1lambda](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html) per definire la tua funzione e le risorse di supporto con poche righe di codice. ## Prerequisiti Prima di iniziare questo tutorial, installatelo AWS CDK eseguendo il seguente comando. ``` npm install -g aws-cdk ``` ## Fase 1: Configura il tuo AWS CDK progetto Crea una directory per la tua nuova AWS CDK app e inizializza il progetto. ------ #### [ JavaScript ] ``` mkdir hello-lambda cd hello-lambda cdk init --language javascript ``` ------ #### [ TypeScript ] ``` mkdir hello-lambda cd hello-lambda cdk init --language typescript ``` ------ #### [ Python ] ``` mkdir hello-lambda cd hello-lambda cdk init --language python ``` Una volta avviato il progetto, attiva l'ambiente virtuale del progetto e installa le dipendenze di base per AWS CDK. ``` source .venv/bin/activate python -m pip install -r requirements.txt ``` ------ #### [ Java ] ``` mkdir hello-lambda cd hello-lambda cdk init --language java ``` Importa questo progetto Maven nel tuo ambiente di sviluppo integrato (IDE) Java. Ad esempio, in Eclipse, usa **File**, **Importa**, **Maven**, **Progetti Maven esistenti**. ------ #### [ C\$1 ] ``` mkdir hello-lambda cd hello-lambda cdk init --language csharp ``` ------ **Nota** Il modello di AWS CDK applicazione utilizza il nome della directory del progetto per generare nomi per i file e le classi di origine. In questo esempio, la directory è denominata `hello-lambda`. Se utilizzi un nome di directory del progetto diverso, l'app non corrisponderà a queste istruzioni. AWS CDK v2 include costrutti stabili per tutti Servizi AWS in un unico pacchetto chiamato. `aws-cdk-lib` Questo pacchetto viene installato come dipendenza quando inizializzi il progetto. Quando lavori con determinati linguaggi di programmazione, il pacchetto viene installato quando crei il progetto per la prima volta. ## Fase 2: Definire lo stack AWS CDK Uno *stack* CDK è una raccolta di uno o più costrutti che definiscono le risorse. AWS Ogni stack CDK rappresenta uno stack nell'app CDK. CloudFormation Per definire lo stack CDK, segui le istruzioni relative al tuo linguaggio di programmazione preferito. Questo stack definisce quanto segue: + Il nome logico della funzione: `MyFunction` + La posizione del codice della funzione, specificata nella proprietà `code`. Per ulteriori informazioni, consulta [Codice dell'handler](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html#handler-code) nella *Documentazione di riferimento API AWS Cloud Development Kit (AWS CDK) *. + Il nome logico della REST API: `HelloApi` + Il nome logico dell'endpoint API Gateway: `ApiGwEndpoint` Tieni presente che tutti gli stack CDK di questo tutorial utilizzano il [runtime](lambda-runtimes.md) Node.js per la funzione Lambda. È possibile utilizzare diversi linguaggi di programmazione per lo stack CDK e la funzione Lambda per sfruttare i punti di forza di ogni linguaggio. Ad esempio, è possibile utilizzare lo stack CDK TypeScript per sfruttare i vantaggi della digitazione statica per il codice dell'infrastruttura. È possibile utilizzare la funzione Lambda JavaScript per sfruttare la flessibilità e il rapido sviluppo di un linguaggio digitato dinamicamente. ------ #### [ JavaScript ] Apri il file `lib/hello-lambda-stack.js` e sostituisci il contenuto con quanto riportato di seguito. ``` const { Stack } = require('aws-cdk-lib'); const lambda = require('aws-cdk-lib/aws-lambda'); const apigw = require('aws-cdk-lib/aws-apigateway'); class HelloLambdaStack extends Stack { /** * * @param {Construct} scope * @param {string} id * @param {StackProps=} props */ constructor(scope, id, props) { super(scope, id, props); const fn = new lambda.Function(this, 'MyFunction', { code: lambda.Code.fromAsset('lib/lambda-handler'), runtime: lambda.Runtime.NODEJS_LATEST, handler: 'index.handler' }); const endpoint = new apigw.LambdaRestApi(this, 'MyEndpoint', { handler: fn, restApiName: "HelloApi" }); } } module.exports = { HelloLambdaStack } ``` ------ #### [ TypeScript ] Apri il file `lib/hello-lambda-stack.ts` e sostituisci il contenuto con quanto riportato di seguito. ``` import * as cdk from 'aws-cdk-lib'; import { Construct } from 'constructs'; import * as apigw from "aws-cdk-lib/aws-apigateway"; import * as lambda from "aws-cdk-lib/aws-lambda"; import * as path from 'node:path'; export class HelloLambdaStack extends cdk.Stack { constructor(scope: Construct, id: string, props?: cdk.StackProps){ super(scope, id, props) const fn = new lambda.Function(this, 'MyFunction', { runtime: lambda.Runtime.NODEJS_LATEST, handler: 'index.handler', code: lambda.Code.fromAsset(path.join(__dirname, 'lambda-handler')), }); const endpoint = new apigw.LambdaRestApi(this, `ApiGwEndpoint`, { handler: fn, restApiName: `HelloApi`, }); } } ``` ------ #### [ Python ] Apri il file `/hello-lambda/hello_lambda/hello_lambda_stack.py` e sostituisci il contenuto con quanto riportato di seguito. ``` from aws_cdk import ( Stack, aws_apigateway as apigw, aws_lambda as _lambda ) from constructs import Construct class HelloLambdaStack(Stack): def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None: super().__init__(scope, construct_id, **kwargs) fn = _lambda.Function( self, "MyFunction", runtime=_lambda.Runtime.NODEJS_LATEST, handler="index.handler", code=_lambda.Code.from_asset("lib/lambda-handler") ) endpoint = apigw.LambdaRestApi( self, "ApiGwEndpoint", handler=fn, rest_api_name="HelloApi" ) ``` ------ #### [ Java ] Apri il file `/hello-lambda/src/main/java/com/myorg/HelloLambdaStack.java` e sostituisci il contenuto con quanto riportato di seguito. ``` package com.myorg; import software.constructs.Construct; import software.amazon.awscdk.Stack; import software.amazon.awscdk.StackProps; import software.amazon.awscdk.services.apigateway.LambdaRestApi; import software.amazon.awscdk.services.lambda.Function; public class HelloLambdaStack extends Stack { public HelloLambdaStack(final Construct scope, final String id) { this(scope, id, null); } public HelloLambdaStack(final Construct scope, final String id, final StackProps props) { super(scope, id, props); Function hello = Function.Builder.create(this, "MyFunction") .runtime(software.amazon.awscdk.services.lambda.Runtime.NODEJS_LATEST) .code(software.amazon.awscdk.services.lambda.Code.fromAsset("lib/lambda-handler")) .handler("index.handler") .build(); LambdaRestApi api = LambdaRestApi.Builder.create(this, "ApiGwEndpoint") .restApiName("HelloApi") .handler(hello) .build(); } } ``` ------ #### [ C\$1 ] Apri il file `src/HelloLambda/HelloLambdaStack.cs` e sostituisci il contenuto con quanto riportato di seguito. ``` using Amazon.CDK; using Amazon.CDK.AWS.APIGateway; using Amazon.CDK.AWS.Lambda; using Constructs; namespace HelloLambda { public class HelloLambdaStack : Stack { internal HelloLambdaStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props) { var fn = new Function(this, "MyFunction", new FunctionProps { Runtime = Runtime.NODEJS_LATEST, Code = Code.FromAsset("lib/lambda-handler"), Handler = "index.handler" }); var api = new LambdaRestApi(this, "ApiGwEndpoint", new LambdaRestApiProps { Handler = fn }); } } } ``` ------ ## Fase 3: creazione del codice della funzione Lambda 1. Dalla root del tuo progetto (`hello-lambda`), crea la directory `/lib/lambda-handler` per il codice della funzione Lambda. Questa directory è specificata nella `code` proprietà dello stack. AWS CDK 1. Crea un nuovo file chiamato `index.js` nella `/lib/lambda-handler` directory. Incolla il codice seguente nel file. La funzione estrae proprietà specifiche dalla richiesta API e le restituisce come risposta JSON. ``` exports.handler = async (event) => { // Extract specific properties from the event object const { resource, path, httpMethod, headers, queryStringParameters, body } = event; const response = { resource, path, httpMethod, headers, queryStringParameters, body, }; return { body: JSON.stringify(response, null, 2), statusCode: 200, }; }; ``` ## Fase 4: Distribuire lo stack AWS CDK 1. Dalla root del progetto, esegui il comando [cdk synth](https://docs.aws.amazon.com/cdk/v2/guide/ref-cli-cmd-synth.html): ``` cdk synth ``` Questo comando sintetizza un AWS CloudFormation modello dallo stack CDK. Il modello è un file YAML di circa 400 righe simile al seguente. **Nota** Se viene visualizzato il seguente errore, assicurarti di trovarti nella root della directory del tuo progetto. ``` --app is required either in command-line, in cdk.json or in ~/.cdk.json ``` **Example CloudFormation modello** ``` Resources: MyFunctionServiceRole3C357FF2: Type: AWS::IAM::Role Properties: AssumeRolePolicyDocument: Statement: - Action: sts:AssumeRole Effect: Allow Principal: Service: lambda.amazonaws.com Version: "2012-10-17" ManagedPolicyArns: - Fn::Join: - "" - - "arn:" - Ref: AWS::Partition - :iam::aws:policy/service-role/AWSLambdaBasicExecutionRole Metadata: aws:cdk:path: HelloLambdaStack/MyFunction/ServiceRole/Resource MyFunction1BAA52E7: Type: AWS::Lambda::Function Properties: Code: S3Bucket: Fn::Sub: cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region} S3Key: ab1111111cd32708dc4b83e81a21c296d607ff2cdef00f1d7f48338782f92l3901.zip Handler: index.handler Role: Fn::GetAtt: - MyFunctionServiceRole3C357FF2 - Arn Runtime: nodejs24.x ... ``` 1. Esegui il comando [cdk deploy](https://docs.aws.amazon.com/cdk/v2/guide/ref-cli-cmd-deploy.html): ``` cdk deploy ``` Attendi che le tue risorse vengano create. L'output finale include l'URL per l'endpoint API Gateway. Esempio: ``` Outputs: HelloLambdaStack.ApiGwEndpoint77F417B1 = https://abcd1234.execute-api.us-east-1.amazonaws.com/prod/ ``` ## Fase 5: esecuzione del test della funzione Per richiamare la funzione Lambda, copia l'endpoint API Gateway e incollalo in un browser Web o esegui un comando `curl`: ``` curl -s https://abcd1234.execute-api.us-east-1.amazonaws.com/prod/ ``` La risposta è una rappresentazione JSON delle proprietà selezionate dall'oggetto evento originale, che contiene informazioni sulla richiesta effettuata all'endpoint API Gateway. Esempio: ``` { "resource": "/", "path": "/", "httpMethod": "GET", "headers": { "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7", "Accept-Encoding": "gzip, deflate, br, zstd", "Accept-Language": "en-US,en;q=0.9", "CloudFront-Forwarded-Proto": "https", "CloudFront-Is-Desktop-Viewer": "true", "CloudFront-Is-Mobile-Viewer": "false", "CloudFront-Is-SmartTV-Viewer": "false", "CloudFront-Is-Tablet-Viewer": "false", "CloudFront-Viewer-ASN": "16509", "CloudFront-Viewer-Country": "US", "Host": "abcd1234.execute-api.us-east-1.amazonaws.com", ... ``` ## Fase 6: eliminare le risorse L'endpoint API Gateway è accessibile pubblicamente. Per evitare addebiti imprevisti, esegui il comando [cdk destroy](https://docs.aws.amazon.com/cdk/v2/guide/ref-cli-cmd-destroy.html) per eliminare lo stack e tutte le risorse associate. ``` cdk destroy ``` ## Fasi successive Per informazioni sulla scrittura di AWS CDK app nella lingua che preferisci, consulta quanto segue: ------ #### [ TypeScript ] [Lavorare con AWS CDK in TypeScript](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-typescript.html) ------ #### [ JavaScript ] [Lavorare con l' AWS CDK interno JavaScript](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-javascript.html) ------ #### [ Python ] [Lavorare con il AWS CDK in Python](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-python.html) ------ #### [ Java ] [Lavorare con il AWS CDK in Java](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-java.html) ------ #### [ C\$1 ] [Lavorare con il AWS CDK in C\$1](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-csharp.html) ------ #### [ Go ] [Lavorare con AWS CDK in Go](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-go.html) ------