Utilisation des langages AWS CDK de programmation pris en charge

TypeScript prend en charge l'importation d'un espace de noms complet ou d'objets individuels à partir d'un espace de noms. Chaque espace de noms inclut des constructions et d'autres classes à utiliser avec un service donné 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(...);

Par exemple TypeScript, Python prend en charge les importations de modules avec espace de noms et les importations sélectives. Les espaces de noms en Python ressemblent à aws_cdk. xxx, où xxx représente un nom AWS de service, tel que s3 pour Amazon S3. (Amazon S3 est utilisé dans ces exemples).

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

Les importations de Java fonctionnent différemment de celles TypeScript de Java. Chaque instruction d'importation importe soit un nom de classe unique à partir d'un package donné, soit toutes les classes définies dans ce package (en utilisant*). Les classes sont accessibles en utilisant soit le nom de classe lui-même s'il a été importé, soit le nom de classe qualifié, y compris son package.

Les bibliothèques portent le même nom que software.amazon.awscdk.services.xxx la bibliothèque AWS Construct (la bibliothèque principale estsoftware.amazon.awscdk). L'ID de groupe Maven pour les AWS CDK packages estsoftware.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#, vous importez des types avec la using directive. Il existe deux styles. L'un vous donne accès à tous les types de l'espace de noms spécifié en utilisant leurs noms simples. Avec l'autre, vous pouvez faire référence à l'espace de noms lui-même en utilisant un alias.

Les packages sont nommés de la même manière que Amazon.CDK.AWS.xxx les packages AWS Construct Library. (Le module de base estAmazon.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(...)

Chaque module AWS Construct Library est fourni sous forme de package 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 n'utilise pas de new mot-clé lors de l'instanciation d'une classe. L'argument properties est représenté à l'aide d'arguments de mots clés, et les arguments sont nommés en utilisantsnake_case.

Si une valeur props est elle-même un ensemble d'attributs, elle est représentée par une classe nommée d'après la propriété, qui accepte les arguments par mot clé pour les sous-propriétés.

En Python, l'instance actuelle est transmise aux méthodes en tant que premier argument, nommé self par convention.

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

En Java, l'argument props est représenté par une classe nommée XxxxProps (par exemple, BucketProps pour les accessoires de la Bucket construction). Vous créez l'argument props à l'aide d'un modèle de générateur.

Chaque XxxxProps classe possède un constructeur. Il existe également un générateur pratique pour chaque construction qui construit les accessoires et la construction en une seule étape, comme le montre l'exemple suivant.

Les accessoires portent le même nom que dans TypeScript, usingcamelCase.

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

En C#, les accessoires sont spécifiés à l'aide d'un initialiseur d'objet pour une classe nommée XxxxProps (par exemple, BucketProps pour les accessoires de la Bucket construction).

Les accessoires sont nommés de la même manière que TypeScript, sauf en utilisantPascalCase.

Il est pratique d'utiliser le var mot-clé lors de l'instanciation d'une construction, vous n'avez donc pas besoin de taper le nom de la classe deux fois. Cependant, votre guide de style de code local peut varier.

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

Pour créer une construction dans Go, appelez la fonction NewXxxxxx où Xxxxxxx est le nom de la construction. Les propriétés des constructions sont définies en tant que structure.

Dans Go, tous les paramètres de construction sont des pointeurs, y compris des valeurs telles que des nombres, des booléens et des chaînes. Utilisez les fonctions pratiques telles que jsii.String la création de ces pointeurs.

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

Les noms sontcamelCase.

bucket.bucketArn

Les noms sontsnake_case.

bucket.bucket_arn

Une méthode getter est fournie pour chaque propriété ; ces noms sontcamelCase.

bucket.getBucketArn()

Les noms sontPascalCase.

bucket.BucketArn

Les noms sontPascalCase.

bucket.BucketArn

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

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

Python ne possède pas de fonctionnalité d'interface. Cependant, pour le, AWS CDK vous pouvez indiquer l'implémentation de l'interface en décorant votre classe avec@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}");
    }
}

Les structures Go n'ont pas besoin de déclarer explicitement les interfaces qu'elles implémentent. Le compilateur Go détermine l'implémentation en fonction des méthodes et des propriétés disponibles sur la structure. Par exemple, dans le code suivant, MyAspect implémente l'IAspectinterface car elle fournit une Visit méthode qui prend une construction.

type MyAspect struct {
}

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