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

Questa è la guida per sviluppatori AWS CDK v2. Il vecchio CDK v1 è entrato 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 un semplice serverless Hello World applicazione che implementa un backend API di base composto da quanto segue:

  • Amazon API Gateway REST API— Fornisce un endpoint HTTP che viene utilizzato per richiamare la funzione tramite un HTTP GET richiesta.

  • AWS Lambda function — Funzione che restituisce un Hello World! messaggio quando viene richiamata con HTTP punto finale.

  • 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 una richiesta GET all'endpoint API 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 l'API REST di API Gateway 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 e npm.

  • Installa CDK Toolkit a livello globale, utilizzando. npm install -g aws-cdk

Per ulteriori informazioni, consulta Guida introduttiva al AWS CDK.

Consigliamo inoltre una conoscenza di base di quanto segue:

Fase 1: Creare un progetto CDK

In questo passaggio, si crea un nuovo progetto CDK utilizzando il AWS CDK CLI cdk initcomando.

Per creare un progetto CDK

  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

    Il CDK CLI crea 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

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

TypeScript

Si trova 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 progetto CDK, create 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 progetto CDK:

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 progetto CDK:

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 progetto CDK:

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 progetto CDK:

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 progetto CDK:

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 progetto CDK:

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

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

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. Modificherete questo file per definire i vostri 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 dello stack CDK 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 in 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 Node.js version 20.x.

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

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

Definisci il tuo API Gateway REST API risorsa

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

Modifica il tuo file 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 puoi creare un API Gateway REST API risorsa, insieme a quanto segue:

  • Un'integrazione tra REST API e la tua funzione Lambda, che consente all'API di 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'endpoint dell'API. Questo crea un nuovo endpoint che si aggiunge /hello alla tua base URL.

  • Un metodo GET per la hello risorsa. Quando una richiesta GET viene inviata 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 creando, se necessario, ed eseguendo la convalida di base con AWS CDK CLI cdk synthcomando.

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 codice CDK. Utilizzando i costrutti L2, molti dei dettagli di configurazione richiesti da AWS CloudFormation per facilitare l'interazione tra la funzione Lambda e REST API sono forniti per te 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 emetterà il AWS CloudFormation modello in YAML formatta al prompt dei comandi. A JSON anche il modello formattato viene salvato nella cdk.out directory.

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 questa fase, si utilizza il AWS CDK CLI cdk deploycomando 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

Al termine della distribuzione, AWS CDK CLI mostrerà l'URL del tuo endpoint. Copia questo 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
...

Fase 6: Interagisci con la tua applicazione

In questo passaggio, avviate una richiesta GET all'endpoint API e ricevete la risposta della funzione Lambda.

Individua l'URL dell'endpoint indicato nel passaggio precedente e aggiungi il percorso. /hello Quindi, utilizzando il browser o il prompt dei comandi, invia una richiesta GET al tuo 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 il AWS CDK CLI per eliminare la tua 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. La AWS CDK CLI mostrerà 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 non è definita correttamente nel file stack.

Se output.txt mostra una risposta corretta della funzione Lambda, il problema potrebbe riguardare il modo in cui hai definito l'API REST dell'API Gateway. 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.