Como faço para passar objetos de estrutura para uma referência de pilha cruzada em um único projeto CDK?

Breve descrição

Para fazer uma referência cruzada de pilha, use um dos seguintes métodos:

• (Método nativo do AWS CloudFormation) Crie pilhas e faça referência cruzada
• (Método de armazenamento de parâmetros) Crie pilhas e referências cruzadas para evitar erros no AWS CloudFormation

Solução

(Método nativo do AWS CloudFormation) Crie pilhas e faça referência cruzada

Observação: as etapas a seguir criam dois exemplos de pilhas denominados VpcStack e SecurityGroupStack. O VpcStack é uma pilha de produtores e o SecurityGroupStack é uma pilha de consumidores. No SecurityGroupStack, um grupo de segurança é criado para referenciar a Amazon VPC ID no VpcStack. Ao criar pilhas, você pode personalizar os nomes.

1.    Crie um projeto e invoque o cdk init em um diretório vazio:

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

2.    No arquivo lib/my-project-stack.ts, importe os módulos do AWS CDK:

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

3.    Defina uma pilha e defina uma propriedade para a Amazon VPC (neste exemplo, VpcStack):

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.    Defina uma interface para especificar os suportes que você deseja receber da pilha de destino:

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

5.    Crie outra pilha que consuma o ExportValue do VpcStack:

• O SecurityGroupStack usa VpcStackProps em suportes.
• Adicione vpc: props.vpc para referência cruzada nas propriedades do grupo de segurança.

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.    No arquivo bin/my-project/ts, adicione o seguinte:

#!/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.    Implante a aplicação AWS CDK executando os seguintes comandos:

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

Observação: quando a aplicação AWS CDK é implantada, o ExportValue do vpc-stack é importado pelo sg-stack.

(Método de armazenamento de parâmetros) Crie pilhas e referências cruzadas para evitar erros do CloudFormation

Crie uma pilha do AWS Certificate Manager (ACM) e uma pilha do Application Load Balancer (ALB)

Se você receber o erro do AWS CloudFormation, Exportar EXPORT_NAME não pode ser atualizado porque está sendo usado pelo STACK_NAME, conclua as seguintes etapas:

1.    Crie um projeto e invoque o cdk init em um diretório vazio:

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

2.    Renomeie lib/my-project-stack.ts para lib/acm-stack.ts. Em seguida, importe os seguintes módulos do 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.    Defina e exporte uma interface ** acmProps** em lib/acm-stack.ts:

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

4.    Adicione o seguinte ao arquivo acm-stack.ts:

• Defina uma pilha como acmStack
• Crie um certificado ACM com o seu domainName especificado e seu conjunto de validação especificado.
• Crie um Armazenamento de Parâmetros do SSM para adicionar o certificado ARN como um valor.    

Importante: certifique-se de revisar todos os comandos da AWS Command Line Interface (AWS CLI) e substituir todas as instâncias de strings de exemplo por seus valores. Por exemplo, substitua example_domainName pelo seu nome de domínio especificado.

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

Observação: para a **validação: ** atributo, você pode modificar o método de validação para seus requisitos específicos. Para obter mais informações, consulte métodos de validação.

5.    Crie um arquivo chamado albStack no diretório /lib. Em seguida, importe os seguintes módulos do 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.    Defina uma interface:

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

7.    Adicione o código a seguir ao seu arquivo lib/alb-stack.ts em sua aplicação AWS CDK para fazer o seguinte:

• Crie uma Amazon VPC com um natGateway para reduzir custos.
• Defina um acmArn para recuperar o valor do Armazenamento de Parâmetros do SSM.
• Defina um certificado que converta o acmArn (Tipo: String) para Tipo: IListenerCertificate.
• Crie um ALB.
• Adicione um receptor e um sslCertificateArn que façam referência ao valor nos certificados (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.    Adicione o código a seguir ao seu arquivo bin/my-project.ts para fazer o seguinte:

• Defina a variável env.
• Defina certificateArnSsmPath.
• Defina uma aplicação de CDK da AWS.
• Defina uma pilha ACM com o nome de pilha CDK da AWS cdk-ssm-acm-stack.
• Defina uma pilha ALB com o nome da pilha CDK da AWS cdk-ssm-alb-stack.
• Adicione uma dependência para as pilhas ACM e ALB para garantir que a pilha ACM seja criada antes da pilha 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.    Implemente a aplicação AWS CDK usando os seguintes comandos:

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

Renove o certificado ACM

Para renovar o certificado ACM antes da expiração e garantir que o CloudFormation não fique preso no estado UPDATE_COMPLETE_CLEANUP_IN_PROGRESS, conclua as seguintes etapas:

1.    Adicione um novo certificado no arquivo lib/acm-stack.ts e nomeie-o como renovar. Em seguida, altere o atributo stringValue no parâmetro para renew.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.    Atualize a aplicação AWS CDK:

cdk deploy --all

3.    Quando as pilhas forem atualizadas, limpe o certificado antigo fazendo o seguinte:

• Remova a estrutura do certificado ou comente isso adicionando**//** na frente das estruturas do certificado.
• Substitua example_domainName pelo nome de domínio especificado.

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.    Atualize a aplicação AWS CDK para limpar o certificado antigo: