Importieren und verwenden Sie Konstrukte Konstruiere Levels Konstrukte definieren Mit Konstrukten arbeiten Arbeiten mit Konstrukten von Drittanbietern Weitere Informationen

AWS CDK Konstrukte

Konstrukte sind die Grundbausteine von Anwendungen. AWS Cloud Development Kit (AWS CDK) Ein Konstrukt ist eine Komponente innerhalb Ihrer Anwendung, die eine oder mehrere AWS CloudFormation Ressourcen und deren Konfiguration darstellt. Sie erstellen Ihre Anwendung Stück für Stück, indem Sie Konstrukte importieren und konfigurieren.

Importieren und verwenden Sie Konstrukte

Konstrukte sind Klassen, die Sie aus der AWS Construct-Bibliothek in Ihre CDK Anwendungen importieren. Sie können auch Ihre eigenen Konstrukte erstellen und verteilen oder Konstrukte verwenden, die von Drittanbietern erstellt wurden.

Konstrukte sind Teil des Construct Programming Model (). CPM Sie können zusammen mit anderen Tools verwendet werden, z. B. für CDK Terraform (CDKtf), CDK für Kubernetes (CDK8s) und Projen.

Zahlreiche Dritte haben auch Konstrukte veröffentlicht, die mit dem AWS CDK kompatibel sind. Besuchen Sie Construct Hub, um das Ökosystem der AWS CDK Construct-Partner zu erkunden.

Konstruiere Levels

Konstrukte aus der AWS Construct Library sind in drei Stufen unterteilt. Jede Ebene bietet eine zunehmende Abstraktionsebene. Je höher die Abstraktion, desto einfacher ist die Konfiguration und erfordert weniger Fachwissen. Je niedriger die Abstraktion, desto mehr Anpassungen sind verfügbar und erfordern mehr Fachwissen.

Konstrukte der Stufe 1 (L1)

L1-Konstrukte, auch CFNRessourcen genannt, sind das Konstrukt der untersten Ebene und bieten keine Abstraktion. Jedes L1-Konstrukt ist direkt einer einzelnen Ressource zugeordnet. AWS CloudFormation Bei L1-Konstrukten importieren Sie ein Konstrukt, das eine bestimmte Ressource darstellt. AWS CloudFormation Anschließend definieren Sie die Eigenschaften der Ressource in Ihrer Konstruktinstanz.

L1-Konstrukte eignen sich hervorragend, wenn Sie mit der Definition Ihrer AWS Ressourceneigenschaften vertraut sind AWS CloudFormation und vollständige Kontrolle darüber benötigen.

In der AWS Construct-Bibliothek werden L1-Konstrukte beginnend mit benanntCfn, gefolgt von einem Bezeichner für die AWS CloudFormation Ressource, für die sie stehen. Das CfnBucket Konstrukt ist beispielsweise ein L1-Konstrukt, das eine Ressource darstellt. AWS::S3::Bucket AWS CloudFormation

L1-Konstrukte werden anhand der Ressourcenspezifikation generiert.AWS CloudFormation Wenn eine Ressource in existiert AWS CloudFormation, ist sie AWS CDK als L1-Konstrukt verfügbar. Es kann bis zu einer Woche dauern, bis neue Ressourcen oder Eigenschaften in der AWS Construct-Bibliothek verfügbar sind. Weitere Informationen finden Sie in der Referenz zu AWS Ressourcen- und Eigenschaftstypen im AWS CloudFormation Benutzerhandbuch.

Konstrukte der Ebene 2 (L2)

L2-Konstrukte, auch kuratierte Konstrukte genannt, wurden vom CDK Team sorgfältig entwickelt und sind in der Regel der am häufigsten verwendete Konstrukttyp. L2-Konstrukte werden, ähnlich wie L1-Konstrukte, direkt einzelnen Ressourcen zugeordnet. AWS CloudFormation Im Vergleich zu L1-Konstrukten bieten L2-Konstrukte eine Abstraktion auf höherer Ebene, da sie intuitiv auf Absichten basieren. API L2-Konstrukte beinhalten sinnvolle Standardkonfigurationen für Eigenschaften, bewährte Sicherheitsrichtlinien und generieren einen Großteil des Standardcodes und der Glue-Logik für Sie.

L2-Konstrukte bieten auch Hilfsmethoden für die meisten Ressourcen, mit denen Eigenschaften, Berechtigungen, ereignisbasierte Interaktionen zwischen Ressourcen und mehr einfacher und schneller definiert werden können.

Die s3.Bucket Klasse ist ein Beispiel für ein L2-Konstrukt für eine Bucket-Ressource von Amazon Simple Storage Service (Amazon S3).

Die AWS Construct-Bibliothek enthält L2-Konstrukte, die als stabil und produktionsbereit gekennzeichnet sind. L2-Konstrukte, die sich in der Entwicklung befinden, werden als experimentell eingestuft und in einem separaten Modul angeboten.

Konstrukte der Stufe 3 (L3)

L3-Konstrukte, auch Muster genannt, stellen die höchste Abstraktionsebene dar. Jedes L3-Konstrukt kann eine Sammlung von Ressourcen enthalten, die so konfiguriert sind, dass sie zusammenarbeiten, um eine bestimmte Aufgabe oder einen bestimmten Dienst innerhalb Ihrer Anwendung auszuführen. L3-Konstrukte werden verwendet, um ganze AWS Architekturen für bestimmte Anwendungsfälle in Ihrer Anwendung zu erstellen.

Um komplette Systementwürfe oder wesentliche Teile eines größeren Systems bereitzustellen, bieten L3-Konstrukte individuelle Standardkonfigurationen für Eigenschaften. Sie basieren auf einem bestimmten Ansatz zur Lösung eines Problems und zur Bereitstellung einer Lösung. Mit L3-Konstrukten können Sie schnell und mit dem geringsten Aufwand an Eingabe und Code mehrere Ressourcen erstellen und konfigurieren.

Die ecsPatterns.ApplicationLoadBalancedFargateService Klasse ist ein Beispiel für ein L3-Konstrukt, das einen AWS Fargate Service darstellt, der auf einem Amazon Elastic Container Service (AmazonECS) -Cluster ausgeführt wird und von einem Application Load Balancer unterstützt wird.

Ähnlich wie L2-Konstrukte sind L3-Konstrukte, die für den produktiven Einsatz bereit sind, in der Construct Library enthalten. AWS Diejenigen, die sich in der Entwicklung befinden, werden in separaten Modulen angeboten.

Konstrukte definieren

Composition

Die Komposition ist das Schlüsselmuster für die Definition von Abstraktionen auf höherer Ebene durch Konstrukte. Ein Konstrukt auf hoher Ebene kann aus einer beliebigen Anzahl von Konstrukten niedrigerer Ebenen zusammengesetzt werden. Von unten nach oben betrachtet, verwenden Sie Konstrukte, um die einzelnen AWS Ressourcen zu organisieren, die Sie bereitstellen möchten. Sie verwenden die für Ihren Zweck geeigneten Abstraktionen mit so vielen Ebenen, wie Sie benötigen.

Bei der Komposition definieren Sie wiederverwendbare Komponenten und teilen sie wie jeden anderen Code. Ein Team kann beispielsweise ein Konstrukt definieren, das die Best Practices des Unternehmens für eine Amazon DynamoDB-Tabelle implementiert, einschließlich Backup, globaler Replikation, automatischer Skalierung und Überwachung. Das Team kann das Konstrukt intern mit anderen Teams oder öffentlich teilen.

Teams können Konstrukte wie jedes andere Bibliothekspaket verwenden. Wenn die Bibliothek aktualisiert wird, erhalten Entwickler Zugriff auf die Verbesserungen und Bugfixes der neuen Version, ähnlich wie bei jeder anderen Codebibliothek.

Initialisierung

Konstrukte werden in Klassen implementiert, die die Construct-Basisklasse erweitern. Sie definieren ein Konstrukt, indem Sie die Klasse instanziieren. Alle Konstrukte benötigen drei Parameter, wenn sie initialisiert werden:

