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à.
# Lavora con la AWS libreria CDK
Importa e usa la libreria AWS Cloud Development Kit (AWS CDK) per definire la tua infrastruttura AWS Cloud con un [linguaggio di programmazione supportato](languages.md).
## Importa la libreria AWS CDK
La [libreria AWS CDK](libraries.md) viene spesso denominata con il nome TypeScript del pacchetto. `aws-cdk-lib` Il nome effettivo del pacchetto varia in base alla lingua. Di seguito è riportato un esempio di come installare e importare la libreria CDK:
**Example**
| | |
| --- |--- |
| **Installa** | `npm install aws-cdk-lib` |
| **Importa** | `import * as cdk from 'aws-cdk-lib';` |
| | |
| --- |--- |
| **Installa** | `npm install aws-cdk-lib` |
| **Importa** | `const cdk = require('aws-cdk-lib');` |
| | |
| --- |--- |
| **Installa** | `python -m pip install aws-cdk-lib` |
| **Importa** | `import aws_cdk as cdk` |
| | |
| --- |--- |
| **In`pom.xml`, aggiungi** | `Group software.amazon.awscdk; artifact aws-cdk-lib` |
| **Importa** | `import software.amazon.awscdk.App;` |
| | |
| --- |--- |
| **Installa** | `dotnet add package Amazon.CDK.Lib` |
| **Importa** | `using Amazon.CDK;` |
| | |
| --- |--- |
| **Installa** | `go get github.com/aws/aws-cdk-go/awscdk/v2` |
| **Importa** |
import ( "github.com/aws/aws-cdk-go/awscdk/v2" )
|
La classe `construct` base e il codice di supporto si trovano nella `constructs` libreria. I costrutti sperimentali, in cui l'API è ancora in fase di perfezionamento, vengono distribuiti come moduli separati.
## Utilizzo del CDK API Reference AWS
Utilizzate il [riferimento all'API AWS CDK](libraries.md#libraries-reference) mentre sviluppate con CDK. AWS
Il materiale di riferimento di ogni modulo è suddiviso nelle seguenti sezioni.
+ *Panoramica*: materiale introduttivo necessario conoscere per utilizzare il servizio del AWS CDK, inclusi concetti ed esempi.
+ *Costrutti*: classi di libreria che rappresentano una o più risorse concrete. AWS Queste sono le risorse o i modelli «curati» (L2) (risorse L3) che forniscono un'interfaccia di alto livello con impostazioni predefinite valide.
+ *Classi: classi* non costruite che forniscono funzionalità utilizzate dai costrutti del modulo.
+ *Strutture*: strutture di dati (pacchetti di attributi) che definiscono la struttura di valori compositi come proprietà (l'`props`argomento dei costrutti) e opzioni.
+ *Interfacce*: le interfacce, i cui nomi iniziano tutti con «I», definiscono la funzionalità minima assoluta per il costrutto o altra classe corrispondente. Il CDK utilizza interfacce di costruzione per rappresentare AWS risorse definite all'esterno dell'app AWS CDK e referenziate da metodi come. `Bucket.fromBucketArn()`
+ *Enumerazioni*: raccolte di valori denominati da utilizzare per specificare determinati parametri di costruzione. L'utilizzo di un valore enumerato consente al CDK di verificare la validità di questi valori durante la sintesi.
+ *CloudFormation Risorse*: questi costrutti L1, i cui nomi iniziano con «Cfn», rappresentano esattamente le risorse definite nelle specifiche. CloudFormation Vengono generati automaticamente in base a tale specifica con ogni versione CDK. Ogni costrutto L2 o L3 incapsula una o più risorse. CloudFormation
+ *CloudFormation Tipi di proprietà*: la raccolta di valori denominati che definiscono le proprietà di ogni risorsa. CloudFormation
## Interfacce confrontate con le classi di costruzione
Il AWS CDK utilizza le interfacce in un modo specifico che potrebbe non essere ovvio anche se si ha familiarità con le interfacce come concetto di programmazione.
Il AWS CDK supporta l'utilizzo di risorse definite all'esterno delle applicazioni CDK utilizzando metodi come. `Bucket.fromBucketArn()` Le risorse esterne non possono essere modificate e potrebbero non avere tutte le funzionalità disponibili con le risorse definite nell'app CDK utilizzando, ad esempio, la classe. `Bucket` *Le interfacce, quindi, rappresentano la funzionalità minima disponibile nel CDK per un determinato tipo di AWS risorsa, incluse le risorse esterne.*
Quando si istanziano le risorse nell'app CDK, quindi, è necessario utilizzare sempre classi concrete come. `Bucket` Quando specificate il tipo di argomento che accettate in uno dei vostri costrutti, usate il tipo di interfaccia, ad esempio `IBucket` se siete pronti a gestire risorse esterne (ovvero, non avrete bisogno di cambiarle). Se avete bisogno di un costrutto definito da CDK, specificate il tipo più generale che potete usare.
Alcune interfacce sono versioni minime di pacchetti di proprietà o di opzioni associati a classi specifiche, anziché costrutti. Tali interfacce possono essere utili quando si crea una sottoclasse per accettare argomenti da passare alla classe principale. Se avete bisogno di una o più proprietà aggiuntive, vi consigliamo di implementarle o derivarle da questa interfaccia o da un tipo più specifico.
**Nota**
Alcuni linguaggi di programmazione supportati dal AWS CDK non dispongono di una funzionalità di interfaccia. In questi linguaggi, le interfacce sono solo classi ordinarie. È possibile identificarli con i loro nomi, che seguono lo schema di una «I» iniziale seguita dal nome di qualche altro costrutto (ad esempio`IBucket`). Valgono le stesse regole.
## Gestire le dipendenze
Le dipendenze dell'app o della libreria AWS CDK vengono gestite utilizzando strumenti di gestione dei pacchetti. Questi strumenti sono comunemente usati con i linguaggi di programmazione.
In genere, il AWS CDK supporta lo strumento di gestione dei pacchetti standard o ufficiale del linguaggio, se disponibile. In caso contrario, il AWS CDK supporterà la lingua più diffusa o ampiamente supportata. Potresti anche essere in grado di utilizzare altri strumenti, specialmente se funzionano con gli strumenti supportati. Tuttavia, il supporto ufficiale per altri strumenti è limitato.
Il AWS CDK supporta i seguenti gestori di pacchetti:
| Lingua | Strumento di gestione dei pacchetti supportato |
| --- | --- |
| TypeScript/JavaScript | NPM (Node Package Manager) o Yarn |
| Python | PIP (Package Installer per Python) |
| Java | Maven |
| C\$1 | NuGet |
| Go | Moduli Go |
Quando si crea un nuovo progetto utilizzando il comando AWS CDK `cdk init` CLI, le dipendenze per le librerie di base CDK e i costrutti stabili vengono specificate automaticamente.
Per ulteriori informazioni sulla gestione delle dipendenze per i linguaggi di programmazione supportati, consultate quanto segue:
+ [Gestione delle dipendenze](work-with-cdk-typescript.md#work-with-cdk-typescript-dependencies) in. TypeScript
+ [Gestione delle dipendenze](work-with-cdk-javascript.md#work-with-cdk-javascript-dependencies) in. JavaScript
+ [Gestione delle dipendenze in Python](work-with-cdk-python.md#work-with-cdk-python-dependencies).
+ [Gestione delle dipendenze in Java.](work-with-cdk-java.md#work-with-cdk-java-dependencies)
+ [Gestione delle dipendenze in](work-with-cdk-csharp.md#work-with-cdk-csharp-dependencies) C\$1.
+ [Gestione delle dipendenze in](work-with-cdk-go.md#work-with-cdk-go-dependencies) Go.
## Confronto tra AWS CDK e altre TypeScript lingue
TypeScript è stato il primo linguaggio supportato per lo sviluppo di applicazioni AWS CDK. Pertanto, è scritta una notevole quantità di codice CDK di esempio. TypeScript Se state sviluppando in un'altra lingua, potrebbe essere utile confrontare il modo in cui viene implementato il codice AWS CDK TypeScript rispetto al linguaggio prescelto. Questo può aiutarvi a utilizzare gli esempi in tutta la documentazione.
## Importazione di un modulo
**Example**
TypeScript supporta l'importazione di un intero namespace o di singoli oggetti da un namespace. Ogni spazio dei nomi include costrutti e altre classi da utilizzare con un determinato servizio. AWS
```
// Import main CDK library as cdk
import * as cdk from 'aws-cdk-lib'; // ES6 import preferred in TS
const cdk = require('aws-cdk-lib'); // Node.js require() preferred in JS
// Import specific core CDK classes
import { Stack, App } from 'aws-cdk-lib';
const { Stack, App } = require('aws-cdk-lib');
// Import AWS S3 namespace as s3 into current namespace
import { aws_s3 as s3 } from 'aws-cdk-lib'; // TypeScript
const s3 = require('aws-cdk-lib/aws-s3'); // JavaScript
// Having imported cdk already as above, this is also valid
const s3 = cdk.aws_s3;
// Now use s3 to access the S3 types
const bucket = s3.Bucket(...);
// Selective import of s3.Bucket
import { Bucket } from 'aws-cdk-lib/aws-s3'; // TypeScript
const { Bucket } = require('aws-cdk-lib/aws-s3'); // JavaScript
// Now use Bucket to instantiate an S3 bucket
const bucket = Bucket(...);
```
Ad esempio TypeScript, Python supporta le importazioni di moduli con namespace e le importazioni selettive. **I namespace in Python assomigliano a aws\$1cdk.** *xxx*, dove *xxx* rappresenta il nome AWS di un servizio, ad esempio **s3** per Amazon S3. (Amazon S3 viene utilizzato in questi esempi).
```
# Import main CDK library as cdk
import aws_cdk as cdk
# Selective import of specific core classes
from aws_cdk import Stack, App
# Import entire module as s3 into current namespace
import aws_cdk.aws_s3 as s3
# s3 can now be used to access classes it contains
bucket = s3.Bucket(...)
# Selective import of s3.Bucket into current namespace
from aws_cdk.s3 import Bucket
# Bucket can now be used to instantiate a bucket
bucket = Bucket(...)
```
Le importazioni di Java funzionano in modo diverso da quelle TypeScript di Java. Ogni istruzione di importazione importa un singolo nome di classe da un determinato pacchetto o tutte le classi definite in quel pacchetto (utilizzando`\*`). È possibile accedere alle classi utilizzando il nome della classe stessa, se è stata importata, o il nome della classe *qualificata* che include il relativo pacchetto.
Le librerie hanno lo `software.amazon.awscdk.services.xxx` stesso nome della AWS Construct Library (la libreria principale è`software.amazon.awscdk`). L'ID del gruppo Maven per i pacchetti AWS CDK è. `software.amazon.awscdk`
```
// Make certain core classes available
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.App;
// Make all Amazon S3 construct library classes available
import software.amazon.awscdk.services.s3.*;
// Make only Bucket and EventType classes available
import software.amazon.awscdk.services.s3.Bucket;
import software.amazon.awscdk.services.s3.EventType;
// An imported class may now be accessed using the simple class name (assuming that name
// does not conflict with another class)
Bucket bucket = Bucket.Builder.create(...).build();
// We can always use the qualified name of a class (including its package) even without an
// import directive
software.amazon.awscdk.services.s3.Bucket bucket =
software.amazon.awscdk.services.s3.Bucket.Builder.create(...)
.build();
// Java 10 or later can use var keyword to avoid typing the type twice
var bucket =
software.amazon.awscdk.services.s3.Bucket.Builder.create(...)
.build();
```
In C\$1, si importano i tipi con la direttiva. `using` Esistono due stili. Uno ti dà accesso a tutti i tipi nello spazio dei nomi specificato usando i loro nomi semplici. Con l'altro, puoi fare riferimento allo spazio dei nomi stesso usando un alias.
I pacchetti hanno lo stesso nome dei pacchetti `Amazon.CDK.AWS.xxx` AWS Construct Library. (Il modulo principale è`Amazon.CDK`.)
```
// Make CDK base classes available under cdk
using cdk = Amazon.CDK;
// Make all Amazon S3 construct library classes available
using Amazon.CDK.AWS.S3;
// Now we can access any S3 type using its name
var bucket = new Bucket(...);
// Import the S3 namespace under an alias
using s3 = Amazon.CDK.AWS.S3;
// Now we can access an S3 type through the namespace alias
var bucket = new s3.Bucket(...);
// We can always use the qualified name of a type (including its namespace) even without a
// using directive
var bucket = new Amazon.CDK.AWS.S3.Bucket(...);
```
Ogni modulo AWS Construct Library viene fornito come pacchetto Go.
```
import (
"github.com/aws/aws-cdk-go/awscdk/v2" // CDK core package
"github.com/aws/aws-cdk-go/awscdk/v2/awss3" // AWS S3 construct library module
)
// now instantiate a bucket
bucket := awss3.NewBucket(...)
// use aliases for brevity/clarity
import (
cdk "github.com/aws/aws-cdk-go/awscdk/v2" // CDK core package
s3 "github.com/aws/aws-cdk-go/awscdk/v2/awss3" // AWS S3 construct library module
)
bucket := s3.NewBucket(...)
```
## Istanziazione di un costrutto
AWS Le classi di costruzione CDK hanno lo stesso nome in tutte le lingue supportate. La maggior parte dei linguaggi usa la `new` parola chiave per istanziare una classe (Python e Go no). Inoltre, nella maggior parte delle lingue, la parola chiave `this` si riferisce all'istanza corrente. (Python usa per `self` convenzione.) Dovresti passare un riferimento all'istanza corrente come `scope` parametro per ogni costrutto che crei.
Il terzo argomento di un costrutto AWS CDK è `props` un oggetto contenente gli attributi necessari per creare il costrutto. Questo argomento può essere facoltativo, ma quando è richiesto, le lingue supportate lo gestiscono in modo idiomatico. I nomi degli attributi vengono inoltre adattati ai modelli di denominazione standard del linguaggio.
**Example**
```
// Instantiate default Bucket
const bucket = new s3.Bucket(this, 'amzn-s3-demo-bucket');
// Instantiate Bucket with bucketName and versioned properties
const bucket = new s3.Bucket(this, 'amzn-s3-demo-bucket', {
bucketName: 'amzn-s3-demo-bucket',
versioned: true,
});
// Instantiate Bucket with websiteRedirect, which has its own sub-properties
const bucket = new s3.Bucket(this, 'amzn-s3-demo-bucket', {
websiteRedirect: {host: 'aws.amazon.com'}});
```
Python non usa una `new` parola chiave per istanziare una classe. L'argomento delle proprietà è rappresentato utilizzando argomenti di parole chiave e gli argomenti sono denominati utilizzando. `snake_case`
Se un valore props è di per sé un insieme di attributi, è rappresentato da una classe che prende il nome dalla proprietà, che accetta argomenti di parole chiave per le sottoproprietà.
In Python, l'istanza corrente viene passata ai metodi come primo argomento, denominato `self` per convenzione.
```
# Instantiate default Bucket
bucket = s3.Bucket(self, "amzn-s3-demo-bucket")
# Instantiate Bucket with bucket_name and versioned properties
bucket = s3.Bucket(self, "amzn-s3-demo-bucket", bucket_name="amzn-s3-demo-bucket", versioned=true)
# Instantiate Bucket with website_redirect, which has its own sub-properties
bucket = s3.Bucket(self, "amzn-s3-demo-bucket", website_redirect=s3.WebsiteRedirect(
host_name="aws.amazon.com"))
```
In Java, l'argomento props è rappresentato da una classe denominata `XxxxProps` (ad esempio, `BucketProps` per gli oggetti di scena del `Bucket` costrutto). L'argomento props viene creato utilizzando un pattern builder.
Ogni `XxxxProps` classe ha un builder. C'è anche un comodo generatore per ogni costrutto che costruisce gli oggetti di scena e il costrutto in un unico passaggio, come mostrato nell'esempio seguente.
Gli oggetti di scena hanno lo stesso nome di, using. TypeScript `camelCase`
```
// Instantiate default Bucket
Bucket bucket = Bucket(self, "amzn-s3-demo-bucket");
// Instantiate Bucket with bucketName and versioned properties
Bucket bucket = Bucket.Builder.create(self, "amzn-s3-demo-bucket")
.bucketName("amzn-s3-demo-bucket").versioned(true)
.build();
# Instantiate Bucket with websiteRedirect, which has its own sub-properties
Bucket bucket = Bucket.Builder.create(self, "amzn-s3-demo-bucket")
.websiteRedirect(new websiteRedirect.Builder()
.hostName("aws.amazon.com").build())
.build();
```
In C\$1, gli oggetti di scena vengono specificati utilizzando un inizializzatore di oggetti in una classe denominata `XxxxProps` (ad esempio, `BucketProps` per gli oggetti di scena del `Bucket` costrutto).
Gli oggetti di scena sono denominati in modo simile a, tranne using. TypeScript `PascalCase`
È comodo usare la `var` parola chiave quando si crea un'istanza di un costrutto, quindi non è necessario digitare il nome della classe due volte. Tuttavia, la guida allo stile del codice locale può variare.
```
// Instantiate default Bucket
var bucket = Bucket(self, "amzn-s3-demo-bucket");
// Instantiate Bucket with BucketName and Versioned properties
var bucket = Bucket(self, "amzn-s3-demo-bucket", new BucketProps {
BucketName = "amzn-s3-demo-bucket",
Versioned = true});
// Instantiate Bucket with WebsiteRedirect, which has its own sub-properties
var bucket = Bucket(self, "amzn-s3-demo-bucket", new BucketProps {
WebsiteRedirect = new WebsiteRedirect {
HostName = "aws.amazon.com"
}});
```
Per creare un costrutto in Go, chiama la funzione `NewXxxxxx` where `Xxxxxxx` è il nome del costrutto. Le proprietà dei costrutti sono definite come una struttura.
In Go, tutti i parametri di costruzione sono puntatori, inclusi valori come numeri, valori booleani e stringhe. Usa le comode funzioni come `jsii.String` per creare questi puntatori.
```
// Instantiate default Bucket
bucket := awss3.NewBucket(stack, jsii.String("amzn-s3-demo-bucket"), nil)
// Instantiate Bucket with BucketName and Versioned properties
bucket1 := awss3.NewBucket(stack, jsii.String("amzn-s3-demo-bucket"), &awss3.BucketProps{
BucketName: jsii.String("amzn-s3-demo-bucket"),
Versioned: jsii.Bool(true),
})
// Instantiate Bucket with WebsiteRedirect, which has its own sub-properties
bucket2 := awss3.NewBucket(stack, jsii.String("amzn-s3-demo-bucket"), &awss3.BucketProps{
WebsiteRedirect: &awss3.RedirectTarget{
HostName: jsii.String("aws.amazon.com"),
}})
```
## Accesso ai membri
È comune fare riferimento agli attributi o alle proprietà dei costrutti e di altre classi AWS CDK e utilizzare questi valori come, ad esempio, input per creare altri costrutti. Le differenze di denominazione descritte in precedenza per i metodi si applicano anche qui. Inoltre, in Java, non è possibile accedere direttamente ai membri. Viene invece fornito un metodo getter.
**Example**
I nomi sono`camelCase`.
```
bucket.bucketArn
```
I nomi sono`snake_case`.
```
bucket.bucket_arn
```
Per ogni proprietà viene fornito un metodo getter; questi nomi sono`camelCase`.
```
bucket.getBucketArn()
```
I nomi sono`PascalCase`.
```
bucket.BucketArn
```
I nomi sono`PascalCase`.
```
bucket.BucketArn
```
## Costanti Enum
Le costanti Enum rientrano nell'ambito di una classe e hanno nomi in maiuscolo con caratteri di sottolineatura in tutte le lingue (a volte denominate). `SCREAMING_SNAKE_CASE` Poiché i nomi delle classi utilizzano lo stesso maiuscolo e minuscolo in tutte le lingue supportate tranne Go, anche i nomi enum qualificati sono gli stessi in queste lingue.
```
s3.BucketEncryption.KMS_MANAGED
```
In Go, le costanti enum sono attributi dello spazio dei nomi del modulo e sono scritte come segue.
```
awss3.BucketEncryption_KMS_MANAGED
```
## Interfacce a oggetti
Il AWS CDK utilizza interfacce a TypeScript oggetti per indicare che una classe implementa un insieme previsto di metodi e proprietà. È possibile riconoscere un'interfaccia a oggetti perché il suo nome inizia con. `I` Una classe concreta indica le interfacce che implementa utilizzando la `implements` parola chiave.
**Example**
JavaScript non ha una funzionalità di interfaccia. È possibile ignorare la `implements` parola chiave e i nomi delle classi che la seguono.
```
import { IAspect, IConstruct } from 'aws-cdk-lib';
class MyAspect implements IAspect {
public visit(node: IConstruct) {
console.log('Visited', node.node.path);
}
}
```
Python non ha una funzionalità di interfaccia. Tuttavia, per il AWS CDK puoi indicare l'implementazione dell'interfaccia decorando la tua classe con. `@jsii.implements(interface)`
```
from aws_cdk import IAspect, IConstruct
import jsii
@jsii.implements(IAspect)
class MyAspect():
def visit(self, node: IConstruct) -> None:
print("Visited", node.node.path)
```
```
import software.amazon.awscdk.IAspect;
import software.amazon.awscdk.IConstruct;
public class MyAspect implements IAspect {
public void visit(IConstruct node) {
System.out.format("Visited %s", node.getNode().getPath());
}
}
```
```
using Amazon.CDK;
public class MyAspect : IAspect
{
public void Visit(IConstruct node)
{
System.Console.WriteLine($"Visited ${node.Node.Path}");
}
}
```
Le strutture Go non hanno bisogno di dichiarare esplicitamente quali interfacce implementano. Il compilatore Go determina l'implementazione in base ai metodi e alle proprietà disponibili nella struttura. Ad esempio, nel codice seguente, `MyAspect` implementa l'`IAspect`interfaccia perché fornisce un `Visit` metodo che accetta un costrutto.
```
type MyAspect struct {
}
func (a MyAspect) Visit(node constructs.IConstruct) {
fmt.Println("Visited", *node.Node().Path())
}
```
# Lavorare con il AWS CDK in TypeScript
TypeScript è un linguaggio client completamente supportato per il AWS Cloud Development Kit (AWS CDK) ed è considerato stabile. L'utilizzo del AWS CDK TypeScript utilizza strumenti familiari, tra cui il TypeScript compilatore di Microsoft (`tsc`), [Node.js](https://nodejs.org/) e il Node Package Manager (`npm`). Puoi anche usare [Yarn](https://yarnpkg.com/) se preferisci, sebbene gli esempi in questa guida utilizzino NPM. [I moduli che compongono la AWS Construct Library sono distribuiti tramite il repository NPM, npmjs.org.](https://www.npmjs.com/)
Puoi usare qualsiasi editor o IDE. Molti sviluppatori AWS CDK utilizzano [Visual Studio Code](https://code.visualstudio.com/) (o il suo equivalente open source [VSCodium](https://vscodium.com/)), che offre un supporto eccellente per. TypeScript
## Inizia con TypeScript
Per utilizzare il AWS CDK, è necessario disporre di un AWS account e delle credenziali e aver installato Node.js e AWS CDK Toolkit. Vedi [Guida introduttiva](getting-started.md) al CDK. AWS
È necessario anche TypeScript se stesso (versione 3.8 o successiva). Se non lo possiedi già, puoi installarlo utilizzando`npm`.
```
$ npm install -g typescript
```
**Nota**
Se ricevi un errore di autorizzazione e disponi dell'accesso come amministratore sul tuo sistema, prova`sudo npm install -g typescript`.
TypeScript Tieniti aggiornato con un appuntamento abituale`npm update -g typescript`.
**Nota**
Lingua obsoleta di terze parti: la versione linguistica è supportata solo fino alla fine del ciclo di vita (EOL (End Of Life) condivisa dal fornitore o dalla community ed è soggetta a modifiche con preavviso.
## Creare un progetto
È possibile creare un nuovo progetto AWS CDK invocandolo in una directory vuota. `cdk init` Utilizzate l'`--language`opzione e specificate: `typescript`
```
$ mkdir my-project
$ cd my-project
$ cdk init app --language typescript
```
La creazione di un progetto installa anche il [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib-readme.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib-readme.html)modulo e le sue dipendenze.
`cdk init`utilizza il nome della cartella del progetto per denominare vari elementi del progetto, tra cui classi, sottocartelle e file. I trattini nel nome della cartella vengono convertiti in caratteri di sottolineatura. Tuttavia, il nome dovrebbe altrimenti assumere la forma di un TypeScript identificatore; ad esempio, non dovrebbe iniziare con un numero o contenere spazi.
## Utilizzo di locali e `tsc` `cdk`
Per la maggior parte, questa guida presuppone l'installazione TypeScript e l'installazione di CDK Toolkit a livello globale (`npm install -g typescript aws-cdk`), e gli esempi di comandi forniti (ad esempio`cdk synth`) seguano questo presupposto. Questo approccio semplifica l'aggiornamento di entrambi i componenti e, poiché entrambi adottano un approccio rigoroso alla compatibilità con le versioni precedenti, in genere il rischio di utilizzare sempre le versioni più recenti è minimo.
Alcuni team preferiscono specificare tutte le dipendenze all'interno di ogni progetto, inclusi strumenti come il TypeScript compilatore e il CDK Toolkit. Questa pratica consente di associare questi componenti a versioni specifiche e di garantire che tutti gli sviluppatori del team (e l'ambiente CI/CD) utilizzino esattamente quelle versioni. Ciò elimina una possibile fonte di cambiamento, contribuendo a rendere le build e le implementazioni più coerenti e ripetibili.
Il CDK include le dipendenze per entrambi TypeScript e il CDK Toolkit nei modelli di TypeScript progetto`package.json`, quindi se si desidera utilizzare questo approccio, non è necessario apportare alcuna modifica al progetto. Tutto quello che dovete fare è usare comandi leggermente diversi per creare l'app e per emettere comandi. `cdk`
| Operazione | Usa strumenti globali | Usa strumenti locali |
| --- | --- | --- |
| **Inizializza il progetto** | `cdk init --language typescript` | `npx aws-cdk init --language typescript` |
| **Compila** | `tsc` | `npm run build` |
| **Esegui il comando CDK Toolkit** | `cdk …` | `npm run cdk …` o `npx aws-cdk …` |
`npx aws-cdk`esegue la versione di CDK Toolkit installata localmente nel progetto corrente, se ne esiste una, ricorrendo all'eventuale installazione globale. Se non esiste un'installazione globale, `npx` scarica una copia temporanea di CDK Toolkit e la esegue. È possibile specificare una versione arbitraria di CDK Toolkit utilizzando la sintassi: prints. `@` `npx aws-cdk@2.0 --version` `2.0.0`
**Suggerimento**
Imposta un alias in modo da poter utilizzare il `cdk` comando con un'installazione locale di CDK Toolkit.
```
$ alias cdk="npx aws-cdk"
```
```
doskey cdk=npx aws-cdk $*
```
## Gestione dei moduli Construct Library AWS
Utilizzate Node Package Manager (`npm`) per installare e aggiornare i moduli AWS Construct Library per l'uso da parte delle vostre app e degli altri pacchetti di cui avete bisogno. (Puoi usare `yarn` al posto di `npm` se preferisci.) `npm`installa inoltre automaticamente le dipendenze per quei moduli.
La maggior parte dei costrutti AWS CDK si trova nel pacchetto CDK principale, denominato`aws-cdk-lib`, che è una dipendenza predefinita nei nuovi progetti creati da. `cdk init` I moduli «sperimentali» di AWS Construct Library, in cui i costrutti di livello superiore sono ancora in fase di sviluppo, hanno lo stesso nome. `@aws-cdk/-alpha` *Il nome del servizio ha un prefisso aws-.* Se non sei sicuro del nome di un modulo, [cercalo su NPM](https://www.npmjs.com/search?q=%40aws-cdk).
**Nota**
Il [CDK API Reference](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-construct-library.html) mostra anche i nomi dei pacchetti.
Ad esempio, il comando seguente installa il modulo sperimentale per. AWS CodeStar
```
$ npm install @aws-cdk/aws-codestar-alpha
```
Il supporto di Construct Library di alcuni servizi è disponibile in più di un namespace. Ad esempio`aws-route53`, ci sono inoltre tre namespace Amazon Route 53 aggiuntivi,`aws-route53-targets`, `aws-route53-patterns` e. `aws-route53resolver`
Le dipendenze del tuo progetto vengono mantenute in. `package.json` Puoi modificare questo file per bloccare alcune o tutte le tue dipendenze su una versione specifica o per consentire loro di essere aggiornate a versioni più recenti in base a determinati criteri. Per aggiornare le dipendenze NPM del progetto all'ultima versione consentita in base alle regole specificate in: `package.json`
```
$ npm update
```
In TypeScript, importi i moduli nel tuo codice con lo stesso nome che usi per installarli usando NPM. Consigliamo le seguenti pratiche per importare classi AWS CDK e moduli AWS Construct Library nelle vostre applicazioni. Seguire queste linee guida contribuirà a rendere il codice coerente con altre applicazioni AWS CDK e più facile da comprendere.
+ Usa le `import` direttive ES6 -style, no. `require()`
+ In genere, importa singole classi da. `aws-cdk-lib`
```
import { App, Stack } from 'aws-cdk-lib';
```
+ Se hai bisogno di molte classi da`aws-cdk-lib`, puoi usare un alias dello spazio dei nomi di `cdk` invece di importare le singole classi. Evita di fare entrambe le cose.
```
import * as cdk from 'aws-cdk-lib';
```
+ In genere, importate i costrutti dei AWS servizi utilizzando alias di namespace brevi.
```
import { aws_s3 as s3 } from 'aws-cdk-lib';
```
## Gestione delle dipendenze in TypeScript
Nei progetti TypeScript CDK, le dipendenze sono specificate nel `package.json` file nella directory principale del progetto. I moduli AWS CDK principali si trovano in un unico `NPM` pacchetto chiamato. `aws-cdk-lib`
Quando installate un pacchetto utilizzando`npm install`, NPM registra il pacchetto al posto `package.json` vostro.
Se preferisci, puoi usare Yarn al posto di NPM. Tuttavia, il CDK non supporta la modalità di Yarn, che è la plug-and-play modalità predefinita in Yarn 2. Aggiungi quanto segue al `.yarnrc.yml` file del tuo progetto per disattivare questa funzionalità.
```
nodeLinker: node-modules
```
### Applicazioni CDK
Di seguito è riportato un `package.json` file di esempio generato dal `cdk init --language typescript` comando:
```
{
"name": "my-package",
"version": "0.1.0",
"bin": {
"my-package": "bin/my-package.js"
},
"scripts": {
"build": "tsc",
"watch": "tsc -w",
"test": "jest",
"cdk": "cdk"
},
"devDependencies": {
"@types/jest": "^26.0.10",
"@types/node": "10.17.27",
"jest": "^26.4.2",
"ts-jest": "^26.2.0",
"aws-cdk": "2.16.0",
"ts-node": "^9.0.0",
"typescript": "~3.9.7"
},
"dependencies": {
"aws-cdk-lib": "2.16.0",
"constructs": "^10.0.0",
"source-map-support": "^0.5.16"
}
}
```
Per le app CDK distribuibili, `aws-cdk-lib` deve essere specificato nella sezione di`dependencies`. `package.json` Potete utilizzare un identificatore del numero di versione con cursore (^) per indicare che accetterete versioni successive a quella specificata purché si trovino all'interno della stessa versione principale.
Per i costrutti sperimentali, specificate le versioni esatte per i moduli della libreria alpha construct, che potrebbero APIs cambiare. Non utilizzate ^ o \$1 poiché le versioni successive di questi moduli potrebbero apportare modifiche all'API che potrebbero danneggiare l'app.
Specificate le versioni delle librerie e degli strumenti necessari per testare l'app (ad esempio, il framework di `jest` test) nella `devDependencies` sezione di`package.json`. Facoltativamente, usa ^ per specificare che le versioni compatibili successive sono accettabili.
### Librerie di costruzioni di terze parti
Se state sviluppando una libreria di costrutti, specificate le sue dipendenze utilizzando una combinazione delle `devDependencies` sezioni `peerDependencies` e, come mostrato nel seguente file di esempio. `package.json`
```
{
"name": "my-package",
"version": "0.0.1",
"peerDependencies": {
"aws-cdk-lib": "^2.14.0",
"@aws-cdk/aws-appsync-alpha": "2.10.0-alpha",
"constructs": "^10.0.0"
},
"devDependencies": {
"aws-cdk-lib": "2.14.0",
"@aws-cdk/aws-appsync-alpha": "2.10.0-alpha",
"constructs": "10.0.0",
"jsii": "^1.50.0",
"aws-cdk": "^2.14.0"
}
}
```
In`peerDependencies`, usa un accento circonflesso (^) per specificare la versione più bassa con `aws-cdk-lib` cui funziona la tua libreria. Ciò massimizza la compatibilità della tua libreria con una gamma di versioni CDK. Specificate le versioni esatte per i moduli della libreria alpha construct, APIs che potrebbero cambiare. L'utilizzo `peerDependencies` assicura che vi sia una sola copia di tutte le librerie CDK nell'`node_modules`albero.
Nel`devDependencies`, specificate gli strumenti e le librerie necessari per il test, opzionalmente con ^ per indicare che le versioni compatibili successive sono accettabili. Specificate esattamente (senza ^ o \$1) le versioni più basse `aws-cdk-lib` e gli altri pacchetti CDK con cui pubblicizzate la compatibilità della vostra libreria. Questa pratica assicura che i test vengano eseguiti su tali versioni. In questo modo, se usi inavvertitamente una funzionalità presente solo nelle versioni più recenti, i tuoi test possono catturarla.
**avvertimento**
`peerDependencies`vengono installati automaticamente solo da NPM 7 e versioni successive. Se stai usando NPM 6 o versioni precedenti, o se stai usando Yarn, devi includere le dipendenze delle tue dipendenze in. `devDependencies` Altrimenti, non verranno installate e riceverai un avviso sulle dipendenze tra pari non risolte.
### Installazione e aggiornamento delle dipendenze
Esegui il comando seguente per installare le dipendenze del tuo progetto.
**Example**
```
# Install the latest version of everything that matches the ranges in 'package.json'
npm install
# Install the same exact dependency versions as recorded in 'package-lock.json'
npm ci
```
```
# Install the latest version of everything that matches the ranges in 'package.json'
$ yarn upgrade
# Install the same exact dependency versions as recorded in 'yarn.lock'
$ yarn install --frozen-lockfile
```
Per aggiornare i moduli installati, è possibile utilizzare `yarn upgrade` i comandi precedenti `npm install` e. Entrambi i comandi aggiornano i pacchetti `node_modules` alle versioni più recenti che soddisfano le regole in`package.json`. Tuttavia, non `package.json` si aggiornano da soli, cosa che potresti voler fare per impostare una nuova versione minima. Se ospiti il pacchetto su GitHub, puoi configurare [gli aggiornamenti della versione di Dependabot in modo che si aggiornino](https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/configuring-dependabot-version-updates) automaticamente. `package.json` In alternativa, utilizzare [npm-check-updates](https://www.npmjs.com/package/npm-check-updates).
**Importante**
In base alla progettazione, quando installi o aggiorni le dipendenze, NPM e Yarn scelgono la versione più recente di ogni pacchetto che soddisfi i requisiti specificati in. `package.json` C'è sempre il rischio che queste versioni possano essere danneggiate (accidentalmente o intenzionalmente). Esegui un test approfondito dopo aver aggiornato le dipendenze del progetto.
## AWS Idiomi CDK in TypeScript
### Oggetti di scena
**Tutte le classi di AWS Construct Library vengono istanziate utilizzando tre argomenti: l'*ambito* in cui viene definito il costrutto (il suo genitore nell'albero dei costrutti), un id e props.** Argument *props* è un insieme di coppie chiave/valore che il costrutto utilizza per configurare le risorse che crea. AWS Anche altre classi e metodi utilizzano il modello «bundle of attributes» per gli argomenti.
In TypeScript, la forma di `props` è definita utilizzando un'interfaccia che indica gli argomenti obbligatori e facoltativi e i loro tipi. Tale interfaccia è definita per ogni tipo di `props` argomento, in genere specifica per un singolo costrutto o metodo. Ad esempio, il [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.Bucket.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.Bucket.html)costrutto (nel `aws-cdk-lib/aws-s3` modulo) specifica un `props` argomento conforme all'interfaccia. [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html)
Se una proprietà è essa stessa un oggetto, ad esempio la [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html#websiteredirect](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html#websiteredirect)proprietà di`BucketProps`, quell'oggetto avrà una propria interfaccia alla quale la sua forma deve conformarsi, in questo caso. [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.RedirectTarget.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.RedirectTarget.html)
Se state sottoclassando una classe AWS Construct Library (o sovrascrivete un metodo che accetta un argomento simile a props), potete ereditarne una dall'interfaccia esistente per crearne una nuova che specifichi eventuali nuovi oggetti di scena richiesti dal codice. Quando chiamate la classe principale o il metodo base, in genere potete passare l'intero argomento props ricevuto, poiché tutti gli attributi forniti nell'oggetto ma non specificati nell'interfaccia verranno ignorati.
Le future versioni del AWS CDK potrebbero aggiungere casualmente una nuova proprietà con un nome usato per la propria proprietà. Il trasferimento del valore ricevuto nella catena di ereditarietà può quindi causare un comportamento imprevisto. È più sicuro passare una copia superficiale degli oggetti di scena ricevuti con la proprietà rimossa o impostata. `undefined` Per esempio:
```
super(scope, name, {...props, encryptionKeys: undefined});
```
In alternativa, dai un nome alle tue proprietà in modo che sia chiaro che appartengono al tuo costrutto. In questo modo, è improbabile che entrino in collisione con le proprietà nelle future versioni di AWS CDK. Se ce ne sono molte, usate un unico oggetto dal nome appropriato per contenerle.
### Valori mancanti
I valori mancanti in un oggetto (come gli oggetti di scena) hanno il valore in. `undefined` TypeScript La versione 3.7 del linguaggio ha introdotto operatori che semplificano l'utilizzo di questi valori, semplificando la specificazione dei valori predefiniti e il «cortocircuito» il concatenamento quando viene raggiunto un valore indefinito. Per ulteriori informazioni su queste funzionalità, consultate le [Note di rilascio della versione TypeScript 3.7](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html), in particolare le prime due funzionalità, Optional Chaining e Nullish Coalescing.
## Crea ed esegui app CDK
In genere, dovresti trovarti nella directory principale del progetto durante la creazione e l'esecuzione dell'applicazione.
Node.js non può essere eseguito TypeScript direttamente; l'applicazione viene invece convertita per JavaScript utilizzare il TypeScript compilatore,`tsc`. Il JavaScript codice risultante viene quindi eseguito.
Il AWS CDK lo fa automaticamente ogni volta che deve eseguire l'app. Tuttavia, può essere utile eseguire la compilazione manuale per verificare la presenza di errori ed eseguire test. Per compilare la tua TypeScript app manualmente, emetti. `npm run build` Potresti anche dover accedere `npm run watch` alla modalità watch, in cui il TypeScript compilatore ricostruisce automaticamente l'app ogni volta che salvi le modifiche a un file sorgente.
# Lavorare con il AWS CDK in JavaScript
JavaScript è un linguaggio client completamente supportato per il AWS CDK ed è considerato stabile. L'utilizzo del AWS Cloud Development Kit (AWS CDK) JavaScript utilizza strumenti familiari, tra cui [Node.js](https://nodejs.org/) e Node Package Manager (`npm`). Puoi anche usare [Yarn](https://yarnpkg.com/) se preferisci, sebbene gli esempi in questa guida utilizzino NPM. [I moduli che compongono la AWS Construct Library sono distribuiti tramite il repository NPM, npmjs.org.](https://www.npmjs.com/)
Puoi usare qualsiasi editor o IDE. Molti sviluppatori AWS CDK utilizzano [Visual Studio Code](https://code.visualstudio.com/) (o il suo equivalente open source [VSCodium](https://vscodium.com/)), che offre un buon supporto per. JavaScript
## Inizia con JavaScript
Per utilizzare il AWS CDK, è necessario disporre di un AWS account e delle credenziali e aver installato Node.js e AWS CDK Toolkit. Vedi [Guida introduttiva](getting-started.md) al CDK. AWS
JavaScript AWS Le applicazioni CDK non richiedono prerequisiti aggiuntivi oltre a questi.
**Nota**
Approvazione linguistica di terze parti: la versione linguistica è supportata solo fino alla fine del ciclo di vita (EOL (End Of Life) condivisa dal fornitore o dalla community ed è soggetta a modifiche con preavviso.
## Creare un progetto
È possibile creare un nuovo progetto AWS CDK invocandolo in una directory vuota. `cdk init` Utilizzate l'`--language`opzione e specificate: `javascript`
```
$ mkdir my-project
$ cd my-project
$ cdk init app --language javascript
```
La creazione di un progetto installa anche il [aws-cdk-lib](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib-readme.html)modulo e le sue dipendenze.
`cdk init`utilizza il nome della cartella del progetto per denominare vari elementi del progetto, tra cui classi, sottocartelle e file. I trattini nel nome della cartella vengono convertiti in caratteri di sottolineatura. Tuttavia, il nome dovrebbe altrimenti assumere la forma di un JavaScript identificatore; ad esempio, non dovrebbe iniziare con un numero o contenere spazi.
## Utilizzo della lingua locale `cdk`
Per la maggior parte, questa guida presuppone l'installazione di CDK Toolkit a livello globale (`npm install -g aws-cdk`) e gli esempi di comandi forniti (ad esempio`cdk synth`) seguano questo presupposto. Questo approccio semplifica l'aggiornamento di CDK Toolkit e, poiché il CDK adotta un approccio rigoroso alla compatibilità con le versioni precedenti, il rischio di utilizzare sempre la versione più recente è generalmente minimo.
Alcuni team preferiscono specificare tutte le dipendenze all'interno di ciascun progetto, inclusi strumenti come CDK Toolkit. Questa pratica consente di associare tali componenti a versioni specifiche e di garantire che tutti gli sviluppatori del team (e CI/CD dell'ambiente) utilizzino esattamente quelle versioni. Ciò elimina una possibile fonte di cambiamento, contribuendo a rendere le build e le implementazioni più coerenti e ripetibili.
Il CDK include una dipendenza per il CDK Toolkit nei modelli di JavaScript progetto`package.json`, quindi se si desidera utilizzare questo approccio, non è necessario apportare alcuna modifica al progetto. Tutto quello che dovete fare è usare comandi leggermente diversi per creare l'app e per emettere comandi. `cdk`
| Operation | Usa strumenti globali | Usa strumenti locali |
| --- | --- | --- |
| **Inizializza il progetto** | `cdk init --language javascript` | `npx aws-cdk init --language javascript` |
| **Esegui il comando CDK Toolkit** | `cdk …` | `npm run cdk …` o `npx aws-cdk …` |
`npx aws-cdk`esegue la versione di CDK Toolkit installata localmente nel progetto corrente, se ne esiste una, ricorrendo all'eventuale installazione globale. Se non esiste un'installazione globale, `npx` scarica una copia temporanea di CDK Toolkit e la esegue. È possibile specificare una versione arbitraria di CDK Toolkit utilizzando la sintassi: prints. `@` `npx aws-cdk@1.120 --version` `1.120.0`
**Suggerimento**
Imposta un alias in modo da poter utilizzare il `cdk` comando con un'installazione locale di CDK Toolkit.
```
$ alias cdk="npx aws-cdk"
```
```
doskey cdk=npx aws-cdk $*
```
## Gestione dei moduli Construct Library AWS
Utilizzate Node Package Manager (`npm`) per installare e aggiornare i moduli AWS Construct Library per l'uso da parte delle vostre app e degli altri pacchetti di cui avete bisogno. (Puoi usare `yarn` al posto di `npm` se preferisci.) `npm`installa inoltre automaticamente le dipendenze per quei moduli.
La maggior parte dei costrutti AWS CDK si trova nel pacchetto CDK principale, denominato`aws-cdk-lib`, che è una dipendenza predefinita nei nuovi progetti creati da. `cdk init` I moduli «sperimentali» di AWS Construct Library, in cui i costrutti di livello superiore sono ancora in fase di sviluppo, hanno lo stesso nome. `aws-cdk-lib/-alpha` *Il nome del servizio ha un prefisso aws-.* Se non sei sicuro del nome di un modulo, [cercalo su NPM](https://www.npmjs.com/search?q=%40aws-cdk).
**Nota**
Il [CDK API Reference](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-construct-library.html) mostra anche i nomi dei pacchetti.
Ad esempio, il comando seguente installa il modulo sperimentale per. AWS CodeStar
```
npm install @aws-cdk/aws-codestar-alpha
```
Il supporto di Construct Library di alcuni servizi è disponibile in più di un namespace. Ad esempio`aws-route53`, ci sono inoltre tre namespace Amazon Route 53 aggiuntivi,`aws-route53-targets`, `aws-route53-patterns` e. `aws-route53resolver`
Le dipendenze del tuo progetto vengono mantenute in. `package.json` Puoi modificare questo file per bloccare alcune o tutte le tue dipendenze su una versione specifica o per consentire loro di essere aggiornate a versioni più recenti in base a determinati criteri. Per aggiornare le dipendenze NPM del progetto all'ultima versione consentita in base alle regole specificate in: `package.json`
```
npm update
```
In JavaScript, importi i moduli nel tuo codice con lo stesso nome che usi per installarli usando NPM. Consigliamo le seguenti pratiche per importare classi AWS CDK e moduli AWS Construct Library nelle vostre applicazioni. Seguire queste linee guida contribuirà a rendere il codice coerente con altre applicazioni AWS CDK e più facile da comprendere.
+ Usa `require()` direttive, non ES6 in stile. `import` Le versioni precedenti di Node.js non supportano ES6 le importazioni, quindi l'utilizzo della sintassi precedente è più ampiamente compatibile. (Se vuoi davvero usare ES6 le importazioni, usa [esm](https://www.npmjs.com/package/esm) per assicurarti che il tuo progetto sia compatibile con tutte le versioni supportate di Node.js.)
+ In genere, importa singole classi da`aws-cdk-lib`.
```
const { App, Stack } = require('aws-cdk-lib');
```
+ Se hai bisogno di molte classi da`aws-cdk-lib`, puoi usare un alias dello spazio dei nomi di `cdk` invece di importare le singole classi. Evita di fare entrambe le cose.
```
const cdk = require('aws-cdk-lib');
```
+ In genere, importa le librerie AWS Construct utilizzando alias di namespace brevi.
```
const { s3 } = require('aws-cdk-lib/aws-s3');
```
## Gestione delle dipendenze in JavaScript
Nei progetti JavaScript CDK, le dipendenze sono specificate nel `package.json` file nella directory principale del progetto. I moduli AWS CDK principali si trovano in un unico `NPM` pacchetto chiamato. `aws-cdk-lib`
Quando installate un pacchetto utilizzando`npm install`, NPM registra il pacchetto al posto `package.json` vostro.
Se preferisci, puoi usare Yarn al posto di NPM. Tuttavia, il CDK non supporta la modalità di Yarn, che è la plug-and-play modalità predefinita in Yarn 2. Aggiungi quanto segue al `.yarnrc.yml` file del tuo progetto per disattivare questa funzionalità.
```
nodeLinker: node-modules
```
### Applicazioni CDK
Di seguito è riportato un `package.json` file di esempio generato dal `cdk init --language typescript` comando. Il file generato per JavaScript è simile, solo senza le voci TypeScript relative.
```
{
"name": "my-package",
"version": "0.1.0",
"bin": {
"my-package": "bin/my-package.js"
},
"scripts": {
"build": "tsc",
"watch": "tsc -w",
"test": "jest",
"cdk": "cdk"
},
"devDependencies": {
"@types/jest": "^26.0.10",
"@types/node": "10.17.27",
"jest": "^26.4.2",
"ts-jest": "^26.2.0",
"aws-cdk": "2.16.0",
"ts-node": "^9.0.0",
"typescript": "~3.9.7"
},
"dependencies": {
"aws-cdk-lib": "2.16.0",
"constructs": "^10.0.0",
"source-map-support": "^0.5.16"
}
}
```
Per le app CDK distribuibili, `aws-cdk-lib` deve essere specificato nella sezione di. `dependencies` `package.json` Potete utilizzare un identificatore del numero di versione con cursore (^) per indicare che accetterete versioni successive a quella specificata purché si trovino all'interno della stessa versione principale.
Per i costrutti sperimentali, specificate le versioni esatte per i moduli della libreria alpha construct, che potrebbero APIs cambiare. Non utilizzate ^ o \$1 poiché le versioni successive di questi moduli potrebbero apportare modifiche all'API che potrebbero danneggiare l'app.
Specificate le versioni delle librerie e degli strumenti necessari per testare l'app (ad esempio, il framework di `jest` test) nella `devDependencies` sezione di`package.json`. Facoltativamente, usa ^ per specificare che le versioni compatibili successive sono accettabili.
### Librerie di costruzioni di terze parti
Se state sviluppando una libreria di costrutti, specificate le sue dipendenze utilizzando una combinazione delle `devDependencies` sezioni `peerDependencies` e, come mostrato nel seguente file di esempio. `package.json`
```
{
"name": "my-package",
"version": "0.0.1",
"peerDependencies": {
"aws-cdk-lib": "^2.14.0",
"@aws-cdk/aws-appsync-alpha": "2.10.0-alpha",
"constructs": "^10.0.0"
},
"devDependencies": {
"aws-cdk-lib": "2.14.0",
"@aws-cdk/aws-appsync-alpha": "2.10.0-alpha",
"constructs": "10.0.0",
"jsii": "^1.50.0",
"aws-cdk": "^2.14.0"
}
}
```
In`peerDependencies`, usa un accento circonflesso (^) per specificare la versione più bassa con `aws-cdk-lib` cui funziona la tua libreria. Ciò massimizza la compatibilità della tua libreria con una gamma di versioni CDK. Specificate le versioni esatte per i moduli della libreria alpha construct, APIs che potrebbero cambiare. L'utilizzo `peerDependencies` assicura che ci sia una sola copia di tutte le librerie CDK nell'`node_modules`albero.
Nel`devDependencies`, specificate gli strumenti e le librerie necessari per il test, opzionalmente con ^ per indicare che le versioni compatibili successive sono accettabili. Specificate esattamente (senza ^ o \$1) le versioni più basse `aws-cdk-lib` e gli altri pacchetti CDK con cui pubblicizzate la compatibilità della vostra libreria. Questa pratica assicura che i test vengano eseguiti su tali versioni. In questo modo, se usi inavvertitamente una funzionalità presente solo nelle versioni più recenti, i tuoi test possono catturarla.
**avvertimento**
`peerDependencies`vengono installati automaticamente solo da NPM 7 e versioni successive. Se stai usando NPM 6 o versioni precedenti, o se stai usando Yarn, devi includere le dipendenze delle tue dipendenze in. `devDependencies` Altrimenti, non verranno installate e riceverai un avviso sulle dipendenze tra pari non risolte.
### Installazione e aggiornamento delle dipendenze
Esegui il comando seguente per installare le dipendenze del tuo progetto.
**Example**
```
# Install the latest version of everything that matches the ranges in 'package.json'
npm install
# Install the same exact dependency versions as recorded in 'package-lock.json'
npm ci
```
```
# Install the latest version of everything that matches the ranges in 'package.json'
yarn upgrade
# Install the same exact dependency versions as recorded in 'yarn.lock'
yarn install --frozen-lockfile
```
Per aggiornare i moduli installati, è possibile utilizzare `yarn upgrade` i comandi precedenti `npm install` e. Entrambi i comandi aggiornano i pacchetti `node_modules` alle versioni più recenti che soddisfano le regole in`package.json`. Tuttavia, non `package.json` si aggiornano da soli, cosa che potresti voler fare per impostare una nuova versione minima. Se ospiti il pacchetto su GitHub, puoi configurare [gli aggiornamenti della versione di Dependabot in modo che si aggiornino](https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/configuring-dependabot-version-updates) automaticamente. `package.json` In alternativa, utilizzare [npm-check-updates](https://www.npmjs.com/package/npm-check-updates).
**Importante**
In base alla progettazione, quando installi o aggiorni le dipendenze, NPM e Yarn scelgono la versione più recente di ogni pacchetto che soddisfi i requisiti specificati in. `package.json` C'è sempre il rischio che queste versioni possano essere danneggiate (accidentalmente o intenzionalmente). Effettua un test approfondito dopo aver aggiornato le dipendenze del progetto.
## AWS Idiomi CDK in JavaScript
### Props
Tutte le classi di AWS Construct Library vengono istanziate utilizzando tre argomenti: l'*ambito* in cui viene definito il costrutto (l'elemento principale nell'albero di costruzione), un *id* e *props*, un insieme di key/value coppie che il costrutto utilizza per configurare le risorse che crea. AWS Anche altre classi e metodi utilizzano il modello «bundle of attributes» per gli argomenti.
L'uso di un IDE o di un editor con un buon JavaScript completamento automatico aiuterà a evitare errori di ortografia dei nomi delle proprietà. Se un costrutto prevede una `encryptionKeys` proprietà e la scrivete`encryptionkeys`, quando create un'istanza del costrutto non avete passato il valore desiderato. Ciò può causare un errore al momento della sintesi se la proprietà è obbligatoria o causare l'ignoramento silenzioso della proprietà se è facoltativa. In quest'ultimo caso, potresti ottenere un comportamento predefinito che intendevi sostituire. Fate particolare attenzione a questo punto.
Quando sottoclassi una classe AWS Construct Library (o si sovrascrive un metodo che accetta un argomento simile a props), potresti voler accettare proprietà aggiuntive per uso personale. Questi valori verranno ignorati dalla classe principale o dal metodo sovrascritto, perché non sono mai accessibili in quel codice, quindi in genere potete trasmettere tutti gli oggetti di scena che avete ricevuto.
Le future versioni del AWS CDK potrebbero aggiungere casualmente una nuova proprietà con un nome usato per la propria proprietà. Il trasferimento del valore ricevuto nella catena di ereditarietà può quindi causare un comportamento imprevisto. È più sicuro passare una copia superficiale degli oggetti di scena ricevuti con la proprietà rimossa o impostata. `undefined` Esempio:
```
super(scope, name, {...props, encryptionKeys: undefined});
```
In alternativa, dai un nome alle tue proprietà in modo che sia chiaro che appartengono al tuo costrutto. In questo modo, è improbabile che entrino in collisione con le proprietà nelle future versioni di AWS CDK. Se ce ne sono molte, usate un unico oggetto dal nome appropriato per contenerle.
### Valori mancanti
I valori mancanti in un oggetto (ad esempio`props`) hanno il valore in. `undefined` JavaScript Per affrontarli si applicano le tecniche usuali. Ad esempio, un linguaggio comune per accedere a una proprietà di un valore che può essere indefinito è il seguente:
```
// a may be undefined, but if it is not, it may have an attribute b
// c is undefined if a is undefined, OR if a doesn't have an attribute b
let c = a && a.b;
```
Tuttavia, se `a` potesse avere qualche altro valore «falso» oltre a questo`undefined`, è meglio rendere il test più esplicito. Qui, trarremo vantaggio dal fatto che `null` `undefined` siamo uguali per testarli entrambi contemporaneamente:
```
let c = a == null ? a : a.b;
```
**Suggerimento**
Node.js 14.0 e versioni successive supportano nuovi operatori in grado di semplificare la gestione di valori non definiti. Per ulteriori informazioni, consulta le proposte [opzionali di concatenamento](https://github.com/tc39/proposal-optional-chaining/blob/master/README.md) e [nullish](https://github.com/tc39/proposal-nullish-coalescing/blob/master/README.md) coalescenza.
## Utilizzo di esempi con TypeScript JavaScript
[TypeScript](https://www.typescriptlang.org/)è il linguaggio che utilizziamo per sviluppare il AWS CDK ed è stato il primo linguaggio supportato per lo sviluppo di applicazioni, quindi sono scritti molti esempi di codice AWS CDK disponibili. TypeScript Questi esempi di codice possono essere una buona risorsa per JavaScript gli sviluppatori; è sufficiente rimuovere le parti TypeScript specifiche del codice.
TypeScript Gli snippet utilizzano spesso le `export` parole chiave newer ECMAScript `import` and per importare oggetti da altri moduli e dichiarare che gli oggetti devono essere resi disponibili al di fuori del modulo corrente. Node.js ha appena iniziato a supportare queste parole chiave nelle sue ultime versioni. A seconda della versione di Node.js che stai utilizzando (o che desideri supportare), potresti riscrivere le importazioni e le esportazioni per utilizzare la sintassi precedente.
Le importazioni possono essere sostituite con chiamate alla `require()` funzione.
**Example**
```
import * as cdk from 'aws-cdk-lib';
import { Bucket, BucketPolicy } from 'aws-cdk-lib/aws-s3';
```
```
const cdk = require('aws-cdk-lib');
const { Bucket, BucketPolicy } = require('aws-cdk-lib/aws-s3');
```
Le esportazioni possono essere assegnate all'`module.exports`oggetto.
**Example**
```
export class Stack1 extends cdk.Stack {
// ...
}
export class Stack2 extends cdk.Stack {
// ...
}
```
```
class Stack1 extends cdk.Stack {
// ...
}
class Stack2 extends cdk.Stack {
// ...
}
module.exports = { Stack1, Stack2 }
```
**Nota**
Un'alternativa all'utilizzo delle importazioni e delle esportazioni vecchio stile consiste nell'utilizzare il modulo [esm](https://www.npmjs.com/package/esm).
Dopo aver ordinato le importazioni e le esportazioni, puoi approfondire il codice effettivo. Potresti imbatterti in queste funzionalità di uso comune: TypeScript
+ Digita le annotazioni
+ Definizioni di interfaccia
+ Conversioni di tipo/cast
+ Modificatori di accesso
È possibile fornire annotazioni di tipo per variabili, membri della classe, parametri di funzione e tipi restituiti dalle funzioni. Per le variabili, i parametri e i membri, i tipi vengono specificati seguendo l'identificatore con i due punti e il tipo. I valori restituiti dalla funzione seguono la firma della funzione e sono costituiti da due punti e dal tipo.
Per convertire il codice annotato sul tipo in JavaScript, rimuovete i due punti e il tipo. I membri della classe devono inserire un valore JavaScript; impostatelo su `undefined` se hanno solo un'annotazione di tipo. TypeScript
**Example**
```
var encrypted: boolean = true;
class myStack extends cdk.Stack {
bucket: s3.Bucket;
// ...
}
function makeEnv(account: string, region: string) : object {
// ...
}
```
```
var encrypted = true;
class myStack extends cdk.Stack {
bucket = undefined;
// ...
}
function makeEnv(account, region) {
// ...
}
```
In TypeScript, le interfacce vengono utilizzate per dare un nome a gruppi di proprietà obbligatorie e opzionali e ai relativi tipi. È quindi possibile utilizzare il nome dell'interfaccia come annotazione del tipo. TypeScript si assicurerà che l'oggetto utilizzato come, ad esempio, argomento di una funzione abbia le proprietà richieste dei tipi corretti.
```
interface myFuncProps {
code: lambda.Code,
handler?: string
}
```
JavaScript non ha una funzionalità di interfaccia, quindi dopo aver rimosso le annotazioni di tipo, elimina completamente le dichiarazioni dell'interfaccia.
Quando una funzione o un metodo restituisce un tipo generico (ad esempio`object`), ma si desidera trattare tale valore come un tipo figlio più specifico per accedere a proprietà o metodi che non fanno parte dell'interfaccia del tipo più generale, TypeScript consente di eseguire il *cast* del valore utilizzando `as` seguito da un tipo o da un nome di interfaccia. JavaScript non lo supporta (o non ne ha bisogno), quindi è sufficiente rimuovere `as` e il seguente identificatore. Una sintassi cast meno comune consiste nell'utilizzare il nome di un tipo tra parentesi``; anche questi cast devono essere rimossi.
Infine, TypeScript supporta i modificatori `public` di accesso e per i membri delle classi. `protected` `private` Tutti i membri della classe JavaScript sono pubblici. Rimuovi semplicemente questi modificatori ovunque li vedi.
Sapere come identificare e rimuovere queste TypeScript funzionalità è fondamentale per adattare brevi TypeScript frammenti a. JavaScript Tuttavia, potrebbe non essere pratico convertire TypeScript esempi più lunghi in questo modo, poiché è più probabile che utilizzino altre funzionalità. TypeScript Per queste situazioni, consigliamo [Sucrase](https://github.com/alangpierce/sucrase). Sucrase non si lamenterà se il codice utilizza una variabile non definita, ad esempio, come farebbe. `tsc` Se è sintatticamente valido, con poche eccezioni, Sucrase può tradurlo in. JavaScript Ciò lo rende particolarmente utile per convertire frammenti che potrebbero non essere eseguibili da soli.
## Migrazione a TypeScript
Molti JavaScript sviluppatori si trasferiscono [TypeScript](https://www.typescriptlang.org/)man mano che i loro progetti diventano più grandi e complessi. TypeScript è un superset di JavaScript: tutto il JavaScript codice è un TypeScript codice valido, quindi non sono necessarie modifiche al codice, ed è anche un linguaggio CDK supportato. AWS Le annotazioni sui tipi e altre TypeScript funzionalità sono opzionali e possono essere aggiunte all'app AWS CDK non appena ne trovi il valore. TypeScript consente inoltre di accedere in anteprima a nuove JavaScript funzionalità, come il concatenamento opzionale e il nullish coalescing, prima che vengano finalizzate e senza richiedere l'aggiornamento di Node.js.
TypeScript, che definiscono pacchetti di proprietà obbligatorie e opzionali (e i relativi tipi) all'interno di un oggetto, consentono di rilevare gli errori più comuni durante la scrittura del codice e semplificano l'IDE nel fornire solidi consigli di completamento automatico e altri consigli di codifica in tempo reale.
La codifica TypeScript comporta un passaggio aggiuntivo: la compilazione dell'app con il compilatore,. TypeScript `tsc` Per le tipiche app AWS CDK, la compilazione richiede al massimo alcuni secondi.
Il modo più semplice per migrare un'app JavaScript AWS CDK esistente TypeScript è creare un nuovo TypeScript progetto utilizzando `cdk init app --language typescript` e quindi copiare i file sorgente (e qualsiasi altro file necessario, come risorse come il codice sorgente della funzione AWS Lambda) nel nuovo progetto. Rinomina i JavaScript file in modo che terminino `.ts` e inizi a svilupparli in. TypeScript
# Lavorare con il AWS CDK in Python
Python è un linguaggio client completamente supportato per il AWS Cloud Development Kit (AWS CDK) ed è considerato stabile. Lavorare con il AWS CDK in Python utilizza strumenti familiari, tra cui l'implementazione standard di Python CPython ()`virtualenv`, ambienti virtuali con e il programma di installazione del pacchetto Python. `pip` [I moduli che compongono la Construct Library sono distribuiti tramite pypi.org AWS .](https://pypi.org/search/?q=aws-cdk) La versione Python del AWS CDK utilizza anche identificatori in stile Python (ad esempio, i nomi dei metodi). `snake_case`
Puoi usare qualsiasi editor o IDE. [Molti sviluppatori AWS CDK utilizzano [Visual Studio Code](https://code.visualstudio.com/) (o il suo equivalente open source [VSCodium](https://vscodium.com/)), che supporta bene Python tramite un'estensione ufficiale.](https://marketplace.visualstudio.com/items?itemName=ms-python.python) L'editor IDLE incluso in Python sarà sufficiente per iniziare. I moduli Python per il AWS CDK dispongono di suggerimenti di tipo, utili per uno strumento di linting o un IDE che supporti la convalida dei tipi.
## Inizia a usare Python
Per utilizzare il AWS CDK, è necessario disporre di un AWS account e delle credenziali e aver installato Node.js e CDK Toolkit. AWS Vedi [Guida introduttiva](getting-started.md) al CDK. AWS
Le applicazioni Python AWS CDK richiedono Python 3.9 o versione successiva. [Se non l'hai già installato, [scarica una versione compatibile](https://www.python.org/downloads/) per il tuo sistema operativo da python.org.](https://www.python.org/) Se usi Linux, il tuo sistema potrebbe avere una versione compatibile, oppure puoi installarlo usando il gestore di pacchetti della tua distribuzione (`yum``apt`, ecc.). Gli utenti Mac potrebbero essere interessati a [Homebrew](https://brew.sh/), un gestore di pacchetti in stile Linux per macOS.
**Nota**
Obsolitudine linguistica di terze parti: la versione linguistica è supportata solo fino alla fine del ciclo di vita (EOL (End Of Life) condivisa dal fornitore o dalla community ed è soggetta a modifiche con preavviso.
Sono richiesti anche il programma di installazione del pacchetto Python e il gestore dell'ambiente virtuale. `pip` `virtualenv` Le installazioni Windows di versioni Python compatibili includono questi strumenti. Su Linux, `pip` e `virtualenv` può essere fornito come pacchetti separati nel gestore di pacchetti. In alternativa, puoi installarli con i seguenti comandi:
```
python -m ensurepip --upgrade
python -m pip install --upgrade pip
python -m pip install --upgrade virtualenv
```
Se riscontrate un errore di autorizzazione, eseguite i comandi precedenti con il `--user` flag in modo che i moduli siano installati nella vostra directory utente, oppure usateli `sudo` per ottenere le autorizzazioni per installare i moduli a livello di sistema.
**Nota**
È comune che le distribuzioni Linux utilizzino il nome eseguibile `python3` per Python 3.x e `python` facciano riferimento a un'installazione di Python 2.x. Alcune distribuzioni hanno un pacchetto opzionale che puoi installare che fa sì che il `python` comando faccia riferimento a Python 3. In caso contrario, è possibile modificare il comando utilizzato per eseguire l'applicazione modificandolo `cdk.json` nella directory principale del progetto.
**Nota**
Su Windows, potresti voler invocare Python (`pip`and) usando `py` l'eseguibile, il programma di avvio [Python](https://docs.python.org/3/using/windows.html#launcher) per Windows. Tra le altre cose, il programma di avvio consente di specificare facilmente quale versione installata di Python si desidera utilizzare.
Se digitando `python` nella riga di comando viene visualizzato un messaggio sull'installazione di Python da Windows Store, anche dopo aver installato una versione Windows di Python, apri il pannello delle impostazioni Manage App Execution Aliases di Windows e disattiva le due voci dell'App Installer per Python.
## Creare un progetto
È possibile creare un nuovo progetto AWS CDK invocandolo in una directory vuota. `cdk init` Utilizzate l'`--language`opzione e specificate: `python`
```
$ mkdir my-project
$ cd my-project
$ cdk init app --language python
```
`cdk init`utilizza il nome della cartella del progetto per denominare vari elementi del progetto, tra cui classi, sottocartelle e file. I trattini nel nome della cartella vengono convertiti in caratteri di sottolineatura. Tuttavia, il nome dovrebbe altrimenti seguire la forma di un identificatore Python; ad esempio, non dovrebbe iniziare con un numero o contenere spazi.
Per lavorare con il nuovo progetto, attivare il suo ambiente virtuale. Ciò consente di installare le dipendenze del progetto localmente nella cartella del progetto, anziché globalmente.
```
$ source .venv/bin/activate
```
**Nota**
Potresti riconoscerlo come il Mac/Linux comando per attivare un ambiente virtuale. I modelli Python includono un file batch, `source.bat`, che consente di utilizzare lo stesso comando su Windows. Anche il comando tradizionale `.\venv\Scripts\activate` di Windows funziona.
Se hai inizializzato il progetto AWS CDK utilizzando CDK Toolkit v1.70.0 o versione precedente, l'ambiente virtuale si trova invece nella directory. `.env` `.venv`
**Importante**
Attiva l'ambiente virtuale del progetto ogni volta che inizi a lavorarci. Altrimenti, non avrai accesso ai moduli installati lì e i moduli che installerai andranno nella directory globale dei moduli di Python (o genereranno un errore di autorizzazione).
Dopo aver attivato l'ambiente virtuale per la prima volta, installa le dipendenze standard dell'app:
```
$ python -m pip install -r requirements.txt
```
## Gestione dei moduli di AWS Construct Library
Usa il programma di installazione del pacchetto Python per installare e aggiornare i moduli di AWS Construct Library da utilizzare con le tue app e con gli altri pacchetti di cui hai bisogno. `pip` `pip`installa inoltre automaticamente le dipendenze per tali moduli. Se il tuo sistema non riconosce `pip` come comando autonomo, invoca `pip` come modulo Python, in questo modo:
```
$ python -m pip
```
La maggior parte dei AWS costrutti CDK sono presenti. `aws-cdk-lib` I moduli sperimentali si trovano in moduli separati denominati come. `aws-cdk..alpha` Il nome del servizio include un prefisso *aws*. Se non sei sicuro del nome di un modulo, [cercalo in PyPI](https://pypi.org/search/?q=aws-cdk). Ad esempio, il comando seguente installa la libreria. AWS CodeStar
```
$ python -m pip install aws-cdk.aws-codestar-alpha
```
I costrutti di alcuni servizi si trovano in più di un namespace. Ad esempio`aws-cdk.aws-route53`, ci sono inoltre tre namespace Amazon Route 53 aggiuntivi`aws-route53-targets`, `aws-route53-patterns` denominati e. `aws-route53resolver`
**Nota**
L'[edizione Python del CDK API Reference](https://docs.aws.amazon.com/cdk/api/v2/python/index.html) mostra anche i nomi dei pacchetti.
I nomi usati per importare i moduli AWS Construct Library nel codice Python sono i seguenti.
```
import aws_cdk.aws_s3 as s3
import aws_cdk.aws_lambda as lambda_
```
Consigliamo le seguenti pratiche per importare classi AWS CDK e moduli AWS Construct Library nelle applicazioni. Seguire queste linee guida contribuirà a rendere il codice coerente con altre applicazioni AWS CDK e più facile da comprendere.
+ In genere, importa singole classi dal livello superiore`aws_cdk`.
```
from aws_cdk import App, Construct
```
+ Se hai bisogno di molte classi da`aws_cdk`, puoi utilizzare un alias dello spazio dei nomi di `cdk` invece di importare singole classi. Evita di fare entrambe le cose.
```
import aws_cdk as cdk
```
+ In genere, importate le librerie AWS Construct utilizzando alias di namespace brevi.
```
import aws_cdk.aws_s3 as s3
```
Dopo aver installato un modulo, aggiorna il `requirements.txt` file del progetto, che elenca le dipendenze del progetto. È meglio farlo manualmente anziché utilizzare`pip freeze`. `pip freeze`acquisisce le versioni correnti di tutti i moduli installati nell'ambiente virtuale Python, il che può essere utile quando si raggruppa un progetto da eseguire altrove.
Di solito, tuttavia, è `requirements.txt` necessario elencare solo le dipendenze di primo livello (moduli da cui dipende direttamente l'app) e non le dipendenze di tali librerie. Questa strategia semplifica l'aggiornamento delle dipendenze.
È possibile modificare `requirements.txt` per consentire gli aggiornamenti; è sufficiente sostituire il numero di versione `==` precedente con `~=` per consentire l'aggiornamento a una versione compatibile superiore o rimuovere completamente il requisito di versione per specificare l'ultima versione disponibile del modulo.
Se `requirements.txt` modificate in modo appropriato per consentire gli aggiornamenti, eseguite questo comando per aggiornare i moduli installati del progetto in qualsiasi momento:
```
$ pip install --upgrade -r requirements.txt
```
## Gestire le dipendenze in Python
In Python, si specificano le dipendenze inserendole nelle applicazioni o `setup.py` nelle `requirements.txt` librerie di costruzione. Le dipendenze vengono quindi gestite con lo strumento PIP. PIP viene richiamato in uno dei seguenti modi:
```
pip
python -m pip
```
L'`python -m pip`invocazione funziona sulla maggior parte dei sistemi; `pip` richiede che l'eseguibile di PIP si trovi nel percorso di sistema. Se `pip` non funziona, prova a sostituirlo con. `python -m pip`
Il `cdk init --language python` comando crea un ambiente virtuale per il tuo nuovo progetto. Ciò consente a ogni progetto di avere le proprie versioni di dipendenze e anche un `requirements.txt` file di base. È necessario attivare questo ambiente virtuale eseguendolo `source .venv/bin/activate` ogni volta che si inizia a lavorare con il progetto. Su Windows, esegui `.\venv\Scripts\activate` invece
### Applicazioni CDK
Di seguito è riportato un esempio del file `requirements.txt`. Poiché PIP non dispone di una funzionalità di blocco delle dipendenze, si consiglia di utilizzare l'operatore == per specificare le versioni esatte per tutte le dipendenze, come illustrato di seguito.
```
aws-cdk-lib==2.14.0
aws-cdk.aws-appsync-alpha==2.10.0a0
```
L'installazione di un modulo con `pip install` non lo aggiunge automaticamente a. `requirements.txt` Devi farlo tu stesso. Se desideri eseguire l'aggiornamento a una versione successiva di una dipendenza, modificane il numero di versione in`requirements.txt`.
Per installare o aggiornare le dipendenze del progetto dopo la creazione o la modifica`requirements.txt`, esegui quanto segue:
```
python -m pip install -r requirements.txt
```
**Suggerimento**
Il `pip freeze` comando restituisce le versioni di tutte le dipendenze installate in un formato che può essere scritto in un file di testo. Questo può essere usato come file dei requisiti con. `pip install -r` Questo file è utile per aggiungere tutte le dipendenze (comprese quelle transitive) alle versioni esatte con cui hai testato. Per evitare problemi quando si aggiornano i pacchetti in un secondo momento, utilizzate un file separato, ad esempio (not). `freeze.txt` `requirements.txt` Quindi, rigeneralo quando aggiorni le dipendenze del progetto.
### Librerie di costruzioni di terze parti
Nelle librerie, le dipendenze sono specificate in`setup.py`, in modo che le dipendenze transitive vengano scaricate automaticamente quando il pacchetto viene utilizzato da un'applicazione. Altrimenti, ogni applicazione che desidera utilizzare il pacchetto deve copiare le dipendenze al suo interno. `requirements.txt` Un esempio `setup.py` è mostrato qui.
```
from setuptools import setup
setup(
name='my-package',
version='0.0.1',
install_requires=[
'aws-cdk-lib==2.14.0',
],
...
)
```
Per lavorare sul pacchetto per lo sviluppo, crea o attiva un ambiente virtuale, quindi esegui il seguente comando.
```
python -m pip install -e .
```
Sebbene PIP installi automaticamente le dipendenze transitive, può esserci una sola copia installata di ogni pacchetto. Viene selezionata la versione specificata più in alto nell'albero delle dipendenze; le applicazioni hanno sempre l'ultima parola sulla versione dei pacchetti da installare.
## AWS Idiomi CDK in Python
### Conflitti linguistici
In Python, `lambda` è una parola chiave del linguaggio, quindi non è possibile utilizzarla come nome per il modulo della libreria di costruzioni AWS Lambda o per le funzioni Lambda. La convenzione di Python per tali conflitti consiste nell'utilizzare un carattere di sottolineatura finale, come in`lambda_`, nel nome della variabile.
Per convenzione, il secondo argomento dei costrutti AWS CDK viene denominato. `id` Quando scrivi i tuoi stack e i tuoi costrutti, chiamando un parametro `id` «shadows» la funzione incorporata in Python`id()`, che restituisce l'identificatore univoco di un oggetto. Questa funzione non viene usata molto spesso, ma se ti capita di averne bisogno nel tuo costrutto, rinomina l'argomento, ad esempio. `construct_id`
### Argomenti e proprietà
Tutte le classi di AWS Construct Library vengono istanziate utilizzando tre argomenti: l'*ambito* in cui viene definito il costrutto (l'elemento principale nell'albero di costruzione), un *id* e *props*, un insieme di key/value coppie che il costrutto utilizza per configurare le risorse che crea. Anche altre classi e metodi utilizzano il modello «bundle of attributes» per gli argomenti.
*scope* *e *id* devono essere sempre passati come argomenti posizionali, non come argomenti di parole chiave, perché i loro nomi cambiano se il costrutto accetta una proprietà denominata *scope* o id.*
In Python, gli oggetti di scena sono espressi come argomenti di parole chiave. Se un argomento contiene strutture di dati annidate, queste vengono espresse utilizzando una classe che utilizza i propri argomenti di parole chiave al momento dell'istanziazione. Lo stesso schema viene applicato ad altre chiamate di metodo che accettano un argomento strutturato.
Ad esempio, nel `add_lifecycle_rule` metodo di un bucket Amazon S3, la `transitions` proprietà è un elenco di istanze. `Transition`
```
bucket.add_lifecycle_rule(
transitions=[
Transition(
storage_class=StorageClass.GLACIER,
transition_after=Duration.days(10)
)
]
)
```
Quando estendi una classe o sovrascrivi un metodo, potresti voler accettare argomenti aggiuntivi per i tuoi scopi che non sono compresi dalla classe madre. In questo caso dovresti accettare gli argomenti che non ti interessano usando l'idioma \$1\$1kwargs e usare argomenti basati solo su parole chiave per accettare gli argomenti che ti interessano. Quando chiami il costruttore del genitore o il metodo sovrascritto, passa solo gli argomenti che si aspetta (spesso solo \$1\$1kwargs). Il passaggio di argomenti che la classe o il metodo principale non si aspetta genera un errore.
```
class MyConstruct(Construct):
def __init__(self, id, *, MyProperty=42, **kwargs):
super().__init__(self, id, **kwargs)
# ...
```
Le future versioni del AWS CDK potrebbero aggiungere casualmente una nuova proprietà con un nome usato per la propria proprietà. Ciò non causerà alcun problema tecnico agli utenti del vostro costrutto o metodo (poiché la proprietà non viene passata «all'inizio della catena», la classe principale o il metodo sovrascritto utilizzeranno semplicemente un valore predefinito) ma potrebbe causare confusione. Potete evitare questo potenziale problema denominando le proprietà in modo che appartengano chiaramente al vostro costrutto. Se sono presenti molte nuove proprietà, raggruppatele in una classe dal nome appropriato e passatela come argomento di una singola parola chiave.
### Valori mancanti
Il AWS CDK lo utilizza `None` per rappresentare valori mancanti o non definiti. Quando lavori con \$1\$1kwargs, usa il `get()` metodo del dizionario per fornire un valore predefinito se non viene fornita una proprietà. Evita di utilizzarlo`kwargs[…]`, poiché ciò genera valori mancanti`KeyError`.
```
encrypted = kwargs.get("encrypted") # None if no property "encrypted" exists
encrypted = kwargs.get("encrypted", False) # specify default of False if property is missing
```
È possibile che vengano restituiti alcuni metodi AWS CDK (`tryGetContext()`ad esempio per ottenere un valore di contesto di runtime)`None`, che dovrete verificare esplicitamente.
### Utilizzo delle interfacce
Python non ha una funzionalità di interfaccia come altri linguaggi, sebbene abbia [classi base astratte](https://docs.python.org/3/library/abc.html), che sono simili. (Se non hai familiarità con le interfacce, Wikipedia ha [una buona introduzione](https://en.wikipedia.org/wiki/Interface_(computing)#In_object-oriented_languages).) TypeScript, il linguaggio in cui è implementato il AWS CDK, fornisce interfacce e i costrutti e altri oggetti AWS CDK spesso richiedono un oggetto che aderisca a una particolare interfaccia, anziché ereditare da una particolare classe. [Quindi il AWS CDK fornisce la propria funzionalità di interfaccia come parte del livello JSII.](https://github.com/aws/jsii)
Per indicare che una classe implementa una particolare interfaccia, puoi usare il decoratore: `@jsii.implements`
```
from aws_cdk import IAspect, IConstruct
import jsii
@jsii.implements(IAspect)
class MyAspect():
def visit(self, node: IConstruct) -> None:
print("Visited", node.node.path)
```
### Digita le insidie
Python utilizza la tipizzazione dinamica, in cui tutte le variabili possono fare riferimento a un valore di qualsiasi tipo. I parametri e i valori restituiti possono essere annotati con tipi, ma questi sono «suggerimenti» e non vengono applicati. Ciò significa che in Python è facile passare il tipo di valore errato a un costrutto AWS CDK. Invece di ricevere un errore di tipo durante la compilazione, come accadrebbe con un linguaggio tipizzato staticamente, potresti invece ricevere un errore di runtime quando il livello JSII (che traduce tra Python e il core del AWS CDK) non è TypeScript in grado di gestire il tipo imprevisto.
In base alla nostra esperienza, gli errori di tipo commessi dai programmatori Python tendono a rientrare in queste categorie.
+ Passare un singolo valore in cui un costrutto prevede un contenitore (elenco o dizionario Python) o viceversa.
+ Passare un valore di un tipo associato a un costrutto di livello 1 (`CfnXxxxxx`) a un costrutto L2 o L3 o viceversa.
## Prevenzione degli errori di tipo
I moduli AWS CDK Python includono annotazioni di tipo, quindi puoi utilizzare strumenti che li supportano per catturare gli errori di tipo prima della distribuzione.
### Integrazione IDE (consigliata)
Visual Studio Code con Pylance fornisce il controllo dei tipi in tempo reale durante la scrittura del codice:
1. [Installa l'estensione Pylance](https://marketplace.visualstudio.com/items?itemName=ms-python.vscode-pylance)
1. Configura il tipo di check-in rigoroso: `.vscode/settings.json`
```
{
"python.languageServer": "Pylance",
"python.analysis.typeCheckingMode": "strict"
}
```
1. Gli errori di digitazione ora vengono visualizzati immediatamente con scarabocchi rossi e messaggi di errore dettagliati
[PyCharm](https://www.jetbrains.com/pycharm/)offre anche un controllo dei tipi integrato con funzionalità simili.
### Controllo del tipo tramite riga di comando
Per le CI/CD pipeline o la convalida prima del commit, usa uno di questi correttori di tipo:
**MyPy (Basato su Python):**
```
pip install mypy
mypy app.py
```
**Pyright (più veloce, JavaScript basato sullo stesso motore di Pylance):**
```
npm install -g pyright
pyright app.py
```
### Flusso di lavoro raccomandato
1. Durante lo sviluppo: usa Pyt o Pylance per un feedback immediato
1. Prima del commit: Esegui o `mypy app.py` `pyright app.py`
1. In CI/CD: imposta il controllo del tipo come passaggio obbligatorio prima della distribuzione
# Lavorare con il AWS CDK in Java
Java è un linguaggio client completamente supportato per il AWS CDK ed è considerato stabile. Puoi sviluppare applicazioni AWS CDK in Java utilizzando strumenti familiari, tra cui JDK (Oracle o una distribuzione OpenJDK come Amazon Corretto) e Apache Maven.
Il CDK supporta Java 8 e versioni successive. AWS Tuttavia, consigliamo di utilizzare la versione più recente possibile, poiché le versioni successive del linguaggio includono miglioramenti particolarmente utili per lo sviluppo di applicazioni AWS CDK. Ad esempio, Java 9 introduce il `Map.of()` metodo (un modo conveniente per dichiarare hashmap che verrebbero scritte come oggetti letterali). TypeScript Java 10 introduce l'inferenza di tipo locale utilizzando la parola chiave. `var`
**Nota**
La maggior parte degli esempi di codice in questa Guida per gli sviluppatori funziona con Java 8. Alcuni esempi di utilizzo`Map.of()`; questi esempi includono commenti che indicano che richiedono Java 9.
Puoi usare qualsiasi editor di testo o un IDE Java in grado di leggere i progetti Maven per lavorare sulle tue app AWS CDK. Forniamo suggerimenti per [Eclipse](https://www.eclipse.org/downloads/) in questa guida, ma IntelliJ IDEA e altri IDEs possono importare progetti Maven e possono essere utilizzati per lo sviluppo di applicazioni CDK in Java. NetBeans AWS
È possibile scrivere applicazioni AWS CDK in linguaggi ospitati da JVM diversi da Java (ad esempio, Kotlin, Groovy, Clojure o Scala), ma l'esperienza potrebbe non essere particolarmente idiomatica e non siamo in grado di fornire alcun supporto per questi linguaggi.
## Inizia a usare Java
Per utilizzare il AWS CDK, è necessario disporre di un AWS account e delle credenziali e aver installato Node.js e AWS CDK Toolkit. Vedi [Guida introduttiva](getting-started.md) al CDK. AWS
Le applicazioni Java AWS CDK richiedono Java 8 (v1.8) o versione successiva. [Consigliamo [Amazon Corretto](https://aws.amazon.com/corretto/), ma puoi utilizzare qualsiasi distribuzione OpenJDK o JDK di Oracle.](https://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html) Avrai anche bisogno di [Apache](https://maven.apache.org/download.cgi) Maven 3.5 o versione successiva. Puoi anche usare strumenti come Gradle, ma gli scheletri delle applicazioni generati dal AWS CDK Toolkit sono progetti Maven.
**Nota**
Deprecazione linguistica di terze parti: la versione linguistica è supportata solo fino alla fine del ciclo di vita (EOL (End Of Life) condivisa dal fornitore o dalla community ed è soggetta a modifiche con preavviso.
## Creare un progetto
È possibile creare un nuovo progetto AWS CDK invocandolo in una directory vuota. `cdk init` Utilizzate l'`--language`opzione e specificate: `java`
```
$ mkdir my-project
$ cd my-project
$ cdk init app --language java
```
`cdk init`utilizza il nome della cartella del progetto per denominare vari elementi del progetto, tra cui classi, sottocartelle e file. I trattini nel nome della cartella vengono convertiti in caratteri di sottolineatura. Tuttavia, il nome dovrebbe altrimenti assumere la forma di un identificatore Java; ad esempio, non dovrebbe iniziare con un numero o contenere spazi.
Il progetto risultante include un riferimento al pacchetto `software.amazon.awscdk` Maven. Esso e le sue dipendenze vengono installati automaticamente da Maven.
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).
## Gestione dei moduli AWS di Construct Library
Usa Maven per installare i pacchetti AWS Construct Library, che fanno parte del gruppo. `software.amazon.awscdk` La maggior parte dei costrutti si trova nell'artefatto`aws-cdk-lib`, che viene aggiunto ai nuovi progetti Java per impostazione predefinita. I moduli per i servizi il cui supporto CDK di livello superiore è ancora in fase di sviluppo si trovano in pacchetti «sperimentali» separati, denominati con una versione breve (no o prefisso AWS Amazon) del nome del servizio. [Cerca nel Maven Central Repository per trovare i nomi di tutte le librerie](https://search.maven.org/search?q=software.amazon.awscdk) CDK e Construct Module. AWS AWS
**Nota**
L'[edizione Java del CDK API Reference](https://docs.aws.amazon.com/cdk/api/v2/java/index.html) mostra anche i nomi dei pacchetti.
Il supporto di AWS Construct Library di alcuni servizi è disponibile in più di un namespace. Ad esempio, Amazon Route 53 ha le sue funzionalità suddivise in `software.amazon.awscdk.route53``route53-patterns`,`route53resolver`, e`route53-targets`.
Il pacchetto AWS CDK principale viene importato in codice Java come`software.amazon.awscdk`. I moduli per i vari servizi della AWS Construct Library risiedono in `software.amazon.awscdk.services` e hanno un nome simile al nome del pacchetto Maven. Ad esempio, lo spazio dei nomi del modulo Amazon S3 è. `software.amazon.awscdk.services.s3`
Ti consigliamo di scrivere un'`import`istruzione Java separata per ogni classe di AWS Construct Library che usi in ciascuno dei tuoi file sorgente Java ed evitare le importazioni con caratteri jolly. Puoi sempre utilizzare il nome completo di un tipo (incluso il relativo spazio dei nomi) senza un'istruzione. `import`
Se la tua applicazione dipende da un pacchetto sperimentale, modifica il progetto `pom.xml` e aggiungi un nuovo `` elemento nel contenitore. `` Ad esempio, il seguente `` elemento specifica il modulo della libreria di costruzioni CodeStar sperimentali:
```
software.amazon.awscdkcodestar-alpha2.0.0-alpha.10
```
**Suggerimento**
Se si utilizza un IDE Java, probabilmente dispone di funzionalità per la gestione delle dipendenze di Maven. Tuttavia, ti consigliamo di modificare `pom.xml` direttamente, a meno che tu non sia assolutamente sicuro che la funzionalità dell'IDE corrisponda a quella che faresti a mano.
## Gestione delle dipendenze in Java
In Java, le dipendenze vengono specificate `pom.xml` e installate utilizzando Maven. Il `` contenitore include un `` elemento per ogni pacchetto. Di seguito è riportata una sezione `pom.xml` di una tipica app Java CDK.
```
software.amazon.awscdkaws-cdk-lib2.14.0software.amazon.awscdkappsync-alpha2.10.0-alpha.0
```
**Suggerimento**
Molti Java IDEs hanno integrato il supporto Maven e `pom.xml` gli editor visivi, che potresti trovare utili per la gestione delle dipendenze.
Maven non supporta il blocco delle dipendenze. Sebbene sia possibile specificare intervalli di versioni`pom.xml`, ti consigliamo di utilizzare sempre versioni esatte per mantenere le build ripetibili.
Maven installa automaticamente le dipendenze transitive, ma può esserci solo una copia installata di ogni pacchetto. Viene selezionata la versione specificata più in alto nell'albero POM; le applicazioni hanno sempre l'ultima parola sulla versione dei pacchetti da installare.
Maven installa o aggiorna automaticamente le tue dipendenze ogni volta che crei (`mvn compile`) o pacchettizzi () il tuo progetto. `mvn package` CDK Toolkit lo fa automaticamente ogni volta che lo eseguite, quindi in genere non è necessario richiamare manualmente Maven.
## AWS Idiomi CDK in Java
### Props
Tutte le classi di AWS Construct Library vengono istanziate utilizzando tre argomenti: l'*ambito* in cui viene definito il costrutto (l'elemento principale nell'albero di costruzione), un *id* e *props*, un insieme di key/value coppie che il costrutto utilizza per configurare le risorse che crea. Anche altre classi e metodi utilizzano il modello «bundle of attributes» per gli argomenti.
In Java, gli oggetti di scena vengono espressi utilizzando il pattern [Builder](https://en.wikipedia.org/wiki/Builder_pattern). Ogni tipo di costrutto ha un tipo di oggetto corrispondente; ad esempio, il `Bucket` costrutto (che rappresenta un bucket Amazon S3) prende come oggetto di scena un'istanza di. `BucketProps`
La `BucketProps` classe (come ogni classe props di AWS Construct Library) ha una classe interna chiamata. `Builder` Il `BucketProps.Builder` tipo offre metodi per impostare le varie proprietà di un'`BucketProps`istanza. Ogni metodo restituisce l'`Builder`istanza, quindi le chiamate al metodo possono essere concatenate per impostare più proprietà. Alla fine della catena, si chiama `build()` per produrre effettivamente l'`BucketProps`oggetto.
```
Bucket bucket = new Bucket(this, "amzn-s3-demo-bucket", new BucketProps.Builder()
.versioned(true)
.encryption(BucketEncryption.KMS_MANAGED)
.build());
```
I costrutti e le altre classi che utilizzano un oggetto simile a un oggetto simile a un oggetto props come argomento finale offrono una scorciatoia. La classe ha una `Builder` propria istanza che la istanzia e il relativo oggetto props in un unico passaggio. In questo modo, non è necessario istanziare esplicitamente (ad esempio) entrambi `BucketProps` e un `Bucket` --e non è necessaria un'importazione per il tipo props.
```
Bucket bucket = Bucket.Builder.create(this, "amzn-s3-demo-bucket")
.versioned(true)
.encryption(BucketEncryption.KMS_MANAGED)
.build();
```
Quando derivate il vostro costrutto da un costrutto esistente, potreste voler accettare proprietà aggiuntive. Ti consigliamo di seguire questi schemi di costruzione. Tuttavia, non è così semplice come sottoclassare una classe di costrutti. È necessario fornire personalmente le parti mobili delle due nuove `Builder` classi. Potresti preferire che il tuo costrutto accetti semplicemente uno o più argomenti aggiuntivi. È necessario fornire costruttori aggiuntivi quando un argomento è facoltativo.
### Strutture generiche
In alcune APIs, il AWS CDK utilizza JavaScript matrici o oggetti non tipizzati come input per un metodo. (Vedi, ad esempio, AWS CodeBuild il metodo.) [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_codebuild.BuildSpec.html#static-fromwbrobjectvalue](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_codebuild.BuildSpec.html#static-fromwbrobjectvalue) In Java, questi oggetti sono rappresentati come`java.util.Map`. Nei casi in cui i valori sono tutte stringhe, puoi usare`Map`.
Java non fornisce un modo per scrivere valori letterali per tali contenitori come fanno altri linguaggi. In Java 9 e versioni successive, è possibile [https://docs.oracle.com/javase/9/docs/api/java/util/Map.html#ofEntries-java.util.Map.Entry…-](https://docs.oracle.com/javase/9/docs/api/java/util/Map.html#ofEntries-java.util.Map.Entry…-)definire comodamente mappe con un massimo di dieci voci in linea con una di queste chiamate.
```
java.util.Map.of(
"base-directory", "dist",
"files", "LambdaStack.template.json"
)
```
Per creare mappe con più di dieci voci, usa. [https://docs.oracle.com/javase/9/docs/api/java/util/Map.html#ofEntries-java.util.Map.Entry…-](https://docs.oracle.com/javase/9/docs/api/java/util/Map.html#ofEntries-java.util.Map.Entry…-)
Se utilizzi Java 8, potresti fornire metodi personalizzati simili a questi.
JavaScript gli array sono rappresentati come `List