Importa e usa costrutti Costruisci livelli Definizione dei costrutti Lavorare con i costrutti Lavorare con costrutti di terze parti Ulteriori informazioni

AWS CDK Costrutti

I costrutti sono gli elementi costitutivi di base delle AWS Cloud Development Kit (AWS CDK) applicazioni. Un costrutto è un componente all'interno dell'applicazione che rappresenta una o più AWS CloudFormation risorse e la loro configurazione. Puoi creare la tua applicazione, pezzo per pezzo, importando e configurando costrutti.

Importa e usa costrutti

I costrutti sono classi che importate nelle CDK applicazioni dalla AWS Construct Library. È inoltre possibile creare e distribuire costrutti personalizzati o utilizzare costrutti creati da sviluppatori di terze parti.

I costrutti fanno parte del Construct Programming Model (). CPM Sono disponibili per l'uso con altri strumenti come per CDK Terraform (CDKtf), CDK per Kubernetes (CDK8s) e Projen.

Numerose terze parti hanno inoltre pubblicato costrutti compatibili con. AWS CDK Visita Construct Hub per esplorare l'ecosistema di partner di AWS CDK construct.

Costruisci livelli

I costrutti della AWS Construct Library sono suddivisi in tre livelli. Ogni livello offre un livello crescente di astrazione. Maggiore è l'astrazione, più facile è la configurazione e richiede meno esperienza. Più bassa è l'astrazione, maggiore è la personalizzazione disponibile, che richiede maggiore esperienza.

Costrutti di livello 1 (L1)

I costrutti L1, noti anche come CFNrisorse, sono i costrutti di livello più basso e non offrono alcuna astrazione. Ogni costrutto L1 è mappato direttamente su una singola risorsa. AWS CloudFormation Con i costrutti L1, si importa un costrutto che rappresenta una risorsa specifica. AWS CloudFormation Definite quindi le proprietà della risorsa all'interno dell'istanza del costrutto.

I costrutti L1 sono ottimi da usare quando si ha familiarità AWS CloudFormation e si ha bisogno del controllo completo sulla definizione delle proprietà delle risorse. AWS

Nella AWS Construct Library, i costrutti L1 sono denominati a partire daCfn, seguiti da un identificatore per la risorsa che rappresentano. AWS CloudFormation Ad esempio, il CfnBucket costrutto è un costrutto L1 che rappresenta una risorsa. AWS::S3::Bucket AWS CloudFormation

I costrutti L1 vengono generati dalla specifica della risorsa.AWS CloudFormation Se una risorsa esiste in AWS CloudFormation, sarà disponibile AWS CDK come costrutto L1. La disponibilità di nuove risorse o proprietà nella AWS Construct Library può richiedere fino a una settimana. Per ulteriori informazioni, consultate il riferimento ai tipi di AWS risorse e proprietà nella Guida per l'AWS CloudFormation utente.

Costrutti di livello 2 (L2)

I costrutti L2, noti anche come costrutti curati, sono sviluppati con cura dal CDK team e di solito sono il tipo di costrutto più utilizzato. I costrutti L2 vengono mappati direttamente su singole risorse, in modo simile ai costrutti L1. AWS CloudFormation Rispetto ai costrutti L1, i costrutti L2 forniscono un'astrazione di livello superiore attraverso un approccio intuitivo basato sugli intenti. API I costrutti L2 includono configurazioni sensate delle proprietà predefinite, politiche di sicurezza basate sulle migliori pratiche e generano automaticamente gran parte del codice standard e della logica di incollaggio.

I costrutti L2 forniscono anche metodi di supporto per la maggior parte delle risorse che semplificano e velocizzano la definizione di proprietà, autorizzazioni, interazioni basate su eventi tra le risorse e altro ancora.

La s3.Bucket classe è un esempio di costrutto L2 per una risorsa bucket Amazon Simple Storage Service (Amazon S3).

La AWS Construct Library contiene costrutti L2 designati stabili e pronti per l'uso in produzione. Per i costrutti L2 in fase di sviluppo, sono designati come sperimentali e offerti in un modulo separato.

Costrutti di livello 3 (L3)

I costrutti L3, noti anche come pattern, rappresentano il livello di astrazione più elevato. Ogni costrutto L3 può contenere una raccolta di risorse configurate per funzionare insieme per eseguire un'attività o un servizio specifico all'interno dell'applicazione. I costrutti L3 vengono utilizzati per creare intere AWS architetture per casi d'uso particolari nell'applicazione.

Per fornire progetti di sistema completi o parti sostanziali di un sistema più grande, i costrutti L3 offrono configurazioni di proprietà predefinite ponderate. Sono costruiti attorno a un approccio particolare per risolvere un problema e fornire una soluzione. Con i costrutti L3, puoi creare e configurare più risorse rapidamente, con il minor numero di input e codice.

La ecsPatterns.ApplicationLoadBalancedFargateService classe è un esempio di costrutto L3 che rappresenta un AWS Fargate servizio in esecuzione su un cluster Amazon Elastic Container Service ECS (Amazon) e gestito da un sistema di bilanciamento del carico delle applicazioni.

Analogamente ai costrutti L2, i costrutti L3 pronti per l'uso in produzione sono inclusi nella Construct Library. AWS Quelli in fase di sviluppo sono offerti in moduli separati.

Definizione dei costrutti

Composizione

La composizione è il modello chiave per definire astrazioni di livello superiore attraverso costrutti. Un costrutto di alto livello può essere composto da un numero qualsiasi di costrutti di livello inferiore. Da una prospettiva dal basso verso l'alto, si utilizzano i costrutti per organizzare le singole risorse che si desidera distribuire. AWS Utilizzate tutte le astrazioni più adatte al vostro scopo, con tutti i livelli necessari.

Con la composizione, definisci i componenti riutilizzabili e li condividi come qualsiasi altro codice. Ad esempio, un team può definire un costrutto che implementa le best practice aziendali per una tabella Amazon DynamoDB, tra cui backup, replica globale, scalabilità automatica e monitoraggio. Il team può condividere il costrutto internamente con altri team o pubblicamente.

I team possono utilizzare i costrutti come qualsiasi altro pacchetto di libreria. Quando la libreria viene aggiornata, gli sviluppatori hanno accesso ai miglioramenti e alle correzioni di bug della nuova versione, in modo simile a qualsiasi altra libreria di codici.

Inizializzazione

I costrutti sono implementati in classi che estendono la classe di base Construct. Definite un costrutto istanziando la classe. Tutti i costrutti accettano tre parametri al momento dell'inizializzazione:

scope: il genitore o il proprietario del costrutto. Può trattarsi di una pila o di un altro costrutto. L'ambito determina la posizione del costrutto nell'albero del costrutto. Di solito dovresti passare this (in) self Python), che rappresenta l'oggetto corrente, per l'ambito.
id — Un identificatore che deve essere univoco all'interno dell'ambito. L'identificatore funge da namespace per tutto ciò che è definito all'interno del costrutto. Viene utilizzato per generare identificatori univoci, come nomi di risorse e dati logici. AWS CloudFormation IDs

Gli identificatori devono essere unici solo all'interno di un ambito. Ciò consente di creare istanze e riutilizzare i costrutti senza preoccuparsi dei costrutti e degli identificatori che potrebbero contenere e consente di comporre i costrutti in astrazioni di livello superiore. Inoltre, gli ambiti consentono di fare riferimento a gruppi di costrutti contemporaneamente. Gli esempi includono l'etichettatura o la specificazione di dove verranno distribuiti i costrutti.
props: un insieme di proprietà o argomenti di parole chiave, a seconda della lingua, che definiscono la configurazione iniziale del costrutto. I costrutti di livello superiore forniscono più impostazioni predefinite e, se tutti gli elementi prop sono opzionali, potete omettere completamente il parametro props.

Configurazione

La maggior parte dei costrutti accetta props come terzo argomento (o in Python, argomenti di parole chiave), una raccolta di nomi/valori che definisce la configurazione del costrutto. L'esempio seguente definisce un bucket con crittografia AWS Key Management Service (AWS KMS) e hosting di siti Web statici abilitati. Poiché non specifica esplicitamente una chiave di crittografia, il Bucket costrutto ne definisce una nuova kms.Key e la associa al bucket.

