Trabaja con la AWS CDK biblioteca

TypeScript admite la importación de un espacio de nombres completo o de objetos individuales de un espacio de nombres. Cada espacio de nombres incluye componentes fijos y otras clases para su uso con un servicio determinado. 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(...);

Por ejemplo TypeScript, Python admite la importación de módulos con espacios de nombres y las importaciones selectivas. Los espacios de nombres en Python se parecen a aws_cdk. xxx, donde xxx representa el nombre de un AWS servicio, como s3 para Amazon S3. (Amazon S3 se utiliza en estos ejemplos).

# 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(...)

Las importaciones de Java funcionan de forma diferente a las TypeScript de Java. Cada sentencia de importación importa un único nombre de clase de un paquete determinado o todas las clases definidas en ese paquete (mediante*). Se puede acceder a las clases utilizando el nombre de la clase en sí mismo si se ha importado, o el nombre de la clase cualificada, incluido su paquete.

Las bibliotecas reciben el mismo software.amazon.awscdk.services.xxx nombre que la biblioteca AWS Construct (la biblioteca principal essoftware.amazon.awscdk). El identificador de grupo de Maven para AWS CDK los paquetes essoftware.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();

En C#, los tipos se importan con la using directiva. Hay dos estilos. Uno le da acceso a todos los tipos del espacio de nombres especificado utilizando sus nombres simples. Con el otro, puede hacer referencia al propio espacio de nombres mediante un alias.

Los paquetes reciben el mismo nombre que los paquetes Amazon.CDK.AWS.xxx de AWS Construct Library. (El módulo principal esAmazon.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(...)

Cada módulo de AWS Construct Library se proporciona como un paquete 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, '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 no usa una new palabra clave al crear instancias de una clase. El argumento de propiedades se representa mediante argumentos de palabras clave y los argumentos se nombran mediante. snake_case

Si un valor de props es en sí mismo un conjunto de atributos, se representa mediante una clase con el nombre de la propiedad, que acepta argumentos de palabras clave para las subpropiedades.

En Python, la instancia actual se pasa a los métodos como primer argumento, que se denomina self por convención.

# 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"))

En Java, el argumento props se representa mediante una clase denominada XxxxProps (por ejemplo, BucketProps para los props de la Bucket construcción). El argumento props se construye utilizando un patrón de construcción.

Cada XxxxProps clase tiene un constructor. También hay un práctico constructor para cada construcción que construye los accesorios y la construcción en un solo paso, como se muestra en el siguiente ejemplo.

Los accesorios reciben el mismo nombre que en TypeScript, usando. 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();

En C#, los accesorios se especifican mediante un inicializador de objetos para una clase llamada XxxxProps (por ejemplo, BucketProps para los accesorios de la Bucket construcción).

Los accesorios se nombran de forma similar a, excepto por el uso de. TypeScript PascalCase

Es conveniente utilizar la var palabra clave al crear una instancia de una construcción, por lo que no es necesario escribir el nombre de la clase dos veces. Sin embargo, la guía de estilo del código local puede variar.

// 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"
                      }});

Para crear una construcción en Go, llama a la función NewXxxxxx donde Xxxxxxx es el nombre de la construcción. Las propiedades de las construcciones se definen como una estructura.

En Go, todos los parámetros de construcción son punteros, incluidos valores como números, valores booleanos y cadenas. Usa funciones prácticas como jsii.String para crear estos punteros.

	// 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"),
		}})

Los nombres soncamelCase.

bucket.bucketArn

Los nombres sonsnake_case.

bucket.bucket_arn

Se proporciona un método de captación para cada propiedad; estos nombres soncamelCase.

bucket.getBucketArn()

Los nombres sonPascalCase.

bucket.BucketArn

Los nombres sonPascalCase.

bucket.BucketArn

import { IAspect, IConstruct } from 'aws-cdk-lib';

class MyAspect implements IAspect {
  public visit(node: IConstruct) {
    console.log('Visited', node.node.path);
  }
}

Python no tiene una función de interfaz. Sin embargo, para eso AWS CDK puedes indicar la implementación de la interfaz decorando tu clase con ella@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}");
    }
}

Las estructuras Go no necesitan declarar explícitamente qué interfaces implementan. El compilador Go determina la implementación en función de los métodos y propiedades disponibles en la estructura. Por ejemplo, en el código siguiente, MyAspect implementa la IAspect interfaz porque proporciona un Visit método que toma una construcción.

type MyAspect struct {
}

func (a MyAspect) Visit(node constructs.IConstruct) {
	fmt.Println("Visited", *node.Node().Path())
}