Configurazione delle risorse mediante costrutti Riferimento delle risorse Nomi fisici delle risorse Passaggio di identificatori di risorse univoci Concessione di autorizzazioni tra risorse Metriche e allarmi delle risorse Traffico di rete Gestione degli eventi Politiche di rimozione

Risorse e AWS CDK

Le risorse sono ciò che configuri per utilizzare AWS i servizi nelle tue applicazioni. Le risorse sono una funzionalità di AWS CloudFormation. Configurando le risorse e le relative proprietà in un AWS CloudFormation modello, è possibile implementarle AWS CloudFormation per il provisioning delle risorse. Con il AWS Cloud Development Kit (AWS CDK), puoi configurare le risorse tramite costrutti. Quindi distribuisci la tua app CDK, che prevede la sintesi di un AWS CloudFormation modello e la distribuzione per il provisioning delle tue risorse. AWS CloudFormation

Configurazione delle risorse mediante costrutti

Come descritto in AWS CDK Constructs, il AWS CDK fornisce una ricca libreria di classi di costrutti, chiamati costrutti, che rappresentano tutte le risorse. AWS

Per creare un'istanza di una risorsa utilizzando il costrutto corrispondente, passate l'ambito come primo argomento, l'ID logico del costrutto e un insieme di proprietà di configurazione (props). Ad esempio, ecco come creare una coda Amazon SQS con crittografia AWS KMS utilizzando il costrutto della Construct Library. sqs.Queue AWS

Esempio

Alcuni oggetti di configurazione sono opzionali e in molti casi hanno valori predefiniti. In alcuni casi, tutti gli oggetti di scena sono opzionali e l'ultimo argomento può essere omesso completamente.

Attributi delle risorse

La maggior parte delle risorse nella AWS Construct Library espone gli attributi, che vengono risolti al momento della distribuzione da. AWS CloudFormation Gli attributi sono esposti sotto forma di proprietà sulle classi di risorse con il nome del tipo come prefisso. L'esempio seguente mostra come ottenere l'URL di una coda Amazon SQS utilizzando la proprietà queueUrl (Python:). queue_url

Esempio

Consulta Tokens e AWS CDK per informazioni su come il CDK codifica gli attributi di distribuzione come stringhe AWS .

Riferimento delle risorse

Quando si configurano le risorse, spesso è necessario fare riferimento alle proprietà di un'altra risorsa. Di seguito vengono mostrati gli esempi:

Una risorsa Amazon Elastic Container Service (Amazon ECS) richiede un riferimento al cluster su cui viene eseguita.
Una CloudFront distribuzione Amazon richiede un riferimento al bucket Amazon Simple Storage Service (Amazon S3) contenente il codice sorgente.

Puoi fare riferimento alle risorse in uno dei seguenti modi:

Passando una risorsa definita nella tua app CDK, nello stesso stack o in uno diverso
Passando un oggetto proxy che fa riferimento a una risorsa definita nel tuo AWS account, creato da un identificatore univoco della risorsa (come un ARN)

Se la proprietà di un costrutto rappresenta un costrutto per un'altra risorsa, il suo tipo è quello del tipo di interfaccia del costrutto. Ad esempio, il costrutto Amazon ECS accetta una proprietà di tipo. cluster ecs.ICluster Un altro esempio è il costrutto di CloudFront distribuzione che accetta una proprietà sourceBucket (Python:source_bucket) di tipo. s3.IBucket

Puoi passare direttamente qualsiasi oggetto risorsa del tipo corretto definito nella stessa app AWS CDK. L'esempio seguente definisce un cluster Amazon ECS e quindi lo utilizza per definire un servizio Amazon ECS.

Esempio

Riferimento a risorse in uno stack diverso

È possibile fare riferimento a risorse in uno stack diverso, purché siano definite nella stessa app. Gli stack possono trovarsi nello stesso ambiente o in AWS ambienti diversi (account e regioni). In genere viene utilizzato il seguente schema:

Memorizza un riferimento al costrutto come attributo dello stack che produce la risorsa. (Per ottenere un riferimento allo stack del costrutto corrente, usaStack.of(this).)
Passa questo riferimento al costruttore dello stack che utilizza la risorsa come parametro o proprietà. Lo stack di consumo lo passa quindi come proprietà a qualsiasi costrutto che ne abbia bisogno.

L'esempio seguente definisce uno stackstack1. Questo stack definisce un bucket Amazon S3 e memorizza un riferimento al costrutto del bucket come attributo dello stack. Quindi l'app definisce un secondo stack, stack2 che accetta un bucket al momento dell'istanziazione. stack2potrebbe, ad esempio, definire una AWS Glue Table che utilizza il bucket per l'archiviazione dei dati.

Esempio

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

Se il AWS CDK determina che la risorsa si trova nello stesso ambiente, ma in uno stack diverso, sintetizza automaticamente AWS CloudFormation le esportazioni nello stack di produzione e uno Fn::ImportValue nello stack di consumo per trasferire tali informazioni da uno stack all'altro. Si tratta di un riferimento sicuro, il comportamento predefinito. È possibile controllare la forza dei riferimenti tra stack per evitare situazioni di stallo tra dipendenze.

Forza di riferimento

Ogni riferimento trasversale ha una forza che determina il CloudFormation meccanismo utilizzato e l'accoppiamento tra le pile:

Forte (impostazione predefinita): Lo stack di produzione crea un' CloudFormation esportazione e lo stack di consumo utilizzaFn::ImportValue. Ciò significa che lo stack di produzione non può essere aggiornato per rimuovere l'esportazione mentre un consumatore lo importa ancora. CloudFormation impone questo vincolo.
Debole: Lo stack di consumo viene utilizzato Fn::GetStackOutput per leggere gli output direttamente dallo stack di produzione. Non viene creato alcun accoppiamento di esportazione; entrambi gli stack possono essere aggiornati o eliminati indipendentemente.
Entrambi: Uno stato di transizione per la migrazione da forte a debole. Lo stack di produzione mantiene le esportazioni (in modo da non perdere i forti consumatori esistenti), mentre lo stack di consumo passa a. Fn::GetStackOutput

Lo stallo delle dipendenze (abbraccio mortale)

I riferimenti forti possono creare una situazione di stallo che impedisce gli aggiornamenti dello stack. Ciò accade perché CloudFormation non è possibile rimuovere un'esportazione mentre un altro stack la importa e lo stack di consumo non può essere aggiornato per interrompere l'importazione finché l'esportazione non esiste già. Potresti visualizzare un errore del tipo:

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

Ciò si verifica in genere quando si tenta di rimuovere una risorsa condivisa o di ristrutturare gli stack. I riferimenti deboli evitano completamente questo problema, perché non creano esportazioni.

Controllo della forza di riferimento

Puoi controllare la forza di riferimento in tre ambiti: a livello di app, per risorsa o per utilizzo.

App-wide impostazione predefinita

Imposta la seguente chiave di contesto cdk.json per modificare l'impostazione predefinita per tutti i riferimenti cross-stack nell'app:


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

Per-resource

Sostituisci la forza di tutti i riferimenti che puntano a una risorsa specifica utilizzando: CrossStackReferences.of(resource).produce(strength)

Esempio

Tutti i riferimenti bucket provenienti da altri stack verranno ora utilizzati Fn::GetStackOutput indipendentemente dall'impostazione predefinita a livello di app.

Per-usage

Sostituisci la forza di un singolo riferimento nel punto di consumo utilizzando: Stack.consumeReference()

Esempio

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

Usare Stack.consumeListReference() per i riferimenti agli elenchi di stringhe.

Sostituzione con ambito

È inoltre possibile impostare la forza di riferimento per un sottoalbero di costrutti utilizzando. CrossStackReferences.of(scope).consume(strength) Tutti i riferimenti cross-stack utilizzati all'interno di tale ambito utilizzeranno la forza specificata.

Migrazione da riferimenti forti a riferimenti deboli

Se hai già distribuito stack con riferimenti forti, non puoi passare direttamente a quelli deboli: CloudFormation fallirebbe perché l'esportazione è ancora in uso. Utilizzate invece una migrazione in due fasi attraverso lo stato di transizione. BOTH

L'API da utilizzare dipende dal tuo obiettivo:

Rimuovere un singolo riferimento (mantenendo però sia gli stack che la risorsa al loro posto): usalo Stack.consumeReference() per indebolire solo quell'uso specifico.
Rimozione o ristrutturazione della risorsa di produzione: utilizzo CrossStackReferences.of(producer).produce() per indebolire tutti i riferimenti che puntano contemporaneamente a quella risorsa.

Entrambi gli approcci seguono lo stesso schema in due fasi descritto di seguito. Gli esempi mostrano l'approccio per risorsa. Per uso specifico, inserisci il riferimento nella Fase 1 e Stack.consumeReference(ref, ReferenceStrength.BOTH) Stack.consumeReference(ref, ReferenceStrength.WEAK) nella Fase 2.

Fase 1: implementazione con ENTRAMBI

Cambia la forza di riferimento suBOTH. Questo fa sì che lo stack di consumo inizi a utilizzarloFn::GetStackOutput, ma mantiene l'esportazione nello stack di produzione in modo che la transizione sia sicura:

Esempio

Distribuisci entrambi gli stack.

Fase 2: schieramento con WEAK

Ora che nessun consumatore lo utilizzaFn::ImportValue, l'esportazione può essere rimossa in sicurezza. Passa aWEAK:

Esempio

Distribuisci entrambi gli stack. L'esportazione viene rimossa e il riferimento è ora completamente debole.

Dopo questa migrazione, puoi rimuovere, spostare o ristrutturare liberamente la risorsa senza cadere in un abbraccio mortale.

Soluzione manuale (precedente)

Se non state ancora utilizzando i controlli della forza di riferimento, potete aggirare il deadlock manualmente. Rimuovi l'uso della risorsa condivisa dallo stack di consumo. Quindi aggiungi manualmente la stessa esportazione allo stack di produzione utilizzando esattamente lo stesso ID logico dell'esportazione generata automaticamente. Distribuisci entrambi gli stack per rimuovere il. Fn::ImportValue Quindi rimuovi l'esportazione manuale (e la risorsa condivisa se non è più necessaria) e distribuisci nuovamente entrambi gli stack. Il exportValue() metodo dello stack è un modo conveniente per creare l'esportazione manuale a questo scopo.

Fare riferimento alle risorse presenti nel tuo AWS account

Supponiamo di voler utilizzare una risorsa già disponibile nel tuo AWS account nella tua app AWS CDK. Potrebbe trattarsi di una risorsa definita tramite la console, un AWS SDK, direttamente con AWS CloudFormation o in un'altra AWS applicazione CDK. Puoi trasformare l'ARN della risorsa (o un altro attributo identificativo o gruppo di attributi) in un oggetto proxy. L'oggetto proxy funge da riferimento alla risorsa chiamando un metodo factory statico sulla classe della risorsa.

Quando crei un proxy di questo tipo, la risorsa esterna non diventa parte della tua app AWS CDK. Pertanto, le modifiche apportate al proxy nell'app AWS CDK non influiscono sulla risorsa distribuita. Il proxy può, tuttavia, essere passato a qualsiasi metodo AWS CDK che richieda una risorsa di quel tipo.

L'esempio seguente mostra come fare riferimento a un bucket basato su un bucket esistente con l'ARN arn:aws:s3:::amzn-s3-demo-bucket1 e a un Amazon Virtual Private Cloud basato su un VPC esistente con un ID specifico.

Esempio

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

Diamo un'occhiata più da vicino al metodo. Vpc.fromLookup() Poiché il ec2.Vpc costrutto è complesso, ci sono molti modi in cui potresti voler selezionare il VPC da utilizzare con la tua app CDK. Per risolvere questo problema, il costrutto VPC ha un metodo fromLookup statico (Python:from_lookup) che ti consente di cercare l'Amazon VPC desiderato interrogando il tuo account in fase di sintesi. AWS

Per utilizzarloVpc.fromLookup(), il sistema che sintetizza lo stack deve avere accesso all'account proprietario di Amazon VPC. Questo perché il CDK Toolkit interroga l'account per trovare l'Amazon VPC giusto al momento della sintesi.

Inoltre, Vpc.fromLookup() funziona solo in stack definiti con un account e una regione espliciti (vedi Environments for the CDK). AWS Se il AWS CDK tenta di cercare un Amazon VPC da uno stack indipendente dall'ambiente, il CDK Toolkit non sa in quale ambiente interrogare per trovare il VPC.

Devi fornire Vpc.fromLookup() attributi sufficienti per identificare in modo univoco un VPC nel tuo account. AWS Ad esempio, può esserci un solo VPC predefinito, quindi è sufficiente specificare il VPC come predefinito.

Esempio

È inoltre possibile utilizzare la tags proprietà per ricercare i VPC tramite tag. Puoi aggiungere tag ad Amazon VPC al momento della sua creazione utilizzando AWS CloudFormation o il AWS CDK. Puoi modificare i tag in qualsiasi momento dopo la creazione utilizzando la console di AWS gestione, la AWS CLI o un SDK. AWS Oltre ai tag che aggiungi tu stesso, il AWS CDK aggiunge automaticamente i seguenti tag a tutti i VPC che crea.

Nome: il nome del VPC.
aws-cdk:subnet-name — Il nome della sottorete.
aws-cdk:subnet-type — Il tipo di sottorete: pubblica, privata o isolata.

Esempio

I risultati di vengono memorizzati nella cache nel file del progetto. Vpc.fromLookup() cdk.context.json (Vedi Valori di contesto e AWS CDK.) Invia questo file al controllo della versione in modo che la tua app continui a fare riferimento allo stesso Amazon VPC. Funziona anche se successivamente modifichi gli attributi dei tuoi VPC in un modo che comporterebbe la selezione di un VPC diverso. Ciò è particolarmente importante se stai implementando lo stack in un ambiente che non ha accesso all' AWS account che definisce il VPC, come CDK Pipelines. Integrazione e distribuzione continue (CI/CD) con CDK Pipelines

Sebbene sia possibile utilizzare una risorsa esterna ovunque si utilizzi una risorsa simile definita nell'app AWS CDK, non è possibile modificarla. Ad esempio, chiamare addToResourcePolicy (Python:add_to_resource_policy) su un dispositivo esterno s3.Bucket non fa nulla.

Nomi fisici delle risorse

I nomi logici delle risorse in AWS CloudFormation sono diversi dai nomi delle risorse visualizzate nella Console di AWS gestione dopo la distribuzione da AWS CloudFormation. Il AWS CDK chiama questi nomi finali nomi fisici.

Ad esempio, AWS CloudFormation potrebbe creare il bucket Amazon S3 con l'ID logico Stack2MyBucket4DD88B4F e il nome fisico. stack2MyBucket4dd88b4f-iuv1rbv9z3to

È possibile specificare un nome fisico quando si creano costrutti che rappresentano risorse utilizzando la proprietà. <resourceType>Name L'esempio seguente crea un bucket Amazon S3 con il nome fisico. amzn-s3-demo-bucket

Esempio

L'assegnazione di nomi fisici alle risorse presenta alcuni svantaggi in. AWS CloudFormation Soprattutto, qualsiasi modifica alle risorse distribuite che richiedono una sostituzione delle risorse, ad esempio le modifiche alle proprietà di una risorsa che sono immutabili dopo la creazione, avrà esito negativo se a una risorsa è assegnato un nome fisico. Se si finisce in questo stato, l'unica soluzione è eliminare lo AWS CloudFormation stack e quindi distribuire nuovamente l'app CDK. AWS Consulta la AWS CloudFormation documentazione per i dettagli.

In alcuni casi, ad esempio quando si crea un'app AWS CDK con riferimenti interambientali, sono necessari nomi fisici per il corretto funzionamento del AWS CDK. In questi casi, se non vuoi preoccuparti di inventarti tu stesso un nome fisico, puoi lasciare che sia il AWS CDK a chiamarlo per te. A tale scopo, utilizzate il valore specialePhysicalName.GENERATE_IF_NEEDED, come segue.

Esempio

Passaggio di identificatori di risorse univoci

Quando possibile, dovresti passare le risorse per riferimento, come descritto nella sezione precedente. Tuttavia, ci sono casi in cui non hai altra scelta che fare riferimento a una risorsa tramite uno dei suoi attributi. I casi d'uso di esempio includono quanto segue:

Quando si utilizzano AWS CloudFormation risorse di basso livello.
Quando è necessario esporre le risorse ai componenti di runtime di un'applicazione AWS CDK, ad esempio quando si fa riferimento alle funzioni Lambda tramite variabili di ambiente.

Questi identificatori sono disponibili come attributi nelle risorse, come i seguenti.

Esempio

L'esempio seguente mostra come passare il nome di un bucket generato a una AWS funzione Lambda.

Esempio

Concessione di autorizzazioni tra risorse

Higher-level i costrutti rendono possibili le autorizzazioni con privilegi minimi offrendo API semplici e basate sugli intenti per esprimere i requisiti di autorizzazione. Ad esempio, molti costrutti offrono metodi di concessione che è possibile utilizzare per concedere a un'entità (come un ruolo o un utente IAM) l'autorizzazione a lavorare con la risorsa, senza dover creare manualmente le dichiarazioni di autorizzazione IAM.

I metodi Grant sono disponibili tramite le classi Grants (ad esempio BucketGrants per i bucket Amazon S3). Queste classi funzionano con i costrutti L1 e L2. I costrutti L2 espongono una grants proprietà per comodità, ma è anche possibile creare una classe Grants direttamente da un costrutto L1. Puoi combinare le classi Grants con Mixins per ottenere comodità sui costrutti L1. L2-like

L'esempio seguente crea le autorizzazioni per consentire al ruolo di esecuzione di una funzione Lambda di leggere e scrivere oggetti in un particolare bucket Amazon S3. Se il bucket Amazon S3 è crittografato con una chiave AWS KMS, questo metodo concede anche le autorizzazioni al ruolo di esecuzione della funzione Lambda per la decrittografia con la chiave.

Esempio

I metodi iam.Grant di concessione restituiscono un oggetto. Utilizzate l'successattributo dell'Grantoggetto per determinare se la concessione è stata effettivamente applicata (ad esempio, potrebbe non essere stata applicata a risorse esterne). Puoi anche usare il metodo assertSuccess (Python:assert_success) dell'Grantoggetto per far sì che la concessione sia stata applicata correttamente.

Se un metodo di concessione specifico non è disponibile per il particolare caso d'uso, è possibile utilizzare un metodo di concessione generico per definire una nuova concessione con un elenco di azioni specificato.

L'esempio seguente mostra come concedere a una funzione Lambda l'accesso all'azione Amazon DynamoDBCreateBackup.

Esempio

Molte risorse, come le funzioni Lambda, richiedono l'assunzione di un ruolo durante l'esecuzione del codice. Una proprietà di configurazione consente di specificare uniam.IRole. Se non viene specificato alcun ruolo, la funzione crea automaticamente un ruolo specifico per questo uso. È quindi possibile utilizzare i metodi di concessione sulle risorse per aggiungere dichiarazioni al ruolo.

I metodi di concessione sono creati utilizzando API di livello inferiore per la gestione con le politiche IAM. Le policy sono modellate come oggetti. PolicyDocument Aggiungi le istruzioni direttamente ai ruoli (o al ruolo associato a un costrutto) usando il addToRolePolicy metodo (Python:add_to_role_policy) o alla policy di una risorsa (come una Bucket policy) usando il metodo addToResourcePolicy (Python:). add_to_resource_policy

Metriche e allarmi delle risorse

Molte risorse emettono CloudWatch metriche che possono essere utilizzate per configurare dashboard e allarmi di monitoraggio. Higher-level i costrutti dispongono di metodi metrici che consentono di accedere alle metriche senza cercare il nome corretto da utilizzare.

L'esempio seguente mostra come definire un allarme quando il numero ApproximateNumberOfMessagesNotVisible di una coda Amazon SQS supera 100.

Esempio

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

Se non esiste un metodo per una particolare metrica, puoi utilizzare il metodo metrico generale per specificare manualmente il nome della metrica.

Le metriche possono anche essere aggiunte alle dashboard. CloudWatch Consulta CloudWatch.

Traffico di rete

In molti casi, è necessario abilitare le autorizzazioni su una rete affinché un'applicazione funzioni, ad esempio quando l'infrastruttura di elaborazione deve accedere al livello di persistenza. Le risorse che stabiliscono o ascoltano le connessioni espongono metodi che abilitano i flussi di traffico, tra cui l'impostazione delle regole dei gruppi di sicurezza o degli ACL di rete.

Le risorse IConnectable hanno una connections proprietà che funge da gateway per la configurazione delle regole del traffico di rete.

È possibile consentire il flusso dei dati su un determinato percorso di rete utilizzando metodi. allow L'esempio seguente abilita le connessioni HTTPS al Web e le connessioni in entrata dal gruppo Amazon EC2 Auto Scaling. fleet2

Esempio

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

Ad alcune risorse sono associate porte predefinite. Gli esempi includono il listener di un load balancer sulla porta pubblica e le porte su cui il motore di database accetta connessioni per le istanze di un database Amazon RDS. In questi casi, puoi applicare un rigoroso controllo della rete senza dover specificare manualmente la porta. Per farlo, usate i allowToDefaultPort metodi allowDefaultPortFrom and (Python:allow_default_port_from,allow_to_default_port).

L'esempio seguente mostra come abilitare le connessioni da qualsiasi indirizzo IPV4 e una connessione da un gruppo Auto Scaling per accedere a un database.

Esempio

Gestione degli eventi

Alcune risorse possono fungere da sorgenti di eventi. Usa il addEventNotification metodo (Python:add_event_notification) per registrare un evento target su un particolare tipo di evento emesso dalla risorsa. Inoltre, i addXxxNotification metodi offrono un modo semplice per registrare un gestore per tipi di eventi comuni.

L'esempio seguente mostra come attivare una funzione Lambda quando un oggetto viene aggiunto a un bucket Amazon S3.

Esempio

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)

Politiche di rimozione

Le risorse che gestiscono dati persistenti, come database, bucket Amazon S3 e registri Amazon ECR, hanno una politica di rimozione. La politica di rimozione indica se eliminare gli oggetti permanenti quando lo stack AWS CDK che li contiene viene distrutto. I valori che specificano la politica di rimozione sono disponibili tramite l'RemovalPolicyenumerazione nel modulo CDK. AWS core

Nota

Le risorse oltre a quelle che memorizzano i dati in modo persistente potrebbero avere anche una funzione utilizzata per uno removalPolicy scopo diverso. Ad esempio, una versione della funzione Lambda utilizza un removalPolicy attributo per determinare se una determinata versione viene mantenuta quando viene distribuita una nuova versione. Questi hanno significati e valori predefiniti diversi rispetto alla politica di rimozione su un bucket Amazon S3 o una tabella DynamoDB.

Valore	Significato
`RemovalPolicy.RETAIN`	Conserva il contenuto della risorsa quando distruggi lo stack (impostazione predefinita). La risorsa è rimasta orfana dallo stack e deve essere eliminata manualmente. Se tenti di ridistribuire lo stack mentre la risorsa esiste ancora, riceverai un messaggio di errore a causa di un conflitto di nomi.
`RemovalPolicy.DESTROY`	La risorsa verrà distrutta insieme allo stack.

AWS CloudFormation non rimuove i bucket Amazon S3 che contengono file anche se la loro politica di rimozione è impostata su. DESTROY Il tentativo di farlo è un errore. AWS CloudFormation Per fare in modo che il AWS CDK elimini tutti i file dal bucket prima di distruggerlo, imposta la proprietà del bucket su. autoDeleteObjects true

Di seguito è riportato un esempio di creazione di un bucket Amazon S3 con of e impostato su. RemovalPolicy DESTROY autoDeleteOjbects true

Esempio

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

Puoi anche applicare una politica di rimozione direttamente alla AWS CloudFormation risorsa sottostante tramite il applyRemovalPolicy() metodo. Questo metodo è disponibile su alcune risorse con stato che non hanno una removalPolicy proprietà negli oggetti di scena della risorsa L2. Considerare i seguenti esempi:

AWS CloudFormation pile
Pool di utenti Amazon Cognito
istanze di database Amazon DocumentDB
Volumi Amazon EC2
Domini Amazon OpenSearch Service
File system Amazon FSx
Code Amazon SQS

Esempio

Nota

Il AWS CDK RemovalPolicy si traduce in. AWS CloudFormation DeletionPolicy Tuttavia, l'impostazione predefinita in AWS CDK è la conservazione dei dati, che è l'opposto dell'impostazione predefinita. AWS CloudFormation

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

Bootstrapping (Processo di bootstrap)

Identificatori