Gültigkeitsbereich — Das übergeordnete Objekt oder der Eigentümer des Konstrukts. Dies kann entweder ein Stapel oder ein anderes Konstrukt sein. Der Geltungsbereich bestimmt die Position des Konstrukts im Konstruktbaum. In der Regel sollten Sie bestehen this (self Python), das das aktuelle Objekt für den Gültigkeitsbereich darstellt.
id — Ein Bezeichner, der innerhalb des Gültigkeitsbereichs eindeutig sein muss. Der Bezeichner dient als Namespace für alles, was innerhalb des Konstrukts definiert ist. Er wird verwendet, um eindeutige Bezeichner wie Ressourcennamen und AWS CloudFormation logische Bezeichner zu generieren. IDs

Identifikatoren müssen nur innerhalb eines Bereichs eindeutig sein. Auf diese Weise können Sie Konstrukte instanziieren und wiederverwenden, ohne sich Gedanken über die darin enthaltenen Konstrukte und Bezeichner machen zu müssen. Außerdem können Sie Konstrukte zu Abstraktionen auf höherer Ebene zusammensetzen. Darüber hinaus ermöglichen Gültigkeitsbereiche, auf Gruppen von Konstrukten gleichzeitig zu verweisen. Beispiele hierfür sind das Markieren oder die Angabe, wo die Konstrukte eingesetzt werden sollen.
props — Je nach Sprache eine Reihe von Eigenschaften oder Schlüsselwortargumenten, die die ursprüngliche Konfiguration des Konstrukts definieren. Konstrukte auf höherer Ebene bieten mehr Standardwerte, und wenn alle Prop-Elemente optional sind, können Sie den Parameter props komplett weglassen.

Konfiguration

Die meisten Konstrukte akzeptieren props als drittes Argument (oder in Python Schlüsselwortargumente) eine Name/Wertesammlung, die die Konfiguration des Konstrukts definiert. Das folgende Beispiel definiert einen Bucket mit aktivierter AWS Key Management Service (AWS KMS) -Verschlüsselung und aktiviertem statischem Website-Hosting. Da es nicht explizit einen Verschlüsselungsschlüssel spezifiziert, definiert das Bucket Konstrukt einen neuen kms.Key und ordnet ihn dem Bucket zu.

Interaktion mit Konstrukten

Konstrukte sind Klassen, die die Basisklasse Construct erweitern. Nachdem Sie ein Konstrukt instanziiert haben, stellt das Konstruktobjekt eine Reihe von Methoden und Eigenschaften zur Verfügung, mit denen Sie mit dem Konstrukt interagieren und es als Referenz an andere Teile des Systems weitergeben können.

Das AWS CDK Framework schränkt die Anzahl der Konstrukte nicht ein. APIs Autoren können jedes definieren, was API sie wollen. Die AWS Konstrukte, die in der AWS Construct-Bibliothek enthalten sinds3.Bucket, folgen jedoch Richtlinien und gängigen Mustern. Dadurch wird ein einheitliches Benutzererlebnis für alle AWS Ressourcen gewährleistet.

Die meisten AWS Konstrukte verfügen über eine Reihe von Grant-Methoden, mit denen Sie einem Prinzipal AWS Identity and Access Management (IAM) -Berechtigungen für dieses Konstrukt gewähren können. Das folgende Beispiel erteilt der IAM Gruppe die data-science Berechtigung, aus dem Amazon S3 S3-Bucket zu lesenraw-data.

Ein anderes gängiges Muster besteht darin, dass AWS Konstrukte eines der Ressourcenattribute anhand von Daten festlegen, die an anderer Stelle bereitgestellt wurden. Zu den Attributen können Amazon Resource Names (ARNs), Namen oder gehörenURLs.

Der folgende Code definiert eine AWS Lambda Funktion und ordnet sie einer Amazon Simple Queue Service (AmazonSQS) -Warteschlange über die Warteschlange URL in einer Umgebungsvariablen zu.

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

Informationen zu den gängigsten API Mustern in der AWS Construct Library finden Sie unterRessourcen und die AWS CDK.

