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

# Testa e crea applicazioni AWS CDK localmente con la CLI AWS SAM
<a name="testing-locally"></a>

Puoi utilizzare la CLI AWS SAM per testare e creare localmente applicazioni serverless definite utilizzando il AWS Cloud Development Kit (AWS CDK). Poiché la CLI AWS SAM funziona all'interno della struttura del progetto AWS CDK, puoi comunque utilizzare il [riferimento CDK AWS CLI](cli.md) per creare, modificare e distribuire le tue applicazioni CDK. AWS 

*Per i dettagli sull'utilizzo di AWS SAM, consulta la [Guida introduttiva a SAM nella Serverless Application Model AWS Developer](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-getting-started.html) Guide. AWS *

**Topics**
+ [Guida introduttiva ai test locali](testing-locally-getting-started.md)
+ [Test locali di applicazioni AWS CDK con SAM AWS](testing-locally-with-sam-cli.md)
+ [Creazione di applicazioni AWS CDK con SAM AWS](testing-locally-build-with-sam-cli.md)

# Guida introduttiva ai test locali
<a name="testing-locally-getting-started"></a>

Questo argomento descrive cosa è necessario per utilizzare la CLI AWS SAM con le applicazioni AWS CDK e fornisce istruzioni per creare e testare localmente una semplice AWS applicazione CDK.

## Prerequisiti
<a name="testing-locally-getting-started-prerequisites"></a>

Per eseguire il test localmente, è necessario installare AWS SAM CLI. Per istruzioni di installazione, vedere [Installazione della CLI AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/getting_started.html).

## Creare e testare localmente un'applicazione CDK AWS
<a name="testing-locally-getting-started-tutorial"></a>

Per testare localmente un'applicazione AWS CDK utilizzando la CLI AWS SAM, è necessario disporre di AWS un'applicazione CDK che contenga una funzione Lambda. Utilizza i seguenti passaggi per creare un'applicazione AWS CDK di base con una funzione Lambda. Per ulteriori informazioni, consulta [Creazione di un'applicazione serverless utilizzando AWS CDK nella Guida per gli](https://docs.aws.amazon.com/cdk/latest/guide/serverless_example.html) sviluppatori del * AWS Cloud Development Kit (AWS CDK)*.<a name="testing-locally-getting-started-tutorial-init"></a>

 **Fase 1: Creare un'applicazione CDK AWS **   
Per questo tutorial, inizializza un'applicazione AWS CDK che utilizza. TypeScript  
Comando da eseguire:  

```
$ mkdir cdk-sam-example
$ cd cdk-sam-example
$ cdk init app --language typescript
```<a name="testing-locally-getting-started-tutorial-lambda"></a>

 **Fase 2: Aggiungere una funzione Lambda all'applicazione**   
Sostituisci il codice `lib/cdk-sam-example-stack.ts` con quanto segue:  

```
import { Stack, StackProps } from 'aws-cdk-lib';
import { Construct } from 'constructs';
import * as lambda from 'aws-cdk-lib/aws-lambda';

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

    new lambda.Function(this, 'MyFunction', {
      runtime: lambda.Runtime.PYTHON_3_12,
      handler: 'app.lambda_handler',
      code: lambda.Code.fromAsset('./my_function'),
    });
  }
}
```<a name="testing-locally-getting-started-tutorial-code"></a>

 **Fase 3: Aggiungere il codice della funzione Lambda**   
Crea una directory denominata `my_function`. Nella directory, creare un file denominato `app.py`.  
Comando da eseguire:  

**Example**  

```
$ mkdir my_function
$ cd my_function
$ touch app.py
```

```
$ mkdir my_function
$ cd my_function
$ type nul > app.py
```

```
$ mkdir my_function
$ cd my_function
$ New-Item -Path "app.py”
```
Aggiungere il seguente codice a `app.py`:

```
def lambda_handler(event, context):
    return "Hello from SAM and the CDK!"
```<a name="testing-locally-getting-started-tutorial-function"></a>

 **Fase 4: Verifica la tua funzione Lambda**   
È possibile utilizzare la CLI AWS SAM per richiamare localmente una funzione Lambda definita in un'applicazione CDK. AWS A tale scopo, sono necessari l'identificatore del costrutto della funzione e il percorso del modello sintetizzato. AWS CloudFormation   
Eseguite il seguente comando per tornare alla directory: `lib`  

```
$  cd ..
```
 **Comando da eseguire:**   

```
$  cdk synth --no-staging
```

```
$  sam local invoke MyFunction --no-event -t ./cdk.out/CdkSamExampleStack.template.json
```
 **Esempio di output:**   

```
Invoking app.lambda_handler (python3.9)

START RequestId: 5434c093-7182-4012-9b06-635011cac4f2 Version: $LATEST
"Hello from SAM and the CDK!"
END RequestId: 5434c093-7182-4012-9b06-635011cac4f2
REPORT RequestId: 5434c093-7182-4012-9b06-635011cac4f2	Init Duration: 0.32 ms	Duration: 177.47 ms	Billed Duration: 178 ms	Memory Size: 128 MB	Max Memory Used: 128 MB
```

# Test locali di applicazioni AWS CDK con SAM AWS
<a name="testing-locally-with-sam-cli"></a>

È possibile utilizzare la CLI AWS SAM per testare localmente le applicazioni AWS CDK eseguendo i seguenti comandi dalla directory principale del progetto dell'applicazione CDK: AWS 
+  ` [sam local invoke](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-local-invoke.html) ` 
+  ` [sam local start-api](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-local-start-api.html) ` 
+  ` [sam local start-lambda](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-local-start-lambda.html) ` 

Prima di eseguire qualsiasi `sam local` comando con un'applicazione AWS CDK, è necessario eseguire. `cdk synth`

Durante l'esecuzione è `sam local invoke` necessario l'identificatore del costrutto della funzione che si desidera richiamare e il percorso del modello sintetizzato. AWS CloudFormation Se l'applicazione utilizza pile annidate, per risolvere i conflitti di denominazione, è necessario anche il nome dello stack in cui è definita la funzione.

 **Utilizzo**   

```
# Invoke the function FUNCTION_IDENTIFIER declared in the stack STACK_NAME
$  sam local invoke <OPTIONS> <STACK_NAME/FUNCTION_IDENTIFIER>

# Start all APIs declared in the AWS CDK application
$  sam local start-api -t <./cdk.out/CdkSamExampleStack.template.json> <OPTIONS>

# Start a local endpoint that emulates AWS Lambda
$  sam local start-lambda -t <./cdk.out/CdkSamExampleStack.template.json> <OPTIONS>
```

## Esempio
<a name="testing-cdk-applications-examples"></a>

Considerate gli stack e le funzioni dichiarati con l'esempio seguente:

```
app = new HelloCdkStack(app, "HelloCdkStack",
   ...
)
class HelloCdkStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    ...
    new lambda.Function(this, 'MyFunction', {
        ...
    });

    new HelloCdkNestedStack(this, 'HelloNestedStack' ,{
        ...
    });
  }
}

class HelloCdkNestedStack extends cdk.NestedStack {
  constructor(scope: Construct, id: string, props?: cdk.NestedStackProps) {
    ...
    new lambda.Function(this, 'MyFunction', {
        ...
    });
    new lambda.Function(this, 'MyNestedFunction', {
        ...
    });
  }
}
```

I seguenti comandi richiamano localmente le funzioni Lambda definite nell'esempio presentato sopra:

```
# Invoke MyFunction from the HelloCdkStack
$ sam local invoke -t <./cdk.out/HelloCdkStack.template.json> <MyFunction>
```

```
# Invoke MyNestedFunction from the HelloCdkNestedStack
$ sam local invoke -t <./cdk.out/HelloCdkStack.template.json> <MyNestedFunction>
```

```
# Invoke MyFunction from the HelloCdkNestedStack
$ sam local invoke -t <./cdk.out/HelloCdkStack.template.json> <HelloNestedStack/MyFunction>
```

# Creazione di applicazioni AWS CDK con SAM AWS
<a name="testing-locally-build-with-sam-cli"></a>

La CLI AWS SAM fornisce supporto per la creazione di funzioni e livelli Lambda definiti nell'applicazione CDK con. AWS ` [sam build](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-build.html) `

Per le funzioni Lambda che utilizzano elementi zip, esegui `cdk synth` prima di eseguire i comandi. `sam local` `sam build`non è obbligatorio.

Se l'applicazione AWS CDK utilizza funzioni con il tipo di immagine, eseguila `cdk synth` ed eseguila `sam build` prima di eseguire `sam local` i comandi. Durante l'esecuzione`sam build`, AWS SAM non crea funzioni o layer Lambda che utilizzano costrutti specifici del runtime, ad esempio. ` [NodejsFunction](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda_nodejs.NodejsFunction.html) ` `sam build`[non supporta risorse raggruppate.](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.BundlingOptions.html)

## Esempio
<a name="testing-locally-build-with-sam-cli-examples"></a>

L'esecuzione del comando seguente dalla directory principale del progetto AWS CDK crea l'applicazione.

```
$ sam build -t <./cdk.out/CdkSamExampleStack.template.json>
```