Trabalhando com o AWS CDK em linguagens de programação suportadas

TypeScript suporta a importação de um namespace inteiro ou de objetos individuais de um namespace. Cada namespace inclui construções e outras classes para uso com um determinado serviço. 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 exemplo TypeScript, o Python suporta importações de módulos com namespace e importações seletivas. Os namespaces em Python se parecem com aws_cdk. xxx, onde xxx representa um nome AWS de serviço, como s3 para Amazon S3. (O Amazon S3 é usado nesses exemplos).

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

As importações do Java funcionam de forma diferente TypeScript das nossas. Cada instrução de importação importa um único nome de classe de um determinado pacote ou todas as classes definidas nesse pacote (usando*). As classes podem ser acessadas usando o nome da classe por si só, se tiver sido importada, ou o nome da classe qualificada, incluindo seu pacote.

As bibliotecas têm o mesmo software.amazon.awscdk.services.xxx nome da AWS Construct Library (a biblioteca principal ésoftware.amazon.awscdk). O ID do grupo Maven para AWS CDK pacotes é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();

Em C#, você importa tipos com a using diretiva. Há dois estilos. Um fornece acesso a todos os tipos no namespace especificado usando seus nomes simples. Com o outro, você pode se referir ao próprio namespace usando um alias.

Os pacotes são nomeados da mesma forma que Amazon.CDK.AWS.xxx os pacotes da AWS Construct Library. (O módulo principal é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(...)

Cada módulo da AWS Construct Library é fornecido como um pacote 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'}});

O Python não usa uma new palavra-chave ao instanciar uma classe. O argumento de propriedades é representado usando argumentos de palavra-chave e os argumentos são nomeados usandosnake_case.

Se um valor de props for em si um pacote de atributos, ele será representado por uma classe com o nome da propriedade, que aceita argumentos de palavra-chave para as subpropriedades.

Em Python, a instância atual é passada para os métodos como o primeiro argumento, que é nomeado self por convenção.

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

Em Java, o argumento props é representado por uma classe chamada XxxxProps (por exemplo, BucketProps para as props da Bucket construção). Você constrói o argumento props usando um padrão de construtor.

Cada XxxxProps classe tem um construtor. Também existe um construtor conveniente para cada construção que constrói os adereços e a construção em uma única etapa, conforme mostrado no exemplo a seguir.

Os adereços são nomeados da mesma forma que em TypeScript, usandocamelCase.

// 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();

Em C#, os adereços são especificados usando um inicializador de objeto para uma classe chamada XxxxProps (por exemplo, BucketProps para os adereços da Bucket construção).

Os adereços são nomeados de forma semelhante a TypeScript, exceto usandoPascalCase.

É conveniente usar a var palavra-chave ao instanciar uma construção, para que você não precise digitar o nome da classe duas vezes. No entanto, seu guia de estilo de código local pode variar.

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

Para criar uma construção em Go, chame a função NewXxxxxx onde Xxxxxxx está o nome da construção. As propriedades das construções são definidas como uma estrutura.

Em Go, todos os parâmetros de construção são ponteiros, incluindo valores como números, booleanos e cadeias de caracteres. Use as funções de conveniência, como jsii.String criar esses ponteiros.

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

Os nomes sãocamelCase.

bucket.bucketArn

Os nomes sãosnake_case.

bucket.bucket_arn

Um método getter é fornecido para cada propriedade; esses nomes sãocamelCase.

bucket.getBucketArn()

Os nomes sãoPascalCase.

bucket.BucketArn

Os nomes sãoPascalCase.

bucket.BucketArn

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

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

O Python não tem um recurso de interface. No entanto, para o, AWS CDK você pode indicar a implementação da interface decorando sua classe com@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}");
    }
}

As estruturas Go não precisam declarar explicitamente quais interfaces elas implementam. O compilador Go determina a implementação com base nos métodos e propriedades disponíveis na estrutura. Por exemplo, no código a seguir, MyAspect implementa a IAspect interface porque ela fornece um Visit método que usa uma construção.

type MyAspect struct {
}

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