Interazione con i costrutti

I costrutti sono classi che estendono la classe Construct di base. Dopo aver creato un'istanza di un costrutto, l'oggetto construct espone un insieme di metodi e proprietà che consentono di interagire con il costrutto e di passarlo come riferimento ad altre parti del sistema.

Il AWS CDK framework non impone alcuna restrizione ai costrutti. APIs Gli autori possono definire API quello che vogliono. Tuttavia, AWS i costrutti inclusi nella AWS Construct Library, ad esempios3.Bucket, seguono linee guida e schemi comuni. Ciò fornisce un'esperienza coerente su tutte le AWS risorse.

La maggior parte dei AWS costrutti dispone di una serie di metodi di concessione che è possibile utilizzare per concedere AWS Identity and Access Management (IAM) le autorizzazioni su quel costrutto a un principale. L'esempio seguente concede al IAM gruppo l'data-scienceautorizzazione alla lettura dal bucket Amazon raw-data S3.

Un altro schema comune prevede che AWS i costrutti impostino uno degli attributi della risorsa a partire dai dati forniti altrove. Gli attributi possono includere Amazon Resource Names (ARNs), nomi oURLs.

Il codice seguente definisce una AWS Lambda funzione e la associa a una coda di Amazon Simple Queue Service SQS (Amazon) tramite la coda URL in una variabile di ambiente.

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

Per informazioni sui API modelli più comuni nella AWS Construct Library, consulta. Risorse e AWS CDK

L'app e lo stack costruiscono

Le Stack classi App e della AWS Construct Library sono costrutti unici. Rispetto ad altri costrutti, non configurano AWS le risorse da soli. Vengono invece utilizzati per fornire un contesto agli altri costrutti. Tutti i costrutti che rappresentano AWS risorse devono essere definiti, direttamente o indirettamente, nell'ambito di un costrutto. Stack Stacki costrutti sono definiti nell'ambito di un costrutto. App

Per ulteriori informazioni sulle CDK app, consulta. AWS CDK app Per ulteriori informazioni sugli CDK stack, consultaAWS CDK pile.

L'esempio seguente definisce un'app con un singolo stack. All'interno dello stack, viene utilizzato un costrutto L2 per configurare una risorsa bucket 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

Stack definito nel file: HelloCdkStack.java


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

App definita nel HelloCdkApp.java file:


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
}

Lavorare con i costrutti

Lavorare con i costrutti L1

I costrutti L1 si collegano direttamente alle singole risorse. AWS CloudFormation È necessario fornire la configurazione richiesta della risorsa.

In questo esempio, creiamo un bucket oggetto utilizzando il CfnBucket costrutto L1:

Le proprietà di costruzione che non sono semplici booleani, stringhe, numeri o contenitori vengono gestite in modo diverso nelle lingue supportate.

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, queste proprietà sono rappresentate da tipi definiti come classi interne del costrutto L1. Ad esempio, la proprietà opzionale cors_configuration di a CfnBucket richiede un wrapper di tipo. CfnBucket.CorsConfigurationProperty Qui stiamo definendo un'cors_configurationCfnBucketistanza.


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, queste proprietà sono rappresentate da tipi definiti come classi interne del costrutto L1. Ad esempio, la proprietà opzionale corsConfiguration di a CfnBucket richiede un wrapper di tipo. CfnBucket.CorsConfigurationProperty Qui stiamo definendo un'corsConfigurationCfnBucketistanza.


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#, queste proprietà sono rappresentate da tipi definiti come classi interne del costrutto L1. Ad esempio, la proprietà opzionale CorsConfiguration di a CfnBucket richiede un wrapper di tipo. CfnBucket.CorsConfigurationProperty Qui stiamo definendo un'CorsConfigurationCfnBucketistanza.


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, questi tipi vengono denominati utilizzando il nome del costrutto L1, un carattere di sottolineatura e il nome della proprietà. Ad esempio, la proprietà opzionale CorsConfiguration di a CfnBucket richiede un wrapper di tipo. CfnBucket_CorsConfigurationProperty Qui stiamo definendo un'CorsConfigurationCfnBucketistanza.


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

Importante

Non è possibile utilizzare i tipi di proprietà L2 con i costrutti L1 o viceversa. Quando lavorate con i costrutti L1, utilizzate sempre i tipi definiti per il costrutto L1 che state utilizzando. Non utilizzate tipi di altri costrutti L1 (alcuni possono avere lo stesso nome, ma non sono dello stesso tipo).

Alcuni dei nostri API riferimenti specifici del linguaggio attualmente contengono errori nei percorsi dei tipi di proprietà L1 o non documentano affatto queste classi. Speriamo di risolvere il problema al più presto. Nel frattempo, ricorda che questi tipi sono sempre classi interne del costrutto L1 con cui vengono utilizzati.

Lavorare con costrutti L2

Nell'esempio seguente, definiamo un bucket Amazon S3 creando un oggetto dal costrutto L2: Bucket

MyFirstBucketnon è il nome del bucket che crea. AWS CloudFormation È un identificatore logico assegnato al nuovo costrutto nel contesto dell'app. CDK Il physicalNamevalore verrà utilizzato per denominare la AWS CloudFormation risorsa.

Lavorare con costrutti di terze parti

Construct Hub è una risorsa che ti aiuta a scoprire costrutti aggiuntivi forniti da AWS terze parti e dalla comunità open source. CDK

Scrivere i propri costrutti

Oltre a utilizzare costrutti esistenti, puoi anche scrivere i tuoi costrutti e consentire a chiunque di utilizzarli nelle proprie app. Tutti i costrutti sono uguali in. AWS CDK I costrutti della AWS Construct Library vengono trattati allo stesso modo di un costrutto di una libreria di terze parti pubblicata tramite NPM, Maven, oppure PyPI. Anche i costrutti pubblicati nell'archivio di pacchetti interno dell'azienda vengono trattati allo stesso modo.

Per dichiarare un nuovo costrutto, create una classe che estenda la classe base Construct nel constructs pacchetto, quindi seguite lo schema per gli argomenti dell'inizializzatore.

L'esempio seguente mostra come dichiarare un costrutto che rappresenta un bucket Amazon S3. Il bucket S3 invia una notifica Amazon Simple Notification Service SNS (Amazon) ogni volta che qualcuno carica un file al suo interno.

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
}

Nota

Il nostro NotifyingBucket costrutto non eredita da, ma piuttosto da. Bucket Construct Utilizziamo la composizione, non l'ereditarietà, per raggruppare un bucket Amazon S3 e un argomento Amazon. SNS In generale, la composizione è preferita all'ereditarietà quando si sviluppano costrutti. AWS CDK

Il NotifyingBucket costruttore ha una tipica firma del costrutto:,, e. scope id props L'ultimo argomento,props, è facoltativo (ottiene il valore predefinito{}) perché tutti gli oggetti di scena sono opzionali. (La Construct classe base non accetta props argomenti.) Puoi definire un'istanza di questo costrutto nella tua app senzaprops, ad esempio:

Oppure puoi usare props (in Java, un parametro aggiuntivo) per specificare il prefisso del percorso su cui filtrare, ad esempio:

In genere, dovresti anche esporre alcune proprietà o metodi sui tuoi costrutti. Non è molto utile avere un argomento nascosto dietro il costrutto, perché gli utenti del costrutto non sono in grado di sottoscriverlo. L'aggiunta di una topic proprietà consente ai consumatori di accedere all'argomento interno, come mostrato nell'esempio seguente:

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

Per farlo in Go, avremo bisogno di un po' di tubature extra. La nostra NewNotifyingBucket funzione originale ha restituito unawss3.Bucket. Dovremo estendere Bucket per includere un topic membro creando una NotifyingBucket struttura. La nostra funzione restituirà quindi questo tipo.


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
}

Ora i consumatori possono iscriversi all'argomento, ad esempio:

Ulteriori informazioni

Il video seguente fornisce una panoramica completa dei CDK costrutti e spiega come utilizzarli nelle CDK app.

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Stack

Ambienti