Configuración de recursos mediante constructos Recursos de referencia Nombres físicos de los recursos Pasar identificadores de recursos únicos Otorgar permisos entre recursos Métricas de recursos y alarmas Tráfico de red Control de eventos Políticas de eliminación

Los recursos y el AWS CDK

Los recursos son lo que configuras para usar AWS los servicios en tus aplicaciones. Los recursos son una característica de AWS CloudFormation. Al configurar los recursos y sus propiedades en una AWS CloudFormation plantilla, puede implementarlos AWS CloudFormation para aprovisionar sus recursos. Con el kit de desarrollo AWS en la nube (AWS CDK), puede configurar los recursos mediante construcciones. A continuación, implementa la aplicación CDK, lo que implica sintetizar una AWS CloudFormation plantilla e implementarla para AWS CloudFormation aprovisionar los recursos.

Configuración de recursos mediante constructos

Como se describe en AWS CDK Constructs, el AWS CDK proporciona una rica biblioteca de clases de construcciones, denominadas construcciones, que representan todos los recursos. AWS

Para crear una instancia de un recurso utilizando su constructo correspondiente, introduzca el ámbito como primer argumento, el identificador lógico del constructo y un conjunto de propiedades de configuración (props). Por ejemplo, aquí se explica cómo crear una cola de Amazon SQS con cifrado AWS KMS utilizando la construcción de la biblioteca de construcciones. sqs.Queue AWS

ejemplo

Algunos props de configuración son opcionales y, en muchos casos, tienen valores predeterminados. En algunos casos, todos los props son opcionales y el último argumento se puede omitir por completo.

Atributos de recursos

La mayoría de los recursos de la biblioteca AWS Construct muestran atributos, que se resuelven en el momento de la implementación. AWS CloudFormation Los atributos se exponen en forma de propiedades en las clases de recursos con el nombre del tipo como prefijo. En el siguiente ejemplo de código se muestra cómo obtener la URL de una cola de Amazon SQS usando la propiedad queueUrl (Python: queue_url).

ejemplo

Consulte los tokens y el AWS CDK para obtener información sobre cómo el AWS CDK codifica los atributos del momento de la implementación en forma de cadenas.

Recursos de referencia

Al configurar los recursos, a menudo tendrá que hacer referencia a las propiedades de otro recurso. A continuación se muestran algunos ejemplos:

Un recurso de Amazon Elastic Container Service (Amazon ECS) requiere una referencia al clúster en el que se ejecuta.
Una CloudFront distribución de Amazon requiere una referencia al bucket de Amazon Simple Storage Service (Amazon S3) que contiene el código fuente.

Puede hacer referencia a recursos en algunas de las siguientes maneras:

Transfiriendo un recurso definido en su aplicación de CDK, ya sea en la misma pila o en una diferente.
Al pasar un objeto de proxy que haga referencia a un recurso definido en su AWS cuenta, creado a partir de un identificador único del recurso (como un ARN)

Si la propiedad de un constructo representa un constructo de otro recurso, su tipo es el del tipo de interfaz del constructo. Por ejemplo, el constructo Amazon ECS toma una propiedad cluster de tipo ecs.ICluster. Otro ejemplo es la construcción CloudFront de distribución que toma una propiedad de sourceBucket tipo (Python:source_bucket). s3.IBucket

Puedes pasar directamente cualquier objeto de recurso del tipo adecuado definido en la misma aplicación de AWS CDK. En el siguiente ejemplo se define un clúster de Amazon ECS y, a continuación, se utiliza para definir un servicio de Amazon ECS.

ejemplo

Referencia de recursos en una pila diferente

Puedes hacer referencia a los recursos de una pila diferente, siempre que estén definidos en la misma aplicación. Las pilas pueden estar en el mismo entorno o en AWS entornos diferentes (cuentas y regiones). Generalmente, se utiliza el siguiente patrón:

Guarde una referencia al constructo como atributo de la pila que produce el recurso. (Para obtener una referencia a la pila del constructo actual, utilice Stack.of(this)).
Pase esta referencia al constructor de la pila que consume el recurso como parámetro o propiedad. Luego, la pila consumidora la pasa como una propiedad a cualquier constructo que la necesite.

En el ejemplo siguiente se define una pila stack1. Esta pila define un bucket de Amazon S3 y almacena una referencia al constructo del bucket como atributo de la pila. A continuación, la aplicación define una segunda pilastack2, que acepta un bucket en el momento de la instanciación. stack2podría, por ejemplo, definir una tabla AWS adhesiva que utilice el depósito para almacenar datos.

ejemplo

TypeScript


const prod = { account: '123456789012', region: 'us-east-1' };

const stack1 = new StackThatProvidesABucket(app, 'Stack1', { env: prod });

// stack2 will take a property { bucket: IBucket }
const stack2 = new StackThatExpectsABucket(app, 'Stack2', {
  bucket: stack1.bucket,
  env: prod
});

JavaScript


const prod = { account: '123456789012', region: 'us-east-1' };

const stack1 = new StackThatProvidesABucket(app, 'Stack1', { env: prod });

// stack2 will take a property { bucket: IBucket }
const stack2 = new StackThatExpectsABucket(app, 'Stack2', {
  bucket: stack1.bucket,
  env: prod
});

Python


prod = core.Environment(account="123456789012", region="us-east-1")

stack1 = StackThatProvidesABucket(app, "Stack1", env=prod)

# stack2 will take a property "bucket"
stack2 = StackThatExpectsABucket(app, "Stack2", bucket=stack1.bucket, env=prod)

Java


// Helper method to build an environment
static Environment makeEnv(String account, String region) {
    return Environment.builder().account(account).region(region)
            .build();
}

App app = new App();

Environment prod = makeEnv("123456789012", "us-east-1");

StackThatProvidesABucket stack1 = new StackThatProvidesABucket(app, "Stack1",
        StackProps.builder().env(prod).build());

// stack2 will take an argument "bucket"
StackThatExpectsABucket stack2 = new StackThatExpectsABucket(app, "Stack,",
        StackProps.builder().env(prod).build(), stack1.bucket);

C#


Amazon.CDK.Environment makeEnv(string account, string region)
{
    return new Amazon.CDK.Environment { Account = account, Region = region };
}

var prod = makeEnv(account: "123456789012", region: "us-east-1");

var stack1 = new StackThatProvidesABucket(app, "Stack1", new StackProps { Env = prod });

// stack2 will take a property "bucket"
var stack2 = new StackThatExpectsABucket(app, "Stack2", new StackProps { Env = prod,
    bucket = stack1.Bucket});

Si el AWS CDK determina que el recurso está en el mismo entorno, pero en una pila diferente, sintetiza automáticamente AWS CloudFormation las exportaciones en la pila productora y Fn::ImportValue en la pila consumidora para transferir esa información de una pila a la otra. Se trata de una referencia sólida: el comportamiento predeterminado. Puedes controlar la intensidad de las referencias entre pilas para evitar bloqueos de dependencia.

Fuerza de referencia

Cada referencia entre pilas tiene una fuerza que determina el CloudFormation mecanismo utilizado y el acoplamiento entre pilas:

Fuerte (predeterminado): La pila productora crea una CloudFormation exportación y la pila consumidora usaFn::ImportValue. Esto significa que la pila de producción no se puede actualizar para eliminar la exportación mientras ningún consumidor siga importándola. CloudFormation hace cumplir esta restricción.
Débil: La pila consumidora Fn::GetStackOutput suele leer las salidas directamente de la pila productora. No se crea ningún acoplamiento de exportación; cualquiera de las pilas se puede actualizar o eliminar de forma independiente.
Ambos: Un estado de transición para migrar de fuerte a débil. La cadena de producción conserva sus exportaciones (por lo que los consumidores fuertes actuales no se pierden), mientras que la cadena de consumidores cambia aFn::GetStackOutput.

El estancamiento de la dependencia (abrazo mortal)

Las referencias sólidas pueden crear un punto muerto que impida las actualizaciones de la pila. Esto ocurre porque CloudFormation no se puede eliminar una exportación mientras otra pila la sigue importando, y la pila que la consume no se puede actualizar para detener la importación hasta que la exportación ya exista. Es posible que veas un error como el siguiente:

Export Stack1:ExportsOutputFnGetAtt-****** cannot be deleted as it is in use by Stack2

Esto suele ocurrir cuando intentas eliminar un recurso compartido o reestructurar tus pilas. Las referencias débiles evitan este problema por completo, ya que no crean exportaciones.

Controlar la fuerza de referencia

Puedes controlar la fuerza de referencia en tres ámbitos: en toda la aplicación, por recurso o por uso.

App-wide predeterminado

Configura la siguiente clave de contexto cdk.json para cambiar la predeterminada para todas las referencias entre pilas de la aplicación:


{
  "context": {
    "@aws-cdk/core:defaultCrossStackReferences": "weak"
  }
}

Per-resource

Anula la fuerza de todas las referencias que apunten a un recurso específico usando: CrossStackReferences.of(resource).produce(strength)

ejemplo

Ahora se usarán todas las referencias a bucket otras pilas Fn::GetStackOutput independientemente de la configuración predeterminada en toda la aplicación.

Per-usage

Anula la fuerza de una sola referencia en el punto de consumo mediante: Stack.consumeReference()

ejemplo

TypeScript


declare const topic: sns.Topic;

const consumer = new Stack(app, 'Consumer', {
  env: { account: '123456789012', region: 'us-east-1' },
});
new sns.Subscription(consumer, 'Subscription', {
  topic: sns.Topic.fromTopicArn(consumer, 'Topic',
    Stack.consumeReference(topic.topicArn, ReferenceStrength.WEAK)),
  endpoint: 'https://example.com/webhook',
  protocol: sns.SubscriptionProtocol.HTTPS,
});

JavaScript


const { Stack, ReferenceStrength } = require('aws-cdk-lib');
const sns = require('aws-cdk-lib/aws-sns');
const subscriptions = require('aws-cdk-lib/aws-sns-subscriptions');

const consumer = new Stack(app, 'Consumer', {
  env: { account: '123456789012', region: 'us-east-1' },
});
new sns.Subscription(consumer, 'Subscription', {
  topic: sns.Topic.fromTopicArn(consumer, 'Topic',
    Stack.consumeReference(topic.topicArn, ReferenceStrength.WEAK)),
  endpoint: 'https://example.com/webhook',
  protocol: sns.SubscriptionProtocol.HTTPS,
});

Python


from aws_cdk import Stack, ReferenceStrength
import aws_cdk.aws_sns as sns

consumer = Stack(app, "Consumer",
    env=core.Environment(account="123456789012", region="us-east-1")
)
sns.Subscription(consumer, "Subscription",
    topic=sns.Topic.from_topic_arn(consumer, "Topic",
        Stack.consume_reference(topic.topic_arn, ReferenceStrength.WEAK)),
    endpoint="https://example.com/webhook",
    protocol=sns.SubscriptionProtocol.HTTPS
)

Java


import software.amazon.awscdk.Stack;
import software.amazon.awscdk.ReferenceStrength;
import software.amazon.awscdk.services.sns.*;

Stack consumer = new Stack(app, "Consumer", StackProps.builder()
        .env(Environment.builder().account("123456789012").region("us-east-1").build())
        .build());
Subscription.Builder.create(consumer, "Subscription")
        .topic(Topic.fromTopicArn(consumer, "Topic",
            Stack.consumeReference(topic.getTopicArn(), ReferenceStrength.WEAK)))
        .endpoint("https://example.com/webhook")
        .protocol(SubscriptionProtocol.HTTPS)
        .build();

C#


using Amazon.CDK;
using Amazon.CDK.AWS.SNS;

var consumer = new Stack(app, "Consumer", new StackProps
{
    Env = new Amazon.CDK.Environment { Account = "123456789012", Region = "us-east-1" }
});
new Subscription(consumer, "Subscription", new SubscriptionProps
{
    Topic = Topic.FromTopicArn(consumer, "Topic",
        Stack.ConsumeReference(topic.TopicArn, ReferenceStrength.WEAK)),
    Endpoint = "https://example.com/webhook",
    Protocol = SubscriptionProtocol.HTTPS
});

Go


import (
  "github.com/aws/aws-cdk-go/awscdk/v2"
  "github.com/aws/aws-cdk-go/awscdk/v2/awssns"
  "github.com/aws/jsii-runtime-go"
)

consumer := awscdk.NewStack(app, jsii.String("Consumer"), &awscdk.StackProps{
  Env: &awscdk.Environment{Account: jsii.String("123456789012"), Region: jsii.String("us-east-1")},
})
awssns.NewSubscription(consumer, jsii.String("Subscription"), &awssns.SubscriptionProps{
  Topic: awssns.Topic_FromTopicArn(consumer, jsii.String("Topic"),
    awscdk.Stack_ConsumeReference(topic.TopicArn(), awscdk.ReferenceStrength_WEAK)),
  Endpoint: jsii.String("https://example.com/webhook"),
  Protocol: awssns.SubscriptionProtocol_HTTPS,
})

Úselo Stack.consumeListReference() para referencias a listas de cadenas.

Anulación por ámbito

También puede establecer la fuerza de referencia para un subárbol de construcciones utilizando. CrossStackReferences.of(scope).consume(strength) Todas las referencias de pila cruzada que se consuman dentro de ese ámbito utilizarán la fuerza especificada.

Migración de referencias fuertes a referencias débiles

Si ya ha desplegado pilas con referencias seguras, no puede cambiar directamente a las débiles; CloudFormation podría fallar porque la exportación aún está en uso. En su lugar, utilice una migración en dos fases a través del estado de BOTH transición.

La API que utilices depende de tu objetivo:

Eliminar una sola referencia (pero manteniendo tanto las pilas como el recurso): úsala Stack.consumeReference() para debilitar solo ese uso específico.
Eliminar o reestructurar el recurso productor: utilízalo CrossStackReferences.of(producer).produce() para debilitar todas las referencias que apunten a ese recurso a la vez.

Ambos enfoques siguen el mismo patrón de dos fases que se describe a continuación. Los ejemplos muestran el enfoque por recurso. Para cada uso, defina la referencia con Stack.consumeReference(ref, ReferenceStrength.BOTH) la fase 1 y Stack.consumeReference(ref, ReferenceStrength.WEAK) la fase 2.

Fase 1: Implemente con AMBOS

Cambie la fuerza de referencia aBOTH. Esto hace que la pila consumidora comience a Fn::GetStackOutput usarse, pero mantiene la exportación en la pila productora para que la transición sea segura:

ejemplo

Implemente ambas pilas.

Fase 2: Despliegue con WEAK

Ahora que ningún consumidor lo usaFn::ImportValue, la exportación se puede retirar de forma segura. Cambie aWEAK:

ejemplo

Despliegue ambas pilas. La exportación se ha eliminado y la referencia ahora es totalmente débil.

Tras esta migración, puedes retirar, mover o reestructurar el recurso libremente sin caer en un abrazo mortal.

Solución alternativa manual (antigua)

Si aún no utiliza los controles de intensidad de referencia, puede solucionar el punto muerto manualmente. Elimine el uso del recurso compartido de la pila consumidora. A continuación, añada manualmente la misma exportación a la pila de producción utilizando exactamente el mismo ID lógico que la exportación generada automáticamente. Implemente ambas pilas para eliminar elFn::ImportValue. A continuación, elimine la exportación manual (y el recurso compartido si ya no es necesario) y vuelva a implementar ambas pilas. El método exportValue() de la pila es una forma cómoda de crear la exportación manual para este propósito.

Haciendo referencia a los recursos de su AWS inscrita

Supongamos que quieres usar un recurso que ya está disponible en tu AWS cuenta en tu aplicación AWS CDK. Puede tratarse de un recurso que se definió a través de la consola, un AWS SDK, directamente con AWS CloudFormation una aplicación de CDK o en una aplicación de AWS CDK diferente. Puede convertir el ARN del recurso (u otro atributo de identificación o grupo de atributos) en un objeto proxy. El objeto proxy sirve como referencia al recurso al llamar a un método de fábrica estático de la clase del recurso.

Al crear un proxy de este tipo, el recurso externo no pasa a formar parte de la aplicación de AWS CDK. Por lo tanto, los cambios que realices en el proxy de tu aplicación de AWS CDK no afectan al recurso desplegado. Sin embargo, el proxy se puede pasar a cualquier método de AWS CDK que requiera un recurso de ese tipo.

El siguiente ejemplo muestra cómo hacer referencia a un bucket basado en un bucket existente con el ARN arn:aws:s3:::amzn-s3-demo-bucket1 y una Amazon Virtual Private Cloud basada en una VPC existente con un identificador específico.

ejemplo

TypeScript


// Construct a proxy for a bucket by its name (must be same account)
s3.Bucket.fromBucketName(this, 'MyBucket', 'amzn-s3-demo-bucket1');

// Construct a proxy for a bucket by its full ARN (can be another account)
s3.Bucket.fromBucketArn(this, 'MyBucket', 'arn:aws:s3:::amzn-s3-demo-bucket1');

// Construct a proxy for an existing VPC from its attribute(s)
ec2.Vpc.fromVpcAttributes(this, 'MyVpc', {
  vpcId: 'vpc-1234567890abcde',
});

JavaScript


// Construct a proxy for a bucket by its name (must be same account)
s3.Bucket.fromBucketName(this, 'MyBucket', 'amzn-s3-demo-bucket1');

// Construct a proxy for a bucket by its full ARN (can be another account)
s3.Bucket.fromBucketArn(this, 'MyBucket', 'arn:aws:s3:::amzn-s3-demo-bucket1');

// Construct a proxy for an existing VPC from its attribute(s)
ec2.Vpc.fromVpcAttributes(this, 'MyVpc', {
  vpcId: 'vpc-1234567890abcde'
});

Python


# Construct a proxy for a bucket by its name (must be same account)
s3.Bucket.from_bucket_name(self, "MyBucket", "amzn-s3-demo-bucket1")

# Construct a proxy for a bucket by its full ARN (can be another account)
s3.Bucket.from_bucket_arn(self, "MyBucket", "arn:aws:s3:::amzn-s3-demo-bucket1")

# Construct a proxy for an existing VPC from its attribute(s)
ec2.Vpc.from_vpc_attributes(self, "MyVpc", vpc_id="vpc-1234567890abcdef")

Java


// Construct a proxy for a bucket by its name (must be same account)
Bucket.fromBucketName(this, "MyBucket", "amzn-s3-demo-bucket1");

// Construct a proxy for a bucket by its full ARN (can be another account)
Bucket.fromBucketArn(this, "MyBucket",
        "arn:aws:s3:::amzn-s3-demo-bucket1");

// Construct a proxy for an existing VPC from its attribute(s)
Vpc.fromVpcAttributes(this, "MyVpc", VpcAttributes.builder()
        .vpcId("vpc-1234567890abcdef").build());

C#


// Construct a proxy for a bucket by its name (must be same account)
Bucket.FromBucketName(this, "MyBucket", "amzn-s3-demo-bucket1");

// Construct a proxy for a bucket by its full ARN (can be another account)
Bucket.FromBucketArn(this, "MyBucket", "arn:aws:s3:::amzn-s3-demo-bucket1");

// Construct a proxy for an existing VPC from its attribute(s)
Vpc.FromVpcAttributes(this, "MyVpc", new VpcAttributes
{
    VpcId = "vpc-1234567890abcdef"
});

Go


// Define a proxy for a bucket by its name (must be same account)
s3.Bucket_FromBucketName(stack, jsii.String("MyBucket"), jsii.String("amzn-s3-demo-bucket1"))

// Define a proxy for a bucket by its full ARN (can be another account)
s3.Bucket_FromBucketArn(stack, jsii.String("MyBucket"), jsii.String("arn:aws:s3:::amzn-s3-demo-bucket1"))

// Define a proxy for an existing VPC from its attributes
ec2.Vpc_FromVpcAttributes(stack, jsii.String("MyVpc"), &ec2.VpcAttributes{
  VpcId: jsii.String("vpc-1234567890abcde"),
})

Echemos un vistazo más de cerca al método Vpc.fromLookup(). Como el constructo ec2.Vpc es complejo, hay muchas maneras de seleccionar la VPC que se va a usar con la aplicación de CDK. Para solucionar este problema, la construcción de la VPC cuenta con un método fromLookup estático (Python:from_lookup) que le permite buscar la Amazon VPC deseada consultando su AWS cuenta en el momento de la síntesis.

Para utilizar Vpc.fromLookup(), el sistema que sintetiza la pila debe tener acceso a la cuenta propietaria de la VPC de Amazon. Esto se debe a que el kit de herramientas de CDK consulta la cuenta para encontrar la VPC de Amazon adecuada en el momento de la síntesis.

Además, solo Vpc.fromLookup() funciona en pilas que estén definidas con una cuenta y una región explícitas (consulte Entornos para ver el CDK). AWS Si el AWS CDK intenta buscar una Amazon VPC desde una pila independiente del entorno, el CDK Toolkit no sabe qué entorno consultar para encontrar la VPC.

Debe proporcionar Vpc.fromLookup() atributos suficientes para identificar de forma exclusiva una VPC en su cuenta. AWS Por ejemplo, solo puede haber una VPC predeterminada, por lo que basta con especificar la VPC como predeterminada.

ejemplo

También puede utilizar la propiedad tags para consultar VPC por etiqueta. Puede añadir etiquetas a la Amazon VPC en el momento de su creación mediante el uso del AWS CloudFormation AWS CDK. Puede editar las etiquetas en cualquier momento después de crearlas mediante la consola AWS de administración, la AWS CLI o un AWS SDK. Además de las etiquetas que añada usted mismo, el AWS CDK agrega automáticamente las siguientes etiquetas a todas las VPC que crea.

Nombre: nombre de la VPC.
aws-cdk:subnet-name: nombre de la subred.
aws-cdk:subnet-type: tipo de subred: pública, privada o aislada.

ejemplo

Los resultados de Vpc.fromLookup() se almacenan en caché en el archivo cdk.context.json del proyecto. (Consulte Los valores de contexto y el AWS CDK). Confirme este archivo al control de versiones para que la aplicación siga haciendo referencia a la misma VPC de Amazon. Esto funciona incluso si más adelante cambia los atributos de sus VPC de forma que se seleccione una VPC diferente. Esto es especialmente importante si vas a implementar la pila en un entorno que no tiene acceso a la AWS cuenta que define la VPC, como CDK Pipelines.

Aunque puedes usar un recurso externo en cualquier lugar donde utilices un recurso similar definido en tu aplicación de AWS CDK, no puedes modificarlo. Por ejemplo, llamar a addToResourcePolicy (Python: add_to_resource_policy) en un s3.Bucket externo no hace nada.

Nombres físicos de los recursos

Los nombres lógicos de los recursos de AWS CloudFormation son diferentes de los nombres de los recursos que aparecen en la consola AWS de administración una vez implementados AWS CloudFormation. El AWS CDK denomina a estos nombres finales nombres físicos.

Por ejemplo, AWS CloudFormation podría crear el bucket de Amazon S3 con el identificador lógico Stack2MyBucket4DD88B4F y el nombre stack2MyBucket4dd88b4f-iuv1rbv9z3to físico.

Puede especificar un nombre físico al crear constructo que representen recursos mediante la propiedad <resourceType>Name. En el siguiente ejemplo se crea un bucket de Amazon S3 con el nombre físico amzn-s3-demo-bucket.

ejemplo

La asignación de nombres físicos a los recursos tiene algunas desventajas en AWS CloudFormation: Y lo que es más importante, cualquier cambio en los recursos implementados que requiera la sustitución de un recurso, como los cambios en las propiedades de un recurso que sean inmutables tras su creación, fallará si a un recurso se le ha asignado un nombre físico. Si terminas en ese estado, la única solución es eliminar la AWS CloudFormation pila y, a continuación, volver a implementar la aplicación AWS CDK. Consulte la documentación de AWS CloudFormation para obtener más detalles.

En algunos casos, como cuando se crea una aplicación de AWS CDK con referencias entre entornos, se requieren nombres físicos para que el AWS CDK funcione correctamente. En esos casos, si no quieres molestarte en crear un nombre físico tú mismo, puedes dejar que el AWS CDK lo nombre por ti. Para ello, use el valor especial PhysicalName.GENERATE_IF_NEEDED, de la siguiente manera.

ejemplo

Pasar identificadores de recursos únicos

Siempre que sea posible, debe pasar recursos por referencia, como se describe en la sección anterior. Sin embargo, hay casos en los que no tiene otra opción que hacer referencia a un recurso por uno de sus atributos. Algunos ejemplos de casos de uso incluyen lo siguiente:

Cuando utilizas recursos de bajo nivel. AWS CloudFormation
Cuando necesita exponer los recursos a los componentes de tiempo de ejecución de una aplicación AWS CDK, por ejemplo, cuando hace referencia a las funciones de Lambda mediante variables de entorno.

Estos identificadores están disponibles como atributos en los recursos, como los siguientes.

ejemplo

El siguiente ejemplo muestra cómo pasar un nombre de bucket generado a una función de AWS Lambda.

ejemplo

Otorgar permisos entre recursos

Higher-level las construcciones permiten obtener permisos con privilegios mínimos al ofrecer API sencillas y basadas en la intención para expresar los requisitos de permisos. Por ejemplo, muchas construcciones ofrecen métodos de concesión que puedes usar para conceder a una entidad (como un rol o un usuario de IAM) permiso para trabajar con el recurso, sin tener que crear manualmente declaraciones de permiso de IAM.

Los métodos de concesión están disponibles en las clases de Grants (por ejemplo, en el caso de BucketGrants los buckets de Amazon S3). Estas clases funcionan con las construcciones L1 y L2. Las construcciones L2 exponen una grants propiedad para mayor comodidad, pero también puedes crear una clase Grants directamente a partir de una construcción L1. Puedes combinar las clases de Grants con las de Mixins para que te resulte más L2-like cómodo usar las construcciones de nivel 1.

El siguiente ejemplo crea los permisos para permitir que el rol de ejecución de una función de Lambda lea y escriba objetos en un bucket de Amazon S3 concreto. Si el bucket de Amazon S3 está cifrado con una clave de AWS KMS, este método también otorga permisos al rol de ejecución de la función de Lambda para descifrarlo con la clave.

ejemplo

Los métodos de concesión devuelven un objeto iam.Grant. Utilice el atributo success del objeto Grant para determinar si la subvención se aplicó de manera efectiva (por ejemplo, es posible que no se haya aplicado a recursos externos). También puede usar el método assertSuccess (Python: assert_success) del objeto Grant para garantizar que la concesión se haya aplicado correctamente.

Si un método de concesión específico no está disponible para un caso de uso concreto, puede usar un método de concesión genérico para definir una nueva concesión con una lista de acciones específica.

En el siguiente ejemplo se muestra cómo conceder acceso a una función de Lambda al CreateBackup de Amazon DynamoDB.

ejemplo

Muchos recursos, como las funciones de Lambda, requieren que se asuma un rol al ejecutar el código. Una propiedad de configuración le permite especificar un iam.IRole. Si no se especifica ningún rol, la función crea automáticamente un rol específico para este uso. A continuación, puede utilizar métodos de concesión en los recursos para agregar declaraciones al rol.

Los métodos de concesión se crean con la API de nivel inferior para administrarlos con las políticas de IAM. Las políticas se modelan como objetos. PolicyDocument Agregue instrucciones directamente a los roles (o al rol adjunto de un constructo) mediante el método addToRolePolicy (Python: add_to_role_policy) o a la política de un recurso (como una política Bucket) mediante el método addToResourcePolicy (Python: add_to_resource_policy).

Métricas de recursos y alarmas

Muchos recursos emiten CloudWatch métricas que se pueden usar para configurar alarmas y paneles de monitoreo. Higher-level los constructos tienen métodos métricos que permiten acceder a las métricas sin tener que buscar el nombre correcto que se va a utilizar.

El siguiente ejemplo muestra cómo definir una alarma cuando el ApproximateNumberOfMessagesNotVisible de Amazon SQS supera 100.

ejemplo

TypeScript


import * as cw from '@aws-cdk/aws-cloudwatch';
import * as sqs from '@aws-cdk/aws-sqs';
import { Duration } from '@aws-cdk/core';

const queue = new sqs.Queue(this, 'MyQueue');

const metric = queue.metricApproximateNumberOfMessagesNotVisible({
  label: 'Messages Visible (Approx)',
  period: Duration.minutes(5),
  // ...
});
metric.createAlarm(this, 'TooManyMessagesAlarm', {
  comparisonOperator: cw.ComparisonOperator.GREATER_THAN_THRESHOLD,
  threshold: 100,
  // ...
});

JavaScript


const cw = require('@aws-cdk/aws-cloudwatch');
const sqs = require('@aws-cdk/aws-sqs');
const { Duration } = require('@aws-cdk/core');

const queue = new sqs.Queue(this, 'MyQueue');

const metric = queue.metricApproximateNumberOfMessagesNotVisible({
  label: 'Messages Visible (Approx)',
  period: Duration.minutes(5)
  // ...
});
metric.createAlarm(this, 'TooManyMessagesAlarm', {
  comparisonOperator: cw.ComparisonOperator.GREATER_THAN_THRESHOLD,
  threshold: 100
  // ...
});

Python


import aws_cdk.aws_cloudwatch as cw
import aws_cdk.aws_sqs as sqs
from aws_cdk.core import Duration

queue = sqs.Queue(self, "MyQueue")
metric = queue.metric_approximate_number_of_messages_not_visible(
    label="Messages Visible (Approx)",
    period=Duration.minutes(5),
    # ...
)
metric.create_alarm(self, "TooManyMessagesAlarm",
    comparison_operator=cw.ComparisonOperator.GREATER_THAN_THRESHOLD,
    threshold=100,
    # ...
)

Java


import software.amazon.awscdk.core.Duration;
import software.amazon.awscdk.services.sqs.Queue;
import software.amazon.awscdk.services.cloudwatch.Metric;
import software.amazon.awscdk.services.cloudwatch.MetricOptions;
import software.amazon.awscdk.services.cloudwatch.CreateAlarmOptions;
import software.amazon.awscdk.services.cloudwatch.ComparisonOperator;

Queue queue = new Queue(this, "MyQueue");

Metric metric = queue
        .metricApproximateNumberOfMessagesNotVisible(MetricOptions.builder()
                .label("Messages Visible (Approx)")
                .period(Duration.minutes(5)).build());

metric.createAlarm(this, "TooManyMessagesAlarm", CreateAlarmOptions.builder()
                .comparisonOperator(ComparisonOperator.GREATER_THAN_THRESHOLD)
                .threshold(100)
                // ...
                .build());

C#


using cdk = Amazon.CDK;
using cw = Amazon.CDK.AWS.CloudWatch;
using sqs = Amazon.CDK.AWS.SQS;

var queue = new sqs.Queue(this, "MyQueue");
var metric = queue.MetricApproximateNumberOfMessagesNotVisible(new cw.MetricOptions
{
    Label = "Messages Visible (Approx)",
    Period = cdk.Duration.Minutes(5),
    // ...
});
metric.CreateAlarm(this, "TooManyMessagesAlarm", new cw.CreateAlarmOptions
{
    ComparisonOperator = cw.ComparisonOperator.GREATER_THAN_THRESHOLD,
    Threshold = 100,
    // ..
});

Go


import (
  "github.com/aws/aws-cdk-go/awscdk/v2"
  "github.com/aws/jsii-runtime-go"
  cw "github.com/aws/aws-cdk-go/awscdk/v2/awscloudwatch"
  sqs "github.com/aws/aws-cdk-go/awscdk/v2/awssqs"
)

queue := sqs.NewQueue(this, jsii.String("MyQueue"), &sqs.QueueProps{})
metric := queue.MetricApproximateNumberOfMessagesNotVisible(&cw.MetricOptions{
  Label: jsii.String("Messages Visible (Approx)"),
  Period: awscdk.Duration_Minutes(jsii.Number(5)),
})

metric.CreateAlarm(this, jsii.String("TooManyMessagesAlarm"), &cw.CreateAlarmOptions{
  ComparisonOperator: cw.ComparisonOperator_GREATER_THAN_THRESHOLD,
  Threshold: jsii.Number(100),
})

Si no hay ningún método para una métrica en particular, puede utilizar el método de métrica general para especificar el nombre de la métrica manualmente.

Las métricas también se pueden agregar a los CloudWatch paneles. Consulte CloudWatch.

Tráfico de red

En muchos casos, debe habilitar los permisos en una red para que una aplicación funcione, por ejemplo, cuando la infraestructura informática necesita acceder a la capa de persistencia. Los recursos que establecen o detectan las conexiones exponen métodos que permiten los flujos de tráfico, como el establecimiento de reglas de grupos de seguridad o ACL de red.

Los recursos de iConnectable tienen una propiedad connections que es la puerta de enlace a la configuración de las reglas de tráfico de la red.

Para permitir que los datos fluyan en una ruta de red determinada, se utilizan métodos allow. El siguiente ejemplo habilita las conexiones HTTPS a la web y las conexiones entrantes desde el grupo Amazon EC2 Auto Scaling fleet2.

ejemplo

TypeScript


import * as asg from '@aws-cdk/aws-autoscaling';
import * as ec2 from '@aws-cdk/aws-ec2';

const fleet1: asg.AutoScalingGroup = asg.AutoScalingGroup(/*...*/);

// Allow surfing the (secure) web
fleet1.connections.allowTo(new ec2.Peer.anyIpv4(), new ec2.Port({ fromPort: 443, toPort: 443 }));

const fleet2: asg.AutoScalingGroup = asg.AutoScalingGroup(/*...*/);
fleet1.connections.allowFrom(fleet2, ec2.Port.AllTraffic());

JavaScript


const asg = require('@aws-cdk/aws-autoscaling');
const ec2 = require('@aws-cdk/aws-ec2');

const fleet1 = asg.AutoScalingGroup();

// Allow surfing the (secure) web
fleet1.connections.allowTo(new ec2.Peer.anyIpv4(), new ec2.Port({ fromPort: 443, toPort: 443 }));

const fleet2 = asg.AutoScalingGroup();
fleet1.connections.allowFrom(fleet2, ec2.Port.AllTraffic());

Python


import aws_cdk.aws_autoscaling as asg
import aws_cdk.aws_ec2 as ec2

fleet1 = asg.AutoScalingGroup( ... )

# Allow surfing the (secure) web
fleet1.connections.allow_to(ec2.Peer.any_ipv4(),
  ec2.Port(PortProps(from_port=443, to_port=443)))

fleet2 = asg.AutoScalingGroup( ... )
fleet1.connections.allow_from(fleet2, ec2.Port.all_traffic())

Java


import software.amazon.awscdk.services.autoscaling.AutoScalingGroup;
import software.amazon.awscdk.services.ec2.Peer;
import software.amazon.awscdk.services.ec2.Port;

AutoScalingGroup fleet1 = AutoScalingGroup.Builder.create(this, "MyFleet")
        /* ... */.build();

// Allow surfing the (secure) Web
fleet1.getConnections().allowTo(Peer.anyIpv4(),
        Port.Builder.create().fromPort(443).toPort(443).build());

AutoScalingGroup fleet2 = AutoScalingGroup.Builder.create(this, "MyFleet2")
        /* ... */.build();
fleet1.getConnections().allowFrom(fleet2, Port.allTraffic());

C#


using cdk = Amazon.CDK;
using asg = Amazon.CDK.AWS.AutoScaling;
using ec2 = Amazon.CDK.AWS.EC2;

// Allow surfing the (secure) Web
var fleet1 = new asg.AutoScalingGroup(this, "MyFleet", new asg.AutoScalingGroupProps { /* ... */ });
fleet1.Connections.AllowTo(ec2.Peer.AnyIpv4(), new ec2.Port(new ec2.PortProps
  { FromPort = 443, ToPort = 443 }));

var fleet2 = new asg.AutoScalingGroup(this, "MyFleet2", new asg.AutoScalingGroupProps { /* ... */ });
fleet1.Connections.AllowFrom(fleet2, ec2.Port.AllTraffic());

Go


import (
  "github.com/aws/aws-cdk-go/awscdk/v2"
  "github.com/aws/jsii-runtime-go"
  autoscaling "github.com/aws/aws-cdk-go/awscdk/v2/awsautoscaling"
  ec2 "github.com/aws/aws-cdk-go/awscdk/v2/awsec2"
)

fleet1 := autoscaling.NewAutoScalingGroup(this, jsii.String("MyFleet1"), &autoscaling.AutoScalingGroupProps{})
fleet1.Connections().AllowTo(ec2.Peer_AnyIpv4(),ec2.NewPort(&ec2.PortProps{ FromPort: jsii.Number(443), ToPort: jsii.Number(443) }),jsii.String("secure web"))

fleet2 := autoscaling.NewAutoScalingGroup(this, jsii.String("MyFleet2"), &autoscaling.AutoScalingGroupProps{})
fleet1.Connections().AllowFrom(fleet2, ec2.Port_AllTraffic(),jsii.String("all traffic"))

Algunos recursos tienen puertos predeterminados asociados. Los ejemplos incluyen el oyente de un equilibrador de carga en el puerto público y los puertos en los que el motor de base de datos acepta conexiones para instancias de una base de datos de Amazon RDS. En estos casos, puede imponer un control estricto de la red sin tener que especificar el puerto manualmente. Para hacerlo, utilice los métodos allowDefaultPortFrom y allowToDefaultPort (Python: allow_default_port_from, allow_to_default_port).

El siguiente ejemplo muestra cómo habilitar las conexiones desde cualquier dirección IPV4 y una conexión desde un grupo de escalado automático para acceder a una base de datos.

ejemplo

Control de eventos

Algunos recursos pueden actuar como fuentes de eventos. Utilice el método addEventNotification (Python: add_event_notification) para registrar un objetivo de evento en un tipo de evento concreto emitido por el recurso. Además, los métodos addXxxNotification ofrecen una forma sencilla de registrar un controlador para los tipos de eventos más comunes.

En el siguiente ejemplo se muestra cómo activar una función de Lambda cuando se agrega un objeto a un bucket de Amazon S3.

ejemplo

TypeScript


import * as s3nots from '@aws-cdk/aws-s3-notifications';

const handler = new lambda.Function(this, 'Handler', { /*…*/ });
const bucket = new s3.Bucket(this, 'Bucket');
bucket.addObjectCreatedNotification(new s3nots.LambdaDestination(handler));

JavaScript


const s3nots = require('@aws-cdk/aws-s3-notifications');

const handler = new lambda.Function(this, 'Handler', { /*…*/ });
const bucket = new s3.Bucket(this, 'Bucket');
bucket.addObjectCreatedNotification(new s3nots.LambdaDestination(handler));

Python


import aws_cdk.aws_s3_notifications as s3_nots

handler = lambda_.Function(self, "Handler", ...)
bucket = s3.Bucket(self, "Bucket")
bucket.add_object_created_notification(s3_nots.LambdaDestination(handler))

Java


import software.amazon.awscdk.services.s3.Bucket;
import software.amazon.awscdk.services.lambda.Function;
import software.amazon.awscdk.services.s3.notifications.LambdaDestination;

Function handler = Function.Builder.create(this, "Handler")/* ... */.build();
Bucket bucket = new Bucket(this, "Bucket");
bucket.addObjectCreatedNotification(new LambdaDestination(handler));

C#


using lambda = Amazon.CDK.AWS.Lambda;
using s3 = Amazon.CDK.AWS.S3;
using s3Nots = Amazon.CDK.AWS.S3.Notifications;

var handler = new lambda.Function(this, "Handler", new lambda.FunctionProps { .. });
var bucket = new s3.Bucket(this, "Bucket");
bucket.AddObjectCreatedNotification(new s3Nots.LambdaDestination(handler));

Go


import (
  "github.com/aws/aws-cdk-go/awscdk/v2"
  "github.com/aws/jsii-runtime-go"
  s3 "github.com/aws/aws-cdk-go/awscdk/v2/awss3"
  s3nots "github.com/aws/aws-cdk-go/awscdk/v2/awss3notifications"
)

handler := lambda.NewFunction(this, jsii.String("MyFunction"), &lambda.FunctionProps{})
bucket := s3.NewBucket(this, jsii.String("Bucket"), &s3.BucketProps{})
bucket.AddObjectCreatedNotification(s3nots.NewLambdaDestination(handler), nil)

Políticas de eliminación

Los recursos que mantienen datos persistentes, como las bases de datos, los buckets de Amazon S3 y los registros de Amazon ECR, tienen una política de eliminación. La política de eliminación indica si se deben eliminar los objetos persistentes cuando se destruye la pila de AWS CDK que los contiene. Los valores que especifican la política de eliminación están disponibles en la RemovalPolicy enumeración del módulo AWS core CDK.

nota

Los recursos, además de los que almacenan datos de forma persistente, también pueden tener una removalPolicy que se utilice para un propósito diferente. Por ejemplo, una versión de una función de Lambda usa un atributo removalPolicy para determinar si una versión determinada se conserva cuando se implementa una nueva versión. Tienen significados y valores predeterminados diferentes en comparación con la política de eliminación de un bucket de Amazon S3 o tabla de DynamoDB.

Valor	Significado
`RemovalPolicy.RETAIN`	Conserve el contenido del recurso al destruir la pila (opción predeterminada). El recurso queda huérfano de la pila y se debe eliminar manualmente. Si intenta volver a implementar la pila mientras el recurso aún existe, recibirá un mensaje de error debido a un conflicto de nombres.
`RemovalPolicy.DESTROY`	El recurso se destruirá junto con la pila.

AWS CloudFormation no elimina los buckets de Amazon S3 que contienen archivos, aunque su política de eliminación esté establecida en. DESTROY Intentar hacerlo es un AWS CloudFormation error. Para que el AWS CDK elimine todos los archivos del depósito antes de destruirlo, defina true la autoDeleteObjects propiedad del depósito en.

A continuación, se muestra un ejemplo de cómo crear un bucket de Amazon S3 con la RemovalPolicy de DESTROY y autoDeleteOjbects establecido en true.

ejemplo

TypeScript


import * as cdk from '@aws-cdk/core';
import * as s3 from '@aws-cdk/aws-s3';

export class CdkTestStack extends cdk.Stack {
  constructor(scope: cdk.Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    const bucket = new s3.Bucket(this, 'Bucket', {
      removalPolicy: cdk.RemovalPolicy.DESTROY,
      autoDeleteObjects: true
    });
  }
}

JavaScript


const cdk = require('@aws-cdk/core');
const s3 = require('@aws-cdk/aws-s3');

class CdkTestStack extends cdk.Stack {
  constructor(scope, id, props) {
    super(scope, id, props);

    const bucket = new s3.Bucket(this, 'Bucket', {
      removalPolicy: cdk.RemovalPolicy.DESTROY,
      autoDeleteObjects: true
    });
  }
}

module.exports = { CdkTestStack }

Python


import aws_cdk.core as cdk
import aws_cdk.aws_s3 as s3

class CdkTestStack(cdk.stack):
    def __init__(self, scope: cdk.Construct, id: str, **kwargs):
        super().__init__(scope, id, **kwargs)

        bucket = s3.Bucket(self, "Bucket",
            removal_policy=cdk.RemovalPolicy.DESTROY,
            auto_delete_objects=True)

Java


software.amazon.awscdk.core.*;
import software.amazon.awscdk.services.s3.*;

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

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

        Bucket.Builder.create(this, "Bucket")
                .removalPolicy(RemovalPolicy.DESTROY)
                .autoDeleteObjects(true).build();
    }
}

C#


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

public CdkTestStack(Construct scope, string id, IStackProps props) : base(scope, id, props)
{
    new Bucket(this, "Bucket", new BucketProps {
        RemovalPolicy = RemovalPolicy.DESTROY,
        AutoDeleteObjects = true
    });
}

Go


import (
  "github.com/aws/aws-cdk-go/awscdk/v2"
  "github.com/aws/jsii-runtime-go"
  s3 "github.com/aws/aws-cdk-go/awscdk/v2/awss3"
)

s3.NewBucket(this, jsii.String("Bucket"), &s3.BucketProps{
  RemovalPolicy: awscdk.RemovalPolicy_DESTROY,
  AutoDeleteObjects: jsii.Bool(true),
})

También puedes aplicar una política de eliminación directamente al AWS CloudFormation recurso subyacente mediante applyRemovalPolicy() este método. Este método está disponible en algunos recursos con estado que no tienen una propiedad removalPolicy en los props de sus recursos de nivel 2. Algunos ejemplos son los siguientes:

AWS CloudFormation pilas
Grupos de usuarios de Amazon Cognito
Instancias de base de datos de Amazon DocumentDB
Volúmenes de Amazon EC2
Dominios de Amazon OpenSearch Service
Sistemas de archivos de Amazon FSx
Colas de Amazon SQS

ejemplo

nota

Los AWS CDK RemovalPolicy se traducen como «s AWS CloudFormation». DeletionPolicy Sin embargo, lo predeterminado en el AWS CDK es retener los datos, que es lo contrario de lo predeterminado. AWS CloudFormation

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

Bootstrapping (Proceso de arranque)

Identificadores