Zum Inhalt springen
AggregaAggrega
Sprache wählen: Deutsch
Diese Seite wurde maschinell übersetzt. Das englische Original lesen.

CloudFormation-Provider

Der cloudformation-Provider rendert Recipes von Aggrega in AWS-CloudFormation-Stack-Templates. Jede Komponente, die unter diesem Provider in dasselbe Ausgabeverzeichnis rendert, wird zu einem Stack zusammengesetzt, der als ein einziges reines JSON-Template ausgegeben wird, das intrinsische Funktionen in Langform verwendet. Eine Boundary wird daher im gewöhnlichen Fall zu einem Stack — und zwei Boundaries, deren directory: sich zum selben Pfad auflöst, werden gemeinsam zu einem Stack zusammengesetzt und teilen sich die Namen dieses Templates. Wie jeder Aggrega-Provider ist er offline und hermetisch — ein Aggrega-Build ist eine Ahead-of-Time-Kompilierung, daher ruft der Provider nie AWS auf, löst nie vom Konto generierte Bezeichner auf und führt nie CloudFormation aus. Reine Laufzeitwerte bleiben als intrinsische CloudFormation-Referenzen (Fn::GetAtt, Fn::ImportValue, Fn::GetStackOutput) erhalten, die CloudFormation zum Bereitstellungszeitpunkt auflöst.

Zu einem Stack zusammengesetzte Fragment-Recipes

Ein cloudformation-Recipe verfasst ein Fragment — die CloudFormation-Ressourcen, die eine einzelne Komponente beiträgt — statt eines ganzen Templates. Wenn die Komponenten einer Boundary rendern, setzt der Provider jedes Fragment der Verteilungsgruppe zu einem Stack-Template zusammen: Die Ressourcen werden unter einer einzigen Map Resources zusammengeführt, die Werte in provides jeder Komponente erscheinen als Outputs des Stacks, und die übrigen Abschnitte oberster Ebene des Templates werden einzeln unter Abschnitte oberster Ebene im zusammengesetzten Stack behandelt. Zwei Authoring-Formen werden akzeptiert:

  • Fragment-Eingabe (Artefakte). Ein Recipe verfasst Ressourcenfragmente direkt; der Provider normalisiert sie zu reinem JSON mit intrinsischen Funktionen in Langform und führt sie in den zusammengesetzten Stack zusammen.
  • Quellbasierte Eingabe. Ein Recipe verweist auf ein vorhandenes CloudFormation-Template (YAML oder JSON); der Provider normalisiert es zu JSON in Langform und validiert seine Struktur vor dem Zusammensetzen, befüllt die Parameter, die das Template deklariert, aus dem valuesMapping des Recipe — siehe Werte für die Parameter eines als Quelle verwendeten Templates — und lässt jede Ressource aus, die die Einträge in omits: des Recipe nennen — siehe Ressourcen aus einem als Quelle verwendeten Template auslassen.

Das zusammengesetzte Template ist reines JSON. Intrinsische Funktionen werden unverändert ausgegeben und nie zur Build-Zeit ausgewertet — der Compiler kann keinen Wert auflösen, der erst existiert, nachdem der Stack bereitgestellt wurde, und einen solchen auszuwerten würde den Ahead-of-Time-Vertrag brechen.

Ein an eine Komponente angebundenes Feature trägt zum selben Stack bei

Ein an eine Komponente angebundenes Feature trägt seine Ressourcen zu dem Stack bei, zu dem seine Host-Komponente zusammengesetzt wird, zu denselben Bedingungen wie das eigene Recipe der Host-Komponente. Daneben gibt es kein separates Template: Der zusammengesetzte Stack ist alles, was dieser Provider für ein Ausgabeverzeichnis ausgibt, daher sind die Ressourcen eines angebundenen Feature entweder in diesem Stack, oder sie werden überhaupt nicht bereitgestellt. Das Lösen der Anbindung des Feature entfernt genau diese Ressourcen und lässt die eigenen der Host-Komponente unberührt.

Da sie im zusammengesetzten Stack landen, teilen sie dessen Namen. Die logischen IDs der Ressourcen eines angebundenen Feature liegen im selben Raum wie die der Host-Komponente und wie die jedes anderen daneben angebundenen Feature, daher gilt Namen im zusammengesetzten Stack für sie unverändert. Wo zwei Beitragende auf einen Namen treffen, nennt der Abbruch die Komponente und den Schlüssel, unter dem das Feature angebunden ist, sodass beide Enden der Kollision in Ihren eigenen Dateien auffindbar sind.

Die Ausgaben eines angebundenen Feature werden unter dem Namen seiner Host-Komponente veröffentlicht, die logischen IDs seiner Ressourcen nicht. Die beiden Hälften des Stacks werden nach unterschiedlichen Regeln benannt und beantworten dies daher unterschiedlich. Eine logische Ressourcen-ID wird genau so ausgegeben, wie das FeatureRecipe sie verfasst hat, wie die jedes Recipe. Eine Ausgabe wird nach der veröffentlichenden Komponente und dem Eintrag zusammen benannt — und für ein an eine Komponente angebundenes Feature ist die veröffentlichende Komponente der Host: Ein an payments-db angebundenes Feature, das alarm veröffentlicht, gelangt zu paymentsXzhdbXXalarm, demselben Namen, zu dem es gelangen würde, hätte die Host-Komponente diesen Eintrag selbst veröffentlicht. Ein Eintragsname, den auch der Host veröffentlicht, trifft daher an einem Ausgabenamen auf den der Anbindung, und der Build hält an und nennt die Komponente und den Schlüssel, unter dem das Feature angebunden ist, neben der Komponente für sich allein. Eintragsnamen zu wählen, die sich als die eigenen des Feature lesen — backup-alarm statt alarm —, hält sie von denen des Hosts fern.

Jede Ressource, die ein Feature beiträgt, behält in den Herkunftsangaben, die der Build in sie schreibt, die für diese Anbindung gebildete Identität statt der der Host-Komponente, sodass beide innerhalb eines Stacks unterscheidbar bleiben, zu dem beide beigetragen haben. Labels und Annotationen beschreibt, wie diese Identität gebildet wird.

Abschnitte oberster Ebene im zusammengesetzten Stack

Mehrere Komponenten werden zu einem Stack zusammengesetzt, daher muss die Zusammensetzung jeden Abschnitt oberster Ebene berücksichtigen, den ein CloudFormation-Template zulässt — einschließlich Globals und Hooks, der beiden Abschnitte, die eine von CloudFormation gehostete Transformation der Template-Sprache hinzufügt. Jeder davon fällt in genau eine der Gruppen unten, und ein Schlüssel oberster Ebene, den eine Komponente schreibt und der überhaupt kein Abschnitt ist, erhält eine Warnung, die die Komponente und den Schlüssel nennt, sodass nichts verworfen wird, ohne dass es gesagt wird.

Unter Namen zusammengesetzt, denen der Provider einen Geltungsbereich gibt, oder so gelesen, wie sie geschrieben sind. Resources und Outputs, die Namen im zusammengesetzten Stack vollständig behandelt. AWSTemplateFormatVersion wird vom Provider geschrieben, statt aus einer Komponente gelesen zu werden: Die Template-Sprache lässt dafür einen einzigen Wert zu, daher gibt es für eine Komponente nichts zu entscheiden.

Unter genau den Namen übernommen, die Sie geschrieben haben. Parameters, Mappings, Conditions, Metadata und Rules. Jeder dieser Abschnitte ist eine Map mit Schlüsseln, die Sie gewählt haben, daher erreichen die Einträge jeder Komponente den zusammengesetzten Stack unter diesen Namen, unverändert — und genau das lässt eine Condition: einer Ressource, ein Fn::FindInMap oder eine Ref auf einen Parameter gegen die Deklaration auflösen, die mit ihr angekommen ist. Jeder wird für sich übernommen, weil jeder für sich verfasst wird: Eine Regel trifft Aussagen über einen Parameter desselben Dokuments, eine Bedingung kann auch gar keinen Parameter referenzieren, und CloudFormation erlaubt keine Parameterreferenz innerhalb eines Mappings.

Ein Wort deckt hier zwei verschiedene Stellen ab, und nur die erste davon gehört Ihnen. Das Metadata in der Liste oben ist der eigene Abschnitt oberster Ebene des Templates, eine Map von Namen, die Sie gewählt haben. Eine einzelne Ressource trägt außerdem ein eigenes Attribut Metadata, und dort schreibt der Build die Provenienz — unter einem einzigen reservierten Schlüssel aggrega.ai/, hinzugefügt neben allem, was Sie dort geschrieben haben, statt es zu ersetzen. Ein Provenienzeintrag, der innerhalb einer Ressource erscheint, ist also weder etwas, das Sie verfasst haben, noch etwas, das der Abschnitt oberster Ebene übernommen hat.

Parameters, Mappings, Conditions und Rules benennen ihre Einträge mit einer logischen ID. Weil der Provider einen Namen genau so übernimmt, wie Sie ihn geschrieben haben, erreicht das Alphabet, das eine logische ID zulässt, auch diese Abschnitte: Ein Name in einem der vier, der etwas anderes als Buchstaben und Ziffern enthält, bricht den Build ab — siehe Ein übernommener Abschnittsname außerhalb des Alphabets bricht den Build ab. Die Namen des Abschnitts Metadata oberster Ebene hält der Provider nicht an dieses Alphabet: Sie benennen Informationen, die Sie ablegen, und nichts, was das Template adressiert.

