Introduzione agli AWS CDK stack

Modalità Focus

Introduzione agli AWS CDK stack - AWS Cloud Development Kit (AWS CDK) v2

Informazioni sull'API dello stack Utilizzo degli stack di

Questa è la guida per sviluppatori AWS CDK v2. Il vecchio CDK v1 è entrato in manutenzione il 1° giugno 2022 e ha terminato il supporto il 1° giugno 2023.

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Questa è la guida per sviluppatori AWS CDK v2. Il vecchio CDK v1 è entrato in manutenzione il 1° giugno 2022 e ha terminato il supporto il 1° giugno 2023.

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Uno AWS CDK stack è la singola unità di distribuzione più piccola. Rappresenta una raccolta di AWS risorse che definisci utilizzando costrutti CDK. Quando si distribuiscono app CDK, le risorse all'interno di uno stack CDK vengono distribuite insieme come uno stack. AWS CloudFormation Per ulteriori informazioni sugli AWS CloudFormation stack, consulta Managing AWS resources as a single unit with AWS CloudFormation stacks nella AWS CloudFormation User Guide.

Puoi definire uno stack estendendo o ereditando dal costrutto. Stack L'esempio seguente è un modello comune per definire uno stack CDK su un file separato, noto come file stack. Qui, estendiamo o ereditiamo la Stack classe e definiamo un costruttore che accetta, e. scope id props Quindi, invochiamo il costruttore della Stack classe base utilizzando super con il file ricevutoscope, e: id props

TypeScript


import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';

export class MyCdkStack extends cdk.Stack { 
  constructor(scope: Construct, id: string, props?: cdk.StackProps) { 
    super(scope, id, props); 
    
    // Define your constructs here

  }
}

JavaScript


const { Stack } = require('aws-cdk-lib');

class MyCdkStack extends Stack {
  constructor(scope, id, props) {
    super(scope, id, props);

    // Define your constructs here

  }
}

module.exports = { MyCdkStack }

Python


from aws_cdk import (
  Stack,
)
from constructs import Construct

class MyCdkStack(Stack):

  def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
    super().__init__(scope, construct_id, **kwargs)

    # Define your constructs here

Java


package com.myorg;

import software.constructs.Construct;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;

public class MyCdkStack extends Stack {
  public MyCdkStack(final Construct scope, final String id) {  
    this(scope, id, null);
  }
  
  public MyCdkStack(final Construct scope, final String id, final StackProps props) {
    super(scope, id, props);

    // Define your constructs here
  }
}

C#


using Amazon.CDK; 
using Constructs;

namespace MyCdk
{
  public class MyCdkStack : Stack
  {
    internal MyCdkStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
    {
      // Define your constructs here
    }
  }
}

Go


package main

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

type CdkDemoAppStackProps struct {
	awscdk.StackProps
}

func NewCdkDemoAppStack(scope constructs.Construct, id string, props *CdkDemoAppStackProps) awscdk.Stack {
	var sprops awscdk.StackProps
	if props != nil {
		sprops = props.StackProps
	}
	stack := awscdk.NewStack(scope, &id, &sprops)

	// The code that defines your stack goes here

	return stack
}

func main() {
	defer jsii.Close()

	app := awscdk.NewApp(nil)

	NewCdkDemoAppStack(app, "CdkDemoAppStack", &CdkDemoAppStackProps{
		awscdk.StackProps{
			Env: env(),
		},
	})

	app.Synth(nil)
} 

//...

anchor anchor anchor anchor anchor anchor


import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';

export class MyCdkStack extends cdk.Stack { 
  constructor(scope: Construct, id: string, props?: cdk.StackProps) { 
    super(scope, id, props); 
    
    // Define your constructs here

  }
}

L'esempio precedente ha definito solo uno stack. Per creare lo stack, è necessario crearne un'istanza nel contesto dell'app CDK. Uno schema comune consiste nel definire l'app CDK e inizializzare lo stack su un file separato, noto come file dell'applicazione.

Di seguito è riportato un esempio che crea uno stack CDK denominato. MyCdkStack Qui, l'app CDK viene creata e MyCdkStack viene istanziata nel contesto dell'app:

anchor anchor anchor anchor anchor anchor


#!/usr/bin/env node
import 'source-map-support/register';
import * as cdk from 'aws-cdk-lib';
import { MyCdkStack } from '../lib/my-cdk-stack';

const app = new cdk.App();
new MyCdkStack(app, 'MyCdkStack', {
});

L'esempio seguente crea un'app CDK che contiene due stack:

anchor anchor anchor anchor anchor anchor


const app = new App();

new MyFirstStack(app, 'stack1');
new MySecondStack(app, 'stack2');

app.synth();

Informazioni sull'API dello stack

L'Stackoggetto fornisce un'API ricca, che include quanto segue:

Stack.of(construct)— Un metodo statico che restituisce lo Stack in cui è definito un costrutto. Ciò è utile se è necessario interagire con uno stack dall'interno di un costrutto riutilizzabile. La chiamata fallisce se non è possibile trovare uno stack nell'ambito.
stack.stackName(Python:stack_name) — Restituisce il nome fisico dello stack. Come accennato in precedenza, tutti gli AWS CDK stack hanno un nome fisico che AWS CDK possono risolvere durante la sintesi.
stack.regione stack.account — Restituisce rispettivamente la AWS regione e l'account in cui verrà distribuito questo stack. Queste proprietà restituiscono una delle seguenti:
- L'account o la regione specificati esplicitamente al momento della definizione dello stack
- Un token con codifica a stringa che si risolve negli AWS CloudFormation pseudo parametri per account e regione per indicare che questo stack è indipendente dall'ambiente
Per informazioni su come vengono determinati gli ambienti per gli stack, consulta. Ambienti per AWS CDK
stack.addDependency(stack)(Python: stack.add_dependency(stack) — Può essere usato per definire esplicitamente l'ordine di dipendenza tra due pile. Questo ordine viene rispettato dal cdk deploy comando quando si distribuiscono più stack contemporaneamente.
stack.tags— Restituisce un tag TagManagerche è possibile utilizzare per aggiungere o rimuovere tag a livello di stack. Questo gestore di tag tagga tutte le risorse all'interno dello stack e tagga anche lo stack stesso quando viene creato. AWS CloudFormation
stack.partition, stack.urlSuffix (Python:url_suffix), (stack.stackIdPython:) e (stack.notificationArnPython: stack_idnotification_arn) — Restituiscono token che si risolvono nei rispettivi pseudo parametri, ad esempio. AWS CloudFormation { "Ref": "AWS::Partition" } Questi token sono associati all'oggetto stack specifico in modo che il framework possa identificare i riferimenti cross-stack. AWS CDK
stack.availabilityZones(Python:availability_zones) — Restituisce l'insieme di zone di disponibilità disponibili nell'ambiente in cui viene distribuito questo stack. Per gli stack indipendenti dall'ambiente, questo restituisce sempre un array con due zone di disponibilità. Per gli stack specifici dell'ambiente, AWS CDK interroga l'ambiente e restituisce l'esatto set di zone di disponibilità disponibili nella regione specificata.
stack.parseArn(arn)and stack.formatArn(comps) (Python:parse_arn,format_arn) — Può essere usato per lavorare con Amazon Resource Names ()ARNs.
stack.toJsonString(obj)(Python:to_json_string) — Può essere usato per formattare un oggetto arbitrario come stringa JSON che può essere incorporata in un modello. AWS CloudFormation L'oggetto può includere token, attributi e riferimenti, che vengono risolti solo durante la distribuzione.
stack.templateOptions(Python:template_options) — Utilizzalo per specificare le opzioni del AWS CloudFormation modello, come Transform, Description e Metadata, per il tuo stack.

Utilizzo degli stack di

Gli stack vengono distribuiti come stack in un AWS CloudFormation ambiente. AWS L'ambiente copre uno specifico e. Account AWS Regione AWS

Quando si esegue il cdk synth comando per un'app con più stack, l'assembly cloud include un modello separato per ogni istanza dello stack. Anche se i due stack sono istanze della stessa classe, li AWS CDK emette come due modelli singoli.

È possibile sintetizzare ogni modello specificando il nome dello stack nel comando. cdk synth L'esempio seguente sintetizza il modello per: stack1


$ cdk synth stack1

Questo approccio è concettualmente diverso dal modo in cui vengono normalmente utilizzati i AWS CloudFormation modelli, in cui un modello può essere distribuito più volte e parametrizzato tramite parametri.AWS CloudFormation Sebbene AWS CloudFormation i parametri possano essere definiti in AWS CDK, in genere sono sconsigliati perché AWS CloudFormation i parametri vengono risolti solo durante la distribuzione. Ciò significa che non è possibile determinarne il valore nel codice.

Ad esempio, per includere in modo condizionale una risorsa nell'app in base al valore di un parametro, è necessario impostare una AWS CloudFormation condizione e contrassegnare la risorsa con essa. Adotta un AWS CDK approccio in cui i modelli concreti vengono risolti in fase di sintesi. Pertanto, è possibile utilizzare un'ifistruzione per verificare il valore e determinare se è necessario definire una risorsa o applicare alcuni comportamenti.

Nota

AWS CDK Fornisce la massima risoluzione possibile durante il periodo di sintesi per consentire l'uso idiomatico e naturale del linguaggio di programmazione.

Come qualsiasi altro costrutto, le pile possono essere composte insieme in gruppi. Il codice seguente mostra un esempio di servizio composto da tre stack: un piano di controllo, un piano dati e stack di monitoraggio. Il costrutto del servizio viene definito due volte: una volta per l'ambiente beta e una volta per l'ambiente di produzione.

TypeScript


import { App, Stack } from 'aws-cdk-lib';
import { Construct } from 'constructs';

interface EnvProps {
  prod: boolean;
}

// imagine these stacks declare a bunch of related resources
class ControlPlane extends Stack {}
class DataPlane extends Stack {}
class Monitoring extends Stack {}

class MyService extends Construct {

  constructor(scope: Construct, id: string, props?: EnvProps) {
  
    super(scope, id);
  
    // we might use the prod argument to change how the service is configured
    new ControlPlane(this, "cp");
    new DataPlane(this, "data");
    new Monitoring(this, "mon");  }
}

const app = new App();
new MyService(app, "beta");
new MyService(app, "prod", { prod: true });

app.synth();

JavaScript


const { App, Stack } = require('aws-cdk-lib');
const { Construct } = require('constructs');

// imagine these stacks declare a bunch of related resources
class ControlPlane extends Stack {}
class DataPlane extends Stack {}
class Monitoring extends Stack {}

class MyService extends Construct {

  constructor(scope, id, props) {
  
    super(scope, id);
  
    // we might use the prod argument to change how the service is configured
    new ControlPlane(this, "cp");
    new DataPlane(this, "data");
    new Monitoring(this, "mon");
  }
}

const app = new App();
new MyService(app, "beta");
new MyService(app, "prod", { prod: true });

app.synth();

Python


from aws_cdk import App, Stack
from constructs import Construct

# imagine these stacks declare a bunch of related resources
class ControlPlane(Stack): pass
class DataPlane(Stack): pass
class Monitoring(Stack): pass

class MyService(Construct):

  def __init__(self, scope: Construct, id: str, *, prod=False):
  
    super().__init__(scope, id)
  
    # we might use the prod argument to change how the service is configured
    ControlPlane(self, "cp")
    DataPlane(self, "data")
    Monitoring(self, "mon")
    
app = App();
MyService(app, "beta")
MyService(app, "prod", prod=True)

app.synth()

Java


package com.myorg;

import software.amazon.awscdk.App;
import software.amazon.awscdk.Stack;
import software.constructs.Construct;

public class MyApp {

    // imagine these stacks declare a bunch of related resources
    static class ControlPlane extends Stack {
        ControlPlane(Construct scope, String id) {
            super(scope, id);
        }
    }

    static class DataPlane extends Stack {
        DataPlane(Construct scope, String id) {
            super(scope, id);
        }
    }

    static class Monitoring extends Stack {
        Monitoring(Construct scope, String id) {
            super(scope, id);
        }
    }

    static class MyService extends Construct {
        MyService(Construct scope, String id) {
            this(scope, id, false);
        }
        
        MyService(Construct scope, String id, boolean prod) {
            super(scope, id);
            
            // we might use the prod argument to change how the service is configured
            new ControlPlane(this, "cp");
            new DataPlane(this, "data");
            new Monitoring(this, "mon");         
        }
    }
    
    public static void main(final String argv[]) {
        App app = new App();

        new MyService(app, "beta");
        new MyService(app, "prod", true);
        
        app.synth();
    }
}

C#


using Amazon.CDK;
using Constructs;

// imagine these stacks declare a bunch of related resources
public class ControlPlane : Stack {
    public ControlPlane(Construct scope, string id=null) : base(scope, id) { }
}

public class DataPlane : Stack {
    public DataPlane(Construct scope, string id=null) : base(scope, id) { }
}

public class Monitoring : Stack
{
    public Monitoring(Construct scope, string id=null) : base(scope, id) { }
}

public class MyService : Construct
{
    public MyService(Construct scope, string id, Boolean prod=false) : base(scope, id)
    {
        // we might use the prod argument to change how the service is configured
        new ControlPlane(this, "cp");
        new DataPlane(this, "data");
        new Monitoring(this, "mon");
    }
}

class Program
{
    static void Main(string[] args)
    {

        var app = new App();
        new MyService(app, "beta");
        new MyService(app, "prod", prod: true);
        app.Synth();
    }
}

Go


package main

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

type ControlPlaneStackProps struct {
	awscdk.StackProps
}

func NewControlPlaneStack(scope constructs.Construct, id string, props *ControlPlaneStackProps) awscdk.Stack {
	var sprops awscdk.StackProps
	if props != nil {
		sprops = props.StackProps
	}
	ControlPlaneStack := awscdk.NewStack(scope, jsii.String(id), &sprops)

	// The code that defines your stack goes here

	return ControlPlaneStack
}

type DataPlaneStackProps struct {
	awscdk.StackProps
}

func NewDataPlaneStack(scope constructs.Construct, id string, props *DataPlaneStackProps) awscdk.Stack {
	var sprops awscdk.StackProps
	if props != nil {
		sprops = props.StackProps
	}
	DataPlaneStack := awscdk.NewStack(scope, jsii.String(id), &sprops)

	// The code that defines your stack goes here

	return DataPlaneStack
}

type MonitoringStackProps struct {
	awscdk.StackProps
}

func NewMonitoringStack(scope constructs.Construct, id string, props *MonitoringStackProps) awscdk.Stack {
	var sprops awscdk.StackProps
	if props != nil {
		sprops = props.StackProps
	}
	MonitoringStack := awscdk.NewStack(scope, jsii.String(id), &sprops)

	// The code that defines your stack goes here

	return MonitoringStack
}

type MyServiceStackProps struct {
	awscdk.StackProps
	Prod bool
}

func NewMyServiceStack(scope constructs.Construct, id string, props *MyServiceStackProps) awscdk.Stack {
	var sprops awscdk.StackProps
	if props != nil {
		sprops = props.StackProps
	}
	MyServiceStack := awscdk.NewStack(scope, jsii.String(id), &sprops)

	NewControlPlaneStack(MyServiceStack, "cp", &ControlPlaneStackProps{
		StackProps: sprops,
	})
	NewDataPlaneStack(MyServiceStack, "data", &DataPlaneStackProps{
		StackProps: sprops,
	})
	NewMonitoringStack(MyServiceStack, "mon", &MonitoringStackProps{
		StackProps: sprops,
	})

	return MyServiceStack
}

func main() {
	defer jsii.Close()

	app := awscdk.NewApp(nil)

	betaProps := MyServiceStackProps{
		StackProps: awscdk.StackProps{
			Env: env(),
		},
		Prod: false,
	}

	NewMyServiceStack(app, "beta", &betaProps)

	prodProps := MyServiceStackProps{
		StackProps: awscdk.StackProps{
			Env: env(),
		},
		Prod: true,
	}

	NewMyServiceStack(app, "prod", &prodProps)

	app.Synth(nil)
}

// ...

anchor anchor anchor anchor anchor anchor


import { App, Stack } from 'aws-cdk-lib';
import { Construct } from 'constructs';

interface EnvProps {
  prod: boolean;
}

// imagine these stacks declare a bunch of related resources
class ControlPlane extends Stack {}
class DataPlane extends Stack {}
class Monitoring extends Stack {}

class MyService extends Construct {

  constructor(scope: Construct, id: string, props?: EnvProps) {
  
    super(scope, id);
  
    // we might use the prod argument to change how the service is configured
    new ControlPlane(this, "cp");
    new DataPlane(this, "data");
    new Monitoring(this, "mon");  }
}

const app = new App();
new MyService(app, "beta");
new MyService(app, "prod", { prod: true });

app.synth();

Questa AWS CDK app alla fine è composta da sei pile, tre per ogni ambiente:


$ cdk ls
    
betacpDA8372D3
betadataE23DB2BA
betamon632BD457
prodcp187264CE
proddataF7378CE5
prodmon631A1083

I nomi fisici degli AWS CloudFormation stack vengono determinati automaticamente in AWS CDK base al percorso di costruzione dello stack nell'albero. Per impostazione predefinita, il nome di uno stack deriva dall'ID del costrutto dell'oggetto. Stack Tuttavia, puoi specificare un nome esplicito usando il stackName prop (in Python,stack_name), come segue.

anchor anchor anchor anchor anchor


new MyStack(this, 'not:a:stack:name', { stackName: 'this-is-stack-name' });

Utilizzo di stack nidificati

Uno stack annidato è uno stack CDK creato all'interno di un altro stack, noto come stack principale. È possibile creare pile annidate utilizzando il costrutto. NestedStack

Utilizzando gli stack annidati, è possibile organizzare le risorse su più stack. Gli stack annidati offrono anche un modo per aggirare il limite di 500 risorse per gli AWS CloudFormation stack. Uno stack nidificato conta come una sola risorsa nello stack che lo contiene. Tuttavia, può contenere fino a 500 risorse, inclusi stack annidati aggiuntivi.

L'ambito di uno stack nidificato deve essere un costrutto or. Stack NestedStack Lo stack nidificato non deve essere dichiarato lessicalmente all'interno dello stack principale. È necessario solo passare lo stack principale come primo parametro (scope) quando si istanzia lo stack nidificato. A parte questa restrizione, la definizione dei costrutti in uno stack annidato funziona esattamente come in uno stack ordinario.

Al momento della sintesi, lo stack annidato viene sintetizzato in un proprio AWS CloudFormation modello, che viene caricato nello staging bucket al momento della distribuzione. AWS CDK Gli stack annidati sono legati allo stack principale e non vengono trattati come artefatti di distribuzione indipendenti. Non sono elencati da cdk list e non possono essere distribuiti da. cdk deploy

I riferimenti tra gli stack principali e gli stack annidati vengono tradotti automaticamente in parametri e output dello stack nei AWS CloudFormation modelli generati, come con qualsiasi riferimento cross-stack.

avvertimento

Le modifiche al livello di sicurezza non vengono visualizzate prima della distribuzione degli stack annidati. Queste informazioni vengono visualizzate solo per gli stack di primo livello.