Importa y usa construcciones Construye niveles Definir construcciones Trabajando con construcciones Trabajar con construcciones de terceros Más información

AWS CDK Construcciones

Las construcciones son los componentes básicos de las AWS Cloud Development Kit (AWS CDK) aplicaciones. Una construcción es un componente de la aplicación que representa uno o más AWS CloudFormation recursos y su configuración. Para crear la aplicación, pieza por pieza, se importan y configuran componentes fijos.

Importa y usa construcciones

Los componentes fijos son clases que se importan a CDK las aplicaciones desde la biblioteca de componentes fijos AWS . También puede crear y distribuir sus propias construcciones o usar construcciones creadas por desarrolladores externos.

Las construcciones forman parte del modelo de programación de construcciones (). CPM Están disponibles para su uso con otras herramientas, como CDK para Terraform (CDKtf), CDK para Kubernetes (CDK8s), y Projen.

Numerosos terceros también han publicado construcciones compatibles con. AWS CDK Visite Construct Hub para explorar el ecosistema de socios de AWS CDK construcción.

Construye niveles

Los componentes fijos de la AWS biblioteca de componentes se clasifican en tres niveles. Cada nivel ofrece un nivel de abstracción cada vez mayor. Cuanto mayor sea la abstracción, más fácil será la configuración y se requerirá menos experiencia. Cuanto menor sea la abstracción, mayor será la personalización disponible, lo que requerirá más experiencia.

Construcciones de nivel 1 (L1)

Los constructos L1, también conocidos como CFNrecursos, son los constructos de nivel más bajo y no ofrecen abstracción. Cada construcción de L1 se asigna directamente a un único recurso. AWS CloudFormation Con las construcciones de L1, se importa una construcción que representa un recurso específico. AWS CloudFormation A continuación, defina las propiedades del recurso en la instancia de construcción.

Las construcciones L1 son ideales para utilizarlas cuando se conoce AWS CloudFormation y se necesita un control total sobre la definición de las propiedades de los AWS recursos.

En la biblioteca de AWS construcciones, las construcciones de L1 se nombran empezando porCfn, seguido de un identificador para el AWS CloudFormation recurso que representan. Por ejemplo, la CfnBucket construcción es una construcción L1 que representa un recurso. AWS::S3::Bucket AWS CloudFormation

Las construcciones de L1 se generan a partir de la AWS CloudFormation especificación del recurso. Si existe un recurso en AWS CloudFormation, estará disponible AWS CDK como una construcción L1. Los nuevos recursos o propiedades pueden tardar hasta una semana en estar disponibles en la biblioteca de AWS construcciones. Para obtener más información, consulte la referencia sobre los tipos de AWS recursos y propiedades en la Guía del AWS CloudFormation usuario.

Construcciones de nivel 2 (L2)

Las construcciones L2, también conocidas como construcciones seleccionadas, son desarrolladas cuidadosamente por el CDK equipo y, por lo general, son el tipo de construcción más utilizado. Las construcciones L2 se asignan directamente a recursos individuales AWS CloudFormation , de forma similar a las construcciones L1. En comparación con las construcciones L1, las construcciones L2 proporcionan una abstracción de alto nivel mediante un enfoque intuitivo basado en la intención. API Las construcciones de nivel 2 incluyen configuraciones de propiedades predeterminadas y sensatas, políticas de seguridad recomendadas y generan gran parte del código repetitivo y de la lógica necesaria para el usuario.

Las construcciones de nivel 2 también proporcionan métodos auxiliares para la mayoría de los recursos, que facilitan y agilizan la definición de propiedades, permisos, interacciones entre recursos basadas en eventos, etc.

La s3.Bucket clase es un ejemplo de una construcción de nivel 2 para un recurso de bucket de Amazon Simple Storage Service (Amazon S3).

La biblioteca AWS Construct contiene construcciones de nivel 2 designadas como estables y listas para su uso en producción. En el caso de las construcciones de nivel 2 en fase de desarrollo, se denominan experimentales y se ofrecen en un módulo independiente.