Zwei Komponenten, die in einem dieser Abschnitte unterschiedliche Namen deklarieren, landen beide. Zwei, die einen Namen mit identischem Inhalt deklarieren, werden zu einem einzigen Eintrag zusammengeführt, und der Build läuft weiter. Zwei, die einen Namen mit unterschiedlichem Inhalt deklarieren, brechen den Build ab und nennen den Abschnitt, den Namen und beide Komponenten — weil sonst einer der beiden Inhalte verworfen würde und die Komponente, die ihn geschrieben hat, eine Deklaration hätte, die der Stack nicht übernimmt. Das ist derselbe Abgleich, dem die Ressourcen- und Ausgabenamen folgen, und das Umbenennen eines der beiden behebt ihn.

Benannt statt übernommen. Description ist eine einzige Aussage über ein ganzes Template statt einer Map von Namen, die Sie gewählt haben, daher hat eine Zusammensetzung, die aus mehreren Komponenten schöpft, darauf keine Antwort: Zwei Beschreibungen sind zwei Antworten auf eine Frage, und keine davon ist die des Stacks. Hooks wird nur von der Transformation AWS::CodeDeployBlueGreen gelesen, die der zusammengesetzte Stack nie übernimmt (siehe unten). Der zusammengesetzte Stack übernimmt daher keinen der beiden Abschnitte, und jede Komponente, die einen davon verfasst hat, erhält eine Warnung, die die Komponente und den Abschnitt nennt. Ebenso eine Komponente, die Globals schreibt, ohne die Transformation AWS::Serverless-2016-10-31 zu deklarieren, die diesen Abschnitt liest. Die Warnung ist beratend und Out-of-Band: Das ausgegebene Template ist Byte für Byte das, was es ohne sie wäre, und --no-unsupported-field-warnings bringt sie zusammen mit dem Rest dieser Klasse zum Schweigen.

Transform wird aus den Transformationen aller Komponenten gebildet. Eine Transformation ist ein Makro, das CloudFormation über das gesamte Template ausführt, bevor es irgendetwas bereitstellt, daher ist der Abschnitt Transform des zusammengesetzten Stacks die Vereinigung der Transformationen, die seine Komponenten deklarieren — die eines als Quelle verwendeten Templates ebenso wie die eines Fragments — in der Reihenfolge, die CloudFormation dokumentiert: ein Makro, das Ihr Konto definiert, vor den Transformationen, die CloudFormation hostet, und AWS::LanguageExtensions vor AWS::Serverless-2016-10-31. Die eigene Reihenfolge jeder Komponente bleibt erhalten, und zwei Transformationen, die nichts ordnet, laufen in der Reihenfolge, in der die Komponenten sie zuerst deklarieren, sodass dieselben Komponenten denselben Stack ergeben. Eine Transformation wird als Zeichenkette geschrieben, mehrere als Liste. Ein Stack mit nur einer Komponente, die ihren Abschnitt Transform in einem Template oder Fragment deklariert, behält ihn genau so, wie er geschrieben wurde, überall dort, wo die Tabelle unten ihn übernimmt, und ein Stack, dessen Komponenten keine Transformation deklarieren, übernimmt keine. Die Transformation einer Komponente löst keine Warnung aus: Sie wird übernommen, oder der Build bricht ab und nennt sie.

Weil eine Transformation das gesamte Template verarbeitet, ändert das Übernehmen einer Transformation, wie der Inhalt jeder anderen Komponente bereitgestellt wird, es sei denn, was sie tut, ist auf den für sie geschriebenen Inhalt beschränkt. Daher erhält jede Transformation die Behandlung, die die eigene Dokumentation von CloudFormation zu ihr stützt, und eine Kombination, die der Stack nicht übernehmen kann, bricht den Build ab und nennt die Transformation und jede Komponente im Stack:

Transformationim zusammengesetzten Stack
AWS::Serverless-2016-10-31übernommen, mit den Globals der Komponente, die sie deklariert. Sie bricht den Build ab, wo diese Globals die Serverless-Ressourcen einer anderen Komponente erreichen würden und wo eine der Ereignisquellen ihrer Ressourcen eine Ressource nennt, die eine andere Komponente deklariert, weil die Transformation die Ressource umschreibt, die ein Ereignis nennt.
AWS::LanguageExtensionsallein übernommen oder neben AWS::Serverless-2016-10-31 aus derselben Komponente. Neben dem Serverless-Inhalt einer anderen Komponente bricht sie den Build ab, weil die Serverless-Transformation das, was sie erzeugt, anders benennt, sobald die Spracherweiterungen ihre Werte aufgelöst haben.
AWS::SecretsManager-2020-07-23, AWS::SecretsManager-2024-09-16übernommen: Sie verarbeiten nur die Rotationszeitpläne, die sie anfordern.
AWS::ServiceCatalogfür einen Stack mit nur einer Komponente übernommen. Neben jeder anderen bricht sie den Build ab, weil sie ihr Referenzmuster überall im Template ersetzt.
AWS::CodeDeployBlueGreenbricht den Build ab, sogar allein: CloudFormation lehnt Outputs und Fn::ImportValue überall in einem Template ab, das sie deklariert, und der zusammengesetzte Stack übernimmt die Ausgaben, die seine Komponenten veröffentlichen.
AWS::Includebricht den Build ab, sogar allein: Sie fügt Inhalt ein, der beim Bereitstellen des Stacks aus S3 abgerufen wird und den der Build nicht lesen kann.
ein Makro, das Ihr Konto definiertfür einen Stack mit nur einer Komponente übernommen. Neben jeder anderen bricht es den Build ab, weil das, was es mit dem Rest des Templates macht, dem Build unbekannt ist.

Zwei Komponenten, die ein Paar von Transformationen in entgegengesetzter Reihenfolge deklarieren, brechen den Build ebenfalls ab und nennen beide Reihenfolgen und beide Komponenten, da der Stack sie in einer einzigen Reihenfolge ausführt. Eine Komponente, die eine Transformation braucht, die der Stack nicht übernehmen kann, gehört in eine eigene Boundary.

Namen im zusammengesetzten Stack

Eine logische ID in CloudFormation ist innerhalb eines Templates eindeutig und lässt nur Buchstaben und Ziffern zu, und jede Komponente, die in dieses Template zusammengesetzt wird, teilt dessen Namen — einschließlich Komponenten aus einer zweiten Boundary, wenn beide in dasselbe Ausgabeverzeichnis aufgelöst werden. Daher muss jeder Name, unter dem der Stack etwas adressiert, über alle Komponenten hinweg eindeutig sein, die dazu beigetragen haben, und die Menge der Beitragenden ist nicht immer eine einzige Boundary.

Logische Ressourcen-IDs stammen aus dem Recipe. Der Provider gibt sie genau so aus, wie sie verfasst wurden, und schreibt keine davon um, daher ist der Name, den Sie im zusammengesetzten Template lesen, der Name, den das Recipe geschrieben hat. Die CloudFormation-Recipes der Standardbibliothek leiten ihn aus dem eigenen Namen der Komponenteninstanz ab und lesen die Trennzeichen dieses Namens als Wortgrenzen: Die Instanz payments-db benennt ihre Ressource PaymentsDb. Zwei Instanzen desselben Typs beschreiben daher zwei Ressourcen, statt um eine zu konkurrieren.

Ausgabenamen haben den Geltungsbereich der Komponente, die sie veröffentlicht hat. Jeder Eintrag in provides erscheint als eine Ausgabe, die nach der veröffentlichenden Komponente und dem Eintrag zusammen benannt ist — die Komponente payments-db, die host veröffentlicht, erscheint als paymentsXzhdbXXhost —, daher erreichen zwei Komponenten, die denselben Eintrag veröffentlichen, zwei getrennte Ausgaben, und die Bedeutung einer Ausgabe ändert sich nicht, wenn eine weitere Komponente dem Stack beitritt. Ein Stack-übergreifender Konsument im selben Konto und in derselben Region importiert über den Exportnamen statt über diesen, daher ist der Exportname nicht betroffen; ein konten- oder regionsübergreifender Lesezugriff nennt diese Ausgabe, so wie der Provider sie für Sie schreibt (siehe Stack-übergreifende Verdrahtung).

Wie ein Ausgabename gebildet wird

Eine logische ID lässt kein Trennzeichen zu, daher muss ein Name, der aus etwas gebildet wird, das Sie geschrieben haben, Ihre Trennzeichen irgendwie mitnehmen. Sie wegzulassen wäre verlustbehaftet: payments-db und payments_db sind zwei Komponenten, und ein Name, der die Interpunktion weglässt, würde keine der beiden identifizieren. Daher codiert der Provider stattdessen, was das Alphabet ablehnt, und schreibt jedes abgelehnte Zeichen in Zeichen aus, die das Alphabet zulässt.

Das Schema reserviert ein Zeichen, mit dem ein Escape eröffnet wird — ein großes X —, und schreibt alles andere so, wie Sie es eingegeben haben, Großbuchstaben eingeschlossen. Nur der Großbuchstabe ist reserviert, daher wird das kleine x eines Namens wie nginx-proxy so übernommen, wie Sie es geschrieben haben:

was Sie geschrieben habenwas daraus wirdwarum
ein Buchstabe oder eine Ziffer, außer Xdas Zeichen selbstdas Alphabet lässt es zu
-Xzhdas Alphabet lehnt einen Bindestrich ab
_Xzudas Alphabet lehnt einen Unterstrich ab
.Xzddas Alphabet lehnt einen Punkt ab
/Xzsdas Alphabet lehnt einen Schrägstrich ab, den eine verschachtelte Komponentenidentität trägt
XXzx000058reserviert, um ein Escape zu eröffnen, daher wird es über seinen Codepunkt ausgeschrieben
alles andereXzx und der Codepunkt des Zeichenseine Regel deckt jedes übrige Zeichen ab
das Zusammentreffen der beiden HälftenXXzwei öffnende Zeichen hintereinander, die keine der beiden Hälften enthalten kann

