Tutorial: crea un'applicazione Hello World senza server - AWS Cloud Development Kit (AWS CDK) v2
PrerequisitiFase 1: Creare un CDK progettoFase 2: Crea la tua funzione LambdaFase 3: Definisci i tuoi costruttiFase 4: Preparare l'applicazione per la distribuzioneFase 5: distribuzione dell'applicazionePassaggio 6: Interagisci con l'applicazionePassaggio 7: Eliminare l'applicazioneRisoluzione dei problemi

Questa è la guida per sviluppatori AWS CDK v2. La versione precedente della CDK versione 1 è entrata in manutenzione il 1° giugno 2022 e ha terminato il supporto il 1° giugno 2023.

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

Tutorial: crea un'applicazione Hello World senza server

In questo tutorial, si utilizza AWS Cloud Development Kit (AWS CDK) per creare una semplice Hello World applicazione serverless che implementa un API backend di base composto da quanto segue:

  • Amazon API Gateway REST API: fornisce un HTTP endpoint che viene utilizzato per richiamare la funzione tramite una HTTP GET richiesta.

  • AWS Lambda function: funzione che restituisce un Hello World! messaggio quando viene richiamata con l'endpoint. HTTP

  • Integrazioni e autorizzazioni: dettagli di configurazione e autorizzazioni per consentire alle risorse di interagire tra loro ed eseguire azioni, come la scrittura di log su Amazon. CloudWatch

Il diagramma seguente mostra i componenti di questa applicazione:

Diagramma di una funzione Lambda che viene richiamata quando si invia GET una richiesta all'APIendpoint Gateway.

Per questo tutorial, creerai e interagirai con la tua applicazione nei seguenti passaggi:

  1. Crea un AWS CDK progetto.

  2. Definisci una funzione Lambda e un API gateway REST API utilizzando i costrutti L2 della Construct Library. AWS

  3. Distribuisci la tua applicazione su. Cloud AWS

  4. Interagisci con la tua applicazione in. Cloud AWS

  5. Eliminare l'applicazione di esempio da Cloud AWS.

Prerequisiti

Prima di iniziare questo tutorial, completa quanto segue:

  • Crea un Account AWS file e installa e configura AWS Command Line Interface (AWS CLI).

  • Installa Node.js enpm.

  • Installa il CDK Toolkit a livello globale, utilizzandonpm install -g aws-cdk.

Per ulteriori informazioni, consulta Iniziare con AWS CDK.

Raccomandiamo inoltre una conoscenza di base di quanto segue:

Fase 1: Creare un CDK progetto

In questo passaggio, crei un nuovo CDK progetto utilizzando il AWS CDK CLI cdk init comando.

Per creare un CDK progetto

  1. Da una directory iniziale a tua scelta, crea e naviga fino a una directory di progetto denominata cdk-hello-world sul tuo computer:

    $ mkdir cdk-hello-world && cd cdk-hello-world

  2. Usa il cdk init comando per creare un nuovo progetto nel tuo linguaggio di programmazione preferito:

    TypeScript
    $ cdk init --language typescript

    Installa AWS CDK le librerie:

    $ npm install aws-cdk-lib constructs
    JavaScript
    $ cdk init --language javascript

    Installa AWS CDK le librerie:

    $ npm install aws-cdk-lib constructs
    Python
    $ cdk init --language python

    Attiva l'ambiente virtuale:

    $ source .venv/bin/activate # On Windows, run '.\venv\Scripts\activate' instead

    Installa AWS CDK le librerie e le dipendenze del progetto:

    (.venv)$ python3 -m pip install -r requirements.txt
    Java
    $ cdk init --language java

    Installa AWS CDK le librerie e le dipendenze del progetto:

    $ mvn package
    C#
    $ cdk init --language csharp

    Installa AWS CDK le librerie e le dipendenze del progetto:

    $ dotnet restore src
    Go
    $ cdk init --language go

    Installa le dipendenze del progetto:

    $ go get github.com/aws/aws-cdk-go/awscdk/v2
$ go get github.com/aws/aws-cdk-go/awscdk/v2/awslambda
$ go get github.com/aws/aws-cdk-go/awscdk/v2/awsapigateway
$ go mod tidy

    CDKCLIcrea un progetto con la seguente struttura:

    TypeScript
    cdk-hello-world
├── .git
├── .gitignore
├── .npmignore
├── README.md
├── bin
│   └── cdk-hello-world.ts
├── cdk.json
├── jest.config.js
├── lib
│   └── cdk-hello-world-stack.ts
├── node_modules
├── package-lock.json
├── package.json
├── test
│   └── cdk-hello-world.test.ts
└── tsconfig.json
    JavaScript
    cdk-hello-world
├── .git
├── .gitignore
├── .npmignore
├── README.md
├── bin
│   └── cdk-hello-world.js
├── cdk.json
├── jest.config.js
├── lib
│   └── cdk-hello-world-stack.js
├── node_modules
├── package-lock.json
├── package.json
└── test
    └── cdk-hello-world.test.js
    Python
    cdk-hello-world
├── .git
├── .gitignore
├── .venv
├── README.md
├── app.py
├── cdk.json
├── cdk_hello_world
│   ├── __init__.py
│   └── cdk_hello_world_stack.py
├── requirements-dev.txt
├── requirements.txt
├── source.bat
└── tests
    Java
    cdk-hello-world
├── .git
├── .gitignore
├── README.md
├── cdk.json
├── pom.xml
├── src
│   ├── main
│   │   └── java
│   │       └── com
│   │           └── myorg
│   │               ├── CdkHelloWorldApp.java
│   │               └── CdkHelloWorldStack.java
└── target
    C#
    cdk-hello-world
├── .git
├── .gitignore
├── README.md
├── cdk.json
└── src
    ├── CdkHelloWorld
    │   ├── CdkHelloWorld.csproj
    │   ├── CdkHelloWorldStack.cs
    │   ├── GlobalSuppressions.cs
    │   └── Program.cs
    └── CdkHelloWorld.sln
    Go
    cdk-hello-world
├── .git
├── .gitignore
├── README.md
├── cdk-hello-world.go
├── cdk-hello-world_test.go
├── cdk.json
├── go.mod
└── go.sum

Crea CDK CLI automaticamente un'CDKapp che contiene un singolo stack. L'istanza CDK dell'app viene creata dalla App classe. Quanto segue è una parte del file CDK dell'applicazione:

TypeScript

Situato inbin/cdk-hello-world.ts:

#!/usr/bin/env node
import 'source-map-support/register';
import * as cdk from 'aws-cdk-lib';
import { CdkHelloWorldStack } from '../lib/cdk-hello-world-stack';

const app = new cdk.App();
new CdkHelloWorldStack(app, 'CdkHelloWorldStack', {
});
JavaScript

Situato inbin/cdk-hello-world.js:

#!/usr/bin/env node
const cdk = require('aws-cdk-lib');
const { CdkHelloWorldStack } = require('../lib/cdk-hello-world-stack');
const app = new cdk.App();
new CdkHelloWorldStack(app, 'CdkHelloWorldStack', {
});
Python

Situato inapp.py:

#!/usr/bin/env python3
import os
import aws_cdk as cdk
from cdk_hello_world.cdk_hello_world_stack import CdkHelloWorldStack

app = cdk.App()
CdkHelloWorldStack(app, "CdkHelloWorldStack",)
app.synth()
Java

Situato insrc/main/java/.../CdkHelloWorldApp.java:

package com.myorg;

import software.amazon.awscdk.App;
import software.amazon.awscdk.Environment;
import software.amazon.awscdk.StackProps;

import java.util.Arrays;

public class JavaApp {
    public static void main(final String[] args) {
        App app = new App();

        new JavaStack(app, "JavaStack", StackProps.builder()
                .build());

        app.synth();
    }
}
C#

Situato insrc/CdkHelloWorld/Program.cs:

using Amazon.CDK;
using System;
using System.Collections.Generic;
using System.Linq;

namespace CdkHelloWorld
{
    sealed class Program
    {
        public static void Main(string[] args)
        {
            var app = new App();
            new CdkHelloWorldStack(app, "CdkHelloWorldStack", new StackProps
            {
            
            });
            app.Synth();
        }
    }
}
Go

Situato incdk-hello-world.go:

package main
import (
    "github.com/aws/aws-cdk-go/awscdk/v2"
    "github.com/aws/constructs-go/constructs/v10"
    "github.com/aws/jsii-runtime-go"
)

// ...

func main() {
    defer jsii.Close()
    app := awscdk.NewApp(nil)
    NewCdkHelloWorldStack(app, "CdkHelloWorldStack", &CdkHelloWorldStackProps{
        awscdk.StackProps{
            Env: env(),
        },
    })
    app.Synth(nil)
}

func env() *awscdk.Environment {
    return nil
}

Fase 2: Crea la tua funzione Lambda

All'interno del CDK progetto, crea una lambda directory che includa un nuovo hello.js file. Di seguito è riportato un esempio:

TypeScript

Dalla radice del progetto, esegui quanto segue:

$ mkdir lambda && cd lambda
$ touch hello.js

Quanto segue dovrebbe ora essere aggiunto al tuo CDK progetto:

cdk-hello-world
└── lambda
    └── hello.js
JavaScript

Dalla radice del progetto, esegui quanto segue:

$ mkdir lambda && cd lambda
$ touch hello.js

Quanto segue dovrebbe ora essere aggiunto al tuo CDK progetto:

cdk-hello-world
└── lambda
    └── hello.js
Python

Dalla radice del progetto, esegui quanto segue:

$ mkdir lambda && cd lambda
$ touch hello.js

Quanto segue dovrebbe ora essere aggiunto al tuo CDK progetto:

cdk-hello-world
└── lambda
    └── hello.js
Java

Dalla radice del progetto, esegui quanto segue:

$ mkdir -p src/main/resources/lambda
$ cd src/main/resources/lambda
$ touch hello.js

Quanto segue dovrebbe ora essere aggiunto al tuo CDK progetto:

cdk-hello-world
└── src
    └── main
        └──resources
            └──lambda
                └──hello.js
C#

Dalla radice del progetto, esegui quanto segue:

$ mkdir lambda && cd lambda
$ touch hello.js

Quanto segue dovrebbe ora essere aggiunto al tuo CDK progetto:

cdk-hello-world
└── lambda
    └── hello.js
Go

Dalla radice del progetto, esegui quanto segue:

$ mkdir lambda && cd lambda
$ touch hello.js

Quanto segue dovrebbe ora essere aggiunto al tuo CDK progetto:

cdk-hello-world
└── lambda
    └── hello.js
Nota

Per semplificare questo tutorial, utilizziamo una funzione JavaScript Lambda per tutti i CDK linguaggi di programmazione.

Definisci la tua funzione Lambda aggiungendo quanto segue al file appena creato:

exports.handler = async (event) => {
    return {
        statusCode: 200,
        headers: { "Content-Type": "text/plain" },
        body: JSON.stringify({ message: "Hello, World!" }),
    };
};

Fase 3: Definisci i tuoi costrutti

In questo passaggio, definirai le tue risorse Lambda e API Gateway utilizzando costrutti AWS CDK L2.

Apri il file di progetto che definisce lo stack. CDK Modificherai questo file per definire i tuoi costrutti. Di seguito è riportato un esempio del file stack iniziale:

TypeScript

Situato inlib/cdk-hello-world-stack.ts:

import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';

export class CdkHelloWorldStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);
    
    // Your constructs will go here
    
  }
}
JavaScript

Situato inlib/cdk-hello-world-stack.js:

const { Stack, Duration } = require('aws-cdk-lib');
const lambda = require('aws-cdk-lib/aws-lambda');
const apigateway = require('aws-cdk-lib/aws-apigateway');

class CdkHelloWorldStack extends Stack {

  constructor(scope, id, props) {
    super(scope, id, props);
    
    // Your constructs will go here
    
  }
}

module.exports = { CdkHelloWorldStack }
Python

Situato incdk_hello_world/cdk_hello_world_stack.py:

from aws_cdk import Stack
from constructs import Construct

class CdkHelloWorldStack(Stack):
    def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
        super().__init__(scope, construct_id, **kwargs)
          
          // Your constructs will go here
Java

Situato insrc/main/java/.../CdkHelloWorldStack.java:

package com.myorg;

import software.constructs.Construct;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;

public class CdkHelloWorldStack extends Stack {
    public CdkHelloWorldStack(final Construct scope, final String id) {
        this(scope, id, null);
    }

    public CdkHelloWorldStack(final Construct scope, final String id, final StackProps props) {
        super(scope, id, props);

        // Your constructs will go here
    }
}
C#

Situato insrc/CdkHelloWorld/CdkHelloWorldStack.cs:

using Amazon.CDK;
using Constructs;

namespace CdkHelloWorld
{
    public class CdkHelloWorldStack : Stack
    {
        internal CdkHelloWorldStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
        {
            // Your constructs will go here
        }
    }
}
Go

Situato incdk-hello-world.go:

package main
            
import (
    "github.com/aws/aws-cdk-go/awscdk/v2"
    "github.com/aws/constructs-go/constructs/v10"
    "github.com/aws/jsii-runtime-go"
)

type CdkHelloWorldStackProps struct {
    awscdk.StackProps
}

func NewCdkHelloWorldStack(scope constructs.Construct, id string, props *CdkHelloWorldStackProps) awscdk.Stack {
    var sprops awscdk.StackProps
    if props != nil {
        sprops = props.StackProps
    }
    stack := awscdk.NewStack(scope, &id, &sprops)
    
    // Your constructs will go here
    
    return stack
}

func main() {

    // ...
    
}

func env() *awscdk.Environment {

    return nil
    
}

In questo file, AWS CDK sta facendo quanto segue:

  • L'istanza CDK dello stack viene istanziata dalla classe. Stack

  • La classe Constructs base viene importata e fornita come ambito o elemento principale dell'istanza stack.

Definisci la risorsa della tua funzione Lambda

Per definire la risorsa della funzione Lambda, importate e utilizzate il costrutto aws-lambda L2 dalla Construct Library. AWS

Modificate il file dello stack come segue:

TypeScript
import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
// Import Lambda L2 construct
import * as lambda from 'aws-cdk-lib/aws-lambda';

export class CdkHelloWorldStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    // Define the Lambda function resource
    const helloWorldFunction = new lambda.Function(this, 'HelloWorldFunction', {
      runtime: lambda.Runtime.NODEJS_20_X, // Choose any supported Node.js runtime
      code: lambda.Code.fromAsset('lambda'), // Points to the lambda directory
      handler: 'hello.handler', // Points to the 'hello' file in the lambda directory
    });
  }
}
JavaScript
const { Stack, Duration } = require('aws-cdk-lib');
// Import Lambda L2 construct
const lambda = require('aws-cdk-lib/aws-lambda');


class CdkHelloWorldStack extends Stack {
  constructor(scope, id, props) {
    super(scope, id, props);

    // Define the Lambda function resource
    const helloWorldFunction = new lambda.Function(this, 'HelloWorldFunction', {
      runtime: lambda.Runtime.NODEJS_20_X, // Choose any supported Node.js runtime
      code: lambda.Code.fromAsset('lambda'), // Points to the lambda directory
      handler: 'hello.handler', // Points to the 'hello' file in the lambda directory
    });
  }
}

module.exports = { CdkHelloWorldStack }
Python
from aws_cdk import (
    Stack,
    # Import Lambda L2 construct
    aws_lambda as _lambda,
)
# ...

class CdkHelloWorldStack(Stack):

    def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
        super().__init__(scope, construct_id, **kwargs)

        # Define the Lambda function resource
        hello_world_function = _lambda.Function(
            self,
            "HelloWorldFunction",
            runtime = _lambda.Runtime.NODEJS_20_X, # Choose any supported Node.js runtime
            code = _lambda.Code.from_asset("lambda"), # Points to the lambda directory
            handler = "hello.handler", # Points to the 'hello' file in the lambda directory
        )
Nota

Importiamo il aws_lambda modulo _lambda perché lambda è un identificatore incorporato. Python

Java
// ...
// Import Lambda L2 construct
import software.amazon.awscdk.services.lambda.Code;
import software.amazon.awscdk.services.lambda.Function;
import software.amazon.awscdk.services.lambda.Runtime;

public class CdkHelloWorldStack extends Stack {
    public CdkHelloWorldStack(final Construct scope, final String id) {
        this(scope, id, null);
    }

    public CdkHelloWorldStack(final Construct scope, final String id, final StackProps props) {
        super(scope, id, props);

        // Define the Lambda function resource
        Function helloWorldFunction = Function.Builder.create(this, "HelloWorldFunction")
                .runtime(Runtime.NODEJS_20_X)  // Choose any supported Node.js runtime
                .code(Code.fromAsset("src/main/resources/lambda")) // Points to the lambda directory
                .handler("hello.handler")  // Points to the 'hello' file in the lambda directory
                .build();
    }
}
C#
// ...
// Import Lambda L2 construct
using Amazon.CDK.AWS.Lambda;

namespace CdkHelloWorld
{
    public class CdkHelloWorldStack : Stack
    {
        internal CdkHelloWorldStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
        {
            // Define the Lambda function resource
            var helloWorldFunction = new Function(this, "HelloWorldFunction", new FunctionProps
            {
                Runtime = Runtime.NODEJS_20_X, // Choose any supported Node.js runtime
                Code = Code.FromAsset("lambda"), // Points to the lambda directory
                Handler = "hello.handler" // Points to the 'hello' file in the lambda directory
            });
        }
    }
}
Go
package main

import (
    // ...
    // Import Lambda L2 construct
    "github.com/aws/aws-cdk-go/awscdk/v2/awslambda"
    // Import S3 assets construct
    "github.com/aws/aws-cdk-go/awscdk/v2/awss3assets"
    // ...
)

// ...

func NewCdkHelloWorldStack(scope constructs.Construct, id string, props *CdkHelloWorldStackProps) awscdk.Stack {
    var sprops awscdk.StackProps
    if props != nil {
        sprops = props.StackProps
    }
    stack := awscdk.NewStack(scope, &id, &sprops)

    // Define the Lambda function resource
    helloWorldFunction := awslambda.NewFunction(stack, jsii.String("HelloWorldFunction"), &awslambda.FunctionProps{
        Runtime: awslambda.Runtime_NODEJS_20_X(), // Choose any supported Node.js runtime
        Code:    awslambda.Code_FromAsset(jsii.String("lambda"), &awss3assets.AssetOptions{}), // Points to the lambda directory
        Handler: jsii.String("hello.handler"), // Points to the 'hello' file in the lambda directory
    })

    return stack
}

// ...

Qui si crea una risorsa per la funzione Lambda e si definiscono le seguenti proprietà:

  • runtime— L'ambiente in cui viene eseguita la funzione. Qui, usiamo la Node.js versione20.x.

  • code— Il percorso del codice della funzione sul computer locale.

  • handler— Il nome del file specifico che contiene il codice della funzione.

Definisci la tua REST API risorsa API Gateway

Per definire la REST API risorsa API Gateway, importate e utilizzate il costrutto aws-apigateway L2 dalla AWS Construct Library.

Modificate il file dello stack come segue:

TypeScript
// ...
//Import API Gateway L2 construct
import * as apigateway from 'aws-cdk-lib/aws-apigateway';


export class CdkHelloWorldStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    // ...
    
    // Define the API Gateway resource
    const api = new apigateway.LambdaRestApi(this, 'HelloWorldApi', {
      handler: helloWorldFunction,
      proxy: false,
    });
        
    // Define the '/hello' resource with a GET method
    const helloResource = api.root.addResource('hello');
    helloResource.addMethod('GET');
  }
}
JavaScript
// ...
// Import API Gateway L2 construct
const apigateway = require('aws-cdk-lib/aws-apigateway');


class CdkHelloWorldStack extends Stack {
  constructor(scope, id, props) {
    super(scope, id, props);

    // ...

    // Define the API Gateway resource
    const api = new apigateway.LambdaRestApi(this, 'HelloWorldApi', {
      handler: helloWorldFunction, 
      proxy: false,
    });
    
    // Define the '/hello' resource with a GET method
    const helloResource = api.root.addResource('hello');
    helloResource.addMethod('GET');
  };
};

// ...
Python
from aws_cdk import (
    # ...
    # Import API Gateway L2 construct
    aws_apigateway as apigateway,
)
from constructs import Construct

class CdkHelloWorldStack(Stack):

    def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
        super().__init__(scope, construct_id, **kwargs)

        # ...

        # Define the API Gateway resource
        api = apigateway.LambdaRestApi(
            self,
            "HelloWorldApi",
            handler = hello_world_function,
            proxy = False,
        )
        
        # Define the '/hello' resource with a GET method
        hello_resource = api.root.add_resource("hello")
        hello_resource.add_method("GET")
Java
// ...
// Import API Gateway L2 construct
import software.amazon.awscdk.services.apigateway.LambdaRestApi;
import software.amazon.awscdk.services.apigateway.Resource;

public class CdkHelloWorldStack extends Stack {
    public CdkHelloWorldStack(final Construct scope, final String id) {
        this(scope, id, null);
    }

    public CdkHelloWorldStack(final Construct scope, final String id, final StackProps props) {
        super(scope, id, props);

        // ...

        // Define the API Gateway resource
        LambdaRestApi api = LambdaRestApi.Builder.create(this, "HelloWorldApi")
                .handler(helloWorldFunction)
                .proxy(false) // Turn off default proxy integration
                .build();

        // Define the '/hello' resource and its GET method
        Resource helloResource = api.getRoot().addResource("hello");
        helloResource.addMethod("GET");
    }
}
C#
// ...
// Import API Gateway L2 construct
using Amazon.CDK.AWS.APIGateway;

namespace CdkHelloWorld
{
    public class CdkHelloWorldStack : Stack
    {
        internal CdkHelloWorldStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
        {
           // ...

            // Define the API Gateway resource
            var api = new LambdaRestApi(this, "HelloWorldApi", new LambdaRestApiProps
            {
                Handler = helloWorldFunction,
                Proxy = false
            });

            // Add a '/hello' resource with a GET method
            var helloResource = api.Root.AddResource("hello");
            helloResource.AddMethod("GET");
        }
    }
}
Go

// ...

import (
    // ...
    // Import Api Gateway L2 construct
    "github.com/aws/aws-cdk-go/awscdk/v2/awsapigateway"
    // ...
)

// ...

func NewCdkHelloWorldStack(scope constructs.Construct, id string, props *CdkHelloWorldStackProps) awscdk.Stack {
    var sprops awscdk.StackProps
    if props != nil {
        sprops = props.StackProps
    }
    stack := awscdk.NewStack(scope, &id, &sprops)

    // Define the Lambda function resource
    // ...
    
    // Define the API Gateway resource
    api := awsapigateway.NewLambdaRestApi(stack, jsii.String("HelloWorldApi"), &awsapigateway.LambdaRestApiProps{
        Handler: helloWorldFunction,
        Proxy: jsii.Bool(false),
    })

    // Add a '/hello' resource with a GET method
    helloResource := api.Root().AddResource(jsii.String("hello"), &awsapigateway.ResourceOptions{})
    helloResource.AddMethod(jsii.String("GET"), awsapigateway.NewLambdaIntegration(helloWorldFunction, &awsapigateway.LambdaIntegrationOptions{}), &awsapigateway.MethodOptions{})

    return stack
}

// ...

Qui crei una REST API risorsa API Gateway, insieme a quanto segue:

  • Un'integrazione tra la REST API e la tua funzione Lambda, che consente di API richiamare la tua funzione. Ciò include la creazione di una risorsa di autorizzazione Lambda.

  • Una nuova risorsa o percorso denominato hello che viene aggiunto alla radice dell'APIendpoint. Questo crea un nuovo endpoint che si aggiunge /hello alla tua base. URL

  • Un GET metodo per la hello risorsa. Quando viene inviata una GET richiesta all'/helloendpoint, viene richiamata la funzione Lambda e viene restituita la relativa risposta.

Fase 4: Preparare l'applicazione per la distribuzione

In questa fase preparate l'applicazione per la distribuzione compilando, se necessario, ed eseguendo la convalida di base con il AWS CDK CLI cdk synth comando.

Se necessario, crea la tua applicazione:

TypeScript

Dalla radice del progetto, esegui quanto segue:

$ npm run build
JavaScript

La costruzione non è necessaria.

Python

L'edificio non è richiesto.

Java

Dalla radice del progetto, esegui quanto segue:

$ mvn package
C#

Dalla radice del progetto, esegui quanto segue:

$ dotnet build src
Go

La costruzione non è necessaria.

Esegui cdk synth per sintetizzare un AWS CloudFormation modello dal tuo CDK codice. Utilizzando i costrutti L2, molti dei dettagli di configurazione richiesti da AWS CloudFormation per facilitare l'interazione tra la funzione Lambda REST API vengono forniti da. AWS CDK

Dalla radice del progetto, esegui quanto segue:

$ cdk synth
Nota

Se ricevi un errore come il seguente, verifica di essere nella cdk-hello-world directory e riprova:

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

In caso di successo, AWS CDK CLI restituirà il AWS CloudFormation modello in YAML formato al prompt dei comandi. Nella cartella viene inoltre salvato un modello JSON formattatocdk.out.

Di seguito è riportato un esempio di output del AWS CloudFormation modello:

Resources:
  HelloWorldFunctionServiceRoleunique-identifier:
    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: CdkHelloWorldStack/HelloWorldFunction/ServiceRole/Resource
  HelloWorldFunctionunique-identifier:
    Type: AWS::Lambda::Function
    Properties:
      Code:
        S3Bucket:
          Fn::Sub: cdk-unique-identifier-assets-${AWS::AccountId}-${AWS::Region}
        S3Key: unique-identifier.zip
      Handler: hello.handler
      Role:
        Fn::GetAtt:
          - HelloWorldFunctionServiceRoleunique-identifier
          - Arn
      Runtime: nodejs20.x
    DependsOn:
      - HelloWorldFunctionServiceRoleunique-identifier
    Metadata:
      aws:cdk:path: CdkHelloWorldStack/HelloWorldFunction/Resource
      aws:asset:path: asset.unique-identifier
      aws:asset:is-bundled: false
      aws:asset:property: Code
  HelloWorldApiunique-identifier:
    Type: AWS::ApiGateway::RestApi
    Properties:
      Name: HelloWorldApi
    Metadata:
      aws:cdk:path: CdkHelloWorldStack/HelloWorldApi/Resource
  HelloWorldApiDeploymentunique-identifier:
    Type: AWS::ApiGateway::Deployment
    Properties:
      Description: Automatically created by the RestApi construct
      RestApiId:
        Ref: HelloWorldApiunique-identifier
    DependsOn:
      - HelloWorldApihelloGETunique-identifier
      - HelloWorldApihellounique-identifier
    Metadata:
      aws:cdk:path: CdkHelloWorldStack/HelloWorldApi/Deployment/Resource
  HelloWorldApiDeploymentStageprod012345ABC:
    Type: AWS::ApiGateway::Stage
    Properties:
      DeploymentId:
        Ref: HelloWorldApiDeploymentunique-identifier
      RestApiId:
        Ref: HelloWorldApiunique-identifier
      StageName: prod
    Metadata:
      aws:cdk:path: CdkHelloWorldStack/HelloWorldApi/DeploymentStage.prod/Resource
  HelloWorldApihellounique-identifier:
    Type: AWS::ApiGateway::Resource
    Properties:
      ParentId:
        Fn::GetAtt:
          - HelloWorldApiunique-identifier
          - RootResourceId
      PathPart: hello
      RestApiId:
        Ref: HelloWorldApiunique-identifier
    Metadata:
      aws:cdk:path: CdkHelloWorldStack/HelloWorldApi/Default/hello/Resource
  HelloWorldApihelloGETApiPermissionCdkHelloWorldStackHelloWorldApiunique-identifier:
    Type: AWS::Lambda::Permission
    Properties:
      Action: lambda:InvokeFunction
      FunctionName:
        Fn::GetAtt:
          - HelloWorldFunctionunique-identifier
          - Arn
      Principal: apigateway.amazonaws.com
      SourceArn:
        Fn::Join:
          - ""
          - - "arn:"
            - Ref: AWS::Partition
            - ":execute-api:"
            - Ref: AWS::Region
            - ":"
            - Ref: AWS::AccountId
            - ":"
            - Ref: HelloWorldApi9E278160
            - /
            - Ref: HelloWorldApiDeploymentStageprodunique-identifier
            - /GET/hello
    Metadata:
      aws:cdk:path: CdkHelloWorldStack/HelloWorldApi/Default/hello/GET/ApiPermission.CdkHelloWorldStackHelloWorldApiunique-identifier.GET..hello
  HelloWorldApihelloGETApiPermissionTestCdkHelloWorldStackHelloWorldApiunique-identifier:
    Type: AWS::Lambda::Permission
    Properties:
      Action: lambda:InvokeFunction
      FunctionName:
        Fn::GetAtt:
          - HelloWorldFunctionunique-identifier
          - Arn
      Principal: apigateway.amazonaws.com
      SourceArn:
        Fn::Join:
          - ""
          - - "arn:"
            - Ref: AWS::Partition
            - ":execute-api:"
            - Ref: AWS::Region
            - ":"
            - Ref: AWS::AccountId
            - ":"
            - Ref: HelloWorldApiunique-identifier
            - /test-invoke-stage/GET/hello
    Metadata:
      aws:cdk:path: CdkHelloWorldStack/HelloWorldApi/Default/hello/GET/ApiPermission.Test.CdkHelloWorldStackHelloWorldApiunique-identifier.GET..hello
  HelloWorldApihelloGETunique-identifier:
    Type: AWS::ApiGateway::Method
    Properties:
      AuthorizationType: NONE
      HttpMethod: GET
      Integration:
        IntegrationHttpMethod: POST
        Type: AWS_PROXY
        Uri:
          Fn::Join:
            - ""
            - - "arn:"
              - Ref: AWS::Partition
              - ":apigateway:"
              - Ref: AWS::Region
              - :lambda:path/2015-03-31/functions/
              - Fn::GetAtt:
                  - HelloWorldFunctionunique-identifier
                  - Arn
              - /invocations
      ResourceId:
        Ref: HelloWorldApihellounique-identifier
      RestApiId:
        Ref: HelloWorldApiunique-identifier
    Metadata:
      aws:cdk:path: CdkHelloWorldStack/HelloWorldApi/Default/hello/GET/Resource
  CDKMetadata:
    Type: AWS::CDK::Metadata
    Properties:
      Analytics: v2:deflate64:unique-identifier
    Metadata:
      aws:cdk:path: CdkHelloWorldStack/CDKMetadata/Default
    Condition: CDKMetadataAvailable
Outputs:
  HelloWorldApiEndpointunique-identifier:
    Value:
      Fn::Join:
        - ""
        - - https://
          - Ref: HelloWorldApiunique-identifier
          - .execute-api.
          - Ref: AWS::Region
          - "."
          - Ref: AWS::URLSuffix
          - /
          - Ref: HelloWorldApiDeploymentStageprodunique-identifier
          - /
Conditions:
  CDKMetadataAvailable:
    Fn::Or:
      - Fn::Or:
          - Fn::Equals:
              - Ref: AWS::Region
              - af-south-1
          - Fn::Equals:
              - Ref: AWS::Region
              - ap-east-1
          - Fn::Equals:
              - Ref: AWS::Region
              - ap-northeast-1
          - Fn::Equals:
              - Ref: AWS::Region
              - ap-northeast-2
          - Fn::Equals:
              - Ref: AWS::Region
              - ap-south-1
          - Fn::Equals:
              - Ref: AWS::Region
              - ap-southeast-1
          - Fn::Equals:
              - Ref: AWS::Region
              - ap-southeast-2
          - Fn::Equals:
              - Ref: AWS::Region
              - ca-central-1
          - Fn::Equals:
              - Ref: AWS::Region
              - cn-north-1
          - Fn::Equals:
              - Ref: AWS::Region
              - cn-northwest-1
      - Fn::Or:
          - Fn::Equals:
              - Ref: AWS::Region
              - eu-central-1
          - Fn::Equals:
              - Ref: AWS::Region
              - eu-north-1
          - Fn::Equals:
              - Ref: AWS::Region
              - eu-south-1
          - Fn::Equals:
              - Ref: AWS::Region
              - eu-west-1
          - Fn::Equals:
              - Ref: AWS::Region
              - eu-west-2
          - Fn::Equals:
              - Ref: AWS::Region
              - eu-west-3
          - Fn::Equals:
              - Ref: AWS::Region
              - il-central-1
          - Fn::Equals:
              - Ref: AWS::Region
              - me-central-1
          - Fn::Equals:
              - Ref: AWS::Region
              - me-south-1
          - Fn::Equals:
              - Ref: AWS::Region
              - sa-east-1
      - Fn::Or:
          - Fn::Equals:
              - Ref: AWS::Region
              - us-east-1
          - Fn::Equals:
              - Ref: AWS::Region
              - us-east-2
          - Fn::Equals:
              - Ref: AWS::Region
              - us-west-1
          - Fn::Equals:
              - Ref: AWS::Region
              - us-west-2
Parameters:
  BootstrapVersion:
    Type: AWS::SSM::Parameter::Value<String>
    Default: /cdk-bootstrap/hnb659fds/version
    Description: Version of the CDK Bootstrap resources in this environment, automatically retrieved from SSM Parameter Store. [cdk:skip]
Rules:
  CheckBootstrapVersion:
    Assertions:
      - Assert:
          Fn::Not:
            - Fn::Contains:
                - - "1"
                  - "2"
                  - "3"
                  - "4"
                  - "5"
                - Ref: BootstrapVersion
        AssertDescription: CDK bootstrap stack version 6 required. Please run 'cdk bootstrap' with a recent version of the CDK CLI.

Utilizzando i costrutti L2, si definiscono alcune proprietà per configurare le risorse e si utilizzano metodi di supporto per integrarle insieme. AWS CDK configura la maggior parte delle AWS CloudFormation risorse e delle proprietà necessarie per il provisioning dell'applicazione.

Fase 5: distribuzione dell'applicazione

In questo passaggio, si utilizza il AWS CDK CLI cdk deploy comando per distribuire l'applicazione. AWS CDK Funziona con il AWS CloudFormation servizio per fornire le tue risorse.

Importante

È necessario eseguire un avvio unico dell' AWS ambiente prima della distribuzione. Per istruzioni, consulta Avvia il tuo ambiente per utilizzarlo con AWS CDK.

Dalla radice del progetto, esegui quanto segue. Conferma le modifiche se richiesto:

$ cdk deploy

✨  Synthesis time: 2.44s

...

Do you wish to deploy these changes (y/n)? y

Una volta completata la distribuzione, AWS CDK CLI verrà emesso il tuo endpoint. URL Copialo URL per il passaggio successivo. Di seguito è riportato un esempio:

...
✅  HelloWorldStack

✨  Deployment time: 45.37s

Outputs:
HelloWorldStack.HelloWorldApiEndpointunique-identifier = https://<api-id>.execute-api.<region>.amazonaws.com/prod/
Stack ARN:
arn:aws:cloudformation:region:account-id:stack/HelloWorldStack/unique-identifier
...

Passaggio 6: Interagisci con l'applicazione

In questo passaggio, si avvia una GET richiesta all'APIendpoint e si riceve la risposta della funzione Lambda.

Individua l'endpoint URL del passaggio precedente e aggiungi il percorso. /hello Quindi, utilizzando il browser o il prompt dei comandi, invia una GET richiesta all'endpoint. Di seguito è riportato un esempio:

$ curl https://<api-id>.execute-api.<region>.amazonaws.com/prod/hello
{"message":"Hello World!"}%

Congratulazioni, hai creato, distribuito e interagito con successo la tua applicazione utilizzando! AWS CDK

Passaggio 7: Eliminare l'applicazione

In questo passaggio, si utilizza AWS CDK CLI per eliminare l'applicazione da Cloud AWS.

Per eliminare l'applicazione, eseguicdk destroy. Quando richiesto, conferma la richiesta di eliminazione dell'applicazione:

$ cdk destroy
Are you sure you want to delete: CdkHelloWorldStack (y/n)? y
CdkHelloWorldStack: destroying... [1/1]
...
 ✅  CdkHelloWorldStack: destroyed

Risoluzione dei problemi

Errore: {«message»: «Errore interno del server»}%

Quando si richiama la funzione Lambda distribuita, si riceve questo errore. Questo errore può verificarsi per diversi motivi.

Per risolvere ulteriormente i problemi

Usa AWS CLI per richiamare la tua funzione Lambda.

  1. Modifica il tuo file stack per acquisire il valore di output del nome della funzione Lambda distribuita. Di seguito è riportato un esempio:

    ...

class CdkHelloWorldStack extends Stack {
  constructor(scope, id, props) {
    super(scope, id, props);

    // Define the Lambda function resource
    // ...

    new CfnOutput(this, 'HelloWorldFunctionName', {
      value: helloWorldFunction.functionName,
      description: 'JavaScript Lambda function'
    });

    // Define the API Gateway resource
    // ...

  2. Implementa nuovamente l'applicazione. AWS CDK CLIProdurrà il valore del nome della funzione Lambda distribuita:

    $ cdk deploy

✨  Synthesis time: 0.29s
...
 ✅  CdkHelloWorldStack

✨  Deployment time: 20.36s

Outputs:
...
CdkHelloWorldStack.HelloWorldFunctionName = CdkHelloWorldStack-HelloWorldFunctionunique-identifier
...

  3. Usa AWS CLI per richiamare la tua funzione Lambda in e inviare Cloud AWS la risposta a un file di testo:

    $ aws lambda invoke --function-name CdkHelloWorldStack-HelloWorldFunctionunique-identifier output.txt

  4. Controlla output.txt per vedere i risultati.

Possibile causa: la risorsa API Gateway è definita in modo errato nel file stack.

Se output.txt mostra una risposta corretta della funzione Lambda, il problema potrebbe riguardare il modo in cui hai definito il tuo API Gateway. REST API AWS CLI richiama la tua Lambda direttamente, non tramite l'endpoint. Controlla il codice per assicurarti che corrisponda a questo tutorial. Quindi, esegui nuovamente l'implementazione.

Possibile causa: la risorsa Lambda è definita in modo errato nel file stack.

Se output.txt restituisce un errore, il problema potrebbe riguardare il modo in cui hai definito la funzione Lambda. Controlla il codice per assicurarti che corrisponda a questo tutorial. Quindi esegui nuovamente l'implementazione.