Qu’est-ce qu’un jeton dans AWS CDK ?

Les jetons dans l’AWS CDK #

Certaines valeurs dans notre code CDK ne peuvent pas être résolues au moment de la synthèse, mais plutôt au moment du déploiement.
mais plutôt au moment du déploiement. Ces valeurs sont appelées Tokens.

Les jetons sont des valeurs codées, le plus souvent des attributs de ressources que nous définissons dans la pile CDK.
notre pile CDK qui ne seront résolus qu’au moment du déploiement..

Par exemple, définissons une simple fonction Lambda et essayons d’accéder à son contenu.
functionName dans notre code CDK :

const myFunction = new NodejsFunction(this, id, {
  runtime: lambda.Runtime.NODEJS_16_X,
  handler: 'main',
  entry: path.join(__dirname, `/../src/path/index.js`),
});

console.log('function name ????', myFunction.functionName);

Si nous exécutons npx aws-cdk deploy nous obtenons un résultat comme ${Token[Token.123]}:

Nous pouvons constater que la valeur de l’élément functionName est un jeton au moment de la
moment de la synthèse.

Définition explicite des noms de ressources #

Même si nous définissons explicitement le functionName sur la Lambda, nous ne pourrions pas
nous ne pourrions pas accéder à la valeur résolue dans notre code..

Ajoutons une table dynamodb à notre code et définissons explicitement l’attribut tableName et
functionName propriétés sur les ressources :

const myTable = new dynamodb.Table(this, 'my-table', {
  
  tableName: 'my-table',
  partitionKey: {name: 'todoId', type: dynamodb.AttributeType.NUMBER},
  billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
  removalPolicy: cdk.RemovalPolicy.DESTROY,
});

console.log('table name ????', myTable.tableName);

const myFunction = new NodejsFunction(this, id, {
  
  functionName: 'my-function',
  runtime: lambda.Runtime.NODEJS_16_X,
  handler: 'main',
  entry: path.join(__dirname, `/../src/path/index.js`),
});

console.log('function name ????', myFunction.functionName);

Si nous exécutons npx aws-cdk deploynous pouvons voir que nous obtenons toujours les valeurs de jetons
non résolues.

De toute évidence, si nous codons en dur les noms de table et de fonction, nous avons accès à ces valeurs dans notre code CDK.
valeurs dans notre code CDK, mais essayer d’accéder aux attributs retourne toujours un
Token.

En passant, vous ne devriez pas attribuer explicitement des noms aux ressources CDK. Consultez
mon autre article
Ne pas attribuer de noms aux ressources CDK.

Comment les jetons CDK fonctionnent réellement #

Depuis que CDK est compilé en code CloudFormation, tous ces jetons sont
représentés comme
Fonctions Ref de CloudFormation.

Mettons à jour notre code afin de supprimer les noms de ressources explicitement définis et de passer le nom de la table dynamodb comme variable d’environnement au lambda.
le nom de la table dynamodb comme variable d’environnement à la lambda et inspectons notre modèle de
modèle CloudFormation :

const myTable = new dynamodb.Table(this, 'my-table', {
  partitionKey: {name: 'todoId', type: dynamodb.AttributeType.NUMBER},
  billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
  removalPolicy: cdk.RemovalPolicy.DESTROY,
});

const myFunction = new NodejsFunction(this, id, {
  runtime: lambda.Runtime.NODEJS_16_X,
  handler: 'main',
  entry: path.join(__dirname, `/../src/path/index.js`),
  
  environment: {
    tableName: myTable.tableName,
  },
});

Synthétisons notre pile CDK et regardons le modèle CloudFormation produit :

npx aws-cdk synth --no-staging > template.yaml

Les parties importantes du modèle CloudFormation sont :

Resources:
  mytable0324D45C:
    Type: AWS::DynamoDB::Table

  mycdkstack4E08F0DD:
    Type: AWS::Lambda::Function
    Properties:
      Environment:
        Variables:
          tableName:
            Ref: mytable0324D45C

Remarquez comment la variable d’environnement du nom de la table pointe vers une référence qui sera éventuellement
qui sera éventuellement remplacée par la valeur réelle de CloudFormation..

Lorsque nous déployons notre pile, nous pouvons voir que la valeur de la variable d’environnement
est résolue et accessible dans notre fonction Lambda :

Problèmes avec les jetons CDK #

Une source fréquente de confusion avec les jetons dans CDK est lorsque nous essayons d’accéder à l’objet
region, accountId ou availabilityZones propriétés dans un environnement
agnostique et obtenir des valeurs Token en retour.

Il est fréquent de devoir mettre à jour conditionnellement les types de ressources en fonction du compte
compte ou la région dans laquelle nous déployons.

const app = new cdk.App();

new MyCdkStack(app, 'my-cdk-stack', {
  stackName: `my-cdk-stack`,
  
  
  
  
  
});

Si nous essayons maintenant d’accéder à la ressource region, accountId ou availabilityZones dans notre
code CDK :

export class MyCdkStack extends cdk.Stack {
  constructor(scope: cdk.App, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    
    console.log('accountId: ', cdk.Stack.of(this).account);
    console.log('region: ', cdk.Stack.of(this).region);
    console.log('availability zones: ', cdk.Stack.of(this).availabilityZones);
  }
}

Nous recevrions simplement des valeurs de Token non résolues :

Pour résoudre ce problème, il faut décommenter les lignes commentées dans le snippet ci-dessus
et de définir explicitement l’environnement de notre pile. J’ai écrit un article sur
cet –
Obtenir la région et le accountId dans CDK

Exportation des valeurs de jetons en tant que sorties #

Il est souvent nécessaire d’exporter les attributs des ressources en tant que sorties, afin qu’ils
afin de pouvoir y accéder depuis notre code frontal.

Par exemple, pour permettre à notre code frontal d’accéder à l’url d’une API, nous utiliserions des
Outputs et écrire les Outputs dans un fichier JSON, que le code frontal peut importer et utiliser.
et utiliser.

Voyons comment nous pouvons exporter nos noms de lambda et de table et quand les valeurs sont
résolues.

const myTable = new dynamodb.Table(this, 'my-table', {
  partitionKey: {name: 'todoId', type: dynamodb.AttributeType.NUMBER},
  billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
  removalPolicy: cdk.RemovalPolicy.DESTROY,
});

const myFunction = new NodejsFunction(this, id, {
  runtime: lambda.Runtime.NODEJS_16_X,
  handler: 'main',
  entry: path.join(__dirname, `/../src/path/index.js`),
  environment: {
    tableName: myTable.tableName,
  },
});


new cdk.CfnOutput(this, 'tableName', {value: myTable.tableName});
new cdk.CfnOutput(this, 'lambdaName', {value: myFunction.functionName});

Déployons notre pile et voyons si les valeurs sont résolues dans le fichier :

npx aws-cdk deploy --outputs-file ./cdk-exports.json

Si nous ouvrons le fichier cdk-exports.json après le déploiement, le résultat ressemble à
comme :

{
  "my-cdk-stack": {
    "tableName": "my-cdk-stack-mytable0324D45C-11VORISY29H3L",
    "lambdaName": "my-cdk-stack-mycdkstack4E08F0DD-KVZpFjrsLC3F"
  }
}

Le concept est le même, notre CloudFormation a spécifié des références
à ces ressources, qui seront éventuellement remplacées par les valeurs réelles au moment du
déploiement:

Resources:
  mytable0324D45C:
    Type: AWS::DynamoDB::Table
  mycdkstack4E08F0DD:
    Type: AWS::Lambda::Function


Outputs:
  tableName:
    Value:
      Ref: mytable0324D45C
  lambdaName:
    Value:
      Ref: mycdkstack4E08F0DD

Discussion #

Les jetons sont des valeurs de remplacement qui sont remplacées par la valeur réelle au moment du déploiement par CloudFormation.
par CloudFormation au moment du déploiement.

La source de confusion la plus courante consiste à essayer d’accéder à la ressource accountId,
region ou availabilityZones et obtenir des valeurs de Token, parce que nous
n’avons pas défini l’environnement de la pile de manière explicite.
Comment obtenir accountId et région dans AWS CDK ?

Lecture complémentaire #