Dies ist der AWS CDK v2-Entwicklerhandbuch. Das ältere CDK v1 wurde am 1. Juni 2022 gewartet und der Support wurde am 1. Juni 2023 eingestellt. Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich. # Identifikatoren und das CDK AWS Beim Erstellen von AWS Cloud Development Kit (AWS CDK) -Apps werden Sie viele Arten von Kennungen und Namen verwenden. Um das AWS CDK effektiv zu nutzen und Fehler zu vermeiden, ist es wichtig, die Arten von Identifikatoren zu verstehen. Identifikatoren müssen innerhalb des Bereichs, in dem sie erstellt wurden, eindeutig sein. Sie müssen in Ihrer AWS CDK-Anwendung nicht global eindeutig sein. Wenn Sie versuchen, einen Bezeichner mit demselben Wert innerhalb desselben Bereichs zu erstellen, löst das AWS CDK eine Ausnahme aus. ## Konstruieren IDs Der häufigste Bezeichner,`id`, ist der Bezeichner, der bei der Instanziierung eines Konstruktobjekts als zweites Argument übergeben wird. Dieser Bezeichner muss, wie alle Bezeichner, nur innerhalb des Bereichs, in dem er erstellt wurde, eindeutig sein. Dies ist das erste Argument bei der Instanziierung eines Konstruktobjekts. **Anmerkung** Der `id` Wert eines Stacks ist auch der Bezeichner, mit dem Sie in der [AWS CDK-CLI-Referenz](cli.md) auf ihn verweisen. Schauen wir uns ein Beispiel an, bei dem wir zwei Konstrukte mit dem Identifier `MyBucket` in unserer App haben. Das erste ist im Bereich des Stacks mit dem Identifier `Stack1` definiert. Der zweite ist im Gültigkeitsbereich eines Stacks mit dem Identifier definiert`Stack2`. Da sie in unterschiedlichen Bereichen definiert sind, verursacht dies keinen Konflikt und sie können problemlos in derselben App koexistieren. **Example** ``` import { App, Stack, StackProps } from 'aws-cdk-lib'; import { Construct } from 'constructs'; import * as s3 from 'aws-cdk-lib/aws-s3'; class MyStack extends Stack { constructor(scope: Construct, id: string, props: StackProps = {}) { super(scope, id, props); new s3.Bucket(this, 'MyBucket'); } } const app = new App(); new MyStack(app, 'Stack1'); new MyStack(app, 'Stack2'); ``` ``` const { App , Stack } = require('aws-cdk-lib'); const s3 = require('aws-cdk-lib/aws-s3'); class MyStack extends Stack { constructor(scope, id, props = {}) { super(scope, id, props); new s3.Bucket(this, 'MyBucket'); } } const app = new App(); new MyStack(app, 'Stack1'); new MyStack(app, 'Stack2'); ``` ``` from aws_cdk import App, Construct, Stack, StackProps from constructs import Construct from aws_cdk import aws_s3 as s3 class MyStack(Stack): def __init__(self, scope: Construct, id: str, **kwargs): super().__init__(scope, id, **kwargs) s3.Bucket(self, "MyBucket") app = App() MyStack(app, 'Stack1') MyStack(app, 'Stack2') ``` ``` // MyStack.java package com.myorg; import software.amazon.awscdk.App; import software.amazon.awscdk.Stack; import software.amazon.awscdk.StackProps; import software.constructs.Construct; import software.amazon.awscdk.services.s3.Bucket; public class MyStack extends Stack { public MyStack(final Construct scope, final String id) { this(scope, id, null); } public MyStack(final Construct scope, final String id, final StackProps props) { super(scope, id, props); new Bucket(this, "MyBucket"); } } // Main.java package com.myorg; import software.amazon.awscdk.App; public class Main { public static void main(String[] args) { App app = new App(); new MyStack(app, "Stack1"); new MyStack(app, "Stack2"); } } ``` ``` using Amazon.CDK; using constructs; using Amazon.CDK.AWS.S3; public class MyStack : Stack { public MyStack(Construct scope, string id, IStackProps props) : base(scope, id, props) { new Bucket(this, "MyBucket"); } } class Program { static void Main(string[] args) { var app = new App(); new MyStack(app, "Stack1"); new MyStack(app, "Stack2"); } } ``` ## Pfade Die Konstrukte in einer AWS CDK-Anwendung bilden eine Hierarchie, die in der Klasse verwurzelt ist. `App` *Wir bezeichnen die Sammlung IDs von einem bestimmten Konstrukt, seinem Elternkonstrukt, seinem übergeordneten Konstrukt usw. bis zur Wurzel des Konstruktbaums als Pfad.* Das AWS CDK zeigt Pfade in Ihren Vorlagen normalerweise als Zeichenfolge an. Die IDs von den Ebenen werden durch Schrägstriche getrennt, beginnend am Knoten unmittelbar unter der `App` Root-Instance, bei der es sich normalerweise um einen Stack handelt. Die Pfade der beiden Amazon S3 S3-Bucket-Ressourcen im vorherigen Codebeispiel lauten beispielsweise `Stack1/MyBucket` und`Stack2/MyBucket`. Sie können programmgesteuert auf den Pfad eines beliebigen Konstrukts zugreifen, wie im folgenden Beispiel gezeigt. Dies erhält den Pfad von `myConstruct` (oder`my_construct`, wie Python-Entwickler ihn schreiben würden). Da sie innerhalb des Bereichs, in dem sie erstellt wurden, eindeutig sein IDs müssen, sind ihre Pfade innerhalb einer AWS CDK-Anwendung immer eindeutig. **Example** ``` const path: string = myConstruct.node.path; ``` ``` const path = myConstruct.node.path; ``` ``` path = my_construct.node.path ``` ``` String path = myConstruct.getNode().getPath(); ``` ``` string path = myConstruct.Node.Path; ``` ## Einzigartig IDs AWS CloudFormation erfordert, dass alle logischen IDs Elemente in einer Vorlage eindeutig sind. Aus diesem Grund muss das AWS CDK in der Lage sein, für jedes Konstrukt in einer Anwendung eine eindeutige Kennung zu generieren. Ressourcen haben weltweit eindeutige Pfade (die Namen aller Bereiche vom Stack bis zu einer bestimmten Ressource). Daher generiert das AWS CDK die erforderlichen eindeutigen Identifikatoren, indem es die Elemente des Pfads verkettet und einen 8-stelligen Hash hinzufügt. (Der Hash ist notwendig, um verschiedene Pfade wie `A/B/C` und zu unterscheiden`A/BC`, die zu derselben Kennung führen würden. AWS CloudFormation AWS CloudFormation Bezeichner sind alphanumerisch und dürfen keine Schrägstriche oder andere Trennzeichen enthalten.) Das AWS CDK nennt diese Zeichenfolge die *eindeutige ID des Konstrukts.* Im Allgemeinen sollte Ihre AWS CDK-App nichts über Unique wissen müssen. IDs Sie können jedoch programmgesteuert auf die eindeutige ID eines beliebigen Konstrukts zugreifen, wie im folgenden Beispiel gezeigt. **Example** ``` const uid: string = Names.uniqueId(myConstruct); ``` ``` const uid = Names.uniqueId(myConstruct); ``` ``` uid = Names.unique_id(my_construct) ``` ``` String uid = Names.uniqueId(myConstruct); ``` ``` string uid = Names.Uniqueid(myConstruct); ``` Die *Adresse* ist eine weitere Art von eindeutiger Kennung, die CDK-Ressourcen eindeutig unterscheidet. Er wurde vom SHA-1-Hash des Pfads abgeleitet und ist nicht für Menschen lesbar. Aufgrund seiner konstanten, relativ kurzen Länge (immer 42 Hexadezimalzeichen) ist er jedoch in Situationen nützlich, in denen die „traditionelle“ eindeutige ID möglicherweise zu lang ist. Einige Konstrukte verwenden möglicherweise die Adresse in der synthetisierten AWS CloudFormation Vorlage anstelle der eindeutigen ID. Auch hier sollte Ihre App im Allgemeinen nichts über die Adressen ihrer Konstrukte wissen müssen, aber Sie können die Adresse eines Konstrukts wie folgt abrufen. **Example** ``` const addr: string = myConstruct.node.addr; ``` ``` const addr = myConstruct.node.addr; ``` ``` addr = my_construct.node.addr ``` ``` String addr = myConstruct.getNode().getAddr(); ``` ``` string addr = myConstruct.Node.Addr; ``` ## Logisch IDs Unique IDs dienen als *logische Bezeichner* (oder *logische Namen*) von Ressourcen in den generierten AWS CloudFormation Vorlagen für Konstrukte, die Ressourcen darstellen AWS . Der Amazon S3 S3-Bucket im vorherigen Beispiel, der innerhalb erstellt wurde, `Stack2` führt beispielsweise zu einer ` AWS::S3::Bucket` Ressource. Die logische ID der Ressource befindet sich `Stack2MyBucket4DD88B4F` in der resultierenden AWS CloudFormation Vorlage. (Einzelheiten darüber, wie dieser Bezeichner generiert wird, finden Sie unter [Unique IDs](#identifiers-unique-ids).) ### Stabilität der logischen ID Vermeiden Sie es, die logische ID einer Ressource zu ändern, nachdem sie erstellt wurde. AWS CloudFormation identifiziert Ressourcen anhand ihrer logischen ID. Wenn Sie also die logische ID einer Ressource ändern, AWS CloudFormation wird eine neue Ressource mit der neuen logischen ID erstellt und anschließend die vorhandene gelöscht. Je nach Ressourcentyp kann dies zu Betriebsunterbrechungen, Datenverlust oder beidem führen.