Tag e AWS CDK - AWS Cloud Development Kit (AWS CDK) v2
Utilizzo dei tagPriorità dei tagProprietà facoltativeEsempioEtichettatura di singoli costrutti

Questa è la guida per sviluppatori AWS CDK v2. La versione precedente della CDK versione 1 è entrata in manutenzione il 1° giugno 2022 e ha terminato il supporto il 1° giugno 2023.

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Tag e AWS CDK

I tag sono elementi chiave-valore informativi che puoi aggiungere ai costrutti dell'app. AWS CDK Un tag applicato a un determinato costrutto si applica anche a tutti i suoi figli taggabili. I tag sono inclusi nel AWS CloudFormation modello sintetizzato dall'app e vengono applicati alle risorse che distribuisce. AWS Puoi utilizzare i tag per identificare e classificare le risorse per i seguenti scopi:

  • Semplificazione della gestione

  • Allocazione dei costi

  • Controllo accessi

  • Qualsiasi altro scopo da te ideato

Suggerimento

Per ulteriori informazioni su come utilizzare i tag con AWS le risorse, consulta le migliori pratiche per l'etichettatura AWS delle risorse nel white paper.AWS

Utilizzo dei tag

La Tagsclasse include il metodo staticoof(), tramite il quale è possibile aggiungere o rimuovere tag dal costrutto specificato.

  • Tags.of(SCOPE).add()applica un nuovo tag al costrutto dato e a tutti i suoi figli.

  • Tags.of(SCOPE).remove()rimuove un tag dal costrutto dato e da tutti i suoi figli, compresi i tag che un costrutto figlio potrebbe aver applicato a se stesso.

Nota

Il tagging è implementato utilizzando. Aspetti e AWS CDK Gli aspetti sono un modo per applicare un'operazione (come l'etichettatura) a tutti i costrutti in un determinato ambito.

L'esempio seguente applica la chiave del tag con il valore value a un costrutto.

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'esempio seguente elimina la chiave del tag da un costrutto.

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{})

Se utilizzate Stage costrutti, applicate il tag al Stage livello o al di sotto. I tag non vengono applicati oltre Stage i limiti.

Priorità dei tag

AWS CDK Applica e rimuove i tag in modo ricorsivo. In caso di conflitti, vince l'operazione di tagging con la priorità più alta. (Le priorità vengono impostate utilizzando la priority proprietà opzionale). Se le priorità di due operazioni sono le stesse, vince l'operazione di etichettatura più vicina alla parte inferiore dell'albero di costruzione. Per impostazione predefinita, l'applicazione di un tag ha una priorità di 100 (ad eccezione dei tag aggiunti direttamente a una AWS CloudFormation risorsa, che ha una priorità di 50). La priorità predefinita per la rimozione di un tag è 200.

Quanto segue applica un tag con una priorità di 300 a un costrutto.

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

Proprietà facoltative

I tag propertiesconsentono di ottimizzare il modo in cui i tag vengono applicati o rimossi dalle risorse. Tutte le proprietà sono facoltative.

applyToLaunchedInstances(Python:) apply_to_launched_instances

Disponibile solo per add (). Per impostazione predefinita, i tag vengono applicati alle istanze avviate in un gruppo Auto Scaling. Imposta questa proprietà su false per ignorare le istanze avviate in un gruppo Auto Scaling.

includeResourceTypes/excludeResourceTypes(Python:include_resource_types/) exclude_resource_types

Usali per manipolare i tag solo su un sottoinsieme di risorse, in base AWS CloudFormation ai tipi di risorse. Per impostazione predefinita, l'operazione viene applicata a tutte le risorse del sottoalbero di costruzione, ma può essere modificata includendo o escludendo determinati tipi di risorse. L'esclusione ha la precedenza sull'inclusione, se vengono specificati entrambi.

priority

Utilizzatelo per impostare la priorità di questa operazione rispetto alle altre Tags.remove() operazioni Tags.add() and. I valori più alti hanno la precedenza sui valori più bassi. L'impostazione predefinita è 100 per le operazioni di aggiunta (50 per i tag applicati direttamente alle AWS CloudFormation risorse) e 200 per le operazioni di rimozione.

L'esempio seguente applica il tag tagname con il valore value e la priorità 100 alle risorse di tipo AWS: :Xxx: :Yyy nel costrutto. Non applica il tag alle istanze avviate in un gruppo Amazon EC2 Auto Scaling o a risorse di AWStipo: :Xxx: :Zzz. (Si tratta di segnaposti per due tipi di risorse arbitrari ma diversi.) AWS CloudFormation

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'esempio seguente rimuove il tag tagname con priorità 200 dalle risorse di tipo AWS: :Xxx: :Yyy nel costrutto, ma non dalle risorse di tipo: :Xxx: :Zzz. AWS

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

Esempio

L'esempio seguente aggiunge il tag key StackTypecon valore TheBesta qualsiasi risorsa creata all'interno del file denominato. Stack MarketingSystem Quindi lo rimuove nuovamente da tutte le risorse tranne le EC2 VPC sottoreti Amazon. Il risultato è che solo le sottoreti hanno il tag applicato.

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

Il codice seguente consente di ottenere lo stesso risultato. Considerate quale approccio (inclusione o esclusione) rende più chiaro il vostro intento.

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

Etichettatura di singoli costrutti

Tags.of(scope).add(key, value)è il modo standard per aggiungere tag ai costrutti in. AWS CDK Il suo comportamento di tree-walking, che contrassegna in modo ricorsivo tutte le risorse taggabili nell'ambito di un determinato ambito, è quasi sempre quello che si desidera. A volte, tuttavia, è necessario etichettare uno o più costrutti specifici e arbitrari.

Uno di questi casi prevede l'applicazione di tag il cui valore deriva da alcune proprietà del costrutto da etichettare. L'approccio di etichettatura standard applica in modo ricorsivo la stessa chiave e lo stesso valore a tutte le risorse corrispondenti nell'ambito. Tuttavia, qui il valore potrebbe essere diverso per ogni costrutto taggato.

I tag vengono implementati utilizzando gli aspetti e le CDK chiamate al visit() metodo del tag per ogni costrutto nell'ambito specificato. Tags.of(scope) Possiamo chiamare Tag.visit() direttamente per applicare un tag a un singolo costrutto.

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)

È possibile etichettare tutti i costrutti in un ambito, ma lasciare che i valori dei tag derivino dalle proprietà di ciascun costrutto. A tale scopo, scrivete un aspetto e applicate il tag nel visit() metodo dell'aspetto, come mostrato nell'esempio precedente. Quindi, aggiungete l'aspetto all'ambito desiderato utilizzandoAspects.of(scope).add(aspect).

L'esempio seguente applica un tag a ciascuna risorsa in uno stack contenente il percorso della risorsa.

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);
Suggerimento

La logica dell'etichettatura condizionale, che include priorità, tipi di risorse e così via, è integrata nella classe. Tag È possibile utilizzare queste funzionalità quando si applicano tag a risorse arbitrarie; il tag non viene applicato se le condizioni non sono soddisfatte. Inoltre, la Tag classe tagga solo le risorse etichettabili, quindi non è necessario verificare se un costrutto è taggabile prima di applicare un tag.