Die App und das Stack-Konstrukt

Die Stack Klassen App und aus der AWS Construct-Bibliothek sind einzigartige Konstrukte. Im Vergleich zu anderen Konstrukten konfigurieren sie AWS Ressourcen nicht eigenständig. Stattdessen werden sie verwendet, um Kontext für Ihre anderen Konstrukte bereitzustellen. Alle Konstrukte, die AWS Ressourcen darstellen, müssen direkt oder indirekt im Rahmen eines Stack Konstrukts definiert werden. StackKonstrukte werden innerhalb des Gültigkeitsbereichs eines App Konstrukts definiert.

Weitere Informationen zu CDK Apps finden Sie unterAWS CDK Apps. Weitere Informationen zu CDK Stacks finden Sie unterAWS CDK Stapel.

Das folgende Beispiel definiert eine App mit einem einzigen Stack. Innerhalb des Stacks wird ein L2-Konstrukt verwendet, um eine Amazon S3 S3-Bucket-Ressource zu konfigurieren.

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

In der HelloCdkStack.java Datei definierter Stack:


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

In der HelloCdkApp.java Datei definierte App:


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
}

Mit Konstrukten arbeiten

Mit L1-Konstrukten arbeiten

L1-Konstrukte sind direkt einzelnen Ressourcen zugeordnet. AWS CloudFormation Sie müssen die für die Ressource erforderliche Konfiguration angeben.

In diesem Beispiel erstellen wir ein bucket Objekt mit dem CfnBucket L1-Konstrukt:

Konstrukteigenschaften, bei denen es sich nicht um einfache Boolesche Werte, Zeichenketten, Zahlen oder Container handelt, werden in den unterstützten Sprachen unterschiedlich behandelt.

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

In Python werden diese Eigenschaften durch Typen repräsentiert, die als innere Klassen des L1-Konstrukts definiert sind. Beispielsweise CfnBucket erfordert die optionale Eigenschaft cors_configuration von a einen Wrapper des Typs. CfnBucket.CorsConfigurationProperty Hier definieren wir für cors_configuration eine CfnBucket Instanz.


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

In Java werden diese Eigenschaften durch Typen repräsentiert, die als innere Klassen des L1-Konstrukts definiert sind. Zum Beispiel CfnBucket erfordert die optionale Eigenschaft corsConfiguration von a einen Wrapper vom Typ. CfnBucket.CorsConfigurationProperty Hier definieren wir für corsConfiguration eine CfnBucket Instanz.


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#

In C# werden diese Eigenschaften durch Typen repräsentiert, die als innere Klassen des L1-Konstrukts definiert sind. Beispielsweise CfnBucket erfordert die optionale Eigenschaft CorsConfiguration von a einen Wrapper des Typs. CfnBucket.CorsConfigurationProperty Hier definieren wir für CorsConfiguration eine CfnBucket Instanz.


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

In Go werden diese Typen mit dem Namen des L1-Konstrukts, einem Unterstrich und dem Eigenschaftsnamen benannt. Beispielsweise CfnBucket erfordert die optionale Eigenschaft CorsConfiguration von a einen Wrapper des Typs. CfnBucket_CorsConfigurationProperty Hier definieren wir für CorsConfiguration eine CfnBucket Instanz.


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

Wichtig

Sie können L2-Eigenschaftstypen nicht mit L1-Konstrukten verwenden oder umgekehrt. Verwenden Sie bei der Arbeit mit L1-Konstrukten immer die Typen, die für das verwendete L1-Konstrukt definiert sind. Verwenden Sie keine Typen aus anderen L1-Konstrukten (einige haben möglicherweise denselben Namen, sind aber nicht vom gleichen Typ).

Einige unserer sprachspezifischen API Referenzen enthalten derzeit Fehler in den Pfaden zu L1-Eigenschaftstypen oder dokumentieren diese Klassen überhaupt nicht. Wir hoffen, das bald beheben zu können. Denken Sie in der Zwischenzeit daran, dass solche Typen immer innere Klassen des L1-Konstrukts sind, mit dem sie verwendet werden.

