Prerequisiti Fase 1: Configurazione del progetto Fase 2: Definire lo stack Fase 3: Creare la funzione Fase 4: Implementazione dello stack Fase 5: Testare la funzione Fase 6: pulizia Passaggi successivi

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 prima scrivere un'app (in una delle CDK lingue supportate) che contenga uno o più stack. Quindi, la sintetizzi in un AWS CloudFormation modello e distribuisci le tue risorse su. Account AWS Segui i passaggi descritti in questo argomento per distribuire una funzione Lambda che restituisce un evento da un endpoint API Amazon Gateway.

La AWS Construct Library, inclusa inCDK, fornisce moduli che puoi usare 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 usare il modulo aws_lambda per definire la tua funzione e le risorse di supporto con poche righe di codice.

Prerequisiti

Prima di iniziare questo tutorial, installalo 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.

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 CDK stack è una raccolta di uno o più costrutti che definiscono le risorse. AWS Ogni CDK stack rappresenta uno AWS CloudFormation stack nella tua app. CDK

Per definire il tuo stackCDK, 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 code proprietà. Per ulteriori informazioni, vedete Handler code nel AWS Cloud Development Kit (AWS CDK) APIReference.
Il nome logico REST API è: HelloApi
Il nome logico dell'endpoint API Gateway: ApiGwEndpoint

Nota che tutti gli CDK stack di questo tutorial utilizzano il runtime Node.js per la funzione Lambda. È possibile utilizzare diversi linguaggi di programmazione per lo CDK stack e la funzione Lambda per sfruttare i punti di forza di ogni linguaggio. Ad esempio, è possibile utilizzare TypeScript for the CDK stack 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.asset('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#

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: Creare il codice della funzione Lambda

Dalla radice del tuo progetto (hello-lambda), crea la /lib/lambda-handler directory per il codice della funzione Lambda. Questa directory è specificata nella code proprietà del tuo AWS CDK stack.

Crea un nuovo file chiamato index.js nella /lib/lambda-handler directory. Incolla il codice seguente nel file. La funzione estrae proprietà specifiche dalla API richiesta e le restituisce come JSON risposta.


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

Dalla radice del progetto, esegui il comando cdk synth:


cdk synth

Questo comando sintetizza un AWS CloudFormation modello dal tuo stack. CDK Il modello è un YAML file di circa 400 righe, simile al seguente.

Nota

Se ricevete il seguente errore, assicuratevi di trovarvi nella cartella principale del progetto.


--app is required either in command-line, in cdk.json or in ~/.cdk.json

Esempio AWS 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: nodejs20.x
      ...

Esegui il comando cdk deploy:
```
cdk deploy
```
Attendi che le tue risorse vengano create. L'output finale include il URL per l'endpoint API Gateway. Esempio:
```
Outputs:
HelloLambdaStack.ApiGwEndpoint77F417B1 = https://abcd1234.execute-api.us-east-1.amazonaws.com/prod/
```

Fase 5: Testare la funzione

Per richiamare la funzione Lambda, copia API l'endpoint 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 JSON rappresentazione delle proprietà selezionate dall'oggetto evento originale, che contiene informazioni sulla richiesta effettuata all'endpoint Gateway. API 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 per eliminare lo stack e tutte le risorse associate.


cdk destroy

Passaggi successivi

Per informazioni sulla scrittura di AWS CDK app nella lingua che preferisci, consulta quanto segue:

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Infrastructure as code (IaC)

Modello di programmazione