¿Cómo puedo transferir objetos de componente para una referencia de pila cruzada en un solo proyecto de CDK?

Descripción breve

Para hacer una referencia de pila cruzada, utilice uno de los métodos siguientes:

• (Método nativo de AWS CloudFormation) Creación de pilas y referencias de pilas cruzadas
• (Método de almacenamiento de parámetros) Cree pilas y referencias de pilas cruzadas para evitar errores de AWS CloudFormation

Resolución

(Método nativo de AWS CloudFormation) Creación de pilas y referencias de pilas cruzadas

Nota: Los siguientes pasos crean dos pilas de ejemplo denominadas VpcStack y SecurityGroupStack. El VpcStack es un paquete para productores y el SecurityGroupStack es un paquete para consumidores. En SecurityGroupStack, se crea un grupo de seguridad para hacer referencia al ID de Amazon VPC en la VpcStack. Al crear pilas, puede personalizar los nombres.

1.    Crear un proyecto e invoca cdk init en un directorio vacío:

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

2.    En el archivo lib/my-project-stack.ts, importe los módulos de AWS CDK:

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

3.    Defina una pila y defina una propiedad para Amazon VPC (por ejemplo, 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 una interfaz para especificar los accesorios que desea recibir de la pila de destino:

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

5.    Cree otra pila que consuma el ExportValue de VpcStack:

• SecurityGroupStack usa VpcStackProps como accesorios.
• Agregue vpc: props.vpc como referencia cruzada en las propiedades del grupo de seguridad.

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.    En el archivo bin/my-project/ts, añada lo siguiente:

#!/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.    Implemente la aplicación AWS CDK mediante la ejecución de los siguientes comandos:

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

Nota: Cuando se implementa la aplicación AWS CDK, el ExportValue de vpc-stack es importado por sg-stack.

(Método de almacenamiento de parámetros) Cree pilas y referencias de pilas cruzadas para evitar errores de CloudFormation

Cree una pila de AWS Certificate Manager (ACM) y una pila de balanceador de carga de aplicaciones (ALB)

Si recibe el error de AWS CloudFormation que STACK\ _NAME no puede actualizar Export\ _NAME porque lo usa STACK\ _NAME, complete los siguientes pasos:

1.    Crear un proyecto e invoca cdk init en un directorio vacío:

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

2.    Cambie el nombre de lib/my-project-stack.ts a lib/acm-stack.ts. A continuación, importe los siguientes módulos de 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 y exporte una interfaz acmProps en lib/acm-stack.ts:

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

4.    Añada lo siguiente al archivo acm-stack.ts:

• Defina una pila denominada acmStack
• Cree un certificado ACM con el nombre de dominio especificado y su conjunto de validación especificado.
• Cree un almacén de parámetros SSM para añadir el ARN del certificado como valor.    

Importante: Asegúrese de revisar todos los comandos de la AWS Command Line Interface (AWS CLI) y de reemplazar todas las instancias de cadenas de ejemplo por los valores suyos. Por ejemplo, sustituya example\ _domainName por el nombre de dominio especificado por usted.

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: Para el atributo validación:, puede modificar el método de validación para sus requisitos específicos. Para obtener más información, consulte métodos de validación.

5.    Cree un archivo llamado ALBStack en el directorio /lib. A continuación, importe los siguientes módulos de 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 una interfaz:

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

7.    Añada el siguiente código a su archivo lib/alb-stack.ts de su aplicación AWS CDK para hacer lo siguiente:

• Cree una Amazon VPC con un natGateway para reducir los costes.
• Defina un acmArn para recuperar el valor del almacén de parámetros SSM.
• Defina un certificado que convierta el acmArn (Tipo: Cadena) para escribir: Certificado iListener.
• Crear un ALB.
• Agregue un agente de escucha y un sslCertificateArn que hagan referencia al valor en los certificados (escriba: 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.    Añada el siguiente código a su archivo bin/my-project.ts para hacer lo siguiente:

• Defina la variable env.
• Defina certificateArnSsmPath.
• Defina una aplicación AWS CDK.
• Defina una pila de ACM con el nombre de pila de CDK de AWS cdk-ssm-acm-stack.
• Defina una pila ALB con el nombre de pila de AWS CDK cdk-ssm-alb-stack.
• Añada una dependencia para las pilas ACM y ALB para asegurarse de que la pila ACM se cree antes que la pila 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 la aplicación AWS CDK mediante los siguientes comandos:

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

Renovar el certificado ACM

Para renovar el certificado ACM antes de su caducidad y asegurarse de que CloudFormation no quede atascado en el estado UPDATE\ _COMPLETE\ _CLEANUP\ _IN\ _PROGRESS, siga estos pasos:

1.    Añada un nuevo certificado al archivo lib/acm-stack.ts y asígnele el nombre renew. A continuación, cambie el atributo StringValue del parámetro a 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.    Actualice la aplicación AWS CDK:

cdk deploy --all

3.    Cuando se actualicen las pilas, limpie el certificado anterior de la siguiente manera:

• Elimine el componente del certificado o coméntelo añadiendo // delante de los componentes del certificado.
• Sustituya el ejemplo\ _domainName por el nombre de dominio especificado por usted.

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.    Actualice la aplicación AWS CDK para limpiar el certificado anterior: