Comment transmettre des objets de construction pour une référence croisée entre piles dans un seul projet CDK ?

Brève description

La référence croisée entre piles s’effectue en appliquant l'une des méthodes suivantes :

• (Méthode native AWS CloudFormation) Création de piles et de références croisées entre piles
• (Méthode Parameter Store) Créez de piles et de références croisées entre piles pour éviter les erreurs d'AWS CloudFormation

Résolution

(Méthode native AWS CloudFormation) Création de piles et de références croisées entre piles

Remarque :les étapes suivantes permettent de créer deux exemples de piles nommées VPCStack et SecurityGroupStack. Le VPCStack est une pile de production et le SecurityGroupStack est une pile de consommation. Dans le SecurityGroupStack, un groupe de sécurité est créé pour référencer l'ID Amazon VPC dans la pile VPCStack. Vous pouvez personnaliser les noms des piles que vous créez.

1.    Créez un projet et invoquez cdk init dans un répertoire vide :

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

2.    Dans le fichier lib/my-project-stack.ts, importez les modules AWS CDK :

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

3.    Définissez une pile et Une propriété pour Amazon VPC (pour cet exemple 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.    Définissez une interface pour spécifier les accessoires que vous souhaitez recevoir de la pile cible :

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

5.    Créez une autre pile qui consomme la valeur d’exportation de la pile VPCStack :

• SecurityGroupStack utilise VPCStackProps dans les accessoires.
• Ajoutez vpc:props.vpc référence croisée dans les propriétés du groupe de sécurité.

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.    Dans le fichier bin/my-project/ts, ajoutez ce qui suit :

#!/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.    Déployez l'application AWS CDK en exécutant les commandes suivantes :

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

**Remarque :**lorsque l'application AWS CDK est déployée, la valeur d’ exportation de vpc-stack est importée par sg-stack.

(Méthode Parameter Store) Créez des piles et des références croisées pour éviter les erreurs CloudFormation

Création d'une pile AWS Certificate Manager (ACM) et d'une pile d'équilibreur de charge d'application (ALB)

Si vous recevez le message d'erreur AWS CloudFormation :** L’export EXPORT_NAME ne peut pas être mis à jour car il est utilisé par STACK_NAME**, procédez comme suit :

1.    Créez un projet et invoquez cdk init dans un répertoire vide :

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

2.    Renommez lib/my-project-stack.ts en ** lib/acm-stack.ts**. Importez ensuite les modules AWS CDK suivants :

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.    Définissez et exportez une interface AcmProps dans lib/acm-stack.ts :

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

4.    Ajoutez ce qui suit au fichier acm-stack.ts :

• Définissez une pile nommée acmStack
• Créez un certificat ACM avec le Nom de domaine et le jeu de validation que vous avez spécifiés.
• Créez un magasin de paramètres SSM pour ajouter l'ARN du certificat en tant que valeur.    

**Important :**n’oubliez pas de consulter toutes les commandes de l'interface de ligne de commande AWS (AWS CLI) et de remplacer toutes les instances d'exemples de chaînes par vos valeurs. Par exemple, remplacez example_DomainName par le nom de domaine que vous aurez spécifié.

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

**Remarque :**pour l'attribut validation : vous pouvez modifier la méthode de validation en fonction de vos besoins spécifiques. Pour en savoir plus, consultez les méthodes de validation.

5.    Créez un fichier nommé AlbStack dans le répertoire /lib. Importez ensuite les modules AWS CDK suivants :

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.    Définissez une interface :

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

7.    Ajoutez le code suivant à votre fichier lib/alb-stack.ts dans votre application AWS CDK pour effectuer les opérations suivantes :

• Créez un Amazon VPC avec une passerelle natGateway pour réduire les coûts.
• Définissez un acmArn pour récupérer la valeur dans le magasin de paramètres SSM.
• Définissez un certificat qui convertit l'acmArn (Type : Chaîne (s) au type : IListenerCertificate.
• Créez un ALB.
• Ajoutez un Listener et SSLCertificateArn qui font référence à la valeur dans les certificats (type : 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.    Ajoutez le code suivant à votre fichier bin/my-project.ts pour effectuer les opérations suivantes :

• Définissez la variable d’environnement env.
• Définissez le chemin certificateArnSsmPath.
• Définissez une application AWS CDK.
• Définissez une pile ACM avec le nom de pile AWS CDK cdk-ssm-acm-stack.
• Définissez une pile ALB avec le nom de pile AWS CDK cdk-ssm-alb-stack.
• Ajoutez une dépendance pour les piles ACM et ALB afin de vous assurer que la pile ACM est créée avant la pile 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.    Déployez l'application AWS CDK à l'aide des commandes suivantes :

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

Renouvelez le certificat ACM

Pour renouveler le certificat ACM avant son expiration et vous assurer que CloudFormation ne reste pas bloqué dans l'état UPDATE_COMPLETE_CLEANUP_IN_PROGRESS, procédez comme suit :

1.    Ajoutez un nouveau certificat dans le fichier lib/acm-stack.ts et nommez-le renew. Modifiez ensuite l'attribut StringValue dans **paramètre ** en 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.    Mettez à jour l'application AWS CDK :

cdk deploy --all

3.    Lorsque les piles sont mises à jour, nettoyez l'ancien certificat en procédant comme suit :

• Supprimez la construction du certificat ou commentez-la en ajoutant // devant les constructions du certificat.
• Remplacez example_DomainName par le nom de domaine que vous avez spécifié.

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.    Mettez à jour l'application AWS CDK pour nettoyer l'ancien certificat :