Tokens und die AWS CDK - AWS Cloud Development Kit (AWS CDK) v2
Tokens und Token-CodierungenZeichenkettencodierte TokenIn der Liste kodierte TokenZahlencodierte TokensFaule WerteKonvertierung zu JSON

Dies ist der AWS CDK v2-Entwicklerhandbuch. Die ältere CDK Version 1 wurde am 1. Juni 2022 in die Wartung aufgenommen 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.

Tokens und die AWS CDK

Tokens stellen Werte dar, die erst zu einem späteren Zeitpunkt im App-Lebenszyklus aufgelöst werden können. Beispielsweise wird der Name eines Amazon Simple Storage Service (Amazon S3) -Buckets, den Sie in Ihrer CDK App definieren, nur zugewiesen, wenn die AWS CloudFormation Vorlage synthetisiert wird. Wenn Sie das bucket.bucketName Attribut drucken, bei dem es sich um eine Zeichenfolge handelt, werden Sie feststellen, dass es etwa Folgendes enthält:

${TOKEN[Bucket.Name.1234]}

Auf diese Weise wird ein Token AWS CDK codiert, dessen Wert zum Zeitpunkt der Erstellung noch nicht bekannt ist, der aber später verfügbar sein wird. Das AWS CDK nennt diese Platzhalter Tokens. In diesem Fall handelt es sich um ein Token, das als Zeichenfolge codiert ist.

Sie können diese Zeichenfolge weitergeben, als wäre es der Name des Buckets. Im folgenden Beispiel wird der Bucket-Name als Umgebungsvariable für eine AWS Lambda Funktion angegeben.

TypeScript
const bucket = new s3.Bucket(this, 'MyBucket');

const fn = new lambda.Function(stack, 'MyLambda', {
  // ...
  environment: {
    BUCKET_NAME: bucket.bucketName,
  }
});
JavaScript
const bucket = new s3.Bucket(this, 'MyBucket');

const fn = new lambda.Function(stack, 'MyLambda', {
  // ...
  environment: {
    BUCKET_NAME: bucket.bucketName
  }
});
Python
bucket = s3.Bucket(self, "MyBucket")

fn = lambda_.Function(stack, "MyLambda",
        environment=dict(BUCKET_NAME=bucket.bucket_name))
Java
final Bucket bucket = new Bucket(this, "MyBucket");

Function fn = Function.Builder.create(this, "MyLambda")
        .environment(java.util.Map.of(    // Map.of requires Java 9+
            "BUCKET_NAME", bucket.getBucketName()))
        .build();
C#
var bucket = new s3.Bucket(this, "MyBucket");
        
var fn = new Function(this, "MyLambda", new FunctionProps {
    Environment = new Dictionary<string, string>
    {
        ["BUCKET_NAME"] = bucket.BucketName
    }
});

Wenn die AWS CloudFormation Vorlage schließlich synthetisiert ist, wird das Token als AWS CloudFormation { "Ref": "MyBucket" } intrinsisches Token gerendert. AWS CloudFormation Ersetzt diesen systeminternen Wert bei der Bereitstellung durch den tatsächlichen Namen des Buckets, der erstellt wurde.

Tokens und Token-Codierungen

Tokens sind Objekte, die die IResolvableSchnittstelle implementieren, die eine einzige resolve Methode enthält. The AWS CDK ruft diese Methode während der Synthese auf, um den endgültigen Wert für die AWS CloudFormation Vorlage zu erzeugen. Tokens sind am Syntheseprozess beteiligt, um beliebige Werte beliebigen Typs zu erzeugen.

Anmerkung

Sie werden selten direkt mit der IResolvable Schnittstelle arbeiten. Sie werden höchstwahrscheinlich nur string-kodierte Versionen von Tokens sehen.

Andere Funktionen akzeptieren normalerweise nur Argumente grundlegender Typen wie oder. string number Um in diesen Fällen Token zu verwenden, können Sie sie in einen von drei Typen codieren, indem Sie statische Methoden in der CDK.Token-Klasse verwenden.

  • Token.asStringum eine Zeichenkettenkodierung zu generieren (oder das Token-Objekt .toString() aufzurufen)

  • Token.asListum eine Listenkodierung zu generieren

  • Token.asNumberum eine numerische Kodierung zu generieren

Diese nehmen einen beliebigen Wert, der ein sein kannIResolvable, und kodieren ihn in einen primitiven Wert des angegebenen Typs.

Wichtig

Da es sich bei jedem der vorherigen Typen potenziell um ein codiertes Token handeln kann, sollten Sie vorsichtig sein, wenn Sie ihren Inhalt analysieren oder versuchen, ihn zu lesen. Wenn Sie beispielsweise versuchen, eine Zeichenfolge zu analysieren, um daraus einen Wert zu extrahieren, und es sich bei der Zeichenfolge um ein codiertes Token handelt, schlägt die Analyse fehl. Ebenso müssen Sie, wenn Sie versuchen, die Länge eines Arrays abzufragen oder mathematische Operationen mit einer Zahl durchzuführen, zunächst überprüfen, ob es sich nicht um kodierte Token handelt.

Um zu überprüfen, ob ein Wert ein ungelöstes Token enthält, rufen Sie die Methode Token.isUnresolved (Python:is_unresolved) auf.

Im folgenden Beispiel wird überprüft, ob ein Zeichenkettenwert, bei dem es sich um ein Token handeln könnte, nicht länger als 10 Zeichen ist.

TypeScript
if (!Token.isUnresolved(name) && name.length > 10) {
  throw new Error(`Maximum length for name is 10 characters`);
}
JavaScript
if ( !Token.isUnresolved(name) && name.length > 10) {
  throw ( new Error(`Maximum length for name is 10 characters`));
}
Python
if not Token.is_unresolved(name) and len(name) > 10:
    raise ValueError("Maximum length for name is 10 characters")
Java
if (!Token.isUnresolved(name) && name.length() > 10)
    throw new IllegalArgumentException("Maximum length for name is 10 characters");
C#
if (!Token.IsUnresolved(name) && name.Length > 10)
    throw new ArgumentException("Maximum length for name is 10 characters");

Wenn Name ein Token ist, wird keine Überprüfung durchgeführt, und in einer späteren Phase des Lebenszyklus, z. B. bei der Bereitstellung, kann immer noch ein Fehler auftreten.

Anmerkung

Sie können Token-Kodierungen verwenden, um das Typsystem zu umgehen. Sie könnten beispielsweise ein Token, das bei der Synthese einen Zahlenwert erzeugt, mit einer Zeichenkette codieren. Wenn Sie diese Funktionen verwenden, liegt es in Ihrer Verantwortung, dafür zu sorgen, dass Ihre Vorlage nach der Synthese wieder in einen brauchbaren Zustand übergeht.

Zeichenkettencodierte Token

Zeichenkettencodierte Token sehen wie folgt aus.

${TOKEN[Bucket.Name.1234]}

Sie können wie normale Zeichenketten weitergegeben und verkettet werden, wie im folgenden Beispiel gezeigt.

TypeScript
const functionName = bucket.bucketName + 'Function';
JavaScript
const functionName = bucket.bucketName + 'Function';
Python
function_name = bucket.bucket_name + "Function"
Java
String functionName = bucket.getBucketName().concat("Function");
C#
string functionName = bucket.BucketName + "Function";

Sie können auch Zeichenketteninterpolation verwenden, sofern Ihre Sprache dies unterstützt, wie im folgenden Beispiel gezeigt.

TypeScript
const functionName = `${bucket.bucketName}Function`;
JavaScript
const functionName = `${bucket.bucketName}Function`;
Python
function_name = f"{bucket.bucket_name}Function"
Java
String functionName = String.format("%sFunction". bucket.getBucketName());
C#
string functionName = $"${bucket.bucketName}Function";

Vermeiden Sie es, die Zeichenfolge auf andere Weise zu manipulieren. Wenn Sie beispielsweise eine Teilzeichenfolge einer Zeichenfolge verwenden, ist es wahrscheinlich, dass das Zeichenketten-Token beschädigt wird.

In der Liste kodierte Token

Listenkodierte Token sehen wie folgt aus:

["#{TOKEN[Stack.NotificationArns.1234]}"]

Die einzig sichere Sache, die man mit diesen Listen machen kann, ist, sie direkt an andere Konstrukte weiterzugeben. Token in Form einer Zeichenkettenliste können nicht verkettet werden, und es kann auch kein Element aus dem Token entnommen werden. Der einzig sichere Weg, sie zu manipulieren, ist die Verwendung AWS CloudFormation systemeigener Funktionen wie fn.Select.

Zahlencodierte Tokens

Zahlenkodierte Token sind eine Reihe winziger negativer Gleitkommazahlen, die wie folgt aussehen.

-1.8881545897087626e+289

Wie bei Listentokens können Sie den Zahlenwert nicht ändern, da das Zahlentokens dadurch wahrscheinlich beschädigt wird. Die einzig zulässige Operation besteht darin, den Wert an ein anderes Konstrukt weiterzugeben.

Faule Werte

Neben der Darstellung von Bereitstellungszeitwerten, wie z. B. AWS CloudFormation Parametern, werden Tokens häufig auch zur Darstellung verzögerter Werte für die Synthesedauer verwendet. Dabei handelt es sich um Werte, für die der endgültige Wert bestimmt wird, bevor die Synthese abgeschlossen ist, jedoch nicht an dem Punkt, an dem der Wert konstruiert wird. Verwenden Sie Tokens, um einen literalen Zeichenketten- oder Zahlenwert an ein anderes Konstrukt zu übergeben, wobei der tatsächliche Wert zum Zeitpunkt der Synthese von einer Berechnung abhängen kann, die noch nicht durchgeführt wurde.

Sie können Tokens erstellen, die verzögerte Synth-Time-Werte darstellen, indem Sie statische Methoden für die Lazy Klasse verwenden, z. B. Lazy.String und Lazy.Number. Diese Methoden akzeptieren ein Objekt, dessen produce Eigenschaft eine Funktion ist, die ein Kontextargument akzeptiert und beim Aufruf den Endwert zurückgibt.

Im folgenden Beispiel wird eine Auto Scaling Scaling-Gruppe erstellt, deren Kapazität nach ihrer Erstellung bestimmt wird.

TypeScript
let actualValue: number;

new AutoScalingGroup(this, 'Group', {
  desiredCapacity: Lazy.numberValue({
    produce(context) {
      return actualValue;
    }
  })
});

// At some later point
actualValue = 10;
JavaScript
let actualValue;

new AutoScalingGroup(this, 'Group', {
  desiredCapacity: Lazy.numberValue({
    produce(context) {
      return (actualValue);
    }
  })
});

// At some later point
actualValue = 10;
Python
class Producer:
    def __init__(self, func):
        self.produce = func

actual_value = None
          
AutoScalingGroup(self, "Group", 
    desired_capacity=Lazy.number_value(Producer(lambda context: actual_value))
)
    
# At some later point
actual_value = 10
Java
double actualValue = 0;

class ProduceActualValue implements INumberProducer {

    @Override
    public Number produce(IResolveContext context) {
        return actualValue;
    }
}

AutoScalingGroup.Builder.create(this, "Group")
    .desiredCapacity(Lazy.numberValue(new ProduceActualValue())).build();

// At some later point
actualValue = 10;
C#
public class NumberProducer : INumberProducer
{
    Func<Double> function;
        
    public NumberProducer(Func<Double> function)
    {
        this.function = function;
    }

    public Double Produce(IResolveContext context)
    {
        return function();
    }
}

double actualValue = 0;

new AutoScalingGroup(this, "Group", new AutoScalingGroupProps
{
    DesiredCapacity = Lazy.NumberValue(new NumberProducer(() => actualValue))
});

// At some later point
actualValue = 10;

Konvertierung zu JSON

Manchmal möchten Sie eine JSON Zeichenfolge mit beliebigen Daten erzeugen, und Sie wissen möglicherweise nicht, ob die Daten Token enthalten. Um jede JSON Datenstruktur korrekt zu kodieren, unabhängig davon, ob sie Token enthält, verwenden Sie den Methodenstapel. toJsonString, wie im folgenden Beispiel gezeigt.

TypeScript
const stack = Stack.of(this);
const str = stack.toJsonString({
  value: bucket.bucketName
});
JavaScript
const stack = Stack.of(this);
const str = stack.toJsonString({
  value: bucket.bucketName
});
Python
stack = Stack.of(self)
string = stack.to_json_string(dict(value=bucket.bucket_name))
Java
Stack stack = Stack.of(this);
String stringVal = stack.toJsonString(java.util.Map.of(    // Map.of requires Java 9+
        put("value", bucket.getBucketName())));
C#
var stack = Stack.Of(this);
var stringVal = stack.ToJsonString(new Dictionary<string, string>
{
    ["value"] = bucket.BucketName
});