Prerequisiti Informazioni sul tutorial Fase 1: Crea il tuo progetto CDK Fase 2: Configurazione dell' AWS ambiente Fase 3: Avvia il tuo ambiente AWS Fase 4: Crea la tua app CDK Passaggio 5: Elenca gli stack CDK nella tua app Fase 6: Definizione della funzione Lambda Fase 7: Definizione dell'URL della funzione Lambda Fase 8: Sintetizzare un modello CloudFormation Fase 9: Implementa lo stack CDK Passaggio 10: Interagisci con la tua applicazione su AWS Passaggio 11: modifica l'applicazione Passaggio 12: Eliminare l'applicazione Passaggi successivi

Tutorial: crea la tua prima app AWS CDK

Inizia a utilizzare AWS Cloud Development Kit (AWS CDK) utilizzando l'interfaccia a riga di AWS CDK comando (AWS CDK CLI) per sviluppare la prima app CDK, avviare l' AWS ambiente e distribuire l'applicazione su. AWS

Prerequisiti

Prima di iniziare questo tutorial, completa tutti i passaggi di configurazione indicati in. Guida introduttiva al AWS CDK

Informazioni sul tutorial

In questo tutorial, creerai e distribuirai una semplice applicazione sull' AWS AWS CDK utilizzo di. L'applicazione è costituita da una AWS Lambda funzione che restituisce un Hello World! messaggio quando viene richiamata. La funzione verrà richiamata tramite un URL della funzione Lambda che funge da endpoint HTTP (S) dedicato per la funzione Lambda.

Attraverso questo tutorial, eseguirai quanto segue:

Crea il tuo progetto: crea un progetto CDK usando il CDK CLI cdk initcomando.
Configura il tuo AWS ambiente: configura l' AWS ambiente in cui distribuirai l'applicazione.
Avvia il tuo AWS ambiente: prepara AWS l'ambiente per la distribuzione avviandolo utilizzando il CDK CLI cdk bootstrapcomando.
Sviluppa la tua app: utilizza i costrutti della AWS Construct Library per definire le risorse URL della funzione Lambda e della funzione Lambda.
Prepara la tua app per la distribuzione: usa il CDK CLI per creare la tua app e sintetizzare un modello. AWS CloudFormation
Implementa la tua app: utilizza il CDK CLI cdk deploycomando per distribuire l'applicazione e fornire le risorse. AWS
Interagisci con la tua applicazione: interagisci con la funzione Lambda distribuita AWS richiamandola e ricevendo una risposta.
Modifica la tua app: modifica la funzione Lambda e distribuiscila per implementare le modifiche.
Elimina la tua app: elimina tutte le risorse che hai creato utilizzando il CDK CLI cdk destroycomando.

Fase 1: Crea il tuo progetto CDK

In questo passaggio, crei un nuovo progetto CDK. Un progetto CDK deve trovarsi nella propria directory, con le proprie dipendenze dei moduli locali.

Per creare un progetto CDK

Da una directory iniziale a tua scelta, crea e naviga fino a una directory denominatahello-cdk:
```
$ mkdir hello-cdk && cd hello-cdk
```
Importante
Assicuratevi di assegnare un nome alla cartella del progettohello-cdk, esattamente come mostrato qui. Il CDK CLI utilizza questo nome di directory per denominare elementi all'interno del codice CDK. Se usi un nome di directory diverso, potresti riscontrare dei problemi durante questo tutorial.
Dalla hello-cdk directory, inizializza un nuovo progetto CDK usando il CDK CLI cdk initcomando. Specificate il app modello e il linguaggio di programmazione preferito con l'--languageopzione:
TypeScript
```
$ cdk init app --language typescript
```
JavaScript
```
$ cdk init app --language javascript
```
Python
```
$ cdk init app --language python
```
Dopo aver creato l'app, inserisci anche i due comandi seguenti. Questi attivano le app Python ambiente virtuale e installa le dipendenze AWS CDK principali.
```
$ source .venv/bin/activate # On Windows, run `.\venv\Scripts\activate` instead
$ python -m pip install -r requirements.txt
```
Java
```
$ cdk init app --language java
```
Se utilizzi un IDE, ora puoi aprire o importare il progetto. In Eclipse, ad esempio, scegli File > Importa > Maven > Progetti Maven esistenti. Assicuratevi che le impostazioni del progetto siano impostate per utilizzare Java 8 (1.8).
C#
```
$ cdk init app --language csharp
```
Se utilizzi Visual Studio, apri il file della soluzione nella src directory.
Go
```
$ cdk init app --language go
```
Dopo aver creato l'app, inserisci anche il seguente comando per installare i moduli AWS Construct Library richiesti dall'app.
```
$ go get
```

Il cdk init comando crea una struttura di file e cartelle all'interno della hello-cdk directory per aiutare a organizzare il codice sorgente dell'app CDK. Questa struttura di file e cartelle è denominata progetto CDK. Prenditi un momento per esplorare il tuo progetto CDK.

Se hai Git installato, ogni progetto creato utilizzando cdk init viene inoltre inizializzato come Git archivio.

Durante l'inizializzazione del progetto, il CDK CLI crea un'app CDK contenente un singolo stack CDK. L'istanza dell'app CDK viene creata utilizzando il costrutto. App Quanto segue è una parte di questo codice dal file dell'applicazione CDK:

Lo stack CDK viene creato utilizzando il Stack costrutto. Quanto segue è una parte di questo codice dal file dello stack CDK:

TypeScript

Situato in: lib/hello-cdk-stack.ts


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

export class HelloCdkStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);
    
    // Define your constructs here

  }
}

JavaScript

Situato inlib/hello-cdk-stack.js:


const { Stack } = require('aws-cdk-lib');

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

    // Define your constructs here

  }
}

module.exports = { HelloCdkStack }

Python

Situato inhello_cdk/hello_cdk_stack.py:


from aws_cdk import (
  Stack,
)
from constructs import Construct

class HelloCdkStack(Stack):

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

    # Define your constructs here

Java

Situato insrc/main/java/.../HelloCdkStack.java:


package com.myorg;

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

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

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

    // Define your constructs here
  }
}

C#

Situato insrc/HelloCdk/HelloCdkStack.cs:


using Amazon.CDK;
using Constructs;

namespace HelloCdk
{
  public class HelloCdkStack : Stack
  {
    internal HelloCdkStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
    {
      // Define your constructs here
    }
  }
}

Go

Situato inhello-cdk.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 HelloCdkStackProps struct {
  awscdk.StackProps
}

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

  return stack
}

// ...

Fase 2: Configurazione dell' AWS ambiente

In questo passaggio, configuri l' AWS ambiente per lo stack CDK. In questo modo, specificate in quale ambiente verrà distribuito lo stack CDK.

Innanzitutto, stabilite l' AWS ambiente che desiderate utilizzare. Un AWS ambiente è costituito da un Account AWS e Regione AWS.

Quando si utilizza AWS CLI per configurare le credenziali di sicurezza sul computer locale, è possibile utilizzarle per AWS CLI ottenere informazioni AWS sull'ambiente per un profilo specifico.

Da utilizzare AWS CLI per ottenere il proprio ID Account AWS

Esegui il AWS CLI comando seguente per ottenere l' Account AWS ID del tuo default profilo:
```
$ aws sts get-caller-identity --query "Account" --output text
```
Se preferisci utilizzare un profilo denominato, fornisci il nome del tuo profilo utilizzando l'--profileopzione:
```
$ aws sts get-caller-identity --profile your-profile-name --query "Account" --output text
```

Per AWS CLI utilizzarlo per ottenere il Regione AWS

Esegui il AWS CLI comando seguente per ottenere la regione che hai configurato per il tuo default profilo:
```
$ aws configure get region
```
Se preferisci usare un profilo denominato, fornisci il nome del tuo profilo utilizzando l'--profileopzione:
```
$ aws configure get region --profile your-profile-name
```

Successivamente, configurerete l' AWS ambiente per lo stack CDK modificando l'HelloCdkStackistanza nel file dell'applicazione. In questo tutorial, codificherete le AWS informazioni sull'ambiente. È consigliato per gli ambienti di produzione. Per informazioni su altri modi di configurare gli ambienti, vedereConfigurare gli ambienti da utilizzare con AWS CDK.

Per configurare l'ambiente per lo stack CDK

Nel file dell'applicazione, utilizzate la env proprietà del Stack costrutto per configurare l'ambiente. Di seguito è riportato un esempio:

TypeScript

Situato inbin/hello-cdk.ts:


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

const app = new cdk.App();
new HelloCdkStack(app, 'HelloCdkStack', {
  env: { account: '123456789012', region: 'us-east-1' },
});

JavaScript

Situato inbin/hello-cdk.js:


#!/usr/bin/env node

const cdk = require('aws-cdk-lib');
const { HelloCdkStack } = require('../lib/hello-cdk-stack');

const app = new cdk.App();
new HelloCdkStack(app, 'HelloCdkStack', {
  env: { account: '123456789012', region: 'us-east-1' },
});

Python

Situato inapp.py:


#!/usr/bin/env python3
import os

import aws_cdk as cdk

from hello_cdk.hello_cdk_stack import HelloCdkStack


app = cdk.App()
HelloCdkStack(app, "HelloCdkStack",
  env=cdk.Environment(account='123456789012', region='us-east-1'),
  )
  
app.synth()

Java

Situato insrc/main/java/.../HelloCdkApp.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 HelloCdkApp {
    public static void main(final String[] args) {
        App app = new App();

        new HelloCdkStack(app, "HelloCdkStack", StackProps.builder()
                .env(Environment.builder()
                        .account("123456789012")
                        .region("us-east-1")
                        .build())

                .build());

        app.synth();
    }
}

C#

Situato insrc/HelloCdk/Program.cs:


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

namespace HelloCdk
{
    sealed class Program
    {
        public static void Main(string[] args)
        {
            var app = new App();
            new HelloCdkStack(app, "HelloCdkStack", new StackProps
            {
                Env = new Amazon.CDK.Environment
                {
                    Account = "123456789012",
                    Region = "us-east-1",
                }
            });
            app.Synth();
        }
    }
}

Go

Situato inhello-cdk.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)

  NewHelloCdkStack(app, "HelloCdkStack", &HelloCdkStackProps{
    awscdk.StackProps{
      Env: env(),
    },
  })

  app.Synth(nil)
}

func env() *awscdk.Environment {
	return &awscdk.Environment{
		Account: jsii.String("123456789012"),
		Region:  jsii.String("us-east-1"),
	}
}

Fase 3: Avvia il tuo ambiente AWS

In questo passaggio, esegui il bootstrap dell' AWS ambiente configurato nel passaggio precedente. Questo prepara l'ambiente per le implementazioni CDK.

Per avviare il tuo ambiente, esegui quanto segue dalla radice del tuo progetto CDK:


$ cdk bootstrap

Effettuando il bootstrap dalla radice del progetto CDK, non è necessario fornire informazioni aggiuntive. Il CDK CLI ottiene informazioni sull'ambiente dal progetto. Quando si esegue il bootstrap all'esterno di un progetto CDK, è necessario fornire informazioni sull'ambiente con il comando. cdk bootstrap Per ulteriori informazioni, consulta Avvia il tuo ambiente per utilizzarlo con AWS CDK.

Fase 4: Crea la tua app CDK

Nella maggior parte degli ambienti di programmazione, il codice viene creato o compilato dopo aver apportato modifiche. Questo non è necessario AWS CDK dal momento che il CDK CLI eseguirà automaticamente questo passaggio. Tuttavia, puoi comunque creare manualmente se desideri catturare errori di sintassi e di tipo. Di seguito è riportato un esempio:

Passaggio 5: Elenca gli stack CDK nella tua app

A questo punto, dovresti avere un'app CDK contenente un singolo stack CDK. Per verificare, usa il CDK CLI cdk listcomando per visualizzare gli stack. L'output dovrebbe mostrare un singolo stack denominato: HelloCdkStack


$ cdk list
HelloCdkStack

Se non vedi questo output, verifica di trovarti nella directory di lavoro corretta del progetto e riprova. Se ancora non vedi il tuo stack, ripeti Fase 1: Crea il tuo progetto CDK e riprova.

Fase 6: Definizione della funzione Lambda

In questo passaggio, importate il aws_lambda modulo dalla AWS Construct Library e utilizzate il costrutto Function L2.

Modificate il file dello stack CDK come segue:

TypeScript

Situato in: lib/hello-cdk-stack.ts


import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
// Import the Lambda module
import * as lambda from 'aws-cdk-lib/aws-lambda';

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

    // Define the Lambda function resource
    const myFunction = new lambda.Function(this, "HelloWorldFunction", {
      runtime: lambda.Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
      handler: "index.handler",
      code: lambda.Code.fromInline(`
        exports.handler = async function(event) {
          return {
            statusCode: 200,
            body: JSON.stringify('Hello World!'),
          };
        };
      `),
    });
  }
}

JavaScript

Situato inlib/hello-cdk-stack.js:


const { Stack } = require('aws-cdk-lib');
// Import the Lambda module
const lambda = require('aws-cdk-lib/aws-lambda');

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

    // Define the Lambda function resource
    const myFunction = new lambda.Function(this, "HelloWorldFunction", {
      runtime: lambda.Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
      handler: "index.handler",
      code: lambda.Code.fromInline(`
        exports.handler = async function(event) {
          return {
            statusCode: 200,
            body: JSON.stringify('Hello World!'),
          };
        };
      `),
    });

  }
}

module.exports = { HelloCdkStack }

Python

Situato inhello_cdk/hello_cdk_stack.py:


from aws_cdk import (
  Stack,
  aws_lambda as _lambda, # Import the Lambda module
)
from constructs import Construct

class HelloCdkStack(Stack):

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

    # Define the Lambda function resource
    my_function = _lambda.Function(
      self, "HelloWorldFunction", 
      runtime = _lambda.Runtime.NODEJS_20_X, # Provide any supported Node.js runtime
      handler = "index.handler",
      code = _lambda.Code.from_inline(
        """
        exports.handler = async function(event) {
          return {
            statusCode: 200,
            body: JSON.stringify('Hello World!'),
          };
        };
        """
      ),
    )

Java

Situato insrc/main/java/.../HelloCdkStack.java:


package com.myorg;

import software.constructs.Construct;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;
// Import Lambda function
import software.amazon.awscdk.services.lambda.Code;
import software.amazon.awscdk.services.lambda.Function;
import software.amazon.awscdk.services.lambda.Runtime;

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

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

    // Define the Lambda function resource
    Function myFunction = Function.Builder.create(this, "HelloWorldFunction")
      .runtime(Runtime.NODEJS_20_X) // Provide any supported Node.js runtime
      .handler("index.handler")
      .code(Code.fromInline(
        "exports.handler = async function(event) {" +
        " return {" +
        " statusCode: 200," +
        " body: JSON.stringify('Hello World!')" +
        " };" +
        "};"))
      .build();

  }
}

C#

Situato insrc/main/java/.../HelloCdkStack.java:


using Amazon.CDK;
using Constructs;
// Import the Lambda module
using Amazon.CDK.AWS.Lambda;

namespace HelloCdk
{
  public class HelloCdkStack : Stack
  {
    internal HelloCdkStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
    {
      // Define the Lambda function resource
      var myFunction = new Function(this, "HelloWorldFunction", new FunctionProps
      {
        Runtime = Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
        Handler = "index.handler",
        Code = Code.FromInline(@"
          exports.handler = async function(event) {
            return {
              statusCode: 200,
              body: JSON.stringify('Hello World!'),
            };
          };
        "),
      });
    }
  }
}

Go

Situato inhello-cdk.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"
  // Import the Lambda module
  "github.com/aws/aws-cdk-go/awscdk/v2/awslambda"
)

type HelloCdkStackProps struct {
  awscdk.StackProps
}

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

  // Define the Lambda function resource
  myFunction := awslambda.NewFunction(stack, jsii.String("HelloWorldFunction"), &awslambda.FunctionProps{
    Runtime: awslambda.Runtime_NODEJS_20_X(), // Provide any supported Node.js runtime
    Handler: jsii.String("index.handler"),
    Code: awslambda.Code_FromInline(jsii.String(`
      exports.handler = async function(event) {
        return {
          statusCode: 200,
          body: JSON.stringify('Hello World!'),
        };
      };
    `)),
  })

  return stack
}

// ...

Diamo un'occhiata più da vicino al Function costrutto. Come tutti i costrutti, la Function classe accetta tre parametri:

scope: definisce l'Stackistanza come genitore del Function costrutto. Tutti i costrutti che definiscono AWS le risorse vengono creati nell'ambito di uno stack. È possibile definire costrutti all'interno dei costrutti, creando una gerarchia (albero). Qui, e nella maggior parte dei casi, l'ambito è (in this self Python).
Id: l'ID di costruzione Function all'interno della tua AWS CDK app. Questo ID, più un hash basato sulla posizione della funzione all'interno dello stack, identifica in modo univoco la funzione durante la distribuzione. AWS CDK Inoltre, fa riferimento a questo ID quando aggiorni il costrutto nell'app e lo ridistribuisci per aggiornare la risorsa distribuita. Qui, il tuo ID di costruzione è. HelloWorldFunction Le funzioni possono anche avere un nome, specificato con la functionName proprietà. È diverso dall'ID del costrutto.
props — Un insieme di valori che definiscono le proprietà della funzione. Qui si definiscono le runtime proprietàhandler, ecode.

Gli oggetti di scena sono rappresentati in modo diverso nelle lingue supportate da. AWS CDK
- In TypeScript e JavaScript, props è un singolo argomento e si passa un oggetto contenente le proprietà desiderate.
- In Python, gli oggetti di scena vengono passati come argomenti di parole chiave.
- In Java, viene fornito un Builder per passare gli oggetti di scena. Ce ne sono due: uno per FunctionProps e un secondo per consentirvi Function di costruire il costrutto e il relativo oggetto props in un unico passaggio. Questo codice utilizza quest'ultimo.
- In C#, si crea un'istanza di un FunctionProps oggetto utilizzando un inizializzatore di oggetti e lo si passa come terzo parametro.
Se gli oggetti di scena di un costrutto sono opzionali, potete omettere completamente il parametro. props

Tutti i costrutti utilizzano gli stessi tre argomenti, quindi è facile rimanere orientati man mano che ne impari di nuovi. E come ci si potrebbe aspettare, è possibile sottoclassare qualsiasi costrutto per estenderlo in base alle proprie esigenze o se si desidera modificarne i valori predefiniti.

Fase 7: Definizione dell'URL della funzione Lambda

In questo passaggio, si utilizza il metodo addFunctionUrl helper del Function costrutto per definire l'URL di una funzione Lambda. Per generare il valore di questo URL al momento della distribuzione, creerai un AWS CloudFormation output utilizzando il costrutto. CfnOutput

Aggiungi quanto segue al tuo file dello stack CDK:

TypeScript

Situato in: lib/hello-cdk-stack.ts


// ...

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

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

    // Define the Lambda function URL resource
    const myFunctionUrl = myFunction.addFunctionUrl({
      authType: lambda.FunctionUrlAuthType.NONE,
    });

    // Define a CloudFormation output for your URL
    new cdk.CfnOutput(this, "myFunctionUrlOutput", {
      value: myFunctionUrl.url,
    })

  }
}

JavaScript

Situato inlib/hello-cdk-stack.js:


const { Stack, CfnOutput } = require('aws-cdk-lib');  // Import CfnOutput

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

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

    // Define the Lambda function URL resource
    const myFunctionUrl = myFunction.addFunctionUrl({
      authType: lambda.FunctionUrlAuthType.NONE,
    });

    // Define a CloudFormation output for your URL
    new CfnOutput(this, "myFunctionUrlOutput", {
      value: myFunctionUrl.url,
    })

  }
}