Mit L2-Konstrukten arbeiten

Im folgenden Beispiel definieren wir einen Amazon S3 S3-Bucket, indem wir ein Objekt aus dem BucketL2-Konstrukt erstellen:

MyFirstBucketist nicht der Name des Buckets, der AWS CloudFormation erstellt wird. Es ist eine logische Kennung, die dem neuen Konstrukt im Kontext Ihrer CDK App zugewiesen wird. Der physicalNameWert wird verwendet, um die AWS CloudFormation Ressource zu benennen.

Arbeiten mit Konstrukten von Drittanbietern

Construct Hub ist eine Ressource, die Ihnen hilft AWS, weitere Konstrukte von Drittanbietern und der CDK Open-Source-Community zu entdecken.

Schreiben Sie Ihre eigenen Konstrukte

Sie können nicht nur bestehende Konstrukte verwenden, sondern auch Ihre eigenen Konstrukte schreiben und sie von jedem in seinen Apps verwenden lassen. Alle Konstrukte sind gleich in der. AWS CDK Konstrukte aus der AWS Konstruktbibliothek werden genauso behandelt wie Konstrukte aus einer Bibliothek eines Drittanbieters, die über veröffentlicht wurden NPM, Maven, oder PyPI. Konstrukte, die im internen Paket-Repository Ihres Unternehmens veröffentlicht wurden, werden ebenfalls auf die gleiche Weise behandelt.

Um ein neues Konstrukt zu deklarieren, erstellen Sie im constructs Paket eine Klasse, die die Construct-Basisklasse erweitert, und folgen Sie dann dem Muster für Initialisierungsargumente.

Das folgende Beispiel zeigt, wie ein Konstrukt deklariert wird, das einen Amazon S3 S3-Bucket darstellt. Der S3-Bucket sendet jedes Mal, wenn jemand eine Datei in ihn hochlädt, eine Amazon Simple Notification Service (AmazonSNS) -Benachrichtigung.

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
}

Anmerkung

Unser NotifyingBucket Konstrukt erbt nicht vonBucket, sondern von. Construct Wir verwenden Komposition, nicht Vererbung, um einen Amazon S3 S3-Bucket und ein SNS Amazon-Thema zu bündeln. Im Allgemeinen wird bei der Entwicklung von AWS CDK Konstrukten die Komposition der Vererbung vorgezogen.

Der NotifyingBucket Konstruktor hat eine typische Konstruktsignatur: scopeid, und. props Das letzte Argument,props, ist optional (erhält den Standardwert{}), da alle Requisiten optional sind. (Die Construct Basisklasse akzeptiert kein props Argument.) Sie könnten eine Instanz dieses Konstrukts in Ihrer App definierenprops, ohne zum Beispiel:

Oder Sie könnten props (in Java einen zusätzlichen Parameter) verwenden, um das Pfadpräfix anzugeben, nach dem gefiltert werden soll, zum Beispiel:

In der Regel möchten Sie auch einige Eigenschaften oder Methoden für Ihre Konstrukte verfügbar machen. Es ist nicht sehr nützlich, ein Thema hinter Ihrem Konstrukt zu verstecken, da Benutzer Ihres Konstrukts es nicht abonnieren können. Durch das Hinzufügen einer topic Eigenschaft können Verbraucher auf das innere Thema zugreifen, wie im folgenden Beispiel gezeigt wird:

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

Um dies in Go zu tun, benötigen wir ein wenig zusätzliche Klempnerarbeiten. Unsere ursprüngliche NewNotifyingBucket Funktion gab eine awss3.Bucket zurück. Wir müssen die Erweiterung Bucket um ein topic Mitglied erweitern, indem wir eine NotifyingBucket Struktur erstellen. Unsere Funktion gibt dann diesen Typ zurück.


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
}

Jetzt können Verbraucher das Thema abonnieren, zum Beispiel:

Weitere Informationen

Das folgende Video bietet einen umfassenden Überblick über CDK Konstrukte und erklärt, wie Sie sie in Ihren CDK Apps verwenden können.

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Stacks

Umgebungen