Das Zurücklesen ist eindeutig, und genau darum geht es, nicht um eine Nettigkeit. Ein X wird nur dann als es selbst behalten, wenn das Zeichen danach eines ist, das das Alphabet zulässt, daher endet eine codierte Hälfte nie mit einem und enthält nie zwei hintereinander — was XX frei lässt, die Verbindungsstelle zu bedeuten, und nur die Verbindungsstelle.

So bleiben drei Namen getrennt, die sich nur darin unterscheiden, wo ihre Interpunktion steht:

component payments-db publishing host → paymentsXzhdbXXhost
component payments_db publishing host → paymentsXzudbXXhost
component payments publishing db-host → paymentsXXdbXzhhost

Die Namen sind länger und weniger unmittelbar lesbar als der Komponentenname, den Sie geschrieben haben, und das ist der Kompromiss. Ein Name, der genau einen Eintrag identifiziert, ist mehr wert als ein kürzerer, der keinen von zweien identifiziert — und Sie adressieren eine Ausgabe über den Exportnamen, statt diesen einzutippen, daher kostet es einen zweiten Blick beim Lesen eines ausgegebenen Templates.

Logische Ressourcen-IDs folgen einer anderen Regel, weil der Provider sie nicht bildet: Er gibt aus, was das Recipe geschrieben hat. Die CloudFormation-Recipes der Standardbibliothek leiten eine ab, indem sie die Trennzeichen des Instanznamens als Wortgrenzen lesen — die Instanz payments-db benennt ihre Ressource PaymentsDb —, und diese Ableitung lässt die Trennzeichen weg, daher leiten zwei Instanznamen, die sich nur in der Interpunktion oder nur in der Groß- und Kleinschreibung eines Buchstabens unterscheiden, trotzdem einen einzigen Ressourcennamen ab. Der Build bricht ab und nennt jede Instanz, die bei dem Namen angekommen ist, zusammen mit dem Namen, auf dem sie gelandet sind, statt eine Ressource auszugeben, wo zwei Komponenten deklariert wurden. Jede von ihnen wird genannt statt nur einiger, weil nichts an einer Kollision die Ableitung einer Instanz zur beabsichtigten macht. Alle bis auf eine umzubenennen behebt den Abbruch.

Eine logische Ressourcen-ID außerhalb des Alphabets bricht den Build ab

Eindeutigkeit und das Alphabet sind zwei getrennte Anforderungen, und eine Menge von Namen kann die erste erfüllen und die zweite verfehlen. Weil der Provider eine logische Ressourcen-ID genau so ausgibt, wie das Recipe sie geschrieben hat, muss die ID, die ein Recipe verfasst, eine sein, die ein CloudFormation-Template für sich allein aufnehmen kann: Buchstaben und Ziffern und sonst nichts.

Hier trennen sich ein abgeleiteter und ein durchgereichter Name. Ein Ausgabename wird vom Provider gebildet, der die veröffentlichende Komponente und den Eintrag codiert, daher liegt ein Ausgabename innerhalb des Alphabets, wie auch immer Sie eine der beiden Hälften schreiben. Eine logische Ressourcen-ID wird durchgereicht, daher bekommt das Template, was auch immer das Recipe geschrieben hat.

Das macht sie auch zu einer Einschränkung für Komponentennamen, wann immer ein Recipe den Namen einer Komponenteninstanz direkt in die logische ID schreibt. Ein Komponentenname darf einen Bindestrich oder einen Unterstrich enthalten; eine logische ID nicht. Eine Komponente, die Sie über ein solches Recipe auf diesen Provider ausrichten, wird daher nur mit Buchstaben und Ziffern benannt — paymentsdb statt payments-db —, und alles andere bricht den Build ab.

Der Abbruch nennt den Beitragenden, dessen Recipe die ID verfasst hat, die ID selbst und jedes Zeichen darin, das dort nicht stehen darf, und er sagt, was Sie stattdessen schreiben können. Zwei Dinge beheben ihn, und das erste steht Ihnen immer zur Verfügung:

  • Lassen Sie das Recipe eine eigene logische ID verfassen, statt einen Namen direkt durchzureichen. Die CloudFormation-Recipes der Standardbibliothek gehen diesen Weg — sie lesen die Trennzeichen des Instanznamens als Wortgrenzen, sodass die Instanz payments-db ihre Ressource PaymentsDb benennt und Sie den gewählten Komponentennamen behalten. Eine ID auf diese Weise abzuleiten, tauscht diesen Abbruch gegen die Kollisionsregel oben: Zwei Instanznamen, die sich nur in der Interpunktion unterscheiden, leiten einen einzigen Ressourcennamen ab.
  • Wo ein Recipe einen Namen doch direkt durchreicht, benennen Sie das, was es durchreicht, nur mit Buchstaben und Ziffern um. Beim eigenen Recipe einer Komponente ist das der Komponentenname. Ein an eine Komponente angebundenes Feature benennt seine Ressourcen aus seinem eigenen FeatureRecipe, daher erreicht das Umbenennen der Host-Komponente sie nicht — die ID, die dieses Recipe schreibt, ist das, was sich ändern muss.

Der Provider lehnt ab; er repariert nicht stillschweigend. Die ID in Ihrem Namen umzuschreiben, sähe nach dem Hilfreichen aus, und das ist es nicht. Eine logische ID ist die Art, wie CloudFormation eine Ressource über Aktualisierungen hinweg identifiziert, daher ist es keine Umbenennung, eine zu ändern — sie adressiert eine andere Ressource. Eine vom Provider ersetzte ID würde woandershin zeigen als auf die Ressource, die bereits unter der von Ihnen geschriebenen ID bereitgestellt ist, und die Ersetzung ist eine, um die Sie nie gebeten haben und die Sie aus dem ausgegebenen Template erschließen müssten. Ein Build, der abbricht, nennt das Problem, solange es noch an Ihnen ist, es zu beheben.

Ein übernommener Abschnittsname außerhalb des Alphabets bricht den Build ab

Logische Ressourcen-IDs sind nicht die einzigen Namen, die der Provider genau so übernimmt, wie Sie sie geschrieben haben. Parameters, Mappings, Conditions und Rules benennen ihre Einträge ebenfalls mit einer logischen ID, und jeder der vier Abschnitte erreicht den zusammengesetzten Stack unter dem Namen, den sein Autor gewählt hat. Die Anforderung ist also dieselbe, auf vier weiteren Flächen: Der Name muss einer sein, den ein CloudFormation-Template für sich allein aufnehmen kann — Buchstaben und Ziffern und sonst nichts —, und alles andere bricht den Build ab.

Es gibt eine Folge über den Abschnitt hinaus, der den Namen trägt, und sie ist der Grund, warum dies den Build abbricht, statt zu warnen. Gegen diese Namen lösen sich eine Condition: einer Ressource, ein Fn::FindInMap oder eine Ref auf einen Parameter auf. Ein Name, den das Alphabet nicht zulässt, nimmt daher die Referenz, die auf ihn zeigt, zusammen mit der Deklaration selbst aus dem bereitstellbaren Template heraus, sodass ein einziger verfasster Name beide auf einmal unerreichbar macht — und ohne den Abbruch wird das erst beim Bereitstellen entdeckt, von demjenigen, der bereitstellt, statt von demjenigen, der den Namen geschrieben hat.

Der Abbruch nennt den Beitragenden, dessen Recipe den Namen geschrieben hat, den Abschnitt, in dem er geschrieben wurde, den Namen selbst und jedes Zeichen darin, das dort nicht stehen darf. Der Abschnitt ist der Begriff, nach dem Sie in Ihren Recipes suchen: Diese Namen werden unter genau dem Abschnitt übernommen, in dem Sie sie geschrieben haben, daher ist er das eine Wort, das sowohl in der Meldung als auch in Ihren eigenen Dateien vorkommt. Den Eintrag nur mit Buchstaben und Ziffern umzubenennen behebt den Abbruch, und das ist die ganze Abhilfe — eine logische Ressourcen-ID bietet die Alternative, das Recipe eine ID ableiten zu lassen, statt einen Namen durchzureichen, und hier gibt es nichts abzuleiten, weil der Name im Abschnitt das ist, was Sie geschrieben haben.

Nur die eigenen Namen eines Abschnitts unterliegen dem Alphabet, nie die Schlüssel innerhalb eines Eintrags. Die Schlüssel zweiter Ebene eines Mappings können Sie frei wählen — us-east-1 unter einer Map RegionCidr ist der gewöhnliche Fall, und er erreicht das ausgegebene Template unverändert. Die Schlüssel im Körper eines Parameters, einer Bedingung oder einer Regel benennen Attribute, Zusicherungen und intrinsische Funktionen statt etwas, das der Stack adressiert: Die Assertions einer Regel und ein darin geschriebenes Fn::Contains sind Schlüssel dieser Art. Keiner davon ist eine logische ID, und keiner wird geprüft.

Zwei Eintragsnamen, die Sie getrennt geschrieben haben, bleiben getrennt

Drei Arten von Eintragsnamen liegen nah genug beieinander, um sich in einem einzigen Ausgabenamen zu treffen, und keine davon ist exotisch. Weil die beiden Hälften codiert statt kompaktiert werden und sich an einer Folge treffen, die keine der beiden Hälften enthalten kann, erreichen alle drei eigene Namen:

  • Einträge, die sich nur in der Interpunktion unterscheiden. Eine Komponente, die sowohl db-host als auch db_host veröffentlicht, erreicht dbXzhhost und dbXzuhost.
  • Einträge, die sich nur in der Groß- und Kleinschreibung eines Buchstabens unterscheiden. host und Host erreichen host und Host, weil ein Buchstabe in der Schreibweise übernommen wird, in der Sie ihn geschrieben haben.
  • Einträge, die sich über die Verbindungsstelle hinweg treffen. Die Component payments-db, die host veröffentlicht, erreicht paymentsXzhdbXXhost; die Komponente payments, die db-host veröffentlicht, erreicht paymentsXXdbXzhhost.

Zwei Einträge treffen sich dennoch, wo sie wirklich ein und dasselbe benennen. Der Ausgabename wird aus der veröffentlichenden Komponente und dem Eintrag gebildet, daher erreicht alles, was beides teilt, einen einzigen Namen, wie auch immer es codiert wird. Der Fall, dem Sie am ehesten begegnen, ist ein Feature, das zweimal an eine einzelne Komponente angebunden ist: Eine Anbindung veröffentlicht unter ihrem Host, daher veröffentlichen zwei Anbindungen eines Feature an einer Komponente beide alarm-id aus payments-db, und in dem Paar gibt es nichts, was sie unterscheidet. Der Build bricht ab, statt eine einzige Ausgabe auszugeben, wo zwei geschrieben wurden, und nennt die Komponente und den Anbindungsschlüssel, den jede Seite trug, sodass beide Enden in Ihren eigenen Dateien auffindbar sind. Binden Sie das Feature entweder nur einmal an, oder verwenden Sie ein Feature, dessen veröffentlichte Eintragsnamen sich als die eigenen dieser Anbindung lesen.

Das gilt unabhängig davon, ob die beiden Einträge denselben Wert tragen. Zwei Einträge mit demselben Wert beschreiben dennoch zwei Ausgaben, die ein Autor verlangt hat, daher würde ein Zusammenführen zu einer einzigen eine der beiden niedergeschriebenen Ausgaben im Stack fehlen lassen.

Ein Name, den ein Recipe in einem Template zusammenstellt, ist hiervon nicht erfasst

Die oben beschriebene Codierung ist die des Providers, und sie gilt für die Ausgabenamen, die der Provider bildet. Innerhalb eines Recipe-Templates steht sie Ihnen nicht zur Verfügung, und ein Name, den Ihr Template zusammenstellt, trägt daher keine ihrer Garantien. Das deutlich zu sagen ist wichtig, weil die Gefahr von innerhalb des Templates unsichtbar ist: Die dort verfügbare Kompaktierung liest ihr Argument als Wörter und lässt alles dazwischen weg, daher verliert das Verbinden zweier Werte vor dem Kompaktieren die Verbindungsstelle zusammen mit der Interpunktion.

Ein FeatureRecipe, das eine Ressource aus einer Instanz und einem Anbindungsschlüssel benennt, verbunden durch ein Leerzeichen und dann kompaktiert, ist die Form, auf die Sie achten sollten — app mit cache und app-cache mit nichts werden beide zu AppCache kompaktiert, und die beiden kollidieren, bevor irgendeine Eigenschaft der Kompaktierung greift. Zwei Dinge halten einen solchen Namen eindeutig, und beide liegen bei Ihnen statt beim Provider:

  • Halten Sie die zusammengestellten Teile in Buchstaben und Ziffern, sodass nichts weggelassen wird und nichts unterschieden werden muss.
  • Verbinden Sie keine zwei Werte, die jeweils das Trennzeichen des anderen enthalten können. Wo ein Name zwei Teile tragen muss, machen Sie einen davon zu einem festen Literal, das der andere nicht enthalten kann.

Wo ein zusammengestellter Name doch kollidiert, kollidiert er als logische Ressourcen-ID statt als Ausgabename, daher ist der Abbruch, dem Sie begegnen, der oben beschriebene für Ressourcennamen.

Ein zweimal in einem Mapping geschriebener Schlüssel bricht den Build ab

Ein CloudFormation-Fragment wird als Mapping gelesen, und ein Mapping enthält einen Wert pro Schlüssel, daher würde ein zweimal geschriebener Schlüssel den Körper behalten, der zuletzt kam, und den anderen verwerfen. Wo das Mapping ein Block Resources oder Outputs ist, ist der verworfene Körper eine Ressource oder eine Ausgabe, die geschrieben wurde und schlicht nicht im Stack wäre.

Der Build bricht stattdessen ab und nennt den wiederholten Schlüssel und beide Zeilen, in denen er geschrieben wurde. Das ist eine Regel für das ganze Fragment und keine Regel über die Namen des Stacks: Sie gilt für jedes Mapping im Fragment, einschließlich der Properties einer Ressource. Am häufigsten gelangt man dorthin über ein Recipe, das eine logische ID aus einem verfassten Wert ableitet, wobei sich zwei verfasste Werte nur in der Interpunktion unterscheiden — app-cache und app_cache leiten beide AppCache ab, daher schreibt das Fragment AppCache zweimal.

Ein Schlüsselname, der an verschiedenen Stellen des Dokuments wiederkehrt, ist gewöhnlich und bleibt unberührt: Type erscheint einmal pro Ressource und Value einmal pro Ausgabe, wie viele Ressourcen und Ausgaben das Fragment auch trägt. Nur eine Wiederholung innerhalb eines einzigen Mappings verliert einen Körper.

Eine einzelne Komponente kann einen Namen zweimal beanspruchen. Ein Recipe steuert mehrere Fragmente bei — mehrere Einträge in artifacts: oder ein als Quelle verwendetes Verzeichnis mit mehreren Templates —, und jedes davon wird in denselben Stack zusammengesetzt, daher teilen sich die eigenen Fragmente einer Komponente die Namen des Stacks untereinander genau so, wie sie sie über Komponenten hinweg teilen. Zwei Fragmente, die einem Namen zwei verschiedene Körper geben, brechen den Build ab, und der Abbruch nennt den Schlüsselraum, in dem der Name liegt — logische Ressourcen-IDs oder Ausgabenamen —, zusammen mit der Komponente und dem Namen selbst. Beide Räume sind auf diese Weise erreichbar: Zwei Fragmente können eine logische Ressourcen-ID über verschiedene Ressourcen verfassen, und eine Komponente erreicht ihre Ausgabenamen über zwei Wege, einen expliziten Block Outputs: und ihre Einträge in provides:, daher treffen sich dort auch zwei Einträge, je einer aus jedem Weg, die einen Namen tragen.

Einen Namen erneut anzugeben ist an sich kein Konflikt. Ein mehrfach mit identischem Inhalt geschriebener Name adressiert so oder so ein einziges Ding, daher werden die Wiederholungen zu einem einzigen Eintrag zusammengeführt, und der Build läuft weiter — eine gewöhnliche Wiederholung kostet nichts. Was abbricht, ist der Fall, der Inhalt verliert: Einer der beiden Körper müsste verworfen werden, und die Ressource oder Ausgabe, die das Recipe deklariert hat, würde dann im Stack fehlen. Das Umbenennen eines der beiden behebt es.

Strukturelle Eingabevalidierung

Ein als Quelle verwendetes CloudFormation-Template wird vor dem Rendern strukturell validiert: Der Provider parst das Template und normalisiert seine intrinsischen Funktionen und bricht den Build mit einer klaren Meldung ab, die den fehlerhaften Knoten nennt, wenn ein Template fehlerhaft aufgebaut ist. Das Parsen prüft die Form, nicht die Semantik — es kontaktiert AWS nicht, löst keine Referenzen auf und wertet keine intrinsischen Funktionen aus.

Ein Template, das sich parsen lässt, wird dadurch nicht vollständig übernommen. Das Parsen sagt, dass das Dokument wohlgeformt ist; was den zusammengesetzten Stack erreicht, wird getrennt und pro Abschnitt entschieden, unter Abschnitte oberster Ebene im zusammengesetzten Stack — ein als Quelle verwendetes Template durchläuft dieselbe Bestandsaufnahme wie ein Fragment.

Ebenso wenig fragt das Parsen, ob die Referenzen des Templates aufgelöst werden. Ob eine Ref einen Parameter benennt oder ein Fn::FindInMap eine Map, ist eine Frage über den zusammengesetzten Stack statt über ein einzelnes Eingabedokument, und es ist an CloudFormation, sie beim Bereitstellen zu beantworten. Der Build gibt an, was er nicht übernommen hat, statt zu beurteilen, worauf das Ergebnis verweist. Die Referenzen, die er doch beurteilt, sind diejenigen, die der Build selbst ins Leere laufen ließ: eine auf einen Parameter, den das Binding eines als Quelle verwendeten Templates befüllt hat, was der nächste Abschnitt behandelt, und eine auf eine Ressource, die ein Eintrag in omits: aus dem Template ausgelassen hat, was der Abschnitt danach behandelt.

Werte für die Parameter eines als Quelle verwendeten Templates

Ein als Quelle verwendetes Template nimmt Werte so entgegen, wie CloudFormation selbst einem Template Werte gibt: über die Parameters, die es deklariert. Das valuesMapping dessen, was es als Quelle verwendet — das Recipe einer Komponente oder das FeatureRecipe eines angebundenen Feature —, schreibt einen Schlüssel pro Parameter, den es befüllt, und der Provider bindet jeden davon in jedem Template der Quelle — jede Ref auf den Parameter in Resources, Outputs, Conditions, Rules und den Globals von SAM wird zum Wert, jedes Fn::Sub, das den Parameter als Variable nennt, erhält den Wert über seine Variablen-Map, und der Parameter verlässt die Parameters jedes Templates, das ihn deklariert. Ein Parameter, den kein Schlüssel nennt, bleibt genau so, wie das Template ihn geschrieben hat, für einen Wert, der beim Bereitstellen des Stacks übergeben wird, oder für seinen Default.

Die Quelle ist die Einheit, die einen Parameter deklariert. Die Templates einer Verzeichnisquelle werden zu einem Stack zusammengesetzt, daher kann ein Template auf einen Parameter verweisen, den ein anderes Template derselben Quelle deklariert. Den Parameter zu befüllen, befüllt ihn auch dort: Ein Template, das ihn nur referenziert, erhält den Wert so, wie das erste ihn deklarierende Template der Quelle ihn konvertiert hat, und nichts in der Quelle verweist danach noch auf einen Parameter, dessen Deklaration das Binding entfernt hat.