module.exports = { HelloCdkStack }

Python

Situato inhello_cdk/hello_cdk_stack.py:


from aws_cdk import (
  # ...
  CfnOutput # Import CfnOutput
)
from constructs import Construct

class HelloCdkStack(Stack):

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

    # Define the Lambda function resource
    # ...

    # Define the Lambda function URL resource
    my_function_url = my_function.add_function_url(
      auth_type = _lambda.FunctionUrlAuthType.NONE,
    )

    # Define a CloudFormation output for your URL
    CfnOutput(self, "myFunctionUrlOutput", value=my_function_url.url)

Java

Situato insrc/main/java/.../HelloCdkStack.java:


package com.myorg;

// ...
// Import Lambda function URL
import software.amazon.awscdk.services.lambda.FunctionUrl;
import software.amazon.awscdk.services.lambda.FunctionUrlAuthType;
import software.amazon.awscdk.services.lambda.FunctionUrlOptions;
// Import CfnOutput
import software.amazon.awscdk.CfnOutput;

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

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

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

    // Define the Lambda function URL resource
    FunctionUrl myFunctionUrl = myFunction.addFunctionUrl(FunctionUrlOptions.builder()
      .authType(FunctionUrlAuthType.NONE)
      .build());

    // Define a CloudFormation output for your URL
    CfnOutput.Builder.create(this, "myFunctionUrlOutput")
      .value(myFunctionUrl.getUrl())
      .build();
  }
}

C#

Situato insrc/main/java/.../HelloCdkStack.java:


// ...

namespace HelloCdk
{
  public class HelloCdkStack : Stack
  {
    internal HelloCdkStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
    {
      // Define the Lambda function resource
      // ...

      // Define the Lambda function URL resource
      var myFunctionUrl = myFunction.AddFunctionUrl(new FunctionUrlOptions
      {
        AuthType = FunctionUrlAuthType.NONE
      });

      // Define a CloudFormation output for your URL
      new CfnOutput(this, "myFunctionUrlOutput", new CfnOutputProps
      {
        Value = myFunctionUrl.Url
      });
    }
  }
}

Go

Situato inhello-cdk.go:


// ...

func NewHelloCdkStack(scope constructs.Construct, id string, props *HelloCdkStackProps) 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 Lambda function URL resource
  myFunctionUrl := myFunction.AddFunctionUrl(&awslambda.FunctionUrlOptions{
    AuthType: awslambda.FunctionUrlAuthType_NONE,
  })

  // Define a CloudFormation output for your URL
  awscdk.NewCfnOutput(stack, jsii.String("myFunctionUrlOutput"), &awscdk.CfnOutputProps{
    Value: myFunctionUrl.Url(),
  })

  return stack
}

// ...

avvertimento

Per semplificare questo tutorial, l'URL della funzione Lambda è definito senza autenticazione. Una volta distribuito, questo crea un endpoint accessibile pubblicamente che può essere utilizzato per richiamare la funzione. Quando hai finito con questo tutorial, segui Passaggio 12: Eliminare l'applicazione per eliminare queste risorse.

Fase 8: Sintetizzare un modello CloudFormation

In questa fase, vi preparate per l'implementazione sintetizzando un CloudFormation modello con il CDK CLI cdk synthcomando. Questo comando esegue la convalida di base del codice CDK, esegue l'app CDK e genera un CloudFormation modello dallo stack CDK.

Se l'app contiene più di uno stack, devi specificare quali stack sintetizzare. Poiché l'app contiene un singolo stack, il CDK CLI rileva automaticamente lo stack da sintetizzare.

Se non sintetizzi un modello, il CDK CLI eseguirà automaticamente questo passaggio al momento della distribuzione. Tuttavia, si consiglia di eseguire questo passaggio prima di ogni distribuzione per verificare la presenza di errori di sintesi.

Prima di sintetizzare un modello, puoi facoltativamente creare la tua applicazione per catturare errori di sintassi e di tipo. Per istruzioni, consulta Fase 4: Crea la tua app CDK.

Per sintetizzare un CloudFormation modello, esegui quanto segue dalla radice del progetto:


$ cdk synth

Nota

Se ricevete un errore come il seguente, verificate di essere nella hello-cdk directory e riprovate:

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

In caso di successo, il CDK CLI emetterà un YAML CloudFormation —modello formattato stdout e salvato un JSON—modello formattato nella cdk.out cartella del progetto.

Di seguito è riportato un esempio di output del 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: HelloCdkStack/HelloWorldFunction/ServiceRole/Resource
  HelloWorldFunctionunique-identifier:
    Type: AWS::Lambda::Function
    Properties:
      Code:
        ZipFile: "

          \        exports.handler = async function(event) {

          \          return {

          \            statusCode: 200,

          \            body: JSON.stringify('Hello World!'),

          \          };

          \        };

          \      "
      Handler: index.handler
      Role:
        Fn::GetAtt:
          - HelloWorldFunctionServiceRoleunique-identifier
          - Arn
      Runtime: nodejs20.x
    DependsOn:
      - HelloWorldFunctionServiceRoleunique-identifier
    Metadata:
      aws:cdk:path: HelloCdkStack/HelloWorldFunction/Resource
  HelloWorldFunctionFunctionUrlunique-identifier:
    Type: AWS::Lambda::Url
    Properties:
      AuthType: NONE
      TargetFunctionArn:
        Fn::GetAtt:
          - HelloWorldFunctionunique-identifier
          - Arn
    Metadata:
      aws:cdk:path: HelloCdkStack/HelloWorldFunction/FunctionUrl/Resource
  HelloWorldFunctioninvokefunctionurlunique-identifier:
    Type: AWS::Lambda::Permission
    Properties:
      Action: lambda:InvokeFunctionUrl
      FunctionName:
        Fn::GetAtt:
          - HelloWorldFunctionunique-identifier
          - Arn
      FunctionUrlAuthType: NONE
      Principal: "*"
    Metadata:
      aws:cdk:path: HelloCdkStack/HelloWorldFunction/invoke-function-url
  CDKMetadata:
    Type: AWS::CDK::Metadata
    Properties:
      Analytics: v2:deflate64:unique-identifier
    Metadata:
      aws:cdk:path: HelloCdkStack/CDKMetadata/Default
    Condition: CDKMetadataAvailable
Outputs:
  myFunctionUrlOutput:
    Value:
      Fn::GetAtt:
        - HelloWorldFunctionFunctionUrlunique-identifier
        - FunctionUrl
Parameters:
  BootstrapVersion:
    Type: AWS::SSM::Parameter::Value<String>
    Default: /cdk-bootstrap/unique-identifier/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.

Nota

Per impostazione predefinita, ogni modello generato contiene una AWS::CDK::Metadata risorsa. Il AWS CDK team utilizza questi metadati per ottenere informazioni sull' AWS CDK utilizzo e trovare modi per migliorarlo. Per i dettagli, incluso come disattivare la segnalazione delle versioni, consultaRapporti sulle versioni.

Definendo un singolo costrutto L2, AWS CDK crea un CloudFormation modello completo contenente le risorse Lambda, insieme alle autorizzazioni e alla logica di collegamento necessarie per consentire alle risorse di interagire all'interno dell'applicazione.

Fase 9: Implementa lo stack CDK

In questo passaggio, si utilizza il CDK CLI cdk deploycomando per distribuire lo stack CDK. Questo comando recupera il CloudFormation modello generato e lo distribuisce AWS CloudFormation, il che fornisce le risorse come parte di uno stack. CloudFormation

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


$ cdk deploy

✨  Synthesis time: 2.69s

HelloCdkStack:  start: Building unique-identifier:current_account-current_region
HelloCdkStack:  success: Built unique-identifier:current_account-current_region
HelloCdkStack:  start: Publishing unique-identifier:current_account-current_region
HelloCdkStack:  success: Published unique-identifier:current_account-current_region
This deployment will make potentially sensitive changes according to your current security approval level (--require-approval broadening).
Please confirm you intend to make the following modifications:

IAM Statement Changes
┌───┬───────────────────────────────────────┬────────┬──────────────────────────┬──────────────────────────────┬───────────┐
│   │ Resource                              │ Effect │ Action                   │ Principal                    │ Condition │
├───┼───────────────────────────────────────┼────────┼──────────────────────────┼──────────────────────────────┼───────────┤
│ + │ ${HelloWorldFunction.Arn}             │ Allow  │ lambda:InvokeFunctionUrl │ *                            │           │
├───┼───────────────────────────────────────┼────────┼──────────────────────────┼──────────────────────────────┼───────────┤
│ + │ ${HelloWorldFunction/ServiceRole.Arn} │ Allow  │ sts:AssumeRole           │ Service:lambda.amazonaws.com │           │
└───┴───────────────────────────────────────┴────────┴──────────────────────────┴──────────────────────────────┴───────────┘
IAM Policy Changes
┌───┬───────────────────────────────────┬────────────────────────────────────────────────────────────────────────────────┐
│   │ Resource                          │ Managed Policy ARN                                                             │
├───┼───────────────────────────────────┼────────────────────────────────────────────────────────────────────────────────┤
│ + │ ${HelloWorldFunction/ServiceRole} │ arn:${AWS::Partition}:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole │
└───┴───────────────────────────────────┴────────────────────────────────────────────────────────────────────────────────┘
(NOTE: There may be security-related changes not in this list. See https://github.com/aws/aws-cdk/issues/1299)

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

Analogamentecdk synth, non è necessario specificare lo AWS CDK stack poiché l'app contiene un unico stack.

Durante la distribuzione, il CDK CLI visualizza le informazioni sullo stato di avanzamento man mano che lo stack viene distribuito. Al termine, puoi accedere alla AWS CloudFormation console per visualizzare lo stack. HelloCdkStack Puoi anche accedere alla console Lambda per visualizzare la tua HelloWorldFunction risorsa.

Al termine della distribuzione, il CDK CLI mostrerà l'URL dell'endpoint. Copia questo URL per il passaggio successivo. Di seguito è riportato un esempio:


...
HelloCdkStack: deploying... [1/1]
HelloCdkStack: creating CloudFormation changeset...

 ✅  HelloCdkStack

✨  Deployment time: 41.65s

Outputs:
HelloCdkStack.myFunctionUrlOutput = https://<api-id>.lambda-url.<Region>.on.aws/
Stack ARN:
arn:aws:cloudformation:Region:account-id:stack/HelloCdkStack/unique-identifier

✨  Total time: 44.34s

Passaggio 10: Interagisci con la tua applicazione su AWS

In questo passaggio, interagisci con l'applicazione richiamando la funzione Lambda tramite l'URL della funzione. AWS Quando accedi all'URL, la funzione Lambda restituisce il Hello World! messaggio.

Per richiamare la funzione, accedi all'URL della funzione tramite il browser o dalla riga di comando. Di seguito è riportato un esempio:


$ curl https://<api-id>.lambda-url.<Region>.on.aws/
"Hello World!"%

Passaggio 11: modifica l'applicazione

In questo passaggio, si modifica il messaggio che la funzione Lambda restituisce quando viene richiamata. Si esegue una differenza utilizzando il CDK CLI cdk diffcomando per visualizzare in anteprima le modifiche e distribuirlo per aggiornare l'applicazione. Quindi interagisci con la tua applicazione AWS per vedere il tuo nuovo messaggio.

Modifica l'myFunctionistanza nel tuo file stack CDK come segue:

TypeScript

Situata in: lib/hello-cdk-stack.ts


// ...

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

    // Modify the Lambda function resource
    const myFunction = new lambda.Function(this, "HelloWorldFunction", {
      runtime: lambda.Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
      handler: "index.handler",
      code: lambda.Code.fromInline(`
        exports.handler = async function(event) {
          return {
            statusCode: 200,
            body: JSON.stringify('Hello CDK!'),
          };
        };
      `),
    });

    // ...

JavaScript

Situato inlib/hello-cdk-stack.js:


// ...

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

    // Modify the Lambda function resource
    const myFunction = new lambda.Function(this, "HelloWorldFunction", {
      runtime: lambda.Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
      handler: "index.handler",
      code: lambda.Code.fromInline(`
        exports.handler = async function(event) {
          return {
            statusCode: 200,
            body: JSON.stringify('Hello CDK!'),
          };
        };
      `),
    });

    // ...

  }
}

module.exports = { HelloCdkStack }

Python

Situato inhello_cdk/hello_cdk_stack.py:


# ...

class HelloCdkStack(Stack):

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

    # Modify the Lambda function resource
    my_function = _lambda.Function(
      self, "HelloWorldFunction", 
      runtime = _lambda.Runtime.NODEJS_20_X, # Provide any supported Node.js runtime
      handler = "index.handler",
      code = _lambda.Code.from_inline(
        """
        exports.handler = async function(event) {
          return {
            statusCode: 200,
            body: JSON.stringify('Hello CDK!'),
          };
        };
        """
      ),
    )

    # ...

Java

Situato insrc/main/java/.../HelloCdkStack.java:


// ...

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

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

    // Modify the Lambda function resource
    Function myFunction = Function.Builder.create(this, "HelloWorldFunction")
      .runtime(Runtime.NODEJS_20_X) // Provide any supported Node.js runtime
      .handler("index.handler")
      .code(Code.fromInline(
        "exports.handler = async function(event) {" +
        " return {" +
        " statusCode: 200," +
        " body: JSON.stringify('Hello CDK!')" +
        " };" +
        "};"))
      .build();

    // ...
  }
}

C#


// ...

namespace HelloCdk
{
  public class HelloCdkStack : Stack
  {
    internal HelloCdkStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
    {
      // Modify the Lambda function resource
      var myFunction = new Function(this, "HelloWorldFunction", new FunctionProps
      {
        Runtime = Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
        Handler = "index.handler",
        Code = Code.FromInline(@"
          exports.handler = async function(event) {
            return {
              statusCode: 200,
              body: JSON.stringify('Hello CDK!'),
            };
          };
        "),
      });

      // ...
    }
  }
}

Go


// ...

type HelloCdkStackProps struct {
  awscdk.StackProps
}

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

