Importer et utiliser des constructions Construisez des niveaux Définition de constructions Travailler avec des constructions Utilisation de constructions tierces En savoir plus

AWS CDK Constructions

Les constructions sont les éléments de base des AWS Cloud Development Kit (AWS CDK) applications. Une construction est un composant de votre application qui représente une ou plusieurs AWS CloudFormation ressources et leur configuration. Vous créez votre application, pièce par pièce, en important et en configurant des constructions.

Importer et utiliser des constructions

Les constructions sont des classes que vous importez dans vos CDK applications depuis la bibliothèque de AWS constructions. Vous pouvez également créer et distribuer vos propres constructions, ou utiliser des constructions créées par des développeurs tiers.

Les constructions font partie du modèle de programmation des constructions (CPM). Ils peuvent être utilisés avec d'autres outils tels CDK que Terraform (CDKtf), CDK pour Kubernetes (CDK8s), et Projen.

De nombreux tiers ont également publié des constructions compatibles avec le AWS CDK. Visitez Construct Hub pour découvrir l'écosystème AWS CDK des partenaires de construction.

Construisez des niveaux

Les constructions de la bibliothèque AWS de constructions sont classées en trois niveaux. Chaque niveau offre un niveau d'abstraction croissant. Plus l'abstraction est élevée, plus la configuration est facile et nécessite moins d'expertise. Plus l'abstraction est faible, plus la personnalisation est importante, ce qui nécessite plus d'expertise.

Constructions de niveau 1 (L1)

Les constructions L1, également appelées CFNressources, sont les constructions de niveau inférieur et n'offrent aucune abstraction. Chaque construction L1 renvoie directement à une seule AWS CloudFormation ressource. Avec les constructions L1, vous importez une construction qui représente une ressource spécifique AWS CloudFormation . Vous définissez ensuite les propriétés de la ressource dans votre instance de construction.

Les constructions L1 sont idéales à utiliser lorsque vous connaissez les propriétés de vos AWS ressources AWS CloudFormation et que vous avez besoin d'un contrôle total sur leur définition.

Dans la AWS bibliothèque de constructions, les constructions L1 sont nommées en commençant parCfn, suivi d'un identifiant pour la AWS CloudFormation ressource qu'elles représentent. Par exemple, la CfnBucket construction est une construction L1 qui représente une AWS::S3::Bucket AWS CloudFormation ressource.

Les constructions L1 sont générées à partir de la spécification de la AWS CloudFormation ressource. Si une ressource existe dans AWS CloudFormation, elle sera disponible AWS CDK sous forme de construction L1. Les nouvelles ressources ou propriétés peuvent prendre jusqu'à une semaine pour être disponibles dans la bibliothèque AWS Construct. Pour plus d'informations, consultez la référence aux types de AWS ressources et de propriétés dans le guide de AWS CloudFormation l'utilisateur.

Constructions de niveau 2 (L2)

Les constructions L2, également appelées constructions sélectionnées, sont développées avec soin par l'CDKéquipe et sont généralement le type de construction le plus utilisé. Les constructions L2 correspondent directement à des AWS CloudFormation ressources uniques, comme les constructions L1. Par rapport aux constructions L1, les constructions L2 fournissent une abstraction de niveau supérieur grâce à une approche intuitive basée sur l'intention. API Les constructions L2 incluent des configurations de propriétés par défaut judicieuses, des politiques de sécurité conformes aux meilleures pratiques et génèrent une grande partie du code standard et de la logique de collage pour vous.

Les constructions L2 fournissent également des méthodes d'assistance pour la plupart des ressources qui simplifient et accélèrent la définition des propriétés, des autorisations, des interactions basées sur des événements entre les ressources, etc.

La s3.Bucket classe est un exemple de construction L2 pour une ressource de bucket Amazon Simple Storage Service (Amazon S3).

La AWS bibliothèque de constructions contient des constructions L2 désignées comme stables et prêtes à être utilisées en production. Pour les constructions L2 en cours de développement, elles sont désignées comme expérimentales et proposées dans un module distinct.

Constructions de niveau 3 (L3)

Les constructions L3, également appelées modèles, constituent le plus haut niveau d'abstraction. Chaque construction L3 peut contenir un ensemble de ressources configurées pour fonctionner ensemble afin d'accomplir une tâche ou un service spécifique au sein de votre application. Les constructions L3 sont utilisées pour créer des AWS architectures complètes pour des cas d'utilisation particuliers dans votre application.

Pour fournir des conceptions de système complètes ou des parties importantes d'un système plus vaste, les constructions L3 proposent des configurations de propriétés par défaut bien définies. Ils sont construits autour d'une approche particulière visant à résoudre un problème et à fournir une solution. Avec les constructions L3, vous pouvez créer et configurer plusieurs ressources rapidement, avec un minimum d'entrées et de code.

La ecsPatterns.ApplicationLoadBalancedFargateService classe est un exemple de construction L3 qui représente un AWS Fargate service exécuté sur un cluster Amazon Elastic Container Service (AmazonECS) et dirigé par un équilibreur de charge d'application.

À l'instar des constructions L2, les constructions L3 prêtes à être utilisées en production sont incluses dans la bibliothèque de constructions. AWS Les modules en cours de développement sont proposés dans des modules distincts.

Définition de constructions

Montage

La composition est le modèle clé pour définir des abstractions de haut niveau par le biais de constructions. Une construction de haut niveau peut être composée d'un nombre quelconque de constructions de niveau inférieur. Du bas vers le haut, vous utilisez des structures pour organiser les AWS ressources individuelles que vous souhaitez déployer. Vous utilisez les abstractions qui conviennent à votre objectif, avec autant de niveaux que vous le souhaitez.

Avec la composition, vous définissez des composants réutilisables et vous les partagez comme n'importe quel autre code. Par exemple, une équipe peut définir une construction qui met en œuvre les meilleures pratiques de l'entreprise pour une table Amazon DynamoDB, notamment la sauvegarde, la réplication globale, le dimensionnement automatique et la surveillance. L'équipe peut partager le concept en interne avec d'autres équipes ou en public.

Les équipes peuvent utiliser des constructions comme n'importe quel autre package de bibliothèque. Lorsque la bibliothèque est mise à jour, les développeurs ont accès aux améliorations et aux corrections de bogues de la nouvelle version, comme pour toute autre bibliothèque de code.

Initialisation

Les constructions sont implémentées dans des classes qui étendent la classe de base Construct. Vous définissez une construction en instanciant la classe. Toutes les constructions prennent trois paramètres lorsqu'elles sont initialisées :

scope — Le parent ou le propriétaire de la construction. Il peut s'agir d'une pile ou d'une autre construction. La portée détermine la place de la construction dans l'arbre de construction. Vous devez généralement transmettre this self Python), qui représente l'objet actuel, pour le scope.
id — Identifiant qui doit être unique dans le champ d'application. L'identifiant sert d'espace de noms pour tout ce qui est défini dans la construction. Il est utilisé pour générer des identifiants uniques, tels que des noms de ressources et des éléments AWS CloudFormation logiquesIDs.

Les identifiants doivent uniquement être uniques au sein d'un périmètre. Cela vous permet d'instancier et de réutiliser des constructions sans vous soucier des constructions et des identifiants qu'elles peuvent contenir, et de composer des constructions sous forme d'abstractions de niveau supérieur. De plus, les portées permettent de faire référence à des groupes de constructions en une seule fois. Les exemples incluent le balisage ou la spécification de l'endroit où les constructions seront déployées.
props — Ensemble de propriétés ou d'arguments de mots clés, selon le langage, qui définissent la configuration initiale de la construction. Les constructions de niveau supérieur fournissent davantage de valeurs par défaut, et si tous les éléments accessoires sont facultatifs, vous pouvez complètement omettre le paramètre props.

Configuration

La plupart des constructions acceptent props comme troisième argument (ou en Python, des arguments de mots clés) une collection nom/valeur qui définit la configuration de la construction. L'exemple suivant définit un bucket avec le chiffrement AWS Key Management Service (AWS KMS) et l'hébergement statique de sites Web activés. Comme elle ne spécifie pas explicitement de clé de chiffrement, la Bucket construction en définit une nouvelle kms.Key et l'associe au bucket.

Interaction avec les constructions

Les constructions sont des classes qui étendent la classe Construct de base. Après avoir instancié une construction, l'objet de construction expose un ensemble de méthodes et de propriétés qui vous permettent d'interagir avec la construction et de la transmettre comme référence à d'autres parties du système.

Le AWS CDK framework n'impose aucune restriction sur APIs les constructions. Les auteurs peuvent définir ce API qu'ils veulent. Cependant, les AWS constructions incluses dans la AWS bibliothèque de constructions, telles ques3.Bucket, suivent les directives et les modèles courants. Cela permet d'offrir une expérience cohérente sur l'ensemble AWS des ressources.

La plupart AWS des constructions comportent un ensemble de méthodes d'octroi que vous pouvez utiliser pour accorder des autorisations AWS Identity and Access Management (IAM) sur cette construction à un principal. L'exemple suivant accorde au IAM groupe l'data-scienceautorisation de lire depuis le compartiment Amazon S3raw-data.

Un autre modèle courant est que AWS les constructions définissent l'un des attributs de la ressource à partir de données fournies ailleurs. Les attributs peuvent inclure les noms des ressources Amazon (ARNs), les noms ouURLs.

Le code suivant définit une AWS Lambda fonction et l'associe à une file d'attente Amazon Simple Queue Service (AmazonSQS) via une variable d'environnement. URL

TypeScript


const jobsQueue = new sqs.Queue(this, 'jobs');
const createJobLambda = new lambda.Function(this, 'create-job', {
  runtime: lambda.Runtime.NODEJS_18_X,
  handler: 'index.handler',
  code: lambda.Code.fromAsset('./create-job-lambda-code'),
  environment: {
    QUEUE_URL: jobsQueue.queueUrl
  }
});

JavaScript


const jobsQueue = new sqs.Queue(this, 'jobs');
const createJobLambda = new lambda.Function(this, 'create-job', {
  runtime: lambda.Runtime.NODEJS_18_X,
  handler: 'index.handler',
  code: lambda.Code.fromAsset('./create-job-lambda-code'),
  environment: {
    QUEUE_URL: jobsQueue.queueUrl
  }
});

Python


jobs_queue = sqs.Queue(self, "jobs")
create_job_lambda = lambda_.Function(self, "create-job",
    runtime=lambda_.Runtime.NODEJS_18_X,
    handler="index.handler",
    code=lambda_.Code.from_asset("./create-job-lambda-code"),
    environment=dict(
        QUEUE_URL=jobs_queue.queue_url
    )
)

Java


final Queue jobsQueue = new Queue(this, "jobs");
Function createJobLambda = Function.Builder.create(this, "create-job")
                .handler("index.handler")
                .code(Code.fromAsset("./create-job-lambda-code"))
                .environment(java.util.Map.of(   // Map.of is Java 9 or later
                    "QUEUE_URL", jobsQueue.getQueueUrl())
                .build();

C#


var jobsQueue = new Queue(this, "jobs");
var createJobLambda = new Function(this, "create-job", new FunctionProps
{
    Runtime = Runtime.NODEJS_18_X,
    Handler = "index.handler",
    Code = Code.FromAsset(@".\create-job-lambda-code"),
    Environment = new Dictionary<string, string>
    {
        ["QUEUE_URL"] = jobsQueue.QueueUrl
    }
});

Go


	createJobLambda := awslambda.NewFunction(stack, jsii.String("create-job"), &awslambda.FunctionProps{
		Runtime: awslambda.Runtime_NODEJS_18_X(),
		Handler: jsii.String("index.handler"),
		Code:    awslambda.Code_FromAsset(jsii.String(".\\create-job-lambda-code"), nil),
		Environment: &map[string]*string{
			"QUEUE_URL": jsii.String(*jobsQueue.QueueUrl()),
		},
	})

Pour plus d'informations sur les API modèles les plus courants de la bibliothèque AWS Construct, consultezLes ressources et le AWS CDK.

Structure de l'application et de la pile

Les Stack classes App et de la bibliothèque AWS de constructions sont des constructions uniques. Comparées à d'autres constructions, elles ne configurent pas AWS les ressources par elles-mêmes. Ils sont plutôt utilisés pour fournir un contexte à vos autres constructions. Toutes les constructions qui représentent AWS des ressources doivent être définies, directement ou indirectement, dans le cadre d'une Stack construction. Stackles constructions sont définies dans le cadre d'une App construction.

Pour en savoir plus sur CDK les applications, voirAWS CDK applications. Pour en savoir plus sur les CDK piles, consultezAWS CDK piles.

L'exemple suivant définit une application avec une pile unique. Au sein de la pile, une construction L2 est utilisée pour configurer une ressource de compartiment Amazon S3.

TypeScript


import { App, Stack, StackProps } from 'aws-cdk-lib';
import * as s3 from 'aws-cdk-lib/aws-s3';

class HelloCdkStack extends Stack {
  constructor(scope: App, id: string, props?: StackProps) {
    super(scope, id, props);

    new s3.Bucket(this, 'MyFirstBucket', {
      versioned: true
    });
  }
}

const app = new App();
new HelloCdkStack(app, "HelloCdkStack");

JavaScript


const { App , Stack } = require('aws-cdk-lib');
const s3 = require('aws-cdk-lib/aws-s3');

class HelloCdkStack extends Stack {
  constructor(scope, id, props) {
    super(scope, id, props);

    new s3.Bucket(this, 'MyFirstBucket', {
      versioned: true
    });
  }
}

const app = new App();
new HelloCdkStack(app, "HelloCdkStack");

Python


from aws_cdk import App, Stack
import aws_cdk.aws_s3 as s3
from constructs import Construct

class HelloCdkStack(Stack):

    def __init__(self, scope: Construct, id: str, **kwargs) -> None:
        super().__init__(scope, id, **kwargs)

        s3.Bucket(self, "MyFirstBucket", versioned=True)

app = App()
HelloCdkStack(app, "HelloCdkStack")

Java

Pile définie dans HelloCdkStack.java le fichier :


import software.constructs.Construct;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;
import software.amazon.awscdk.services.s3.*;

public class HelloCdkStack extends Stack {
    public HelloCdkStack(final Construct scope, final String id) {
        this(scope, id, null);
    }

    public HelloCdkStack(final Construct scope, final String id, final StackProps props) {
        super(scope, id, props);

        Bucket.Builder.create(this, "MyFirstBucket")
            .versioned(true).build();
    }
}

Application définie dans HelloCdkApp.java le fichier :


import software.amazon.awscdk.App;
import software.amazon.awscdk.StackProps;

public class HelloCdkApp {
    public static void main(final String[] args) {
        App app = new App();

        new HelloCdkStack(app, "HelloCdkStack", StackProps.builder()
                .build());

        app.synth();
    }
}

C#


using Amazon.CDK;
using Amazon.CDK.AWS.S3;

namespace HelloCdkApp
{
    internal static class Program
    {
        public static void Main(string[] args)
        {
            var app = new App();
            new HelloCdkStack(app, "HelloCdkStack");
            app.Synth();
        }
    }
    
    public class HelloCdkStack : Stack
    {
        public HelloCdkStack(Construct scope, string id, IStackProps props=null) : base(scope, id, props)
        {
            new Bucket(this, "MyFirstBucket", new BucketProps { Versioned = true });
        }
    }
}

Go


func NewHelloCdkStack(scope constructs.Construct, id string, props *HelloCdkStackProps) awscdk.Stack {
	var sprops awscdk.StackProps
	if props != nil {
		sprops = props.StackProps
	}
	stack := awscdk.NewStack(scope, &id, &sprops)

	awss3.NewBucket(stack, jsii.String("MyFirstBucket"), &awss3.BucketProps{
		Versioned: jsii.Bool(true),
	})

	return stack
}

Travailler avec des constructions

Utilisation des constructions L1

Les constructions L1 mappent directement aux ressources individuelles AWS CloudFormation . Vous devez fournir la configuration requise pour la ressource.

Dans cet exemple, nous créons un bucket objet à l'aide de la construction CfnBucket L1 :

Les propriétés de construction qui ne sont pas de simples booléens, chaînes, nombres ou conteneurs sont traitées différemment dans les langues prises en charge.

TypeScript


const bucket = new s3.CfnBucket(this, "amzn-s3-demo-bucket", {
  bucketName: "amzn-s3-demo-bucket",
  corsConfiguration: {
    corsRules: [{
          allowedOrigins: ["*"],
          allowedMethods: ["GET"]
    }]
  }
});

JavaScript


const bucket = new s3.CfnBucket(this, "amzn-s3-demo-bucket", {
  bucketName: "amzn-s3-demo-bucket",
  corsConfiguration: {
    corsRules: [{
          allowedOrigins: ["*"],
          allowedMethods: ["GET"]
    }]
  }
});

Python

En Python, ces propriétés sont représentées par des types définis comme des classes internes de la construction L1. Par exemple, la propriété optionnelle cors_configuration de a CfnBucket nécessite un wrapper de typeCfnBucket.CorsConfigurationProperty. Ici, nous définissons cors_configuration sur une CfnBucket instance.


bucket = CfnBucket(self, "amzn-s3-demo-bucket", bucket_name="amzn-s3-demo-bucket",
    cors_configuration=CfnBucket.CorsConfigurationProperty(
        cors_rules=[CfnBucket.CorsRuleProperty(
            allowed_origins=["*"],
            allowed_methods=["GET"]
        )]
    )
)

Java

En Java, ces propriétés sont représentées par des types définis comme des classes internes de la construction L1. Par exemple, la propriété optionnelle corsConfiguration de a CfnBucket nécessite un wrapper de typeCfnBucket.CorsConfigurationProperty. Ici, nous définissons corsConfiguration sur une CfnBucket instance.


CfnBucket bucket = CfnBucket.Builder.create(this, "amzn-s3-demo-bucket")
                        .bucketName("amzn-s3-demo-bucket")
                        .corsConfiguration(new CfnBucket.CorsConfigurationProperty.Builder()
                            .corsRules(Arrays.asList(new CfnBucket.CorsRuleProperty.Builder()
                                .allowedOrigins(Arrays.asList("*"))
                                .allowedMethods(Arrays.asList("GET"))
                                .build()))
                            .build())
                        .build();

C#

En C#, ces propriétés sont représentées par des types définis comme des classes internes de la construction L1. Par exemple, la propriété optionnelle CorsConfiguration de a CfnBucket nécessite un wrapper de typeCfnBucket.CorsConfigurationProperty. Ici, nous définissons CorsConfiguration sur une CfnBucket instance.


var bucket = new CfnBucket(this, "amzn-s3-demo-bucket", new CfnBucketProps
{
    BucketName = "amzn-s3-demo-bucket",
    CorsConfiguration = new CfnBucket.CorsConfigurationProperty
    {
        CorsRules = new object[] {
            new CfnBucket.CorsRuleProperty
            {
                AllowedOrigins = new string[] { "*" },
                AllowedMethods = new string[] { "GET" },
            }
        }
    }
});

Go

Dans Go, ces types sont nommés à l'aide du nom de la construction L1, d'un trait de soulignement et du nom de la propriété. Par exemple, la propriété optionnelle CorsConfiguration de a CfnBucket nécessite un wrapper de typeCfnBucket_CorsConfigurationProperty. Ici, nous définissons CorsConfiguration sur une CfnBucket instance.


	awss3.NewCfnBucket(stack, jsii.String("amzn-s3-demo-bucket"), &awss3.CfnBucketProps{
		BucketName: jsii.String("amzn-s3-demo-bucket"),
		CorsConfiguration: &awss3.CfnBucket_CorsConfigurationProperty{
			CorsRules: []awss3.CorsRule{
				awss3.CorsRule{
					AllowedOrigins: jsii.Strings("*"),
					AllowedMethods: &[]awss3.HttpMethods{"GET"},
				},
			},
		},
	})

Important

Vous ne pouvez pas utiliser de types de propriétés L2 avec des constructions L1, ou vice versa. Lorsque vous travaillez avec des constructions L1, utilisez toujours les types définis pour la construction L1 que vous utilisez. N'utilisez pas de types provenant d'autres constructions L1 (certains peuvent porter le même nom, mais ils ne sont pas du même type).

Certaines de nos API références spécifiques au langage contiennent actuellement des erreurs dans les chemins d'accès aux types de propriétés L1, ou ne documentent pas du tout ces classes. Nous espérons pouvoir régler ce problème bientôt. En attendant, n'oubliez pas que ces types sont toujours des classes internes de la construction L1 avec laquelle ils sont utilisés.

Utilisation de constructions L2

Dans l'exemple suivant, nous définissons un compartiment Amazon S3 en créant un objet à partir de la construction BucketL2 :

MyFirstBucketn'est pas le nom du bucket qui est AWS CloudFormation créé. Il s'agit d'un identifiant logique attribué à la nouvelle construction dans le contexte de votre CDK application. La physicalNamevaleur sera utilisée pour nommer la AWS CloudFormation ressource.

Utilisation de constructions tierces

Construct Hub est une ressource qui vous aidera à découvrir des constructions supplémentaires provenant de AWS tiers et de la communauté open sourceCDK.

Rédaction de vos propres constructions

En plus d'utiliser des constructions existantes, vous pouvez également écrire vos propres constructions et permettre à n'importe qui de les utiliser dans ses applications. Toutes les constructions sont égales dans le AWS CDK. Les constructions de la AWS bibliothèque de constructions sont traitées de la même manière qu'une construction d'une bibliothèque tierce publiée via NPM, Maven, ou PyPI. Les constructions publiées dans le référentiel de packages interne de votre entreprise sont également traitées de la même manière.

Pour déclarer une nouvelle construction, créez une classe qui étend la classe de base Construct, dans le constructs package, puis suivez le modèle pour les arguments de l'initialiseur.

L'exemple suivant montre comment déclarer une construction qui représente un compartiment Amazon S3. Le compartiment S3 envoie une notification Amazon Simple Notification Service (AmazonSNS) chaque fois que quelqu'un y télécharge un fichier.

TypeScript


export interface NotifyingBucketProps {
  prefix?: string;
}

export class NotifyingBucket extends Construct {
  constructor(scope: Construct, id: string, props: NotifyingBucketProps = {}) {
    super(scope, id);
    const bucket = new s3.Bucket(this, 'bucket');
    const topic = new sns.Topic(this, 'topic');
    bucket.addObjectCreatedNotification(new s3notify.SnsDestination(topic),
      { prefix: props.prefix });
  }
}

JavaScript


class NotifyingBucket extends Construct {
  constructor(scope, id, props = {}) {
    super(scope, id);
    const bucket = new s3.Bucket(this, 'bucket');
    const topic = new sns.Topic(this, 'topic');
    bucket.addObjectCreatedNotification(new s3notify.SnsDestination(topic),
      { prefix: props.prefix });
  }
}

module.exports = { NotifyingBucket }

Python


class NotifyingBucket(Construct):

    def __init__(self, scope: Construct, id: str, *, prefix=None):
        super().__init__(scope, id)
        bucket = s3.Bucket(self, "bucket")
        topic = sns.Topic(self, "topic")
        bucket.add_object_created_notification(s3notify.SnsDestination(topic),
            s3.NotificationKeyFilter(prefix=prefix))

Java


public class NotifyingBucket extends Construct {

    public NotifyingBucket(final Construct scope, final String id) {
        this(scope, id, null, null);
    }
    
    public NotifyingBucket(final Construct scope, final String id, final BucketProps props) {
        this(scope, id, props, null);
    }
    
    public NotifyingBucket(final Construct scope, final String id, final String prefix) {
        this(scope, id, null, prefix);
    }

    public NotifyingBucket(final Construct scope, final String id, final BucketProps props, final String prefix) {
        super(scope, id);

        Bucket bucket = new Bucket(this, "bucket");
        Topic topic = new Topic(this, "topic");
        if (prefix != null)
            bucket.addObjectCreatedNotification(new SnsDestination(topic),
                NotificationKeyFilter.builder().prefix(prefix).build());
     }
}

C#


public class NotifyingBucketProps : BucketProps
{
    public string Prefix { get; set; }
}

public class NotifyingBucket : Construct
{
    public NotifyingBucket(Construct scope, string id, NotifyingBucketProps props = null) : base(scope, id)
    {
        var bucket = new Bucket(this, "bucket");
        var topic = new Topic(this, "topic");
        bucket.AddObjectCreatedNotification(new SnsDestination(topic), new NotificationKeyFilter
        {
            Prefix = props?.Prefix
        });
    }
}

Go


type NotifyingBucketProps struct {
	awss3.BucketProps
	Prefix *string
}

func NewNotifyingBucket(scope constructs.Construct, id *string, props *NotifyingBucketProps) awss3.Bucket {
	var bucket awss3.Bucket
	if props == nil {
		bucket = awss3.NewBucket(scope, jsii.String(*id+"Bucket"), nil)
	} else {
		bucket = awss3.NewBucket(scope, jsii.String(*id+"Bucket"), &props.BucketProps)
	}
	topic := awssns.NewTopic(scope, jsii.String(*id+"Topic"), nil)
	if props == nil {
		bucket.AddObjectCreatedNotification(awss3notifications.NewSnsDestination(topic))
	} else {
		bucket.AddObjectCreatedNotification(awss3notifications.NewSnsDestination(topic), &awss3.NotificationKeyFilter{
			Prefix: props.Prefix,
		})
	}
	return bucket
}

Note

Notre NotifyingBucket construction n'hérite pas de Bucket mais plutôt deConstruct. Nous utilisons la composition, et non l'héritage, pour regrouper un compartiment Amazon S3 et un SNS sujet Amazon. En général, la composition est préférée à l'héritage lors du développement de AWS CDK constructions.

Le NotifyingBucket constructeur possède une signature de construction typique : scopeid, etprops. Le dernier argumentprops, est facultatif (obtient la valeur par défaut{}) car tous les accessoires sont facultatifs. (La Construct classe de base ne prend aucun props argument.) Vous pouvez définir une instance de cette construction dans votre application sansprops, par exemple :

Vous pouvez également utiliser props (en Java, un paramètre supplémentaire) pour spécifier le préfixe de chemin à filtrer, par exemple :

Généralement, vous souhaiterez également exposer certaines propriétés ou méthodes de vos constructions. Il n'est pas très utile d'avoir un sujet caché derrière votre construction, car les utilisateurs de votre construction ne peuvent pas s'y abonner. L'ajout d'une topic propriété permet aux consommateurs d'accéder au sujet interne, comme illustré dans l'exemple suivant :

TypeScript


export class NotifyingBucket extends Construct {
  public readonly topic: sns.Topic;

  constructor(scope: Construct, id: string, props: NotifyingBucketProps) {
    super(scope, id);
    const bucket = new s3.Bucket(this, 'bucket');
    this.topic = new sns.Topic(this, 'topic');
    bucket.addObjectCreatedNotification(new s3notify.SnsDestination(this.topic), { prefix: props.prefix });
  }
}

JavaScript


class NotifyingBucket extends Construct {

  constructor(scope, id, props) {
    super(scope, id);
    const bucket = new s3.Bucket(this, 'bucket');
    this.topic = new sns.Topic(this, 'topic');
    bucket.addObjectCreatedNotification(new s3notify.SnsDestination(this.topic), { prefix: props.prefix });
  }
}

module.exports = { NotifyingBucket };

Python


class NotifyingBucket(Construct):

    def __init__(self, scope: Construct, id: str, *, prefix=None, **kwargs):
        super().__init__(scope, id)
        bucket = s3.Bucket(self, "bucket")
        self.topic = sns.Topic(self, "topic")
        bucket.add_object_created_notification(s3notify.SnsDestination(self.topic),
            s3.NotificationKeyFilter(prefix=prefix))

Java


public class NotifyingBucket extends Construct {

    public Topic topic = null;
    
    public NotifyingBucket(final Construct scope, final String id) {
        this(scope, id, null, null);
    }
    
    public NotifyingBucket(final Construct scope, final String id, final BucketProps props) {
        this(scope, id, props, null);
    }
    
    public NotifyingBucket(final Construct scope, final String id, final String prefix) {
        this(scope, id, null, prefix);
    }

    public NotifyingBucket(final Construct scope, final String id, final BucketProps props, final String prefix) {
        super(scope, id);

        Bucket bucket = new Bucket(this, "bucket");
        topic = new Topic(this, "topic");
        if (prefix != null)
            bucket.addObjectCreatedNotification(new SnsDestination(topic),
                NotificationKeyFilter.builder().prefix(prefix).build());
     }
}

C#


public class NotifyingBucket : Construct
{
    public readonly Topic topic;

    public NotifyingBucket(Construct scope, string id, NotifyingBucketProps props = null) : base(scope, id)
    {
        var bucket = new Bucket(this, "bucket");
        topic = new Topic(this, "topic");
        bucket.AddObjectCreatedNotification(new SnsDestination(topic), new NotificationKeyFilter
        {
            Prefix = props?.Prefix
        });
    }
}

Go

Pour ce faire dans Go, nous aurons besoin d'un peu plus de plomberie. Notre NewNotifyingBucket fonction d'origine renvoyait unawss3.Bucket. Nous devrons étendre Bucket pour inclure un topic membre en créant une NotifyingBucket structure. Notre fonction renverra alors ce type.


type NotifyingBucket struct {
	awss3.Bucket
	topic awssns.Topic
}

func NewNotifyingBucket(scope constructs.Construct, id *string, props *NotifyingBucketProps) NotifyingBucket {
	var bucket awss3.Bucket
	if props == nil {
		bucket = awss3.NewBucket(scope, jsii.String(*id+"Bucket"), nil)
	} else {
		bucket = awss3.NewBucket(scope, jsii.String(*id+"Bucket"), &props.BucketProps)
	}
	topic := awssns.NewTopic(scope, jsii.String(*id+"Topic"), nil)
	if props == nil {
		bucket.AddObjectCreatedNotification(awss3notifications.NewSnsDestination(topic))
	} else {
		bucket.AddObjectCreatedNotification(awss3notifications.NewSnsDestination(topic), &awss3.NotificationKeyFilter{
			Prefix: props.Prefix,
		})
	}
	var nbucket NotifyingBucket
	nbucket.Bucket = bucket
	nbucket.topic = topic
	return nbucket
}

Désormais, les consommateurs peuvent s'abonner au sujet, par exemple :

En savoir plus

La vidéo suivante fournit un aperçu complet des CDK concepts et explique comment les utiliser dans vos CDK applications.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Piles

Environnements