Construcciones de nivel 3 (L3)

Los constructos L3, también conocidos como patrones, son el nivel más alto de abstracción. Cada construcción de L3 puede contener un conjunto de recursos que están configurados para trabajar juntos a fin de realizar una tarea o un servicio específicos dentro de la aplicación. Las construcciones L3 se utilizan para crear AWS arquitecturas completas para casos de uso particulares de la aplicación.

Para proporcionar diseños de sistemas completos, o partes sustanciales de un sistema más grande, las construcciones L3 ofrecen configuraciones de propiedades predeterminadas y fundamentadas. Se basan en un enfoque particular para resolver un problema y proporcionar una solución. Con las construcciones L3, puede crear y configurar varios recursos rápidamente, con la menor cantidad de entrada y código.

La ecsPatterns.ApplicationLoadBalancedFargateService clase es un ejemplo de una construcción de nivel 3 que representa un AWS Fargate servicio que se ejecuta en un clúster de Amazon Elastic Container Service (AmazonECS) y dirigido por un balanceador de carga de aplicaciones.

Al igual que las construcciones L2, las construcciones L3 que están listas para su uso en producción se incluyen en la biblioteca Construct. AWS Las que están en desarrollo se ofrecen en módulos separados.

Definir construcciones

Composición

La composición es el patrón clave para definir abstracciones de alto nivel a través de constructos. Un constructo de alto nivel puede estar compuesto por cualquier número de constructos de nivel inferior. Desde una perspectiva ascendente, se utilizan componentes fijos para organizar los AWS recursos individuales que se desean implementar. Utiliza las abstracciones que sean convenientes para su propósito, con tantos niveles como necesite.

Con la composición, defines componentes reutilizables y los compartes como cualquier otro código. Por ejemplo, un equipo puede definir una estructura que implemente las mejores prácticas de la empresa para una tabla de Amazon DynamoDB, incluidas las copias de seguridad, la replicación global, el escalado automático y la supervisión. El equipo puede compartir la construcción internamente con otros equipos o públicamente.

Los equipos pueden usar construcciones como cualquier otro paquete de biblioteca. Cuando se actualiza la biblioteca, los desarrolladores tienen acceso a las mejoras y correcciones de errores de la nueva versión, de forma similar a cualquier otra biblioteca de códigos.

Inicialización

Los constructos se implementan en clases que amplían la clase base Construct. Para definir una construcción, se crea una instancia de la clase. Todos los constructos toman tres parámetros cuando se inicializan:

alcance: el padre o el propietario de la construcción. Puede ser una pila u otra construcción. El alcance determina el lugar del componente fijo en el árbol de componentes fijos. Por lo general, debe pasar this (selfentrar) Python), que representa el objeto actual, para el ámbito.
id: un identificador que debe ser único dentro del ámbito. El identificador sirve como espacio de nombres para todo lo que se define en la construcción. Se usa para generar identificadores únicos, como nombres de recursos y lógicos. AWS CloudFormation IDs

Los identificadores solo necesitan ser únicos dentro de un ámbito. Esto le permite crear instancias de las construcciones y reutilizarlas sin preocuparse por las construcciones e identificadores que puedan contener, y permite componer las construcciones en abstracciones de nivel superior. Además, los ámbitos permiten hacer referencia a grupos de construcciones de una sola vez. Algunos ejemplos son el etiquetado o la especificación de dónde se desplegarán las construcciones.
props: conjunto de propiedades o argumentos de palabras clave, según el idioma, que definen la configuración inicial de la construcción. Las construcciones de nivel superior proporcionan más valores predeterminados y, si todos los elementos prop son opcionales, puede omitir el parámetro props por completo.

Configuración

La mayoría de las construcciones aceptan props como tercer argumento (o en Python, argumentos de palabras clave), una colección de nombre/valor que define la configuración de la construcción. El siguiente ejemplo define un depósito con el cifrado AWS Key Management Service (AWS KMS) y el alojamiento de sitios web estáticos habilitados. Como no especifica explícitamente una clave de cifrado, la Bucket construcción define una nueva kms.Key y la asocia al depósito.

Interactuar con los constructos

Los constructos son clases que amplían la clase Construct base. Tras crear una instancia de una construcción, el objeto de construcción expone un conjunto de métodos y propiedades que permiten interactuar con la construcción y transmitirla como referencia a otras partes del sistema.

El AWS CDK marco no impone ninguna restricción a los APIs constructos. Los autores pueden definir API lo que quieran. Sin embargo, las AWS construcciones que se incluyen en la biblioteca AWS Construct, por ejemplos3.Bucket, siguen pautas y patrones comunes. Esto proporciona una experiencia coherente en todos los AWS recursos.

La mayoría de AWS las construcciones tienen un conjunto de métodos de concesión que puedes usar para conceder AWS Identity and Access Management (IAM) permisos sobre esa construcción a un principal. El siguiente ejemplo concede al IAM grupo data-science permiso para leer desde el bucket de Amazon S3raw-data.

Otro patrón común es que AWS las construcciones establezcan uno de los atributos del recurso a partir de datos suministrados en otros lugares. Los atributos pueden incluir nombres de recursos de Amazon (ARNs), nombres oURLs.

El código siguiente define una AWS Lambda función y la asocia a una cola de Amazon Simple Queue Service (AmazonSQS) a través de las colas de una variable URL de entorno.

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

Para obtener información sobre los API patrones más comunes de la biblioteca AWS Construct, consulte. Los recursos y la AWS CDK

La construcción de la aplicación y la pila

StackLas clases App y de la biblioteca AWS Construct son construcciones únicas. En comparación con otras construcciones, no configuran AWS los recursos por sí mismas. En cambio, se utilizan para proporcionar contexto a las otras construcciones. Todos los constructos que representan AWS recursos deben definirse, directa o indirectamente, dentro del ámbito de un Stack constructo. Stacklos constructos se definen dentro del ámbito de un App constructo.

Para obtener más información sobre CDK las aplicaciones, consulteAWS CDK aplicaciones. Para obtener más información sobre las CDK pilas, consulteAWS CDK pilas.

En el siguiente ejemplo, se define una aplicación con una sola pila. Dentro de la pila, se utiliza una construcción L2 para configurar un recurso de bucket de 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

Pila definida en el HelloCdkStack.java archivo:


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

Aplicación definida en el HelloCdkApp.java archivo:


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
}

Trabajando con construcciones

Trabajando con construcciones L1

Las construcciones de L1 asignan directamente a los recursos individuales. AWS CloudFormation Debe proporcionar la configuración requerida del recurso.

En este ejemplo, creamos un bucket objeto mediante la construcción CfnBucket L1:

Las propiedades de construcción que no sean simples booleanos, cadenas, números o contenedores se gestionan de forma diferente en los lenguajes compatibles.

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, estas propiedades se representan mediante tipos definidos como clases internas de la construcción L1. Por ejemplo, la propiedad opcional cors_configuration de a CfnBucket requiere un contenedor de tipo. CfnBucket.CorsConfigurationProperty Aquí estamos definiendo cors_configuration en una CfnBucket instancia.


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, estas propiedades se representan mediante tipos definidos como clases internas de la construcción L1. Por ejemplo, la propiedad opcional corsConfiguration de a CfnBucket requiere un contenedor de tipo. CfnBucket.CorsConfigurationProperty Aquí estamos definiendo corsConfiguration en una CfnBucket instancia.


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#, estas propiedades se representan mediante tipos definidos como clases internas de la construcción L1. Por ejemplo, la propiedad opcional CorsConfiguration de a CfnBucket requiere un contenedor de tipo. CfnBucket.CorsConfigurationProperty Aquí estamos definiendo CorsConfiguration en una CfnBucket instancia.


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

En Go, estos tipos se nombran con el nombre de la construcción L1, un guión bajo y el nombre de la propiedad. Por ejemplo, la propiedad opcional CorsConfiguration de a CfnBucket requiere un contenedor de tipo. CfnBucket_CorsConfigurationProperty Aquí estamos definiendo CorsConfiguration en una CfnBucket instancia.


	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

No puedes usar tipos de propiedades L2 con construcciones L1, o viceversa. Cuando trabaje con construcciones de L1, utilice siempre los tipos definidos para la construcción de L1 que utilice. No utilice tipos de otras construcciones de L1 (algunas pueden tener el mismo nombre, pero no son del mismo tipo).

Actualmente, algunas de nuestras API referencias específicas de idiomas tienen errores en las rutas a los tipos de propiedades de L1 o no documentan estas clases en absoluto. Esperamos solucionar este problema pronto. Mientras tanto, recuerde que estos tipos son siempre clases internas de la construcción L1 con la que se utilizan.

Trabajando con construcciones L2

En el siguiente ejemplo, definimos un bucket de Amazon S3 mediante la creación de un objeto a partir de la construcción BucketL2:

MyFirstBucketno es el nombre del bucket que se AWS CloudFormation crea. Es un identificador lógico que se asigna a la nueva construcción en el contexto de tu CDK aplicación. El physicalNamevalor se usará para nombrar el AWS CloudFormation recurso.

Trabajar con construcciones de terceros

Construct Hub es un recurso que le ayuda a descubrir otras construcciones de AWS terceros y de la comunidad de código abiertoCDK.

Escribiendo tus propias construcciones

Además de usar las construcciones existentes, también puedes escribir las tuyas propias y permitir que cualquiera las use en sus aplicaciones. Todas las construcciones son iguales en. AWS CDK Las construcciones de la biblioteca de AWS construcciones se tratan de la misma manera que una construcción de una biblioteca de terceros publicada mediante NPM, Maven, o PyPI. Los constructos publicados en el repositorio de paquetes interno de su empresa también se tratan de la misma manera.

Para declarar una nueva construcción, cree una clase que amplíe la clase base de Construct en el constructs paquete y, a continuación, siga el patrón de los argumentos del inicializador.

El siguiente ejemplo muestra cómo declarar una construcción que representa un bucket de Amazon S3. El bucket S3 envía una notificación de Amazon Simple Notification Service (AmazonSNS) cada vez que alguien carga un archivo en él.

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

Nuestra NotifyingBucket construcción no hereda de, Bucket sino más bien de. Construct Usamos la composición, no la herencia, para agrupar un bucket de Amazon S3 y un SNS tema de Amazon. En general, se prefiere la composición a la herencia a la hora de desarrollar AWS CDK construcciones.

El NotifyingBucket constructor tiene una firma de construcción típica: scopeid, yprops. El último argumento,props, es opcional (obtiene el valor predeterminado{}) porque todos los accesorios son opcionales. (La Construct clase base no acepta ningún props argumento). Podrías definir una instancia de esta construcción en tu aplicación sinprops, por ejemplo:

O puedes usar props (en Java, un parámetro adicional) para especificar el prefijo de ruta por el que deseas filtrar, por ejemplo:

Por lo general, también querrá exponer algunas propiedades o métodos en sus construcciones. No es muy útil tener un tema oculto detrás de la construcción, ya que los usuarios de la construcción no pueden suscribirse a ella. Añadir una topic propiedad permite a los consumidores acceder al tema interno, como se muestra en el siguiente ejemplo:

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

Para hacer esto en Go, necesitaremos un poco más de fontanería. Nuestra NewNotifyingBucket función original devolvió unawss3.Bucket. Tendremos que ampliarla Bucket para incluir un topic miembro mediante la creación de una NotifyingBucket estructura. Nuestra función devolverá entonces este 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
}

Ahora, los consumidores pueden suscribirse al tema, por ejemplo:

Más información

En el siguiente vídeo se ofrece una visión general CDK completa de las estructuras y se explica cómo utilizarlas en CDK las aplicaciones.

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Pilas

Entornos