Come faccio a passare oggetti costrutti per un riferimento incrociato tra stack in un singolo progetto CDK?

Breve descrizione

Per creare un riferimento incrociato tra stack, utilizza uno dei seguenti metodi:

• (metodo nativo di AWS CloudFormation) Crea stack e riferimenti tra stack
• (metodo Parameter Store) Crea stack e riferimenti tra stack per evitare errori di AWS CloudFormation

Risoluzione

(metodo nativo di AWS CloudFormation) Crea stack e riferimenti tra stack

Nota: I passaggi seguenti creano due stack di esempio denominatiVPCStack eSecurityGroupStack. VPCStack è uno stack di produzione eSecurityGroupStack è uno stack consumer. In SecurityGroupStack viene creato un gruppo di sicurezza per fare riferimento all'ID Amazon VPC inVPCStack. Quando si creano stack, è possibile personalizzare i nomi.

1.    Crea un progetto e richiama cdk init in una directory vuota:

mkdir my-project
cd my-project
cdk init --language typescript

2.    Nel filelib/my-project-stack.ts, importa i moduli AWS CDK:

import as 'aws-cdk-lib/aws-ec2';
import * as cdk from 'aws-cdk-lib';

3.    Definisci uno stack e imposta una proprietà per Amazon VPC (per questo esempioVPCStack):

export class VpcStack extends cdk.Stack {
  public readonly vpc: ec2.IVpc;

  constructor(scope: cdk.App, id: string, props?: cdk.StackProps) {
    super(scope, id, props);
    this.vpc = new ec2.Vpc(this, 'Cross-Ref-Vpc', {
      maxAzs: 2,
      natGateways: 1,
    });
  }
}

4.    Definisci un'interfaccia per specificare gli oggetti di scena che desideri ricevere dallo stack di destinazione:

interface VpcStackProps extends cdk.StackProps {
  vpc: ec2.IVpc;
}

5. Crea un altro stack che consumi l'ExportValue daVPCStack:

• SecurityGroupStack utilizzaVPCStackProps negli oggetti di scena.
• Aggiungivpc: props.vpc come riferimento incrociato nelle proprietà del gruppo di sicurezza.

export class SecurityGroupStack extends cdk.Stack {
  constructor(scope: cdk.App, id: string, props: VpcStackProps) {
    super(scope, id, props);
    const securityGroupName = "BastionHostSg";
    const SecurityGroup = new ec2.SecurityGroup(this, 'securityGroupName', {
      vpc: props.vpc,
      allowAllOutbound: true,
      securityGroupName: securityGroupName,
    });
  }
}

6. Nel file bin/my-project/ts, aggiungi quanto segue:

#!/usr/bin/env node
import 'source-map-support/register';
import * as cdk from 'aws-cdk-lib';
import {VpcStack, SecurityGroupStack} from '../lib/my-project-stack';
const app = new cdk.App();
const vpc_stack = new VpcStack(app, 'vpc-stack', {});
const sg_stack = new SecurityGroupStack(app, 'sg-stack', {
    vpc: vpc_stack.vpc,
});

7. Distribuisci l'applicazione AWS CDK eseguendo i seguenti comandi:

npm update
``````plaintext
cdk deploy --all

Nota:Quando l'applicazione AWS CDK viene distribuita, l'ExportValue davpc-stack viene importato dasg-stack.

(metodo Parameter Store) Crea stack e riferimenti tra stack per evitare errori CloudFormation

Crea uno stack Gestione certificati AWS (ACM) e uno stack Application Load Balancer (ALB)

Se ricevi l'errore AWS CloudFormationExport\ _NAME non può essere aggiornato poiché è utilizzato da STACK\ _NAME, completa i seguenti passaggi:

1.    Crea un progetto e richiama cdk init in una directory vuota:

mkdir my-project
cd my-project
cdk init --language typescript

2. Rinominalib/my-project-stack.ts inlib/acm-stack.ts. Quindi, importa i seguenti moduli AWS CDK:

import \* as cdk from 'aws-cdk-lib';
import \* as acm from "aws-cdk-lib/aws-certificatemanager";
import \* as ssm from "aws-cdk-lib/aws-ssm";
import {Construct} from 'constructs';

3. Definisci ed esporta un'interfacciaacmProps in lib/acm-stack.ts:

export interface acmProps extends cdk.StackProps {
 readonly acmName: string;
 readonly acmArnExportPath: string;
}

4. Aggiungi quanto segue al file acm-stack.ts:

• Definisci uno stack denominatoacmStack
• Crea un certificato ACM con ilnome di dominio specificato e il set di convalida specificato.
• Crea un archivio parametri SSM per aggiungere l'ARN del certificato come valore.    

Importante:Assicurati di esaminare tutti i comandi dell’interfaccia della linea di comando AWS (AWS CLI) e di sostituire tutte le istanze di stringhe di esempio con i tuoi valori. Ad esempio, sostituisciexample_DomainName con il nome di dominio specificato.

export class acmStack extends cdk.Stack {
    constructor(scope: Construct, id: string, props: acmProps) {
    super(scope, id, props);
    const cert = new acm.Certificate(this, 'Certificate', {
        domainName: 'example_domainName.com',
        validation: acm.CertificateValidation.fromDns(),
    });
    const parameter = new ssm.StringParameter(this, 'acmArnParameter', {
        parameterName: props.acmArnExportPath,
        stringValue: cert.certificateArn,
    });
    }
}

**Nota:**Per l'attributo validazione: puoi modificare il metodo di convalida in base alle tue esigenze specifiche. Per ulteriori informazioni, consulta metodi di convalida.

5. Crea un file chiamatoalbStack nella directory**/lib**. Quindi, importa i seguenti moduli AWS CDK:

