Questa è la AWS CDK v2 Developer Guide. 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à.
# Guida introduttiva al CDK AWS
Inizia a usare il AWS Cloud Development Kit (AWS CDK) installando e configurando l'interfaccia a riga di comando AWS CDK (CDK AWS CLI). Quindi, usa la CLI CDK per creare la tua prima app CDK, avviare AWS il tuo ambiente e distribuire l'applicazione.
## Prerequisiti
Prima di iniziare a usare il AWS CDK, completa tutti i prerequisiti. Questi prerequisiti sono necessari per chi è alle prime armi AWS o per chi è alle prime armi con la programmazione. Per istruzioni, consulta Prerequisiti [AWS CDK.](prerequisites.md)
Ti consigliamo di avere una conoscenza di base di cosa sia il AWS CDK. Per ulteriori informazioni, consulta [Cos'è il AWS CDK](home.md)? e [impara i concetti fondamentali del AWS CDK](core-concepts.md).
## Installazione della CLI AWS CDK
Utilizzate il Node Package Manager per installare la CLI CDK. Ti consigliamo di installarlo a livello globale utilizzando il seguente comando:
```
$ npm install -g aws-cdk
```
Per installare una versione specifica della CLI CDK, utilizzate la seguente struttura di comandi:
```
$ npm install -g aws-cdk@X.YY.Z
```
Se desideri utilizzare più versioni del AWS CDK, prendi in considerazione l'installazione di una versione corrispondente della CLI CDK nei singoli progetti CDK. A tale scopo, rimuovete l'`-g`opzione dal comando. `npm install` Quindi, utilizzare `npx aws-cdk` per richiamare la CLI CDK. Questo eseguirà una versione locale, se esiste. In caso contrario, verrà utilizzata la versione installata a livello globale.
**Risoluzione dei problemi relativi all'installazione della CLI CDK**
Se ricevi un errore di autorizzazione e disponi dell'accesso come amministratore sul tuo sistema, esegui quanto segue:
```
$ sudo npm install -g aws-cdk
```
Se ricevi un messaggio di errore, prova a disinstallare la CLI CDK eseguendo quanto segue:
```
$ npm uninstall -g aws-cdk
```
Quindi, ripeti i passaggi per reinstallare la CLI CDK.
## Verifica di una corretta installazione della CLI CDK
Eseguite il comando seguente per verificare l'avvenuta installazione. La CLI AWS CDK dovrebbe restituire il numero di versione:
```
$ cdk --version
```
## Configurazione della CLI AWS CDK
Dopo aver installato la CLI CDK, puoi iniziare a usarla per sviluppare applicazioni sul tuo computer locale. Per interagire AWS, ad esempio per distribuire applicazioni, è necessario disporre di credenziali di sicurezza configurate sul computer locale con le autorizzazioni per eseguire qualsiasi azione avviata.
Per configurare le credenziali di sicurezza sul computer locale, si utilizza la AWS CLI. Il modo in cui configuri le credenziali di sicurezza dipende da come gestisci gli utenti. Per istruzioni, consulta [Autenticazione e credenziali di accesso nella Guida](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-authentication.html) per l'*utente dell'interfaccia a riga di AWS comando*.
La CLI CDK utilizzerà automaticamente le credenziali di sicurezza configurate con la CLI. AWS Ad esempio, se sei un utente di IAM Identity Center, puoi utilizzare il `aws configure sso` comando per configurare le credenziali di sicurezza. Se sei un utente IAM, puoi utilizzare il `aws configure` comando. La AWS CLI ti guiderà nella configurazione delle credenziali di sicurezza sul tuo computer locale e salverà le informazioni necessarie nei tuoi file. `config` `credentials` Quindi, quando utilizzi la CLI CDK, ad esempio distribuendo un'applicazione `cdk deploy` con, la CLI CDK utilizzerà le credenziali di sicurezza configurate.
Proprio come la AWS CLI, la CLI CDK `default` utilizzerà il tuo profilo per impostazione predefinita. È possibile specificare un profilo utilizzando l'opzione CDK [`--profile`](ref-cli-cmd.md#ref-cli-cmd-options-profile)CLI. Per ulteriori informazioni sull'utilizzo delle credenziali di sicurezza con la CLI CDK, consulta [Configurare le credenziali di sicurezza per](configure-access.md) la CLI CDK. AWS
## (Facoltativo) Installa strumenti CDK aggiuntivi AWS
[AWS Toolkit for Visual Studio](https://aws.amazon.com/visualstudiocode/) Code è un plug-in Visual Studio Code open source che consente di creare, eseguire il debug e distribuire applicazioni su. AWS Il toolkit offre un'esperienza integrata per lo sviluppo di applicazioni CDK. AWS Include la funzionalità AWS CDK Explorer per elencare i progetti AWS CDK e sfogliare i vari componenti dell'applicazione CDK. Per le istruzioni, consulta quanto segue:
+ [Installazione del AWS Toolkit for Visual Studio Code](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/setup-toolkit.html).
+ [AWS CDK per VS Code](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/cdk-explorer.html).
## Crea la tua prima app CDK
Ora sei pronto per iniziare a usare AWS CDK creando la tua prima app CDK. Per istruzioni, consulta [Tutorial: crea la tua prima app AWS CDK](hello-world.md).
# Tutorial: crea la tua prima app AWS CDK
Inizia a usare il AWS Cloud Development Kit (AWS CDK) utilizzando la AWS CDK Command Line Interface (AWS CDK CLI) per sviluppare la tua prima app CDK, avviare il AWS tuo ambiente e distribuirvi l'applicazione. AWS
## Prerequisiti
[Prima di iniziare questo tutorial, completa tutti i passaggi di configurazione descritti in Guida introduttiva al CDK. AWS](getting-started.md)
## Informazioni sul tutorial
In questo tutorial, creerai e distribuirai una semplice applicazione sull' AWS uso del AWS CDK. L'applicazione è costituita da una [funzione AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) che restituisce un `Hello World!` messaggio quando viene richiamata. La funzione verrà richiamata tramite un URL della [funzione Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-urls.html) 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 utilizzando il comando CDK CLI. `cdk init`
+ **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 comando CDK CLI. `cdk bootstrap`
+ **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**: utilizza la CLI CDK per creare la tua app e sintetizzare AWS CloudFormation un modello.
+ **Implementa la tua app**: utilizza il `cdk deploy` comando CDK CLI per distribuire l'applicazione e fornire le tue 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 comando CDK `cdk destroy` CLI.
## Passaggio 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**
1. Da una directory iniziale a tua scelta, crea e naviga fino a una directory denominata`hello-cdk`:
```
$ mkdir hello-cdk && cd hello-cdk
```
**Importante**
Assicuratevi di assegnare un nome alla cartella del progetto`hello-cdk`, *esattamente come mostrato qui*. La CLI CDK 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.
1. Dalla `hello-cdk` directory, inizializza un nuovo progetto CDK utilizzando il comando CDK `cdk init` CLI. Specificate il `app` modello e il linguaggio di programmazione preferito con l'opzione: `--language`
**Example**
------
#### [ 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 l'ambiente virtuale Python dell'app e installano le dipendenze principali del AWS CDK.
```
$ 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. Ad esempioEclipse, scegli **File** > **Importa** > Maven > **Progetti Maven** **esistenti**. Assicuratevi che le impostazioni del progetto siano impostate per utilizzare Java 8 (1.8).
------
#### [ C\$1 ]
```
$ 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 lo hai Git installato, ogni progetto che crei utilizzando `cdk init` viene inizializzato anche come repository. Git
Durante l'inizializzazione del progetto, la CLI CDK crea un'app CDK contenente un singolo stack CDK. L'istanza dell'app CDK viene creata utilizzando il costrutto. [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.App.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.App.html) Quanto segue è una parte di questo codice dal file dell'applicazione CDK:
**Example**
Situato in`bin/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', {
});
```
Situato in`bin/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', {
});
```
Situato in`app.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",)
app.synth()
```
Situato in`src/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()
.build());
app.synth();
}
}
```
Situato in`src/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
{});
app.Synth();
}
}
}
```
Situato in`hello-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)
}
// ...
```
Lo stack CDK viene creato utilizzando il [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Stack.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Stack.html)costrutto. Quanto segue è una parte di questo codice dal file dello stack CDK:
**Example**
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
}
}
```
Situato in`lib/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 }
```
Situato in`hello_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
```
Situato in`src/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
}
}
```
Situato in`src/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
}
}
}
```
Situato in`hello-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: Configurare AWS l'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 è composto da un AWS account e da una AWS regione.
Quando si utilizza la AWS CLI per configurare le credenziali di sicurezza sul computer locale, è possibile utilizzare la AWS CLI per ottenere informazioni AWS sull'ambiente per un profilo specifico.
**Per utilizzare la AWS CLI per ottenere l'ID dell'account AWS **
1. Esegui il seguente comando AWS CLI per ottenere l'ID dell' AWS account per il tuo `default` profilo:
```
$ aws sts get-caller-identity --query "Account" --output text
```
1. Se preferisci utilizzare un profilo denominato, fornisci il nome del tuo profilo utilizzando l'`--profile`opzione:
```
$ aws sts get-caller-identity --profile your-profile-name --query "Account" --output text
```
**Per utilizzare la AWS CLI per ottenere la tua regione AWS **
1. Esegui il seguente comando AWS CLI per ottenere la regione che hai configurato per il tuo `default` profilo:
```
$ aws configure get region
```
1. Se preferisci utilizzare un profilo denominato, fornisci il nome del tuo profilo utilizzando l'`--profile`opzione:
```
$ aws configure get region --profile your-profile-name
```
*Successivamente, configurerete l' AWS ambiente per lo stack CDK modificando l'`HelloCdkStack`istanza nel file dell'applicazione.* In questo tutorial, codificherete le AWS informazioni sull'ambiente. Questo non è consigliato per gli ambienti di produzione. Per informazioni su altri modi di configurare gli ambienti, consulta [Configurare gli ambienti da utilizzare con il AWS CDK](configure-env.md).
**Per configurare l'ambiente per lo stack CDK**
1. Nel *file dell'applicazione*, utilizzate la `env` proprietà del `Stack` costrutto per configurare l'ambiente. Di seguito è riportato un esempio:
**Example**
------
#### [ TypeScript ]
Situato in`bin/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 in`bin/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 in`app.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 in`src/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\$1 ]
Situato in`src/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 in`hello-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. La CLI CDK 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, consultate [Bootstrap your environment for use with](bootstrapping-env.md) the CDK. AWS
## 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 con il AWS CDK poiché la CLI CDK eseguirà automaticamente questo passaggio. Tuttavia, puoi comunque creare manualmente se desideri catturare errori di sintassi e di tipo. Di seguito è riportato un esempio:
**Example**
```
$ npm run build
> hello-cdk@0.1.0 build
> tsc
```
Non è necessaria alcuna fase di compilazione.
Non è necessaria alcuna fase di costruzione.
```
$ mvn compile -q
```
Oppure premi `Control-B` in Eclipse (altri Java IDEs possono variare)
```
$ dotnet build src
```
Oppure premi F6 in Visual Studio
```
$ go build
```
## 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 comando CDK `cdk list` CLI per visualizzare i tuoi 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 continui a non visualizzare lo stack, ripeti il [passaggio 1: crea il progetto CDK](#hello-world-create) e riprova.
## Fase 6: Definizione della funzione Lambda
In questo passaggio, importate il [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html)modulo dalla AWS Construct Library e utilizzate il costrutto [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)L2.
Modificate il file dello stack CDK come segue:
**Example**
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!'),
};
};
`),
});
}
}
```
Situato in`lib/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 }
```
Situato in`hello_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!'),
};
};
"""
),
)
```
Situato in`src/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();
}
}
```
Situato in`src/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!'),
};
};
"),
});
}
}
}
```
Situato in`hello-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'`Stack`istanza 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 è `this` (`self`in Python).
+ **Id**: l'ID di costruzione dell'app `Function` AWS CDK. Questo ID, più un hash basato sulla posizione della funzione all'interno dello stack, identifica in modo univoco la funzione durante la distribuzione. Il AWS CDK fa riferimento a questo ID anche 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`, e`code`.
Gli oggetti di scena sono rappresentati in modo diverso nelle lingue supportate dal AWS CDK.
+ In TypeScript and 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 `Function` consentire di creare il costrutto e il relativo oggetto props in un unico passaggio. Questo codice utilizza quest'ultimo.
+ In C\$1, 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 si imparano a conoscerne 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. [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.CfnOutput.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.CfnOutput.html)
Aggiungi quanto segue al tuo file dello stack CDK:
**Example**
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,
})
}
}
```
Situato in`lib/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 }
```
Situato in`hello_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)
```
Situato in`src/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();
}
}
```
Situato in`src/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
});
}
}
}
```
Situato in`hello-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 il [Passaggio 12: Elimina l'applicazione](#hello-world-delete) per eliminare queste risorse.
## Fase 8: Sintetizzare un modello CloudFormation
In questo passaggio, ti prepari per la distribuzione sintetizzando un CloudFormation modello con il comando CDK `cdk synth` CLI. Questo comando esegue la convalida di base del codice CDK, esegue l'app CDK e genera un modello dallo stack CDK. CloudFormation
Se l'app contiene più di uno stack, devi specificare quali stack sintetizzare. Poiché l'app contiene un singolo stack, la CLI CDK rileva automaticamente lo stack da sintetizzare.
Se non sintetizzi un modello, la CLI CDK eseguirà automaticamente questo passaggio al momento della distribuzione. Tuttavia, consigliamo 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: Creazione](#hello-world-build) dell'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 trovarvi nella `hello-cdk` directory e riprovate:
```
--app is required either in command-line, in cdk.json or in ~/.cdk.json
```
In caso di successo, la CLI CDK emetterà `YAML` un modello `stdout` in CloudFormation formato —e lo `JSON` salverà nella directory del progetto. `cdk.out`
Di seguito è riportato un esempio di output del modello: CloudFormation
### AWS CloudFormation modello
```
Resources:
HelloWorldFunctionServiceRole:
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
HelloWorldFunction:
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:
- HelloWorldFunctionServiceRole
- Arn
Runtime: nodejs20.x
DependsOn:
- HelloWorldFunctionServiceRole
Metadata:
aws:cdk:path: HelloCdkStack/HelloWorldFunction/Resource
HelloWorldFunctionFunctionUrl:
Type: AWS::Lambda::Url
Properties:
AuthType: NONE
TargetFunctionArn:
Fn::GetAtt:
- HelloWorldFunction
- Arn
Metadata:
aws:cdk:path: HelloCdkStack/HelloWorldFunction/FunctionUrl/Resource
HelloWorldFunctioninvokefunctionurl:
Type: AWS::Lambda::Permission
Properties:
Action: lambda:InvokeFunctionUrl
FunctionName:
Fn::GetAtt:
- HelloWorldFunction
- Arn
FunctionUrlAuthType: NONE
Principal: "*"
Metadata:
aws:cdk:path: HelloCdkStack/HelloWorldFunction/invoke-function-url
CDKMetadata:
Type: AWS::CDK::Metadata
Properties:
Analytics: v2:deflate64:
Metadata:
aws:cdk:path: HelloCdkStack/CDKMetadata/Default
Condition: CDKMetadataAvailable
Outputs:
myFunctionUrlOutput:
Value:
Fn::GetAtt:
- HelloWorldFunctionFunctionUrl
- FunctionUrl
Parameters:
BootstrapVersion:
Type: AWS::SSM::Parameter::Value
Default: /cdk-bootstrap//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**
Ogni modello generato contiene una ` AWS::CDK::Metadata` risorsa per impostazione predefinita. Il team AWS CDK utilizza questi metadati per ottenere informazioni sull'utilizzo di AWS CDK e trovare modi per migliorarlo. [Per i dettagli, incluso come disattivare la segnalazione delle versioni, consulta Segnalazione delle versioni.](cli.md#version-reporting)
Definendo un singolo costrutto L2, il 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 comando CDK `cdk deploy` CLI 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 :current_account-current_region
HelloCdkStack: success: Built :current_account-current_region
HelloCdkStack: start: Publishing :current_account-current_region
HelloCdkStack: success: Published :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
```
Analogamente`cdk synth`, non è necessario specificare lo stack AWS CDK poiché l'app contiene un unico stack.
Durante la distribuzione, la CLI CDK mostra 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](https://console.aws.amazon.com/cloudformation/home). `HelloCdkStack` Puoi anche accedere alla console Lambda per visualizzare la tua `HelloWorldFunction` risorsa.
Al termine della distribuzione, la CLI CDK genererà 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://.lambda-url..on.aws/
Stack ARN:
arn:aws:cloudformation::stack/HelloCdkStack/
✨ 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://.lambda-url..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 comando CDK `cdk diff` CLI per visualizzare in anteprima le modifiche e distribuirla per aggiornare l'applicazione. Quindi interagisci con l'applicazione AWS per visualizzare il nuovo messaggio.
Modifica l'`myFunction`istanza nel tuo file stack CDK come segue:
**Example**
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!'),
};
};
`),
});
// ...
}
}
```
Situato in`lib/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 }
```
Situato in`hello_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!'),
};
};
"""
),
)
# ...
```
Situato in`src/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();
// ...
}
}
```
```
// ...
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!'),
};
};
"),
});
// ...
}
}
}
```
```
// ...
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 la CLI CDK 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 HelloWorldFunction
└─ [~] 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, la CLI di CDK richiede all'account dell' AWS account il modello AWS CloudFormation 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 :current_account-current_region
HelloCdkStack: success: Built :current_account-current_region
HelloCdkStack: start: Publishing :current_account-current_region
HelloCdkStack: success: Published :current_account-current_region
HelloCdkStack: deploying... [1/1]
HelloCdkStack: creating CloudFormation changeset...
✅ HelloCdkStack
✨ Deployment time: 26.96s
Outputs:
HelloCdkStack.myFunctionUrlOutput = https://.lambda-url..on.aws/
Stack ARN:
arn:aws:cloudformation::stack/HelloCdkStack/
✨ Total time: 29.07s
```
Per interagire con l'applicazione, ripeti il [Passaggio 10: Interagisci con l'applicazione su AWS](#hello-world-interact). Di seguito è riportato un esempio:
```
$ curl https://.lambda-url..on.aws/
"Hello CDK!"%
```
## Passaggio 12: Eliminare l'applicazione
In questo passaggio, si utilizza il comando CDK `cdk destroy` CLI 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
```
## Fasi successive
Complimenti\$1 Hai completato questo tutorial e hai utilizzato il AWS CDK per creare, modificare ed eliminare correttamente le risorse nel AWS Cloud. Ora sei pronto per iniziare a utilizzare il AWS CDK.
Per ulteriori informazioni sull'utilizzo del AWS CDK nel linguaggio di programmazione preferito, consulta [Lavorare con la libreria AWS CDK](work-with.md).
Per ulteriori risorse, consultate quanto segue:
+ Prova il [CDK Workshop](https://cdkworkshop.com/) per un tour più approfondito che coinvolge un progetto più complesso.
+ Consulta il [riferimento all'API](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-construct-library.html) per iniziare a esplorare i costrutti CDK disponibili per i tuoi servizi preferiti. AWS
+ Visita [Construct Hub](https://constructs.dev/search?q=&cdk=aws-cdk&cdkver=2&sort=downloadsDesc&offset=0) per scoprire i costrutti creati da e altri. AWS
+ Esplora [esempi](https://github.com/aws-samples/aws-cdk-examples) di utilizzo del CDK. AWS
Il AWS CDK è un progetto open source. Per contribuire, consulta [Contributing to the AWS Cloud Development Kit (AWS CDK).](https://github.com/aws/aws-cdk/blob/main/CONTRIBUTING.md)