Lavorare con i AWS CDK linguaggi di programmazione supportati

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_cdk. 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 AWS CDK i pacchetti è. 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#, 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(...)

// Instantiate default Bucket
const bucket = new s3.Bucket(this, 'MyBucket');

// Instantiate Bucket with bucketName and versioned properties
const bucket = new s3.Bucket(this, 'MyBucket', {
  bucketName: 'my-bucket',
   versioned: true,
});

// Instantiate Bucket with websiteRedirect, which has its own sub-properties
const bucket = new s3.Bucket(this, 'MyBucket', {
  websiteRedirect: {host: 'aws.amazon.com'}});

Python non usa una new parola chiave per creare un'istanza di 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, "MyBucket")

# Instantiate Bucket with bucket_name and versioned properties
bucket = s3.Bucket(self, "MyBucket", bucket_name="my-bucket", versioned=true)

# Instantiate Bucket with website_redirect, which has its own sub-properties
bucket = s3.Bucket(self, "MyBucket", 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, "MyBucket");

// Instantiate Bucket with bucketName and versioned properties
Bucket bucket = Bucket.Builder.create(self, "MyBucket")
                      .bucketName("my-bucket").versioned(true)
                      .build();

# Instantiate Bucket with websiteRedirect, which has its own sub-properties
Bucket bucket = Bucket.Builder.create(self, "MyBucket")
                      .websiteRedirect(new websiteRedirect.Builder()
                          .hostName("aws.amazon.com").build())
                      .build();

In C#, 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, "MyBucket");

// Instantiate Bucket with BucketName and Versioned properties
var bucket =  Bucket(self, "MyBucket", new BucketProps {
                      BucketName = "my-bucket",
                      Versioned  = true});

// Instantiate Bucket with WebsiteRedirect, which has its own sub-properties
var bucket = Bucket(self, "MyBucket", 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("MyBucket"), nil)

	// Instantiate Bucket with BucketName and Versioned properties
	bucket1 := awss3.NewBucket(stack, jsii.String("MyBucket"), &awss3.BucketProps{
		BucketName: jsii.String("my-bucket"),
		Versioned:  jsii.Bool(true),
	})

	// Instantiate Bucket with WebsiteRedirect, which has its own sub-properties
	bucket2 := awss3.NewBucket(stack, jsii.String("MyBucket"), &awss3.BucketProps{
		WebsiteRedirect: &awss3.RedirectTarget{
			HostName: jsii.String("aws.amazon.com"),
		}})

I nomi sonocamelCase.

bucket.bucketArn

I nomi sonosnake_case.

bucket.bucket_arn

Per ogni proprietà viene fornito un metodo getter; questi nomi sonocamelCase.

bucket.getBucketArn()

I nomi sonoPascalCase.

bucket.BucketArn

I nomi sonoPascalCase.

bucket.BucketArn

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, 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'IAspectinterfaccia 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())
}