  // Modify the Lambda function resource
  myFunction := awslambda.NewFunction(stack, jsii.String("HelloWorldFunction"), &awslambda.FunctionProps{
    Runtime: awslambda.Runtime_NODEJS_20_X(), // Provide any supported Node.js runtime
    Handler: jsii.String("index.handler"),
    Code: awslambda.Code_FromInline(jsii.String(`
      exports.handler = async function(event) {
        return {
          statusCode: 200,
          body: JSON.stringify('Hello CDK!'),
        };
      };
    `)),
  })

// ...

Attualmente, le modifiche al codice non hanno apportato alcun aggiornamento diretto alla risorsa Lambda distribuita. Il codice definisce lo stato desiderato della risorsa. Per modificare la risorsa distribuita, utilizzerai il CDK CLI per sintetizzare lo stato desiderato in un nuovo modello. AWS CloudFormation Quindi, distribuirai il nuovo CloudFormation modello come set di modifiche. I set di modifiche apportano solo le modifiche necessarie per raggiungere il nuovo stato desiderato.

Per visualizzare in anteprima le modifiche, esegui il cdk diff comando. Di seguito è riportato un esempio:


$ cdk diff
Stack HelloCdkStack
Hold on while we create a read-only change set to get a diff with accurate replacement information (use --no-change-set to use a less accurate but faster template-only diff)
Resources
[~] AWS::Lambda::Function HelloWorldFunction HelloWorldFunctionunique-identifier
 └─ [~] Code
     └─ [~] .ZipFile:
         ├─ [-] 
                exports.handler = async function(event) {
                    return {
                      statusCode: 200,
                      body: JSON.stringify('Hello World!'),
                    };
                };
                
         └─ [+] 
                exports.handler = async function(event) {
                    return {
                      statusCode: 200,
                      body: JSON.stringify('Hello CDK!'),
                    };
                };
                

✨  Number of stacks with differences: 1

Per creare questa differenza, il CDK CLI chiede al tuo Account AWS account il AWS CloudFormation modello più recente per lo stack. HelloCdkStack Quindi, confronta il modello più recente con il modello appena sintetizzato dalla tua app.

Per implementare le modifiche, esegui il comando. cdk deploy Di seguito è riportato un esempio:


$ cdk deploy

✨  Synthesis time: 2.12s

HelloCdkStack:  start: Building unique-identifier:current_account-current_region
HelloCdkStack:  success: Built unique-identifier:current_account-current_region
HelloCdkStack:  start: Publishing unique-identifier:current_account-current_region
HelloCdkStack:  success: Published unique-identifier:current_account-current_region
HelloCdkStack: deploying... [1/1]
HelloCdkStack: creating CloudFormation changeset...

 ✅  HelloCdkStack

✨  Deployment time: 26.96s

Outputs:
HelloCdkStack.myFunctionUrlOutput = https://unique-identifier.lambda-url.<Region>.on.aws/
Stack ARN:
arn:aws:cloudformation:Region:account-id:stack/HelloCdkStack/unique-identifier

✨  Total time: 29.07s

Per interagire con l'applicazione, ripetiPassaggio 10: Interagisci con la tua applicazione su AWS. Di seguito è riportato un esempio:


$ curl https://<api-id>.lambda-url.<Region>.on.aws/
"Hello CDK!"%

Passaggio 12: Eliminare l'applicazione

In questo passaggio, si utilizza il CDK CLI cdk destroycomando per eliminare l'applicazione. Questo comando elimina lo CloudFormation stack associato allo stack CDK, che include le risorse create.

Per eliminare l'applicazione, esegui il cdk destroy comando e conferma la richiesta di eliminazione dell'applicazione. Di seguito è riportato un esempio:


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

 ✅  HelloCdkStack: destroyed

Passaggi successivi

Complimenti! Hai completato questo tutorial e lo hai utilizzato AWS CDK per creare, modificare ed eliminare correttamente le risorse in Cloud AWS. Ora sei pronto per iniziare a utilizzare il AWS CDK.

Per ulteriori informazioni sull'utilizzo di AWS CDK nel linguaggio di programmazione preferito, consultaLavora con la AWS CDK libreria.

Per ulteriori risorse, consulta quanto segue:

Prova il CDK Workshop per un tour più approfondito che coinvolge un progetto più complesso.
Consulta il riferimento all'API per iniziare a esplorare i costrutti CDK disponibili per i tuoi servizi preferiti. AWS
Visita Construct Hub per scoprire i costrutti creati da e altri. AWS
Esplora esempi di utilizzo di. AWS CDK

AWS CDK È un progetto open source. Per contribuire, vedere Contributing to the AWS Cloud Development Kit (AWS CDK).

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

Nozioni di base

Lavora con la libreria CDK

Tutorial: crea la tua prima app AWS CDK

Prerequisiti

Informazioni sul tutorial

Fase 1: Crea il tuo progetto CDK

Per creare un progetto CDK

Importante

Fase 2: Configurazione dell' AWS ambiente

Da utilizzare AWS CLI per ottenere il proprio ID Account AWS

Per AWS CLI utilizzarlo per ottenere il Regione AWS

Per configurare l'ambiente per lo stack CDK

Fase 3: Avvia il tuo ambiente AWS

Fase 4: Crea la tua app CDK

Passaggio 5: Elenca gli stack CDK nella tua app

Fase 6: Definizione della funzione Lambda

Fase 7: Definizione dell'URL della funzione Lambda

avvertimento

Fase 8: Sintetizzare un modello CloudFormation

Nota

Nota

Fase 9: Implementa lo stack CDK

Passaggio 10: Interagisci con la tua applicazione su AWS

Passaggio 11: modifica l'applicazione

Passaggio 12: Eliminare l'applicazione

Passaggi successivi