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