Nichts anderes im Stack kann auf einen befüllten Parameter verweisen. Inhalt außerhalb der Quelle — das Fragment oder das als Quelle verwendete Template einer anderen Komponente im selben Stack —, der einen Parameter nennt, den das Binding der Quelle befüllt hat, über Ref, eine Variable von Fn::Sub oder das Fn::ValueOf einer Regel, würde etwas nennen, das der zusammengesetzte Stack nicht mehr deklariert, was CloudFormation beim Bereitstellen des Stacks ablehnt. Daher bricht der Build ab und nennt jede Komponente, ihr Template und den Parameter sowie die Komponente, deren valuesMapping ihn befüllt hat — das eines Recipe oder das des FeatureRecipe eines angebundenen Feature; ein an eine Komponente angebundenes Feature wird über diese Komponente benannt, und eines, das an eine Boundary angebunden ist, über die Identität, die seine Ressourcen als aggrega.ai/component-id tragen, gebildet aus dem Pfad der Boundary und dem Namen der Anbindung (bfr--stack--aux für eine Anbindung aux an der Boundary stack). Auch das Fragment der Komponente, an die ein Feature angebunden ist, oder einer Komponente in der Boundary, an die es angebunden ist, das auf einen Parameter verweist, den das Binding der Anbindung befüllt hat, bricht den Build ab. Ein Name, den der Stack noch deklariert, ist nicht betroffen: Wo eine andere Komponente selbst einen Parameter dieses Namens deklariert oder eine Ressource ihn als ihre logische ID trägt, lösen sich seine Referenzen gegen diese Deklaration auf und bleiben, wie sie geschrieben sind. Um den Wert weiterzugeben, lassen Sie die befüllende Komponente ihn veröffentlichen, deklarieren Sie den Parameter in dem Template, das auf ihn verweist, oder entfernen Sie den Schlüssel aus dem valuesMapping.

spec:
capability: cloudformation
implements: core/delivery-stream:1.0.0
source:
kind: git-repository
url: https://github.com/aws-cloudformation/aws-cloudformation-templates.git
ref: a0f43bc6d20813052892546f445037cf84c75b54
module_subdir: DataFirehose
valuesMapping: |
CloudWatchLogGroupRetention: {{ .values.retention_days }}
DestinationBucketName: "{{ .context.inject.env.BUCKET_NAME }}"

Nur ein valuesMapping befüllt Parameter. Die Schlüssel, die es schreibt, sind die Parameternamen, die Sie für das Template gemeint haben, daher muss jeder einen Parameter nennen, den irgendein Template der Quelle deklariert: Ein Schlüssel, der keinen nennt, bricht den Build ab und nennt den Schlüssel und die Parameter, die jedes Template tatsächlich deklariert — der Fehler, den CloudFormation für einen unbekannten Parameter melden würde, gemeldet, solange es noch an Ihnen ist, ihn zu beheben. Ein Recipe oder FeatureRecipe, das kein valuesMapping deklariert, befüllt nichts: Die eigenen Werte der Komponente oder der Anbindung erreichen den Provider unter ihren eigenen Namen, geschrieben für seine anderen Eingaben, und bleiben ungelesen.

Was ein Wert ist, entscheidet, was das Template erreicht.

  • Ein Literal — eine Zeichenkette, eine Zahl, ein boolescher Wert oder eine Liste davon — wird in das Template geschrieben, konvertiert so, wie CloudFormation denselben Wert konvertiert, der beim Bereitstellen des Stacks für den Type des Parameters übergeben wird: Ein Number wird zu der Zeichenkette, die eine Ref darauf liefert, daher kommt 7 als "7" an; ein Typ CommaDelimitedList oder List<…> wird zu einer Liste von Zeichenketten und nimmt entweder eine Liste oder eine kommagetrennte Zeichenkette entgegen, deren Elemente getrimmt werden; jeder andere Typ nimmt eine einzige Zeichenkette entgegen. Ein Literal wird gegen die eigenen AllowedValues, AllowedPattern, MinLength, MaxLength, MinValue und MaxValue des Parameters geprüft, und eines, das sie ablehnen, bricht den Build ab und nennt den Parameter und die Einschränkung, sodass das Befüllen eines Parameters keine Prüfung entfernt, die das Template deklariert hat. Ein Muster, das in einer Syntax für reguläre Ausdrücke geschrieben ist, die der Build nicht lesen kann, wird CloudFormation zur Prüfung beim Bereitstellen des Stacks überlassen.
  • Ein Wert, der vollständig eine intrinsische Funktion von CloudFormation ist, erreicht die Referenzstelle als diese intrinsische Funktion, damit CloudFormation sie beim Bereitstellen des Stacks auswertet: ein Mapping in Langform wie {"Fn::GetAtt": [Queue, Arn]} oder eine Zeichenkette, die genau eine Kurzform ist — !GetAtt Queue.Arn, !Ref Bucket, !Sub … und die anderen Formen, die CloudFormation definiert. So erreicht die veröffentlichte Referenz einer anderen Komponente einen Parameter: Die CloudFormation-Recipes des Katalogs veröffentlichen eine solche Referenz als Text in Kurzform, und ein valuesMapping, das sie aus dem Injektionskontext liest, gibt sie weiter. Eine eingefügte Referenz liest sich in Anführungszeichen oder ohne gleich. In Anführungszeichen — "{{ .context.inject.env.BUCKET_NAME }}" — gibt das Mapping die Zeichenkette !GetAtt Queue.Arn weiter; ohne liest das eigene YAML des Mappings !GetAtt Queue.Arn als Tag, und der Tag wird mit seinem Argument behalten statt verworfen. Beide erreichen den Parameter als die intrinsische Funktion. Ein Wert, der nur mit einem Ausrufezeichen beginnt oder keine Kurzform von CloudFormation nennt, bleibt Text.
  • Eine dynamische Referenz — {{resolve:ssm:…}}, {{resolve:ssm-secure:…}} oder {{resolve:secretsmanager:…}} — erreicht die Referenzstelle so, wie sie geschrieben ist, damit CloudFormation sie beim Bereitstellen des Stacks auflöst, daher steht der Wert, den sie nennt, nie im Template.
  • Ein Wert, den eine andere Komponente aus einem anderen Stack veröffentlicht, erreicht das Template als Stack-übergreifende Referenz, dasselbe Fn::ImportValue oder Fn::GetStackOutput, das ein Fragment erhält (siehe Stack-übergreifende Verdrahtung), an jeder Stelle, an der das Template den Parameter referenziert hat.

Ein Parameter, dessen Typ CloudFormation aus dem Parameter Store liest — AWS::SSM::Parameter::Value<…> —, hat kein Literal, das nachbildet, was CloudFormation damit tun würde, daher bricht ein daran gebundenes Literal den Build ab; binden Sie eine Referenz {{resolve:ssm:…}} oder eine intrinsische Funktion, oder lassen Sie ihn ungebunden. Eine Liste, die an einen Parameter gebunden ist, den das Template als Variable von Fn::Sub nennt, bricht den Build ebenfalls ab, weil eine Variable eine einzige Zeichenkette ersetzt. Ein Schlüssel, den das valuesMapping auf null setzt, bricht den Build ebenso ab und nennt den Parameter, weil ein Parameter einen Wert annimmt und null keiner ist; um einen Parameter für einen beim Bereitstellen des Stacks übergebenen Wert oder für seinen Default zu belassen, lassen Sie seinen Schlüssel aus dem Mapping weg.

Eine Regel, die einen Parameter über seinen Namen liest, hält ihn ungebunden. Fn::ValueOf in den Rules eines Templates nennt einen deklarierten Parameter über seine logische ID statt über Ref, und das Befüllen des Parameters entfernt seine Deklaration, daher bricht das Binden eines Parameters, den eine Regel auf diese Weise liest, den Build ab und nennt die Regel und den Parameter.

Ein Literal, das ein Geheimnis tragen kann, wird abgelehnt; eine intrinsische Funktion wird so geschrieben, wie sie gegeben ist. Ein Wert, der in das Template geschrieben wird, ist für jeden lesbar, der das Template des Stacks lesen kann:

  • Ein Parameter, den das Template als NoEcho deklariert, nimmt eine dynamische Referenz oder eine intrinsische Funktion entgegen, und ein daran gebundenes Literal bricht den Build ab.
  • Wo das valuesMapping einen Wert liest, den ein Autor als sensibel deklariert hat, lässt sich nichts von seiner Ausgabe auf den Wert zurückführen, aus dem es stammt, daher bricht jedes Literal, das es bindet, den Build ab. Eine dynamische Referenz und eine intrinsische Funktion, die es bindet, werden so geschrieben, wie sie gegeben sind — einschließlich des Texts innerhalb einer intrinsischen Funktion. Ein Geheimnis, das das Mapping etwa in den Text eines Fn::Sub einfügt, erreicht das Template daher als dieser Text: Nur eine dynamische Referenz hält das Geheimnis selbst aus dem Template heraus. Wo ein solcher Build weiterläuft, gibt er außerdem einen Hinweis pro deklariertem Blatt aus, für das Mapping eines Recipe ebenso wie für das des FeatureRecipe eines an eine Komponente angebundenen Feature, und nennt das Blatt und die Entität, deren Mapping es ist — siehe A declared-sensitive value reaches the target through a values mapping (Ein als sensibel deklarierter Wert erreicht das Ziel über ein values-Mapping).
  • Eine dynamische Referenz bricht den Build ab, wo ihr Parameter in der Eigenschaft UserData einer Ressource, in Metadaten von AWS::CloudFormation::Init oder in Outputs referenziert wird: CloudFormation löst eine dynamische Referenz in EC2-Benutzerdaten oder in diesen Metadaten nicht auf und zeigt Outputs jedem, der den Stack liest.

Jede solche Ablehnung nennt die Parameter und zitiert keinen Wert.

Ressourcen aus einem als Quelle verwendeten Template weglassen

Die Ressourcen eines als Quelle verwendeten Templates gehören diesem selbst: Werte erreichen es nur über die Parameter, die es deklariert, daher kann ein aus einem Git-Repository abgerufenes Template, das eine Ressource deklariert, die das Release nicht erstellen darf — einen Bucket, den der Operator bereits zur Verfügung stellt, einen Schlüssel, den die Plattform anderswo verwaltet —, nicht durch einen Wert geändert werden. Genau dafür sind die Einträge omits: eines Recipe oder eines FeatureRecipe da. Dieser Provider berücksichtigt sie bei einem als Quelle verwendeten Template und bei nichts anderem: Die Fragmente, die ein Eintrag artifacts: verfasst, werden ohne sie gerendert.

spec:
capability: cloudformation
implements: core/store:1.0.0
source:
kind: git-repository
url: https://git.example.com/platform/templates.git
ref: v3.2.0
module_subdir: store
omits:
# The template bundles an access-log bucket; this Release logs elsewhere.
- kind: AWS::S3::Bucket
name: StoreLogs

Ein Eintrag benennt eine Ressource über ihren Type und ihre logische ID. Der kind des Eintrags ist der Type der Ressource, etwa AWS::S3::Bucket, und sein name ist die logische ID der Ressource, ihr Schlüssel unter Resources; beide werden genau so verglichen, wie sie geschrieben sind, und beide müssen übereinstimmen, daher lässt ein Eintrag, dessen Type stimmt und dessen logische ID nicht stimmt, nichts weg. Ein Template hat keine Namespaces, daher bricht ein Eintrag, der einen namespace trägt, den Build ab, wenn die Komponente gerendert wird, und nennt den Eintrag; jeder Eintrag wird geprüft, bevor irgendetwas weggelassen wird.

Jedes Template der Quelle wird abgeglichen. Eine Einzeldatei-Quelle hat ein Template. Eine Verzeichnisquelle — eine aus einem Git-Repository abgerufene Quelle ist immer eine — hat jede Datei, die auf .yaml, .yml, .json oder .template endet, und ein Eintrag lässt jede Ressource weg, die er in irgendeiner davon nennt; eine Datei, die neben den Templates mitgeführt wird, wird nie gelesen. Der Provider meldet, wie viele Ressourcen jeder Eintrag über alle hinweg weggelassen hat, und ein Eintrag, der keine weggelassen hat, bricht den Build ab; siehe An omits entry left out nothing the source rendered (Ein omits-Eintrag hat nichts von dem weggelassen, was die Quelle gerendert hat).

Eine weggelassene Ressource ist verschwunden, bevor irgendetwas anderes das Template liest. Sie wird nicht mit Provenienz versehen und nicht zu den Namen gezählt, die der Stack trägt — sodass eine andere Komponente eine Ressource unter derselben logischen ID beitragen kann, ohne dass sich die beiden begegnen —, und sie erreicht nie den zusammengesetzten Stack. Alles andere im Template wird genau so geschrieben, wie es wäre, wenn das Template ohne die Ressource verfasst worden wäre, und ein Template, dessen Ressourcen alle weggelassen werden, behält einen leeren Abschnitt Resources.

Eine weggelassene Ressource darf von dem, was übrig bleibt, nicht weiter genannt werden, weil CloudFormation ein Template ablehnt, das eine Ressource nennt, die es nicht deklariert. Sobald die Ressourcen entfernt sind, bricht jede Referenz, die die verbleibenden Templates noch auf eine von ihnen machen, den Build ab, und die Meldung nennt das Template, die Ressource, wie die Referenz sie nennt und wo die Referenz steht, als Pfad von der Wurzel des Templates — etwa /Resources/Store/Properties/LoggingConfiguration/DestinationBucketName. Eine Referenz ist das, was die Template-Referenz von CloudFormation als Nennung einer Ressource über ihre logische ID definiert, gelesen im Körper jeder Ressource — einschließlich ihrer Eigenschaften, ihrer Metadaten und ihrer Richtlinien — und in jeder Ausgabe:

  • Ref, mit der logischen ID als Argument;
  • Fn::GetAtt, als Liste, deren erstes Element die logische ID ist, oder als eine Zeichenkette — !GetAtt StoreLogs.Arn —, deren Text vor dem ersten Punkt sie ist;
  • das DependsOn einer Ressource, als eine logische ID oder als Liste davon;
  • jede Variable von Fn::Sub, in ihrer Zeichenkettenform und in ihrer Listenform: ${StoreLogs} und ${StoreLogs.Arn} nennen beide StoreLogs.

Manche Werte sehen nur wie Referenzen aus und werden nicht als solche gelesen. ${!StoreLogs} ist wörtlicher Text, und eine Variable, die die Map der Listenform nennt, ist der Wert dieser Map. Die Condition einer Ressource und das erste Argument von Fn::If nennen eine Bedingung, Fn::FindInMap nennt ein Mapping, Fn::ImportValue einen Export eines anderen Stacks und Fn::GetAZs eine Region. Die Abschnitte Conditions, Mappings, Parameters und Rules können keine Ressource nennen, und der eigene Abschnitt Metadata oberster Ebene des Templates ist Information, die CloudFormation ablegt statt liest, daher wird keiner von ihnen geprüft. Ein Ref oder Fn::GetAtt, dessen logische ID selbst als intrinsische Funktion geschrieben ist, ist nur unter der Transformation AWS::LanguageExtensions gültig, die ihn beim Bereitstellen des Stacks auflöst (siehe Abschnitte oberster Ebene im zusammengesetzten Stack), daher nennt er keine Ressource, die die Prüfung lesen kann, und bleibt unverändert; ebenso eine Referenz auf eine Ressource, die die Quelle nie deklariert hat.

Die Prüfung liest die eigenen Templates des deklarierenden Recipe oder FeatureRecipe gemeinsam. Sie werden zu einem Stack zusammengesetzt, daher wird eine Referenz auf eine logische ID, die ein anderes dieser Templates noch deklariert, nicht gestoppt. Nichts anderes wird gelesen: Eine Referenz auf eine weggelassene Ressource bricht den Build auch dort ab, wo eine andere Komponente eine Ressource mit dieser logischen ID deklariert, und eine Referenz von irgendetwas anderem, das in den Stack zusammengesetzt wird — einer anderen Komponente, einem angebundenen Feature oder den eigenen Einträgen artifacts: des Recipe —, sieht diese Prüfung nicht, daher lehnt CloudFormation den Stack ab, wenn er bereitgestellt wird. Um eine Referenz zu behalten, behalten Sie die Ressource. Ein an einen Parameter gebundener Wert ersetzt nur eine Referenz auf diesen Parameter, daher gehört eine Referenz auf eine Ressource dem Template selbst und kann durch keinen Wert geändert werden: Lassen Sie auch die Ressource weg, die sie macht, oder entfernen Sie den Eintrag. Eine Ausgabe ist keine Ressource, und kein Eintrag nennt eine, daher kann eine Ressource, die die Outputs des Templates nennen, nicht daraus weggelassen werden: Sie wegzulassen bricht den Build ab.

Cloud-Ziel-Annotationen

Drei Boundary-Annotationen teilen dem Provider mit, wo ein Stack bereitgestellt wird, damit er Stack-übergreifende Referenzen korrekt verdrahten kann:

  • aggrega.ai/aws-account — das AWS-Konto, in dem der Stack bereitgestellt wird.
  • aggrega.ai/aws-region — die AWS-Region, in der der Stack bereitgestellt wird.
  • aggrega.ai/aws-assume-role-arn — der ARN der IAM-Rolle, die ein kontenübergreifender Stack-Lesezugriff annimmt, um die exportierten Werte eines Peer-Stacks zu erreichen.

Diese Annotationen sind für den Compiler opak — er leitet ihre Werte an den Provider weiter, ohne sie zu interpretieren (siehe well-known-annotations.md). Sie werden auf der Boundary des Produzenten verfasst — dem Stack, dem der exportierte Wert gehört. Ein kontenübergreifender Lesezugriff nimmt eine Rolle im Konto des Produzenten an, daher stammen Konto, Region und Rolle, die den Lesezugriff beschreiben, alle aus den Annotationen der Boundary des Produzenten, nicht aus denen des Konsumenten.

Stack-interne Referenzen

Wenn eine Kante uses zwei Komponenten verbindet, die in derselben Boundary landen — demselben Stack —, wird der konsumierte Wert als Fn::GetAtt gegen die logische ID der Ressource des Produzenten innerhalb des einen Templates verdrahtet. Der Wert provides des Produzenten fließt als native Stack-interne Referenz in die gerenderte Eingabe des Konsumenten; es wird weder ein Export noch ein Import benötigt. Das Fragment des Konsumenten kann einen solchen Wert ohne Anführungszeichen schreiben — Value: {{ .context.inject.env.DB_HOST }} — oder in Anführungszeichen — Value: "{{ .context.inject.env.DB_HOST }}": In beiden Fällen liest das Template !GetAtt Db.Endpoint.Address als die intrinsische Funktion, weil eine Zeichenkette, die genau eine Kurzform ist, den Stack in einem Fragment ebenso als diese intrinsische Funktion erreicht wie in einem valuesMapping. Das Beispiel aws-rds-and-ecs-service zeigt das an einer Amazon-ECS-Task-Definition, die die Adresse einer RDS-Instanz in einem Stack liest.

Stack-übergreifende Verdrahtung

Wenn eine Kante uses von einer Boundary in eine andere übergeht — die beiden Komponenten werden in verschiedene Stacks zusammengesetzt —, kann die Referenz kein einfacher Wert sein, weil der erzeugte Wert erst existiert, wenn der Stack des Produzenten bereitgestellt wird. Der Provider verdrahtet sie als Stack-übergreifende Referenz von CloudFormation. Der erzeugende Stack veröffentlicht den Wert als Output des Stacks mit einem Export unter einem deterministischen Exportnamen (abgeleitet aus dem Release-Namen, der Boundary, der Komponente und dem gelieferten Schlüssel). Der konsumierende Stack liest ihn mit einer von zwei intrinsischen Funktionen, ausgewählt durch den Vergleich der deklarierten Platzierung der beiden Boundaries:

  • Fn::ImportValue — der Fall mit demselben Konto und derselben Region. CloudFormation löst den Import gegen den passenden Exportnamen innerhalb des Kontos und der Region auf.
  • Fn::GetStackOutput — ein echter konten- oder regionsübergreifender Lesezugriff. Der Konsument liest die Ausgabe des erzeugenden Stacks direkt und nimmt dabei die Rolle aws-assume-role-arn der Boundary des Produzenten im Konto und in der Region des Produzenten an.

Erkennungssemantik. Der Provider leitet nur dann zu Fn::GetStackOutput, wenn beide Endpunkte eine Platzierung (Konto/Region) deklarieren und diese Platzierungen sich unterscheiden. In jedem anderen Fall — keiner deklariert eine, nur einer deklariert eine, oder beide deklarieren dieselbe Platzierung — verwendet er Fn::ImportValue. Das ist eine konservative Regel: Ein Stack-übergreifender Lesezugriff im selben Konto bleibt ein einfacher Import, und die intrinsische Funktion für den direkten Lesezugriff ist einem echten konten- oder regionsübergreifenden Sprung vorbehalten.

Der erzeugende Stack veröffentlicht den Export immer, auch wenn ein bestimmter Konsument ihn kontenübergreifend über Fn::GetStackOutput liest. Ein ungenutzter Export ist wirkungslos, und ihn bedingungslos zu veröffentlichen hält das Template des Produzenten unabhängig davon, wie jeder Konsument den Wert zu lesen wählt.

Mehrere Konsumenten eines Werts lesen einen Export. Wenn mehr als eine Komponente denselben gelieferten Wert über eine Boundary hinweg liest — zwei Konsumenten in einem Stack oder Konsumenten in mehreren Stacks —, veröffentlicht der erzeugende Stack den Export dieses Werts einmal, und jeder Konsument liest den einen Namen: Jedes Fn::ImportValue importiert denselben Export, und ein Konsument, der in einem anderen Konto oder einer anderen Region platziert ist, liest dieselbe Ausgabe über Fn::GetStackOutput. Ein Konsument, der außerdem einen Wert liest, den kein anderer Konsument liest, fügt nur den Export dieses Werts hinzu.

Das Beispiel aws-rds-and-ecs-service baut den Fall mit demselben Konto: Der Stack einer RDS-Instanz exportiert jeden Eintrag, den die Kante eines Servers konsumiert, und der Stack des Servers liest jeden davon mit Fn::ImportValue zurück.

Versionshinweis. Fn::GetStackOutput ist eine native intrinsische Funktion von CloudFormation. Eine damit gerenderte kontenübergreifende Referenz erfordert CloudFormation-Werkzeuge, die die intrinsische Funktion erkennen. Der Pfad mit demselben Konto verwendet Fn::ImportValue, das überall verfügbar ist.

Ein Wert, der von der Verbindung gelesen statt injiziert wird

Das Recipe eines Konsumenten kann die Werte eines Produzenten direkt von der Verbindung lesen, über .context.uses.<alias>.provides, statt sie über den Block inject der Verbindung zu erhalten. Über eine Stack-Grenze hinweg wird ein solcher Lesezugriff genauso verdrahtet wie ein injizierter Wert:

  • Ein Wert, der eine intrinsische Funktion von CloudFormation ist — ein Kurzform-Tag wie !GetAtt Db.Endpoint.Address oder ein Ref oder ein Mapping Fn:: in Langform — nennt etwas, das nur der Stack des Produzenten deklariert, daher erhält der Konsument dieselbe Stack-übergreifende Referenz wie ein injizierter Wert: Der erzeugende Stack veröffentlicht einen Export für diesen Schlüssel, und der Konsument liest ihn mit Fn::ImportValue oder mit Fn::GetStackOutput, wo die beiden Boundaries unterschiedliche Platzierungen deklarieren.
  • Ein Wert, der einfacher Text ist — ein Port, ein Protokoll, ein Datenbankname — bedeutet in beiden Stacks dasselbe, daher erhält der Konsument den Wert selbst, und für ihn wird kein Export veröffentlicht. Er landet in der Form, in der CloudFormation ihn liest: Ein ganz geschriebener Wert wird so gerendert, wie er es ohne die Boundary wäre, und ein zahlenförmiger Wert in Anführungszeichen landet als Zahl.

Ob ein Wert eine intrinsische Funktion ist, entscheidet dieser Provider, indem er den Wert so liest, wie er den eigenen Block provides des Produzenten liest. Der Compiler übergibt den Wert so, wie das Recipe des Produzenten ihn geschrieben hat, und interpretiert ihn nicht.

Ein Template darf einen solchen Wert nur kopieren. Es darf den Wert ganz schreiben, innerhalb einer längeren Zeichenkette oder ihn durch eine Funktion leiten, die ihn unverändert lässt, etwa quote. Ein Vergleich, eine Verzweigung, eine Länge oder eine Funktion, die den Wert ändert — eq, if, len, upper —, würde gegen etwas anderes als den Wert entschieden, weil das Template auf einer solchen Verbindung einen Platzhalter erhält, den der Provider ersetzt, sobald beide Stacks zusammengesetzt sind. Stattdessen bricht der Build ab und nennt das Template und jeden Wert, den es gelesen hat, mit der Verbindung, von der es ihn gelesen hat, und der Komponente an jedem Ende; verzweigen Sie auf einem eigenen Wert der konsumierenden Komponente. Dasselbe gilt für das injectMapping eines angebundenen FeatureRecipe und für ein FeatureRecipe mit Boundary-Geltungsbereich, das die Verbindungen der Boundary liest. Ein innerhalb einer längeren Zeichenkette geschriebener Wert trifft außerdem auf die eigene Grenze des Providers: Eine Stack-übergreifende Referenz kann nur als ganzer Wert stehen, daher bricht eine innerhalb einer längeren Zeichenkette geschriebene intrinsische Funktion den Build ab, wie bei einem injizierten Wert.

Wie ein Exportname gebildet wird

Die vier Teile werden mit einem doppelten Bindestrich verbunden, und jeder Teil wird in die Buchstaben, Ziffern und Bindestriche geschrieben, aus denen ein Exportname besteht. Ein Buchstabe oder eine Ziffer wird so übernommen, wie er geschrieben ist, ebenso ein Bindestrich innerhalb eines Teils — payments-db bleibt payments-db. Jedes andere Zeichen wird als kurzes Escape geschrieben, das mit -z beginnt: ein Schrägstrich als -zs, ein Unterstrich als -zu, ein Punkt als -zd. Ein Teil ganz ohne Wert wird -ze geschrieben. Ein Stackname wird auf dieselbe Weise aus dem Release-Namen und der Boundary gebildet.

Der Export, der host aus der Komponente db veröffentlicht, in der Boundary, deren Ausgabeverzeichnis unter dist/ stack-a/cloudformation ist, mit dem Release-Namen orders, lautet also:

aggrega--orders--stack-a-zscloudformation--db--host

Das Zurücklesen ist eindeutig, und das ist der Zweck und keine Nettigkeit: Weil ein Teil nie zwei Bindestriche hintereinander enthält und nie mit einem endet, sind die doppelten Bindestriche immer die Verbindungsstellen. Zwei verschiedene Mengen von Teilen ergeben daher immer zwei verschiedene Namen. payments-db und payments_db erreichen zwei getrennte Exporte, statt auf einem zusammenzulaufen, und ein Bindestrich am Rand eines Teils kann nicht als zu seinem Nachbarn gehörig gelesen werden.

Wogegen ein Exportname eindeutig ist und wo das endet

Innerhalb eines Builds identifiziert ein Exportname genau eine Release-Identität, eine Boundary, eine Komponente und einen gelieferten Schlüssel — keine zwei solchen Kombinationen laufen auf einem einzigen Namen zusammen, daher kann ein Build keinen exportierten Wert hinter einem anderen verlieren.

CloudFormation verlangt zusätzlich, dass ein Exportname über alles hinweg eindeutig ist, was bereits in das Konto und die Region bereitgestellt ist, in denen der Stack landet. Das ist eine Eigenschaft der Bereitstellung und nicht des Builds, und sie liegt jenseits dessen, was eine Ableitung zur Build-Zeit erreichen kann: Der Compiler authentifiziert sich nicht bei AWS, fragt es nicht ab und kann die Ausgabe eines anderen Builds nicht lesen, daher kann nichts im Voraus Berechnetes beobachten, was dort bereits bereitgestellt ist.

Was die Unterscheidung über diese Linie trägt, ist die Release-Identität am Anfang jedes Export- und Stacknamens. Zwei Bereitstellungen, die ein Konto und eine Region teilen, halten ihre Exporte getrennt, indem sie unter unterschiedlichen Release-Namen veröffentlicht werden — das ist der Hebel, den Sie in der Hand haben, und der Grund, warum die Release-Identität den Namen anführt, statt ihn abzuschließen.

Ein Outputs-Eintrag kann seinen eigenen Exportnamen deklarieren

Der Block Outputs: eines Recipe ist verfasstes CloudFormation, und ein Eintrag darin kann ein eigenes Export: mit einem Name: tragen. Dieser Name erreicht den zusammengesetzten Stack genau so, wie er geschrieben ist — der Provider schreibt ihn nicht um, versieht ihn nicht mit einem Präfix und verlangt nicht, dass er wie ein abgeleiteter aussieht.

Meist gibt es dazu nichts weiter zu sagen. Ein verfasster Exportname, der keinem Namen entspricht, den der Provider ableitet, wird neben den abgeleiteten veröffentlicht und nie beanstandet. Das Verfassen wird unterstützt; nur ein Zusammentreffen nicht.

Der Build bricht ab, wenn ein verfasster Exportname einem Namen gleicht, den der Provider für eine Boundary-übergreifende Verknüpfung im selben Build ableitet. Beide Deklarationen würden das zusammengesetzte Template erreichen und einen Exportnamen zweimal in einem Stack deklariert hinterlassen — und ein Exportname muss eindeutig sein, daher können nicht beide bestehen. Der Abbruch nennt den abgeleiteten Exportnamen und die vier Teile, aus denen er gebildet wurde, damit Sie sehen, welche Verknüpfung ihn erzeugt hat, und er nennt die Stack-Ausgabe, unter der die verfasste Deklaration steht, gekennzeichnet als ein Name, den der Provider zusammensetzt, und nicht als einer, den ein Recipe geschrieben hat. Der Exportname ist der Begriff, nach dem Sie in Ihren Recipes suchen. Der verfasste Eintrag schreibt ihn genau so wie der Abbruch — diese Identität macht die beiden erst zu einer Kollision —, daher ist er die eine Zeichenkette, die sowohl in der Meldung als auch in Ihren eigenen Dateien vorkommt. Das Umbenennen des Exportnamens, den dieser Eintrag deklariert, beseitigt den Abbruch, ebenso das Entfernen des Blocks Export: dieses Eintrags, sodass die Stack-übergreifende Verdrahtung den Export selbst veröffentlicht.

Die Prüfung gilt im Geltungsbereich des Builds, und ihr Geltungsbereich ist ein Stack. Sie vergleicht die Exportnamen, die ein zusammengesetzter Stack deklariert, mit den Namen, die der Provider für die Boundary-übergreifenden Verknüpfungen ableitet, die in denselben Stack veröffentlichen — der Vergleich, den der Build aus dem anstellen kann, was er zusammengesetzt hat. Zwei Stacks werden nicht miteinander verglichen. Und worauf ein verfasster Name unter den Exporten trifft, die bereits in ein Konto und eine Region bereitgestellt sind, ist eine Eigenschaft der Bereitstellung, die jenseits dessen liegt, was eine Ableitung zur Build-Zeit erreichen kann, aus dem unter Wogegen ein Exportname eindeutig ist und wo das endet dargelegten Grund: Der Compiler authentifiziert sich nicht bei AWS, fragt es nicht ab und kann die Ausgabe eines anderen Builds nicht lesen. Ein Exportname, der als intrinsische Funktion statt als einfache Zeichenkette geschrieben ist, liegt auf der anderen Seite derselben Linie — er wird zur Bereitstellungszeit aufgelöst, und nichts hier wertet eine intrinsische Funktion aus, daher gibt es keinen Namen, den der Build vergleichen könnte.

Der Build bricht auch ab, wenn die Ausgabe, auf der eine Boundary-übergreifende Verknüpfung veröffentlicht, bereits einen Export trägt, den die Verknüpfung nicht geschrieben hat. Diese Ausgabe ist diejenige, die der Provider für den gelieferten Schlüssel zusammensetzt, den ein Konsument liest, daher setzt ein Recipe, dessen Block Outputs: unter genau diesem Schlüssel einen Eintrag mit einem eigenen Export: schreibt, seinen Export genau dorthin, wo der der Verknüpfung hingehört. Sofern der Name dieses Exports nicht genau der ist, den der Provider ableitet — in diesem Fall ist es der eigene Export der Verknüpfung, und jeder Konsument importiert ihn —, können die beiden dort nicht beide bestehen: Den Export der Verknüpfung zu schreiben, würde Ihren überschreiben, und Ihren zu behalten, würde jeden Konsumenten einen Namen importieren lassen, den die Verknüpfung nicht veröffentlicht hat. Der Abbruch nennt den abgeleiteten Exportnamen und die vier Teile, aus denen er gebildet wurde, und sagt, was er an dieser Ausgabe gefunden hat: den Exportnamen, den der Eintrag deklariert, einen als intrinsische Funktion geschriebenen Namen, einen Block Export:, der nichts benennt, oder ein Export:, das als einfacher Wert statt als Block geschrieben ist. Das Entfernen des Blocks Export: dieses Eintrags beseitigt ihn, und die Stack-übergreifende Verdrahtung veröffentlicht dann den Export, den jeder Konsument importiert.

Bereitstellungsreihenfolge

Der Wert syncWave: einer Boundary eines Release ordnet die Provisionierung des Stacks, in den diese Boundary zusammengesetzt wird. Jede Komponente in der Boundary erbt die Welle der Boundary, und wo mehrere Boundaries auf dasselbe Ausgabeverzeichnis aufgelöst werden — sodass ihre Fragmente in ein einziges Template zusammengesetzt werden —, enthält der Stack mehr als eine Welle, und der Provider drückt die Reihenfolge zwischen ihnen als DependsOn aus.

Jede Ressource nennt jede Ressource der unmittelbar vorhergehenden Welle, die überhaupt Ressourcen hat, und keine frühere Welle als diese. CloudFormation verkettet den Rest: Eine Ressource in Welle 2 hängt von Welle 1 ab, die von Welle 0 abhängt, sodass die gesamte Abfolge geordnet ist, während die eigene Liste jeder Ressource so groß wie eine Welle bleibt statt wie der ganze Stack. Wellen müssen nicht lückenlos sein, und negative Werte sind gewöhnlich — -1 ist eine übliche Wahl für einen Bucket oder eine Rolle, die der Rest des Stacks liest. Die niedrigste Welle nennt nichts, weil ihr nichts vorausgeht.

Was die Reihenfolge ist: Erstellungsreihenfolge und, umgekehrt, Löschreihenfolge. CloudFormation bearbeitet Ressourcen parallel, soweit es kann, und DependsOn setzt diese Parallelität außer Kraft, um die genannten Ressourcen in einer festgelegten Reihenfolge zu bearbeiten. Das Attribut gilt für beide Richtungen, daher löscht eine Welle, die eine Ressource früher erstellt, sie auch später — die korrekte Abbaureihenfolge ergibt sich mit der Reihenfolge, ohne dass es etwas anderes braucht.

Es ist keine Bereitschaftsreihenfolge. Ein Stack-Template drückt keine Vorstellung davon aus, dass eine Ressource einsatzfähig ist, daher wartet hier nichts darauf, dass eine bereit wird — nur darauf, dass CloudFormation ihre Erstellung abschließt. Das ist ein echter Unterschied zu derselben Welle auf compose, wo auf einen Service, der einen healthcheck deklariert, gewartet wird, bis er sich als gesund meldet: compose hat ein Bereitschaftsprimitiv, auf das gewartet werden kann, und ein Stack-Template hat keines. Die Erstellungsreihenfolge ist das, was dieses Ziel bietet, und sie klar zu benennen ist nützlicher als ein Vorbehalt an einem Versprechen, das es nicht geben kann.

Ein verfasstes DependsOn wird erweitert, nie ersetzt. Ein Fragment, das eine eigene Reihenfolgebedingung deklariert, behält sie: Die Einträge, die es geschrieben hat, bleiben vorn, in der Reihenfolge, in der es sie geschrieben hat, und die Einträge der Welle folgen. Beide Anforderungen gelten, und keine verdeckt die andere. Eine einzelne logische ID und eine Liste werden beide gelesen, und der zusammengeführte Wert wird als Liste ausgegeben, die einzige Schreibweise, die trägt, wie viele Einträge die Zusammenführung auch erzeugt.

Ein Stack, dessen Ressourcen alle eine einzige Welle tragen, gewinnt dadurch nichts. Ebenso ein Release, das überhaupt kein syncWave deklariert: Jeder Beitragende trägt den Standardwert des Felds, 0, das zusammengesetzte Template enthält eine einzige Welle, und die Ausgabe ist genau so, wie sie wäre, wenn der Provider keine Wellenreihenfolge ausdrückte.

Eine Reihenfolge über zwei Stacks hinweg ist nicht ausdrückbar, und sie wird nicht angenähert. DependsOn nennt eine Ressource innerhalb desselben Templates, und Komponenten, die in einen anderen Stack zusammengesetzt werden, liegen außerhalb davon. Eine Welle ordnet also jede Ressource in dem Stack, in den sie zusammengesetzt wird, und nichts darüber hinaus. Zwei Stacks in eine Abfolge zu bringen ist Sache des Betreibers, so wie eine Stack-übergreifende Referenz eine Auflösung zur Bereitstellungszeit und nicht zur Build-Zeit ist.

Eine Reihenfolge, die die Wellen nicht ausdrücken, bleibt Sache von CloudFormation selbst, und die Referenzen zwischen Ressourcen tragen bereits viel davon: Ein Fn::GetAtt gegen eine Ressource des Produzenten weist CloudFormation an, diese Ressource zuerst zu erstellen. Ein Fragment, das eine Bedingung braucht, die weder die Referenzen noch die Wellen implizieren, verfasst DependsOn selbst — der Fall, den die obige Zusammenführung bewahrt.

Determinismus

Bei denselben Eingaben gibt der Provider über alle Läufe hinweg ein byteidentisches Stack-Template aus: Logische IDs, Ausgabeschlüssel, Exportnamen und die Reihenfolge der Ressourcen sind alle deterministisch, sodass sich ein CloudFormation-Stack-Template im GitOps-Review sauber vergleichen lässt.