Identification - AWS Cloud Development Kit (AWS CDK) v2
Utilisation de balisesPriorités des tagsPropriétés facultativesExempleMarquage de constructions individuelles

Ceci est le guide du AWS CDK développeur de la version 2. L'ancien CDK v1 est entré en maintenance le 1er juin 2022 et a pris fin le 1er juin 2023.

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Identification

Les balises sont des éléments clé-valeur informatifs que vous pouvez ajouter aux constructions de votre application. AWS CDK Une balise appliquée à une construction donnée s'applique également à tous ses enfants étiquetables. Les balises sont incluses dans le AWS CloudFormation modèle synthétisé à partir de votre application et sont appliquées aux AWS ressources qu'elle déploie. Vous pouvez utiliser des balises pour identifier et classer les ressources aux fins suivantes :

  • Simplification de la gestion

  • Répartition des coûts

  • Contrôle d’accès

  • Tout autre objectif que vous concevez

Astuce

Pour plus d'informations sur la manière dont vous pouvez utiliser les balises avec vos AWS ressources, consultez les meilleures pratiques en matière de balisage AWS des ressources dans le AWS livre blanc.

Utilisation de balises

La Tagsclasse inclut la méthode statiqueof(), grâce à laquelle vous pouvez ajouter ou supprimer des balises à la construction spécifiée.

  • Tags.of(SCOPE).add()applique une nouvelle balise à la construction donnée et à tous ses enfants.

  • Tags.of(SCOPE).remove()supprime une balise de la construction donnée et de tous ses enfants, y compris les balises qu'une construction enfant peut s'être appliquée à elle-même.

Note

Le balisage est implémenté à l'aide deAspects. Les aspects permettent d'appliquer une opération (telle que le balisage) à toutes les constructions d'une portée donnée.

L'exemple suivant applique la clé de balise avec la valeur de valeur à une construction.

TypeScript
Tags.of(myConstruct).add('key', 'value');
JavaScript
Tags.of(myConstruct).add('key', 'value');
Python
Tags.of(my_construct).add("key", "value")
Java
Tags.of(myConstruct).add("key", "value");
C#
Tags.Of(myConstruct).Add("key", "value");
Go
awscdk.Tags_Of(myConstruct).Add(jsii.String("key"), jsii.String("value"), &awscdk.TagProps{})

L'exemple suivant supprime la clé de balise d'une construction.

TypeScript
Tags.of(myConstruct).remove('key');
JavaScript
Tags.of(myConstruct).remove('key');
Python
Tags.of(my_construct).remove("key")
Java
Tags.of(myConstruct).remove("key");
C#
Tags.Of(myConstruct).Remove("key");
Go
awscdk.Tags_Of(myConstruct).Remove(jsii.String("key"), &awscdk.TagProps{})

Si vous utilisez Stage des constructions, appliquez la balise au Stage niveau ou en dessous. Les balises ne sont pas appliquées au-delà Stage des limites.

Priorités des tags

AWS CDK Applique et supprime les balises de manière récursive. En cas de conflit, l'opération de balisage ayant la priorité la plus élevée l'emporte. (Les priorités sont définies à l'aide de la priority propriété facultative.) Si les priorités de deux opérations sont les mêmes, l'opération de balisage la plus proche du bas de l'arbre de construction gagne. Par défaut, l'application d'une balise a une priorité de 100 (sauf pour les balises ajoutées directement à une AWS CloudFormation ressource, qui ont une priorité de 50). La priorité par défaut pour supprimer un tag est 200.

Ce qui suit applique une balise avec une priorité de 300 à une construction.

TypeScript
Tags.of(myConstruct).add('key', 'value', {
  priority: 300
});
JavaScript
Tags.of(myConstruct).add('key', 'value', {
  priority: 300
});
Python
Tags.of(my_construct).add("key", "value", priority=300)
Java
Tags.of(myConstruct).add("key", "value", TagProps.builder()
        .priority(300).build());
C#
Tags.Of(myConstruct).Add("key", "value", new TagProps { Priority = 300 });
Go
awscdk.Tags_Of(myConstruct).Add(jsii.String("key"), jsii.String("value"), &awscdk.TagProps{
  Priority: jsii.Number(300),
})

Propriétés facultatives

Les balises propertiespermettent d'affiner la manière dont les balises sont appliquées ou supprimées des ressources. Toutes les propriétés sont facultatives.

applyToLaunchedInstances(Python :apply_to_launched_instances)

Disponible uniquement pour add (). Par défaut, les balises sont appliquées aux instances lancées dans un groupe Auto Scaling. Définissez cette propriété sur false pour ignorer les instances lancées dans un groupe Auto Scaling.

includeResourceTypes/excludeResourceTypes(Python :include_resource_types/exclude_resource_types)

Utilisez-les pour manipuler les balises uniquement sur un sous-ensemble de ressources, en fonction des types de AWS CloudFormation ressources. Par défaut, l'opération est appliquée à toutes les ressources du sous-arbre de construction, mais cela peut être modifié en incluant ou en excluant certains types de ressources. L'exclusion a priorité sur l'inclusion, si les deux sont spécifiées.

priority

Utilisez-le pour définir la priorité de cette opération par rapport aux autres Tags.remove() opérations Tags.add() et. Les valeurs les plus élevées ont priorité sur les valeurs faibles. La valeur par défaut est de 100 pour les opérations d'ajout (50 pour les balises appliquées directement aux AWS CloudFormation ressources) et de 200 pour les opérations de suppression.

L'exemple suivant applique le tag tagname avec la valeur valeur et la priorité 100 aux ressources de type AWS::Xxx::Yyydans la construction. Il n'applique pas le tag aux instances lancées dans un groupe Amazon EC2 Auto Scaling ni aux ressources de ce type. AWS::Xxx::Zzz (Ce sont des espaces réservés pour deux types de AWS CloudFormation ressources arbitraires mais différents.)

TypeScript
Tags.of(myConstruct).add('tagname', 'value', {
  applyToLaunchedInstances: false,
  includeResourceTypes: ['AWS::Xxx::Yyy'],
  excludeResourceTypes: ['AWS::Xxx::Zzz'],
  priority: 100,
});
JavaScript
Tags.of(myConstruct).add('tagname', 'value', {
  applyToLaunchedInstances: false,
  includeResourceTypes: ['AWS::Xxx::Yyy'],
  excludeResourceTypes: ['AWS::Xxx::Zzz'],
  priority: 100
});
Python
Tags.of(my_construct).add("tagname", "value",
    apply_to_launched_instances=False,
    include_resource_types=["AWS::Xxx::Yyy"],
    exclude_resource_types=["AWS::Xxx::Zzz"],
    priority=100)
Java
Tags.of(myConstruct).add("tagname", "value", TagProps.builder()
                .applyToLaunchedInstances(false)
                .includeResourceTypes(Arrays.asList("AWS::Xxx::Yyy"))
                .excludeResourceTypes(Arrays.asList("AWS::Xxx::Zzz"))
                .priority(100).build());
C#
Tags.Of(myConstruct).Add("tagname", "value", new TagProps
{
    ApplyToLaunchedInstances = false,
    IncludeResourceTypes = ["AWS::Xxx::Yyy"],
    ExcludeResourceTypes = ["AWS::Xxx::Zzz"],
    Priority = 100
});
Go
awscdk.Tags_Of(myConstruct).Add(jsii.String("tagname"), jsii.String("value"), &awscdk.TagProps{
  ApplyToLaunchedInstances: jsii.Bool(false),
  IncludeResourceTypes:     &[]*string{jsii.String("AWS::Xxx:Yyy")},
  ExcludeResourceTypes:     &[]*string{jsii.String("AWS::Xxx:Zzz")},
  Priority:                 jsii.Number(100),
})

L'exemple suivant supprime le tag tagname avec la priorité 200 des ressources de type AWS::Xxx::Yyydans la construction, mais pas des ressources de type AWS::Xxx::Zzz.

TypeScript
Tags.of(myConstruct).remove('tagname', {
  includeResourceTypes: ['AWS::Xxx::Yyy'],
  excludeResourceTypes: ['AWS::Xxx::Zzz'],
  priority: 200,
});
JavaScript
Tags.of(myConstruct).remove('tagname', {
  includeResourceTypes: ['AWS::Xxx::Yyy'],
  excludeResourceTypes: ['AWS::Xxx::Zzz'],
  priority: 200
});
Python
Tags.of(my_construct).remove("tagname",
    include_resource_types=["AWS::Xxx::Yyy"],
    exclude_resource_types=["AWS::Xxx::Zzz"],
    priority=200,)
Java
Tags.of((myConstruct).remove("tagname", TagProps.builder()
        .includeResourceTypes(Arrays.asList("AWS::Xxx::Yyy"))
        .excludeResourceTypes(Arrays.asList("AWS::Xxx::Zzz"))
        .priority(100).build());
C#
Tags.Of(myConstruct).Remove("tagname", new TagProps
{
    IncludeResourceTypes = ["AWS::Xxx::Yyy"],
    ExcludeResourceTypes = ["AWS::Xxx::Zzz"],
    Priority = 100
});
Go
awscdk.Tags_Of(myConstruct).Remove(jsii.String("tagname"), &awscdk.TagProps{
  IncludeResourceTypes: &[]*string{jsii.String("AWS::Xxx:Yyy")},
  ExcludeResourceTypes: &[]*string{jsii.String("AWS::Xxx:Zzz")},
  Priority:             jsii.Number(200),
})

Exemple

L'exemple suivant ajoute la clé de balise StackTypeavec valeur TheBestà toute ressource créée dans le Stack nomMarketingSystem. Il le supprime ensuite à nouveau de toutes les ressources, à l'exception des sous-réseaux Amazon EC2 VPC. Le résultat est que seuls les sous-réseaux ont la balise appliquée.

TypeScript
import { App, Stack, Tags } from 'aws-cdk-lib';

const app = new App();
const theBestStack = new Stack(app, 'MarketingSystem');

// Add a tag to all constructs in the stack
Tags.of(theBestStack).add('StackType', 'TheBest');

// Remove the tag from all resources except subnet resources
Tags.of(theBestStack).remove('StackType', {
  excludeResourceTypes: ['AWS::EC2::Subnet']
});
JavaScript
const { App, Stack, Tags } = require('aws-cdk-lib');

const app = new App();
const theBestStack = new Stack(app, 'MarketingSystem');

// Add a tag to all constructs in the stack
Tags.of(theBestStack).add('StackType', 'TheBest');

// Remove the tag from all resources except subnet resources
Tags.of(theBestStack).remove('StackType', {
  excludeResourceTypes: ['AWS::EC2::Subnet']
});
Python
from aws_cdk import App, Stack, Tags

app = App();
the_best_stack = Stack(app, 'MarketingSystem')

# Add a tag to all constructs in the stack
Tags.of(the_best_stack).add("StackType", "TheBest")

# Remove the tag from all resources except subnet resources
Tags.of(the_best_stack).remove("StackType",
    exclude_resource_types=["AWS::EC2::Subnet"])
Java
import software.amazon.awscdk.App;
import software.amazon.awscdk.Tags;

// Add a tag to all constructs in the stack
Tags.of(theBestStack).add("StackType", "TheBest");

// Remove the tag from all resources except subnet resources
Tags.of(theBestStack).remove("StackType", TagProps.builder()
        .excludeResourceTypes(Arrays.asList("AWS::EC2::Subnet"))
        .build());
C#
using Amazon.CDK;

var app = new App();
var theBestStack = new Stack(app, 'MarketingSystem');

// Add a tag to all constructs in the stack
Tags.Of(theBestStack).Add("StackType", "TheBest");

// Remove the tag from all resources except subnet resources
Tags.Of(theBestStack).Remove("StackType", new TagProps
{
    ExcludeResourceTypes = ["AWS::EC2::Subnet"]
});
Go
import "github.com/aws/aws-cdk-go/awscdk/v2"
app := awscdk.NewApp(nil)
theBestStack := awscdk.NewStack(app, jsii.String("MarketingSystem"), &awscdk.StackProps{})

// Add a tag to all constructs in the stack
awscdk.Tags_Of(theBestStack).Add(jsii.String("StackType"), jsii.String("TheBest"), &awscdk.TagProps{})

// Remove the tag from all resources except subnet resources
awscdk.Tags_Of(theBestStack).Add(jsii.String("StackType"), jsii.String("TheBest"), &awscdk.TagProps{
  ExcludeResourceTypes: &[]*string{jsii.String("AWS::EC2::Subnet")},
})

Le code suivant permet d'obtenir le même résultat. Déterminez quelle approche (inclusion ou exclusion) rend votre intention plus claire.

TypeScript
Tags.of(theBestStack).add('StackType', 'TheBest',
  { includeResourceTypes: ['AWS::EC2::Subnet']});
JavaScript
Tags.of(theBestStack).add('StackType', 'TheBest',
  { includeResourceTypes: ['AWS::EC2::Subnet']});
Python
Tags.of(the_best_stack).add("StackType", "TheBest",
    include_resource_types=["AWS::EC2::Subnet"])
Java
Tags.of(theBestStack).add("StackType", "TheBest", TagProps.builder()
        .includeResourceTypes(Arrays.asList("AWS::EC2::Subnet"))
        .build());
C#
Tags.Of(theBestStack).Add("StackType", "TheBest", new TagProps {
    IncludeResourceTypes = ["AWS::EC2::Subnet"]
});
Go
awscdk.Tags_Of(theBestStack).Add(jsii.String("StackType"), jsii.String("TheBest"), &awscdk.TagProps{
  IncludeResourceTypes: &[]*string{jsii.String("AWS::EC2::Subnet")},
})

Marquage de constructions individuelles

Tags.of(scope).add(key, value)est la méthode standard pour ajouter des balises aux constructions du AWS CDK. Son comportement arborescent, qui balise de manière récursive toutes les ressources étiquetables dans le cadre d'une portée donnée, correspond presque toujours à ce que vous recherchez. Cependant, vous devez parfois étiqueter une ou plusieurs constructions arbitraires spécifiques.

L'un de ces cas implique l'application de balises dont la valeur est dérivée d'une propriété de la construction étiquetée. L'approche de balisage standard applique de manière récursive la même clé et la même valeur à toutes les ressources correspondantes du périmètre. Cependant, ici, la valeur peut être différente pour chaque construction étiquetée.

Les balises sont implémentées à l'aide d'aspects, et le CDK appelle la visit() méthode de la balise pour chaque construction dans le cadre que vous avez spécifié en utilisantTags.of(scope). Nous pouvons appeler Tag.visit() directement pour appliquer une balise à une seule construction.

TypeScript
new cdk.Tag(key, value).visit(scope);
JavaScript
new cdk.Tag(key, value).visit(scope);
Python
cdk.Tag(key, value).visit(scope)
Java
Tag.Builder.create(key, value).build().visit(scope);
C#
new Tag(key, value).Visit(scope);
Go
awscdk.NewTag(key, value, &awscdk.TagProps{}).Visit(scope)

Vous pouvez étiqueter toutes les constructions d'une portée, mais laisser les valeurs des balises dériver des propriétés de chaque construction. Pour ce faire, écrivez un aspect et appliquez la balise dans la visit() méthode de l'aspect, comme indiqué dans l'exemple précédent. Ajoutez ensuite l'aspect à la portée souhaitée à l'aide deAspects.of(scope).add(aspect).

L'exemple suivant applique une balise à chaque ressource d'une pile contenant le chemin de la ressource.

TypeScript
class PathTagger implements cdk.IAspect {
  visit(node: IConstruct) {
    new cdk.Tag("aws-cdk-path", node.node.path).visit(node);
  }
}
 
stack = new MyStack(app);
cdk.Aspects.of(stack).add(new PathTagger())
JavaScript
class PathTagger {
  visit(node) {
    new cdk.Tag("aws-cdk-path", node.node.path).visit(node);
  }
}

stack = new MyStack(app);
cdk.Aspects.of(stack).add(new PathTagger())
Python
@jsii.implements(cdk.IAspect)
class PathTagger:
    def visit(self, node: IConstruct):
        cdk.Tag("aws-cdk-path", node.node.path).visit(node)

stack = MyStack(app) 
cdk.Aspects.of(stack).add(PathTagger())
Java
final class PathTagger implements IAspect {
	public void visit(IConstruct node) {
		Tag.Builder.create("aws-cdk-path", node.getNode().getPath()).build().visit(node);
	}
}

stack stack = new MyStack(app);
Aspects.of(stack).add(new PathTagger());
C#
public class PathTagger : IAspect
{
    public void Visit(IConstruct node)
    {
        new Tag("aws-cdk-path", node.Node.Path).Visit(node);
    }
}

var stack = new MyStack(app);
Aspects.Of(stack).Add(new PathTagger);
Astuce

La logique du balisage conditionnel, y compris les priorités, les types de ressources, etc., est intégrée à la Tag classe. Vous pouvez utiliser ces fonctionnalités lorsque vous appliquez des balises à des ressources arbitraires ; la balise n'est pas appliquée si les conditions ne sont pas remplies. De plus, la Tag classe balise uniquement les ressources balisables, vous n'avez donc pas besoin de tester si une construction est balisable avant d'appliquer une balise.