import * as cdk from 'aws-cdk-lib';
import * as ec2 from "aws-cdk-lib/aws-ec2";
import * as elbv2 from 'aws-cdk-lib/aws-elasticloadbalancingv2';
import * as ssm from "aws-cdk-lib/aws-ssm";
import * as acm from "aws-cdk-lib/aws-certificatemanager";
import {Construct} from 'constructs';

6. Definisci un'interfaccia:

export interface albProps extends cdk.StackProps {
    readonly acmArnExportPath: string;
}

7. Aggiungi il seguente codice al filelib/alb-stack.ts nell'applicazione AWS CDK per effettuare le seguenti operazioni:

• Crea un Amazon VPC con unNatGateway per ridurre i costi.
• Definisci unacmArn per recuperare il valore dall'archivio parametri SSM.
• Definisci un certificato che converte l'acmArn (Tipo: stringa) a: IListenerCertificate.
• Crea un ALB.
• Aggiungi un ascoltatore esslCertificateArn che faccia riferimento al valore nei certificati (tipo: IListenerCertificate).

export class albStack extends cdk.Stack {
    constructor(scope: Construct, id: string, props: albProps) {
    super(scope, id, props);
    const vpc = new ec2.Vpc(this, "VPC", { natGateways:1 });
    const acmArn = ssm.StringParameter.valueForStringParameter(this, props.acmArnExportPath);
    const certificate = acm.Certificate.fromCertificateArn(this, 'acm', acmArn);
    const alb = new elbv2.ApplicationLoadBalancer(this, 'ALB', {
        vpc,
        internetFacing: true,
        });
        alb.addRedirect();
    const listener = alb.addListener ('Listener',{
        port: 443,
        certificates: [certificate],
        });
        listener.addTargets('Instance', {port: 80});
    }
}

8. Aggiungi il seguente codice al tuo filebin/my-project.ts per fare quanto segue:

• Definisci la variabileenv.
• DefiniscicertificateArnSsmPath.
• Definisci un'applicazione AWS CDK.
• Definisci uno stack ACM con il nome dello stack AWS CDKcdk-ssm-acm-stack.
• Definisci uno stack ALB con il nome dello stack AWS CDKcdk-ssm-alb-stack.
• Aggiungi una dipendenza per gli stack ACM e ALB per assicurarti che lo stack ACM venga creato prima dello stack ALB.

#!/usr/bin/env node
import 'source-map-support/register';
import * as cdk from 'aws-cdk-lib';
import {acmStack, acmProps} from '../lib/acm-stack';
import {albStack, albProps} from '../lib/alb-stack';
import {addDependency} from 'aws-cdk-lib/core/lib/deps';

const env = {account: process.env.CDK_DEFAULT_ACCOUNT, region: process.env.CDK_DEFAULT_REGION}
const certificateArnSsmPath = "/cdk/acm/cross-stacks-reference/certArn";
const app = new cdk.App();
const acm_stack = new acmStack(app, "cdk-ssm-acm-stack", {
    env: env,
    acmName: "ssm-acm",
    acmArnExportPath: certificateArnSsmPath,
});
const alb_stack = new albStack(app, "cdk-ssm-alb-stack", {
    env: env,
    acmArnExportPath: certificateArnSsmPath,
});
alb_stack.addDependency(acm_stack)

9. Distribuisci l'applicazione AWS CDK utilizzando i seguenti comandi:

npm update
``````plaintext
cdk deploy --all

Rinnova il certificato ACM

Per rinnovare il certificato ACM prima della scadenza e assicurarti che CloudFormation non rimanga bloccato nello statoUPDATE\ _COMPLETE\ _CLEANUP\ _IN\ _PROGRESS, completa i seguenti passaggi:

1. Aggiungi un nuovo certificato nel filelib/acm-stack.ts e chiamalo rinnovo. Quindi, modifica l'attributo stringValue nelparametro inrenew.certificateARN:

export class acmStack extends cdk.Stack {
    constructor(scope: Construct, id: string, props: acmProps) {
    super(scope, id, props);
    const cert = new acm.Certificate(this, 'Certificate', {
        domainName: 'example_domainName.com',
        validation: acm.CertificateValidation.fromDns(),
    });
    const renew = new acm.Certificate(this, 'renewCertificate', {
       domainName: 'example_domainName.com',
       validation: acm.CertificateValidation.fromDns(),
    });
    const parameter = new ssm.StringParameter(this, 'acmArnParameter', {
        parameterName: props.acmArnExportPath,
        stringValue: renew.certificateArn,
    });
    }
}

2. Aggiorna l'applicazione AWS CDK:

cdk deploy --all

3. Quando gli stack vengono aggiornati, ripulisci il vecchio certificato procedendo come segue:

• Rimuovi il costrutto del certificato o commentalo aggiungendo**//**davanti ai costrutti del certificato.
• Sostituisci example\ _DomainName con il nome di dominio specificato.

export class acmStack extends cdk.Stack {
    constructor(scope: Construct, id: string, props: acmProps) {
    super(scope, id, props);
    // const cert = new acm.Certificate(this, 'Certificate', {
    //     domainName: 'example_domainName.com',
    //     validation: acm.CertificateValidation.fromDns(),
    // });
    const renew = new acm.Certificate(this, 'renewCertificate', {
       domainName: 'example_domainName.com',
       validation: acm.CertificateValidation.fromDns(),
    });
    const parameter = new ssm.StringParameter(this, 'acmArnParameter', {
        parameterName: props.acmArnExportPath,
        stringValue: renew.certificateArn,
    });
    }
}

4. Aggiorna l'applicazione AWS CDK per ripulire il vecchio certificato: