Terraform-Provider
Der terraform-Provider rendert Recipes von Aggrega in Terraform-Konfiguration. Er gibt Konfiguration aus und führt Terraform nie aus: Ein Build von Aggrega ist eine Ahead-of-Time-Kompilierung, daher kann er die Ressourcen-IDs, IP-Adressen und Ausgaben nicht auflösen, die erst nach terraform apply existieren. Die Interpolationen ${ ... } von Terraform werden unverändert als deterministische Zeiger-Strings durchgereicht, die die Terraform-Laufzeit später auflöst. Der Provider ist offline und hermetisch — er greift nie auf das Netzwerk zu und ruft nie terraform oder tofu auf.
Wie eine Boundary aufgebaut ist
Der terraform-Provider komponiert eine Boundary, statt ihre Komponenten nebeneinander auszugeben. Jede Boundary, die er rendert, erhält genau eine Root-Konfiguration, aggrega.modules.tf, die jede dort gerenderte Komponente als Block module deklariert, dessen source das eigene Unterverzeichnis dieser Komponente unter modules/ ist:
module "cache" { source = "./modules/cache"}
module "db" { source = "./modules/db"
allocated_storage = 100 db_name = "appdb" engine_version = "11.4"}Die eigenen Dateien jeder Komponente — das lokal kopierte Modul (Vendoring) oder der verfasste Körper sowie der Provenienzstempel — liegen in dem Unterverzeichnis, auf das ihr Block zeigt. Das ist die Standardstruktur von Terraform, in der die Root-Konfiguration die Kindmodule komponiert und deren Konvention vorsieht, dass verschachtelte Module unter einem Unterverzeichnis modules/ liegen, und es ist der Aufbau, den jede terraform-Boundary erhält, ob sie eine Komponente enthält oder mehrere. Ein an eine Komponente oder an die Boundary angebundenes Feature wird als eigener Block module in derselben Root-Konfiguration deklariert — siehe Wo die Ausgabe eines angebundenen Feature landet.
Die Form ist tragend und nicht kosmetisch, aus zwei Gründen.
Ein Terraform-Abhängigkeitsgraph gilt pro Konfiguration. Components, die in getrennte Verzeichnisse ausgegeben werden, sind getrennte Graphen ohne Beziehung: Weder eine Referenz noch ein depends_on kann von einer zur anderen reichen, und kein einzelnes terraform plan sieht beide. Eine Root-Konfiguration, die jede Komponente als Kindmodul komponiert, bringt eine ganze Boundary in einen Graphen und einen Plan.
Die Dateien einer Komponente werden über ihr eigenes Verzeichnis adressiert. Zwei Komponenten in einer Boundary können Module lokal kopieren, die gleichnamige Dateien schreiben — main.tf, variables.tf —, und jeder Satz liegt unter dem Verzeichnis seiner eigenen Komponente, statt mit dem anderen um einen Pfad zu konkurrieren.
Wo ein Provider konfiguriert wird
Die Konfiguration eines Providers — ein Block provider — wird auf Root-Ebene geschrieben, nie innerhalb des Moduls einer Komponente. Die Dokumentation von Terraform besagt, dass ein Modul, das von einem anderen aufgerufen werden soll, keine Blöcke provider enthalten darf, und dass ein aufgerufenes Modul die Standardkonfiguration erbt, die die Root-Konfiguration für jeden Provider festlegt, den dieses Modul verwendet. Ein Modul mit einem eigenen Block provider kann nicht mit depends_on, count oder for_each aufgerufen werden, und dieser Provider schreibt depends_on auf den Block module einer Komponente, sobald eine andere Komponente derselben Root-Konfiguration eine frühere syncWave trägt, wie unten unter Bereitstellungsreihenfolge beschrieben; Terraform lehnt dann die gesamte Konfiguration schon beim Laden ab, bevor es irgendetwas plant.
Ein Recipe, dessen Provider eine Konfiguration benötigt, schreibt diese Konfiguration daher als Datei unter spec.boundary.artifacts. Jede solche Datei wird einmal neben aggrega.modules.tf geschrieben, wo Terraform sie zusammen mit der Root-Konfiguration liest, und das Modul der Komponente behält nur seine Deklaration required_providers der Quelle und Version des Providers:
infra/terraform/ aggrega.modules.tf provider-azurerm.tf modules/ gateway/main.tfComponents einer Root-Konfiguration, die dieselbe Datei mit denselben Bytes deklarieren, teilen sich die eine Kopie; derselbe Name mit unterschiedlichen Bytes bricht den Build ab. Die Ressourcen der Module werden gegen diese eine Konfiguration erfasst, daher ist sie auch das, womit Terraform sie zerstört. Ein Release, das die letzte Komponente entfernt, die die Datei deklariert, entfernt die Datei mit ihr, und Terraform weigert sich dann, die Zerstörung dessen zu planen, was diese Module erstellt haben, und verlangt einen Provider-Block, der den Provider konfiguriert. Zerstören Sie diese Ressourcen, bevor Sie die letzte solche Komponente entfernen.
Wo die Eingaben einer Komponente übergeben werden
Die Eingaben einer Komponente sind die Argumente ihres Blocks module in der Root-Konfiguration, und nur dort werden sie geschrieben. Ein Block trägt Argumente, wenn der Compiler die Eingaben des Moduls liefert — ein Recipe, das ein Modul mit source: lokal kopiert. Er ist leer, wenn das Recipe den Konfigurationskörper selbst verfasst und seine Werte in diesen Körper aufgelöst hat, sodass für den Compiler nichts mehr zu übergeben bleibt.
Ein Modulargument ist eine Position, die Terraform auswertet, weshalb die Werte dorthin gehören. Ein Zeiger ${ ... }, den ein Recipe liefert, wird dort aufgelöst, statt als literale Zeichenkette beim Modul anzukommen. Wogegen er aufgelöst wird, ist die Root-Konfiguration: Eine Referenz benennt etwas, das diese Konfiguration deklariert — einen ihrer Blöcke module, als module.<name>.<output> —, und eine Referenz auf etwas, das sie nicht deklariert, ist beim Planen ein deutlicher Fehler, der das fehlende Referenzziel benennt.
Das eigene Verzeichnis einer Komponente ist daher keine Konfiguration, die Sie so planen können, wie sie bereitgestellt wird. Ihre Eingaben werden eine Ebene höher angegeben, in der Root-Konfiguration, sodass das Ausführen der Engine in modules/<component> etwas anderes plant, und welches von zwei Dingen geschieht, hängt von den eigenen Blöcken variable des Moduls ab:
- Wo mindestens eine Eingabe kein
defaultdeklariert, schlägt der Plan mit einer deutlichen Meldung fehl —No value for required variable, mit jeder nicht gesetzten Variable und ihrer Zeile, und mit Terraforms eigener Abhilfe-var/-var-file. - Wo jede Eingabe ein
defaultträgt, gelingt der Plan und baut auf den Standardwerten des Moduls auf statt auf den Werten, die die Root-Konfiguration liefert. Nichts warnt, daher ist dies der Fall, den man kennen muss: Ein Plan, der richtig aussieht, beschreibt eine Konfiguration, die niemand angefordert hat.
Planen Sie stattdessen das eigene Ausgabeverzeichnis der Boundary — dasjenige, das aggrega.modules.tf enthält, unmittelbar über modules/. Dort befinden sich die Werte der Bereitstellung, und es ist der einzige Ort, an dem ein einzelner Plan die ganze Boundary sieht.
Den veröffentlichten Wert einer anderen Komponente konsumieren
Eine Komponente, die über eine Kante uses mit einer anderen verbunden ist, liest die veröffentlichten Werte dieser Komponente über ihre eigene Pipe .context.inject (oder über .context.uses.<alias>.provides.<name>). Was sie liest, ist eine Zeichenkette, die der Compiler ohne Interpretation weiterleitet, und wo diese Zeichenkette landet, ist Text, den Terraform in dem Gültigkeitsbereich auswertet, in den das Recipe ihn geschrieben hat. Eine terraform-Boundary hat zwei solche Gültigkeitsbereiche, und nur einer davon deklariert die Modulaufrufe, die eine komponentenübergreifende Referenz benötigt:
- die Root-Konfiguration deklariert jeden Beitragenden als Block
module, sodassmodule.<name>.<output>dort aufgelöst wird; - das eigene Verzeichnis einer Komponente deklariert überhaupt keine Modulaufrufe, sodass
module.<name>.<output>dort nichts benennt — was auch immer<name>ist. Den richtigen Namen einzusetzen ändert nichts, denn was fehlt, ist die Deklaration, nicht die Schreibweise.
Also entscheidet die Eingabeart des konsumierenden Recipe, ob eine konsumierte Referenz aufgelöst werden kann, und nicht der konsumierte Wert.
Schreiben Sie ein konsumierendes Recipe als Recipe source:. Sein valuesMapping: wird zu den Argumenten seines eigenen Blocks module in der Root-Konfiguration — der einzigen Position, die sowohl ausgewertet wird als auch in einem Gültigkeitsbereich liegt, in dem ihre Nachbarn deklariert sind.
Ein ausgearbeitetes Paar
Der Produzent veröffentlicht eine Adresse, die seinen eigenen Modulaufruf benennt, also die Form, die der Gültigkeitsbereich seines Konsumenten deklariert. .context.instance_id liegt auf der Auswertungsoberfläche von provides, und für eine Komponente, die das Aggregate der Bereitstellung deklariert, ist es der Name, den der Block module dieser Komponente trägt:
# Recipe — the producer. Its vendored module declares `output "endpoint"`.spec: capability: terraform implements: example/storage/object-store:1.0.0 source: ./module valuesMapping: | bucket: "{{ .values.bucket }}" provides: endpoint: "${module.{{ .context.instance_id }}.endpoint}"Der Konsument kopiert ein Modul lokal, das eine Eingabe deklariert, und bildet den injizierten Wert darauf ab:
# Recipe — the consumer. Its vendored module declares `variable "store_endpoint"`.spec: capability: terraform implements: example/compute/reporting-api:1.0.0 source: ./module valuesMapping: | store_endpoint: "{{ .context.inject.env.STORE_ENDPOINT }}"Das Aggregate verbindet sie und benennt den veröffentlichten Schlüssel, den die Kante trägt:
spec: components: store: type: example/storage/object-store values: bucket: app-artifacts
api: type: example/compute/reporting-api uses: store: store: target: store inject: env: - in: STORE_ENDPOINT from: endpointDer Build gibt eine einzige Root-Konfiguration aus, in der die Referenz und ihr Referenzziel gemeinsam deklariert sind:
module "api" { source = "./modules/api"
store_endpoint = "${module.store.endpoint}"}
module "store" { source = "./modules/store"
bucket = "app-artifacts"}Terraform löst module.store.endpoint auf, weil dieselbe Konfiguration module "store" deklariert, und der Wert erreicht das Modul des Konsumenten als gewöhnliche Eingabe.
Das Beispiel aws-rds-and-ecs-service baut dieses Paar aus Recipes der Standardbibliothek: eine PostgreSQL-Datenbank, die das veröffentlichte RDS-Modul einrichtet, und ein Server, der auf Amazon ECS läuft und dessen Argument environment den Wert ${module.db.db_instance_address} in der Root-Konfiguration trägt, die module "db" deklariert.
Drei Arten, wie das schiefgeht, und wie jede aussieht
Ein Recipe, das seinen eigenen Körper verfasst, kann keine komponentenübergreifende Referenz konsumieren. Ein Recipe artifacts: löst seine Werte in den Körper auf, den es schreibt, und dieser Körper wird in das eigene Verzeichnis der Komponente ausgegeben. Die Referenz steht dann in einem Gültigkeitsbereich, der keine Modulaufrufe deklariert:
Error: Reference to undeclared module on modules/api/main.tf line 11, in output "seen": 11: value = "${module.store.endpoint}"No module call named "store" is declared in module.api.Keine Schreibweise behebt das, denn die Ausdrücke eines verschachtelten Moduls können ein Geschwistermodul überhaupt nicht benennen — ein verschachteltes Modul erhält den Wert eines Nachbarn nur als Eingabe, also als das Argument des Blocks module, das der Pfad mit Quelle bereits liefert. Eine Komponente, die den veröffentlichten Wert einer anderen Komponente konsumiert, wird als Recipe source: verfasst.
Eine Adresse, die etwas innerhalb des eigenen Moduls des Produzenten benennt, wird gegen die Root-Konfiguration aufgelöst, nicht gegen dieses Modul. Ein Eintrag provides, der aws_db_instance.this.endpoint schreibt, benennt eine Ressource, die das Modul des Produzenten deklariert; als Interpolation geschrieben, wird er dort ausgewertet, wo das Argument des Konsumenten steht, also in der Root-Konfiguration:
Error: Reference to undeclared resource on aggrega.modules.tf line 19, in module "api": 19: store_endpoint = "${aws_db_instance.this.endpoint}"There is no managed resource "aws_db_instance" "this" definition in the root module.Veröffentlichen Sie ${module.<...>.<output>} und geben Sie dem Modul einen Block output für den Wert, statt in seine Ressourcen hineinzugreifen.
Ein Eintrag provides ohne Interpolation wird als Text geliefert. Das ist der Fall, der nicht fehlschlägt: Der Compiler leitet Zeichenketten weiter und kann einen Zeiger nicht von einem Literal unterscheiden, daher wird aws_db_instance.this.endpoint, ohne ${ ... } geschrieben, als Zeichenkette in Anführungszeichen gerendert, der Build gelingt, die Engine validiert, und der Konsument erhält die Zeichen aws_db_instance.this.endpoint. Schreiben Sie die Umhüllung ${ ... }, wann immer der Wert als Referenz gemeint ist — sie ist es, die die Zeichenkette als etwas kennzeichnet, das Terraform auswerten soll.
Eine Grenze, die Sie kennen sollten, bevor Sie sich darauf verlassen
.context.instance_id schreibt die Identität der Komponente aus, und der Name eines Blocks module wird aus dem Verzeichnis abgeleitet, in dem die Dateien der Komponente liegen. Für eine Komponente, die das eigene Aggregate der Bereitstellung deklariert, ist das derselbe Name. Für eine Komponente, die aus einem anderen Aggregate hineinkomponiert wird, ist es das nicht: Die zusammengesetzte Identität und der Modulname werden unterschiedlich in ihre beiden Alphabete geschrieben, und die Referenz schlägt dann auf Root-Ebene mit einer deutlichen Meldung fehl statt stillschweigend:
Error: Reference to undeclared module on aggrega.modules.tf line 25, in module "api": 25: store_endpoint = "${module.nested-zdinner.endpoint}"No module call named "nested-zdinner" is declared in the root module.Deklarieren Sie einen Produzenten, dessen Adresse eine andere Komponente auflöst, im eigenen Aggregate der Bereitstellung, neben der Komponente, die ihn konsumiert.
Wo die Ausgabe eines angebundenen Feature landet
Eine Feature-Anbindung, die eigene Konfiguration rendert, erhält ein eigenes Modul, das in derselben Root-Konfiguration deklariert wird wie die Komponenten daneben. Erst das macht ihre Konfiguration überhaupt zu einem Teil der Bereitstellung: Terraform lädt nur die Dateien, die direkt in einem Verzeichnis liegen, und behandelt ein verschachteltes Verzeichnis als vollständig separates Modul, das explizit aufgerufen werden muss, daher werden die Dateien einer Anbindung gelesen, weil die Root-Konfiguration einen Block deklariert, der das Verzeichnis benennt, in dem sie liegen.
Das Modulverzeichnis einer Anbindung liegt neben dem der Komponente, eine Ebene unter modules/, und ist nach den zwei Dingen benannt, die es identifizieren — der Komponente, die die Anbindung hostet, und dem Namen, unter dem sie angebunden wurde, verbunden durch --. Für eine Komponente api mit einer Anbindung namens aux deklariert die Root-Konfiguration also zwei Module:
module "api--aux" { source = "./modules/api--aux"}
module "api" { source = "./modules/api"}Ein an die Boundary statt an eine Komponente angebundenes Feature hat keine Host-Komponente, die es benennen könnte, daher ist sein Verzeichnis allein sein eigener Name: Eine Anbindung namens aux an einer Boundary, die die Komponente api enthält, ergibt ./modules/aux neben ./modules/api.
Warum daneben statt darin. Terraform führt jede Datei auf oberster Ebene eines Modulverzeichnisses in einen einzigen Namespace zusammen — output, variable, resource und locals gleichermaßen —, sodass zwei Beitragende, die sich ein Verzeichnis teilen, bei jedem Namen kollidieren, den beide deklarieren, wie auch immer ihre Dateien heißen. Ein eigenes Verzeichnis für jeden ist das, was sie auseinanderhält. Daneben statt darin ist auch das, was Terraforms eigener Leitfaden für verschachtelte Module verlangt: dass sie vom Aufrufer komponierbar sind, statt einander direkt aufzurufen und einen tief verschachtelten Modulbaum zu erzeugen.
Die Verbindungsstelle wird pro Koordinate maskiert. Jede der beiden Koordinaten wird in das Verzeichnisalphabet geschrieben, bevor sie verbunden werden, sodass eine Koordinate, die selbst -- enthält, nicht mit der Verbindungsstelle verwechselt werden kann: Ein Host namens a--b mit einer Anbindung c ist von einem Host a mit einer Anbindung b--c unterscheidbar. ASCII-Buchstaben in Groß- und Kleinschreibung, Ziffern, der Punkt und der Unterstrich bleiben wie geschrieben erhalten; ein Bindestrich, den Sie geschrieben haben, bleibt überall dort erhalten, wo das Zeichen danach eines davon ist; alles andere wird maskiert. Dieselbe Regel und dasselbe Alphabet erzeugen die Kindverzeichnisse eines Chart-Ziels, sodass das Verzeichnis einer Anbindung gleich geschrieben wird, welches der beiden Ziele es auch rendert.
Der Name eines Blocks wird aus dem Verzeichnis abgeleitet, auf das sein source zeigt, wobei jedes Zeichen außerhalb von Terraforms Grammatik für einen Modulnamen durch einen Unterstrich ersetzt wird. Diese Abbildung ist nicht eineindeutig, daher bricht der Build dort, wo zwei Beitragende bei einem einzigen Modulnamen ankämen, ab und benennt beide, statt eine Konfiguration auszugeben, die Terraform ablehnen würde.
Daraus, dass eine Anbindung ein eigenes Modul ist, folgen drei Dinge.
Ihre Eingaben stammen aus ihrem eigenen Mapping. Bei einer Anbindung, deren FeatureRecipe ein Modul als Quelle verwendet und ein valuesMapping deklariert, werden die Werte, die dieses Mapping erzeugt, als Argumente ihres eigenen Blocks module geschrieben, so wie das Modul mit Quelle einer Komponente seine Werte erhält. Ein FeatureRecipe, das kein valuesMapping deklariert, übergibt seinem Modul keine Argumente: Eine Variable, die das Modul mit einem default deklariert, übernimmt diesen, und eine ohne Standardwert deklarierte bleibt ungesetzt, sodass Terraform den Plan ablehnt.
Ihre Ressourcen liegen im einen Abhängigkeitsgraphen der Boundary. Eine Referenz oder ein depends_on reicht zwischen einer Anbindung und der Komponente, an die sie angebunden ist, hin und her, und ein einziges terraform plan sieht beide — dieselbe Eigenschaft, die die Form, in der die Root-Konfiguration die Kindmodule komponiert, Komponenten verleiht, aus demselben Grund.
Ihre Namen auf oberster Ebene gehören ihr. Da die oben beschriebene Zusammenführung des Namespace pro Verzeichnis erfolgt, deklariert ein Beitragender in einem eigenen Verzeichnis seine Namen output, variable, resource und locals, ohne mit denen seiner Nachbarn zu konkurrieren — so darf eine Anbindung einen Namen wiederverwenden, den ihr Host bereits deklariert, und keiner der beiden muss wissen, wie der andere irgendetwas genannt hat.
Beachten Sie, was dieses Ziel nicht verlangt, denn die Einschränkung eines Chart-Ziels ist eine andere, und der gemeinsame Aufbau kann so gelesen werden, als impliziere er mehr, als er tut: Ein Modul, das im Verzeichnis eines anderen Beitragenden verschachtelt ist, ist hier dennoch erreichbar, da die Root-Konfiguration das source jedes Beitragenden aus der Position liest, die der Build zusammengesetzt hat, statt es aus einem Bezeichner neu aufzubauen. Was dieses Ziel ablehnt, ist, dass zwei Beitragende sich ein Verzeichnis teilen. Ein Chart-Ziel lehnt die verschachtelte Position grundsätzlich ab, weil es ein Kind-Chart eine Ebene tiefer findet und nicht weiter.
Unterstützte Eingabearten
Der terraform-Provider akzeptiert zwei der drei Recipe-Eingabearten:
- Artefakt-Modus. Ein Recipe verfasst Terraform-Konfiguration als templatebasierten Körper; der Provider wertet das Aggrega-Template aus und gibt das Ergebnis aus, ohne es umzuschreiben. HCL (
main.tf) ist die ergonomische Standardwahl, und Terraform JSON (.tf.json) wird gleichwertig akzeptiert. Die Build-Provenienz wird als Block von Terraform-Kommentaren am Anfang eines HCL-Körpers eingestempelt; bei einem JSON-Körper — der keine Kommentarsyntax hat — wird die Provenienz statt inline in eine Begleitdatei geschrieben,aggrega.provenance.tf. - Modus mit Quelle. Ein Recipe referenziert ein Terraform-Modul mit
source:. Die Dateien des Moduls werden unverändert in das Verzeichnis dieser Komponente lokal kopiert (Vendoring), und dasvaluesMapping:des Recipe wird zu den Argumenten des Blocksmoduledieser Komponente in der Root-Konfiguration der Boundary. Der Modulkörper bleibt genau so erhalten, wie er verfasst wurde, und nichts wird in ihn geschrieben; die Werte werden einmal angegeben, in der Root-Konfiguration, wo Terraform sie auswertet. Wo die deklarierten Blättervaluesdes Knotens direkt zu den Eingaben des Moduls werden — ein Recipesource:ohnevaluesMapping:—, erhält eine Eingabe, die Material trägt, das ein Autor als sensibel deklariert hat, zusätzlich eine generierte Override-Datei, die Terraforms eigenes Sensitivitätsattribut trägt; ein TemplatevaluesMapping:erfindet seine Ausgabenamen, daher trägt dieser Fall keine Markierung, und der Build meldet ihn mit einem beratenden Hinweis. Beides wird unter Als sensibel deklarierte Moduleingaben beschrieben.
Ein null in einem valuesMapping: ist ein Argument null. Ein Schlüssel, den das Mapping auf null setzt, wird als <name> = null in den Modulblock geschrieben, und die Engine gibt der Variable des Moduls den Wert null und überschreibt damit ihr default, es sei denn, die Variable deklariert nullable = false; in diesem Fall gilt ihr default. Um einer Eingabe den Standardwert des Moduls zu geben, lassen Sie den Schlüssel im Mapping weg.
Die synthetisierte Eingabeart wird nicht angeboten. Es gibt keine getreue, gegenüber Fähigkeiten agnostische Abbildung von der Workload-Art der Plattform auf beliebige Terraform-Ressourcen, daher ist ein Recipe, das workload: gegenüber dem terraform-Provider deklariert, ein deutlicher Fehler statt einer erfundenen Übersetzung.
Ein Recipe, das omits: deklariert, wird abgelehnt. Der Schlüssel omits: lässt Dokumente, die eine Quelle rendert, aus dem Build heraus, und dieser Provider rendert zur Build-Zeit nichts aus einem Modul mit Quelle: Er kopiert die Dateien des Moduls unverändert lokal, und Terraform wertet sie aus, wenn die Konfiguration geplant und angewendet wird. Wo nichts gerendert wird, gibt es nichts auszulassen, daher deklariert dieser Provider nicht, dass er den Schlüssel beachtet, und ein Recipe oder FeatureRecipe, das ihn deklariert, wird abgelehnt, bevor irgendetwas lokal kopiert wird — siehe The provider does not support omits (Der Provider unterstützt omits nicht). Für ein Modul, das Sie neben dem Recipe aufbewahren, lässt eine Zeile in der dortigen .aggregaignore stattdessen eine Datei des Moduls aus, ab dem nächsten Pinnen des Recipe.
Ein Modul, das eine Registry veröffentlicht, als Quelle verwenden
Eine Modul-Registry veröffentlicht jede Version eines Moduls als Tag des eigenen Git-Repositorys des Moduls, und was sie antwortet, wenn sie aufgefordert wird, eine Version herunterzuladen, ist eine Git-Quelle, die auf den Commit festgelegt ist, den dieses Tag benennt. Ein Recipe verwendet ein veröffentlichtes Modul daher aus diesem Repository bei diesem Tag als Quelle, mit der Quellart git-repository:
spec: capability: terraform implements: example/storage/database:1.0.0 source: kind: git-repository url: https://github.com/terraform-aws-modules/terraform-aws-rds.git ref: v7.2.2 valuesMapping: | identifier: "{{ .values.identifier }}" provides: host: "${module.{{ .context.instance_id }}.db_instance_address}" port: "${module.{{ .context.instance_id }}.db_instance_port}"ref: ist das Versions-Tag, genau so, wie das Repository es benennt. valuesMapping: liefert die Eingaben des Moduls, unter den Namen, die seine Blöcke variable deklarieren — Terraform verlangt einen Wert für jede Eingabe, die kein default deklariert —, und sie werden zu den Argumenten des Blocks module dieser Komponente in der Root-Konfiguration, wie bei jedem Modul mit Quelle.
Was festgelegt wird. aggrega pin und der Pull lösen das Tag in den Commit auf, den es benennt, und archivieren das Repository bei diesem Commit. Das Lockfile des Release erfasst dann diesen Commit als festgelegte Version der Quelle, das Tag als die Referenz, die Sie geschrieben haben, und den Digest des Archivs. Jeder spätere Build liest das Archiv aus dem Cache und prüft es gegen diesen Digest, bevor irgendetwas lokal kopiert wird, sodass er kein Netzwerk benötigt, und ein zwischengespeichertes Archiv, dessen Bytes nicht mehr übereinstimmen, bricht den Build ab. Ein Tag ist ein Name, den ein Repository auf einen anderen Commit verschieben kann; ein späterer Pull, der Ihr Tag an anderer Stelle aufgelöst findet, bricht ab, statt den neuen Commit zu übernehmen, und aggrega pull --upgrade übernimmt ihn bewusst. Das ist eine engere Festlegung als Terraforms eigenes Abhängigkeits-Lockfile, das die Provider erfasst, die eine Konfiguration ausgewählt hat, und überhaupt kein Modul, sodass ein Modul, das als Git-Quelle bei einem Tag in eine Konfiguration geschrieben wird, nur so fest ist wie das Tag. Hier sind der Commit des Moduls und der Digest seiner Bytes im Lockfile festgelegt, die Bytes werden lokal in die Ausgabe kopiert, und die Root-Konfiguration ruft sie über einen lokalen Pfad auf, sodass die Engine nichts abruft, um das Modul selbst zu laden — ein Modul, das das lokal kopierte über eine Registry- oder Remote-Quelle aufruft, wird dennoch abgerufen, und der Build meldet jeden solchen Aufruf, wie Ein Modulaufruf, den die Engine beim Initialisieren abruft beschreibt.
Was lokal kopiert wird. Das gesamte Repository beim festgelegten Commit, abgesehen von seinem Verzeichnis .git/, landet Byte für Byte im eigenen Verzeichnis der Komponente unter modules/ — die eigenen Konfigurationsdateien und Kindmodule des Moduls und auch alles andere, was das Repository enthält: seine Verzeichnisse examples/ und wrappers/, seine Dokumentation, seine CI-Konfiguration und alle Test-Fixtures, binäre eingeschlossen. Die Engine liest nur, was das Modul aufruft: Wenn die Root-Konfiguration das Verzeichnis der Komponente aufruft, lädt die Engine die Konfigurationsdateien, die direkt darin liegen, und die in jedem Verzeichnis, das ein lokales source von dort aus erreicht. Ein Beispielverzeichnis, das andere Registry-Module aufruft, wird daher lokal kopiert und nie geladen, und nichts, was es aufruft, wird abgerufen.
Eingrenzen, was lokal kopiert wird. Eine abgerufene Quelle ist das Archiv, als das sie abgerufen wurde, daher ist der einzige Weg, sie einzugrenzen, module_subdir:, das ein Verzeichnis des Repositorys zum Artefakt macht. Das hilft nur, wenn das gewünschte Modul in einem Unterverzeichnis liegt: Ein Modul im Wurzelverzeichnis des Repositorys, das seine eigenen ./modules/* aufruft, braucht den ganzen Baum. Weder eine .terraformignore, die das Repository enthält, noch eine .aggregaignore neben dem Recipe ändert, was eine abgerufene Quelle lokal kopiert — beide formen ein Modul, das neben dem Recipe aufbewahrt wird, und keine von beiden wird für eines gelesen, das aus einem Repository abgerufen wurde.
Lesen, was das Modul veröffentlicht. Ein Wert, den das Modul veröffentlicht, ist einer seiner Blöcke output, und ein Konsument liest ihn als ${module.<name>.<output>}, wobei <name> der Modulblock des Produzenten ist — weshalb der Produzent oben ${module.{{ .context.instance_id }}.<output>} veröffentlicht. Die Engine löst die Referenz gegen die eigenen Blöcke output des Moduls auf, wenn sie die Root-Konfiguration validiert, daher wird ein Ausgabename, den das Modul nicht deklariert, dort abgelehnt und benannt:
Error: Unsupported attribute on aggrega.modules.tf line 9, in module "api": 9: db_host = "${module.db.db_instance_addresz}"This object does not have an attribute named "db_instance_addresz".Der Build liest keinen der Blöcke variable oder output des Moduls, schreibt nichts in das Modul und fügt ihm keine Provider-Konfiguration hinzu, daher wird ein falsch geschriebener Ausgabename von der Engine erkannt statt vom Build. Siehe Den veröffentlichten Wert einer anderen Komponente konsumieren für die Seite des Konsumenten.
Unveränderte Ausgabe und lokales Kopieren (Vendoring)
Der terraform-Provider transpiliert Terraform-Körper nicht, formatiert sie nicht neu und schreibt sie nicht um. Ein verfasster Körper in HCL oder .tf.json wird genau so ausgegeben, wie sein Template ausgewertet wird, wobei ein HCL-Körper mit den Provenienzkommentaren beginnt, und ein Modul mit Quelle wird Datei für Datei lokal kopiert. Das hält die terraform-Ausgabe deterministisch und reproduzierbar: Bei denselben Eingaben ist die gerenderte Konfiguration über Läufe hinweg bytegleich, und ein lokal kopiertes Modul durchläuft den Hin- und Rückweg unverändert. Da der Provider nie Laufzeitzustand auflöst, bleibt alles Laufzeitabhängige eine Interpolationszeichenkette, die Terraform zum Zeitpunkt des Apply bindet.
Plattform-Annotationen
Der terraform-Provider liest keine der Annotationen aggrega.ai/. Ein lokal kopiertes Modul, die Artefaktdateien eines Recipe und die Root-Konfiguration, die der Provider schreibt, haben keinen Platz für einen Namespace, ein Registry-Präfix, ein Pull-Secret oder einen Service-Account, daher ändert ein dafür gesetzter Wert nichts an der gerenderten Konfiguration; ein Modul, das einen solchen Wert benötigt, erhält ihn als eine seiner eigenen Eingaben, über die values der Komponente.
Der Provider gibt das in seiner Plugin-Entität an, mit readsNoWellKnownAnnotations: true (siehe die Plugin-Entität), und der Build warnt daher bei jeder Annotation aggrega.ai/, die über ihn ein Rendering erreicht — einmal pro Schlüssel und pro Rendering, unter Nennung der Eingabearten, die dieses Rendering deklariert:
warning: node "db" (provider "terraform"): target "terraform" does not support annotation aggrega.ai/namespace on sourced input and ignored itDer Wert durchläuft den Build dennoch unverändert, und der Build bricht nicht ab: Eine Boundary-Annotation kaskadiert auf jede Komponente darunter, und eine Boundary, deren Komponenten über unterschiedliche Ziele rendern, ist der Normalfall und kein Fehler. Die Warnung gehört zur Klasse unsupported-field und wird mit dem Flag dieser Klasse stummgeschaltet.
Als sensibel deklarierte Moduleingaben
Terraform ist das einzige Ziel der Standardbibliothek mit einem nativen Sensitivitätsprimitiv pro Wert, sodass ein Datum, das ein Autor als sensibel deklariert hat, in Terraforms eigenen Begriffen gerendert werden kann, statt nur in denen von Aggrega erfasst zu werden.
Wenn die Eingabe eines lokal kopierten Moduls Material trägt, das ein Autor als sensibel deklariert hat, fügt der Provider neben dem Modul eine weitere Datei hinzu, aggrega_override.tf.json, die für diese Eingabe sensitive = true deklariert:
{ "variable": { "db_password": { "sensitive": true } }}Terraform führt eine Konfigurationsdatei, deren Name schlicht override lautet oder auf _override endet, mit der Konfiguration im selben Verzeichnis zusammen, sodass der eigene Block variable des Moduls das Attribut erhält, während jedes lokal kopierte Byte genau so bleibt, wie es verfasst wurde. Der deklarierte Typ, der Standardwert und die Beschreibung der Eingabe bleiben unberührt — das Override trägt das Sensitivitätsattribut und sonst nichts. Ein nicht markierter Knoten erhält keine solche Datei.
Diese Grenze ist bewusst gezogen und nicht etwas, das das Dateiformat erzwingt: Nichts in einem Override lehnt ein zweites Attribut ab, und das default eines Blocks variable ist der naheliegendste Platz, zu dem man greifen würde, wollte man einen Wert in ein lokal kopiertes Modul bringen, ohne dessen Bytes zu bearbeiten — aber er käme nicht an. Ein default in der JSON-Konfigurationssyntax, in der diese Datei geschrieben ist, ist keine Position, die Terraform auswertet, daher erreicht ein Wert, der einen dort geschriebenen Zeiger ${ ... } trägt, das Modul als die literalen Zeichen des Zeigers, bei einem Plan, der gelingt und nichts meldet. Derselbe Zeiger, in ein default in nativem HCL geschrieben, wird rundweg abgelehnt, was diese Stille in dieser Syntax verortet und nicht in Override-Dateien als solchen. Daher trägt das Override allein sensitive: Seine Bedeutung hängt nicht davon ab, ausgewertet zu werden.
Welche Eingabe markiert wird, ergibt sich aus einer Deklaration, nie aus einem Namen. Der Provider liest die Markierung, die die Kompilierung berechnet hat, und untersucht selbst nichts: Er erkennt weder password, secret noch token, und er liest nicht den Text des Moduls, um zu raten. Eine Moduleingabe namens db_password, deren Wert keine Deklaration trägt, wird unmarkiert ausgegeben, und eine deklarierte Eingabe namens region wird markiert.
Die Markierung wandert nur dorthin, wo die Identität der Eingabe aus der Deklaration rekonstruierbar ist. Ein Recipe, das ein Modul mit source: lokal kopiert und die deklarierten Blätter values des Knotens direkt zu den Eingaben des Moduls werden lässt, gibt jeder Eingabe denselben Namen, den der Autor deklariert hat, sodass die Verbindung exakt ist — und ebenso das FeatureRecipe eines an eine Komponente angebundenen Feature, das ein Modul auf dieselbe Weise lokal kopiert, über die Blätter, die sein Feature deklariert. Ein Recipe oder ein solches FeatureRecipe, das diese Werte über ein Template valuesMapping: umformt, erfindet seine Ausgabenamen, und keine Deklaration benennt sie — daher fehlt die Markierung, statt angenähert zu werden, und der Build meldet das mit einem beratenden Hinweis pro deklariertem Blatt, der das Blatt und die Entität benennt, deren Mapping es ist (ein an eine Boundary angebundenes Feature rendert gegen überhaupt keine values, hat also nichts zu markieren und löst keinen aus); siehe A declared-sensitive value reaches the target through a values mapping (Ein als sensibel deklarierter Wert erreicht das Ziel über ein values-Mapping). Das Fehlen ist bewusst: Zu raten, welche umgeformte Eingabe das deklarierte Datum trug, würde eine öffentliche Eingabe als geheim markieren, und Terraform würde dann einen Wert aus der Plan-Ausgabe unterdrücken, der nie sensibel war.
Das ausgearbeitete Beispiel terraform-declared-sensitivity baut dies von Anfang bis Ende und ist klein genug, um es vollständig zu lesen: eine Komponente, die drei Blätter values deklariert, von denen zwei öffentliche Bezeichner tragen und eines die Zugangsdaten. Ihre gerenderte Ausgabe zeigt die Argumente des Blocks module, die alle drei Moduleingaben tragen, und das Override, das nur die deklarierte benennt, sodass beide Hälften der Regel im selben Build sichtbar sind — einschließlich dessen, dass ein Bezeichner der Zugangsdaten, der neben dem Geheimnis steht, unmarkiert bleibt. Wird die eine Deklaration entfernt und neu gebaut, wird überhaupt keine Override-Datei ausgegeben.
Was Terraforms sensitive garantiert und was nicht
Aggrega verspricht genau das, was Terraforms eigenes Attribut leistet, und nicht mehr.
Es begrenzt die Anzeige. Ein sensibler Wert erscheint in der Plan-Ausgabe als (sensitive value) und in der Apply-Ausgabe als <sensitive>. Die Markierung pflanzt sich durch Ausdrücke fort, sodass auch ein von einer sensiblen Eingabe abgeleiteter Wert sensibel ist, und Terraform weigert sich, einen solchen aus einem output auf Root-Ebene zu exportieren, der nicht selbst als sensibel markiert ist — ein deutlicher Fehler statt einer stillen Offenlegung.
Es ändert nichts an der Speicherung, und es ist keine Verschlüsselung. Terraform erfasst einen sensiblen Wert im Klartext im State. sensitive = true als Versprechen zu lesen, dass der State gefahrlos committet oder geteilt werden kann, ist das eine Missverständnis, das es zu vermeiden gilt: Den State zu schützen bleibt eine Frage dessen, wie das State-Backend konfiguriert ist, genau wie bei einem Modul, das überhaupt keine Markierung trägt. Das Attribut schränkt auch nicht ein, wer den Wert lesen darf, beeinflusst nicht, was ein Provider überträgt, und ändert die gerenderte Konfiguration auch auf keine andere Weise.
Die Markierung erschwert es also, eine als sensibel deklarierte Eingabe versehentlich offenzulegen, wenn jemand einen Plan liest. Sie macht das, was bereitgestellt wird, nicht sicher veröffentlichbar. Siehe Ein Blatt als sensibel deklarieren für das Schlüsselwort und dafür, was eine Deklaration über alle Ziele hinweg bewirkt.
Strukturelle Eingabevalidierung
Der terraform-Provider validiert die Struktur eines Moduls mit Quelle, bevor er rendert. Er parst die Dateien des Moduls in HCL und .tf.json und meldet Parse-Fehler, wobei er den Build mit einer klaren Meldung abbricht, die den betroffenen Knoten und den Provider benennt. Die Parse-Prüfung prüft die Form, nicht die Semantik — sie löst keine Provider auf, wertet keine Ausdrücke aus und kontaktiert keine Registry. Die Validierung ist hermetisch: Sie verwendet einen eigenständigen, in den Provider kompilierten HCL-Parser, ohne Binärdatei terraform und ohne Netzwerkzugriff. Ein fehlerhaftes Modul wird an der Authoring-Grenze abgefangen, statt bei einem späteren Lauf von terraform als verwirrender Fehler aufzutauchen.
Ein Modulaufruf, den die Engine beim Initialisieren abruft
Derselbe Lesevorgang meldet, als Warnung, die nichts ablehnt, jeden Block module, dessen Quelle Terraform herunterlädt, wenn die Konfiguration initialisiert wird. Commit und Archiv-Digest eines lokal kopierten Moduls sind im Lockfile festgelegt, aber ein Block module darin, dessen source eine Registry-Adresse, eine Git-, Mercurial- oder HTTP-Archiv-URL, ein S3- oder GCS-Bucket oder ein absoluter Pfad ist, benennt ein Modul, das die Engine bei der Initialisierung abruft, in der Version, die sie dann gerade auswählt — und Terraforms eigenes Abhängigkeits-Lockfile erfasst nur Provider, sodass nichts dieses Modul festlegt. Ein lokales source, das aus dem lokal kopierten Modul herausführt, wird ebenfalls gemeldet, weil es Dateien benennt, die der Build nicht lokal kopiert hat. Jeder Befund benennt den Knoten und den Provider, dann den Block, die Datei und die Zeile, in der er steht, und die Quelle wie geschrieben:
warning: node "app" (provider "terraform"): module "vpc" (main.tf, line 2) has the source "terraform-aws-modules/vpc/aws", which Terraform downloads when the configuration is initialised, at whatever version it then selects, so no commit or digest this build records covers that moduleWas gelesen wird. Die Dateien, die die Engine lädt, wenn das Modul aufgerufen wird: die Konfigurationsdateien direkt im eigenen Verzeichnis des Moduls, dann die in jedem Verzeichnis, das ein lokales source — eines, das mit ./ oder ../ beginnt, oder deren Schreibweisen mit Backslash — von dort aus erreicht, von Verzeichnis zu Verzeichnis verfolgt und jedes einmal gelesen. Ein Verzeichnis, das von nichts aufgerufen wird, wird nicht gelesen, daher werden die Aufrufe, die die Verzeichnisse examples/ oder tests/ eines Moduls machen, nicht gemeldet: Die Engine lädt sie nie, wenn das Modul aufgerufen wird, und nichts, was sie aufrufen, wird abgerufen. Die obige Parse-Prüfung parst dennoch jede lokal kopierte Konfigurationsdatei. Der verfasste Körper eines Recipe wird beim Rendern auf dieselbe Weise gelesen, beginnend bei dem Verzeichnis, in das der Körper geschrieben wird, sodass ein Block module, den ein verfasster Körper mit einer Registry-Quelle schreibt, ebenfalls gemeldet wird. Eine Datei unter spec.boundary.artifacts wird vom Compiler selbst ausgewertet und geschrieben und keinem Provider übergeben, daher wird ein darin geschriebener Block module nicht gelesen und löst keine Warnung aus.
Was nicht gelesen wird. Gelesen wird nur, was ein source aussagt. Der Build liest nicht das Modul, das ein Aufruf benennt, beurteilt nicht, was dieses Modul tut, und entscheidet nicht, ob der Aufruf akzeptabel ist. Ein source, das die Engine auswertet, statt es wie geschrieben zu lesen — eines mit einer Interpolation oder einer Referenz —, wird nach seinem führenden Text beurteilt: Eines, das mit einer Adresse beginnt, wird wie geschrieben gemeldet, während eines, das mit einem lokalen Präfix oder mit der Interpolation selbst beginnt, weder gemeldet noch verfolgt wird, weil nicht im Text steht, wohin es führt. Ein source innerhalb von required_providers benennt einen Provider statt eines Moduls und ist kein Modulaufruf.
Warum es gemeldet statt abgelehnt wird. Ein Modul, das ein anderes Modul aufruft, ist eine legitime Eingabe: Terraform ruft das aufgerufene Modul ab, und die Konfiguration funktioniert. Was der Autor aufgibt, ist die Festlegung des aufgerufenen Moduls durch den Build, was eine wissenswerte Tatsache ist und kein zu behebender Fehler, und ob dieser Abruf akzeptabel ist, liegt im Urteil des Autors. Eine Konfiguration, die vollständig festgelegt bleiben muss, kopiert nur Module lokal, die keinen solchen Aufruf machen. Die Warnung, ihr Klassencode und wohin sie sonst noch reicht, sind in Warnungen und Linter-Ausgabe beschrieben.
FeatureRecipe-Patch-Grenze
Ein Schritt pipeline eines FeatureRecipe nach dem Rendern patcht nur Ausgabe, die der Provider in einen strukturierten Baum rendert. Für terraform bedeutet das:
- In JSON verfasstes Terraform ist patchbar. Ein Modul
.tf.jsonist ein strukturiertes Dokument, daher bearbeitet das JSONPatch eines Pipeline-Schritts die adressierten Werte an Ort und Stelle und lässt jedes andere Byte — Reihenfolge, Formatierung, umgebende Schlüssel — unverändert. - Natives HCL ist opak. Ein Körper in nativem HCL (
main.tf) ist kein strukturiertes Patch-Ziel. Ein Patch gegen einen opaken Körper bricht den Build mit einer Diagnose ab, statt Text zu verändern, den er nicht strukturell adressieren kann; einen Pipeline-Schritt gegen einen HCL-Körper zu verfassen, ist ein Entwurfsfehler, der als deutlicher Abbruch zutage tritt, nicht als stilles No-op. - Die Eingaben eines Moduls mit Quelle sind überhaupt kein Patch-Ziel. Sie sind die Argumente des Blocks
moduleder Komponente, der in der Root-Konfiguration steht: natives HCL und daher opak, und ein Artefakt der ganzen Boundary statt eines einzelnen Knotens. Ein Schrittpipelinepatcht die eigene gerenderte Ausgabe eines Knotens, daher gibt es keine Position, von der aus sie adressiert werden könnten.
Ein Autor, der einen Terraform-Körper über die Pipeline patchbar braucht, verfasst ihn daher als .tf.json. Siehe FeatureRecipe für die allgemeine Grenze der Patch-Ziele über alle Provider hinweg.
Bereitstellungsreihenfolge
Der Wert syncWave: einer Release-Boundary ordnet die Blöcke module der Root-Konfiguration, zu der diese Boundary zusammengesetzt wird. Jede Komponente in der Boundary erbt die Welle der Boundary, und wo mehrere Boundaries in dasselbe Ausgabeverzeichnis aufgelöst werden — sodass ihre Komponenten in eine einzige Root-Konfiguration komponiert werden —, enthält diese Root-Konfiguration mehr als eine Welle, und der Provider drückt die Reihenfolge zwischen ihnen als depends_on auf den Blöcken module aus.
Jedes Modul benennt jedes Modul der unmittelbar vorangehenden Welle, die Komponenten hat, und keine frühere Welle als diese. Terraform verkettet den Rest: Ein Modul in Welle 2 hängt von Welle 1 ab, die von Welle 0 abhängt, sodass die ganze Abfolge geordnet ist, während die eigene Liste jedes Moduls die Größe einer Welle behält statt der der ganzen Boundary. 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 der Konfiguration liest. Die niedrigste Welle benennt nichts, weil ihr nichts vorausgeht.
Was die Reihenfolge ist: die Reihenfolge, in der Terraform seine Aktionen ausführt. Terraform baut einen Abhängigkeitsgraphen auf und arbeitet ihn so weit parallel ab, wie der Graph es zulässt. depends_on fügt diesem Graphen eine Kante hinzu, sodass Terraform seine Aktionen an den benannten Modulen abschließt, bevor es mit denen an dem Modul beginnt, das die Abhängigkeit deklariert. Eine Welle gliedert den Lauf daher in Stufen: Auf die Komponenten der früheren Welle wird eingewirkt, bevor mit denen der späteren Welle begonnen wird.
Es ist keine Reihenfolge nach Bereitschaft. Eine Terraform-Konfiguration drückt keinen Begriff davon aus, dass eine Ressource einsatzbereit ist, daher wartet hier nichts darauf, dass eine bereit wird — nur darauf, dass Terraform seine Aktionen an ihr abschließt. Das ist ein echter Unterschied zu derselben Welle bei compose, wo auf einen Dienst, der einen healthcheck deklariert, gewartet wird, bis er sich als gesund meldet: compose hat ein Bereitschaftsprimitiv, auf das es warten kann, und eine Terraform-Konfiguration hat keines. Die Reihenfolge der Aktionen ist das, was dieses Ziel bietet, und sie klar zu benennen, ist nützlicher als ein Vorbehalt, der an ein Versprechen geknüpft ist, das es nicht halten kann.
Keine Abbaureihenfolge wird versprochen. Was depends_on aussagt, ist, dass Terraform die Aktionen der Abhängigkeit abschließt, bevor es mit denen des Abhängigen beginnt; die Reihenfolge, in der ein destroy sie entfernt, ist nicht Teil dieser Aussage, daher wird hier nichts über die Abbaufolge behauptet. Das ist ein engeres Versprechen als das, das dieselbe Welle bei cloudformation trägt, dessen Attribut beide Richtungen regelt — wissenswert, wenn Sie sich darauf verlassen, dass eine Welle einen Abbau in eine Reihenfolge bringt, denn auf diesem Ziel tut sie das nicht.
Eine Boundary, deren Komponenten alle dieselbe Welle tragen, gewinnt dadurch nichts. Ebenso ein Release, das überhaupt keine syncWave deklariert: Jeder Beitragende trägt den Standardwert des Feldes, 0, die Root-Konfiguration enthält eine einzige Welle, und die ausgegebenen Bytes sind genau die, die sie wären, wenn der Provider keine Wellenreihenfolge ausdrückte.
Eine Reihenfolge über zwei Root-Konfigurationen hinweg ist nicht ausdrückbar, und sie wird nicht angenähert. Ein Terraform-Abhängigkeitsgraph gilt pro Konfiguration, und depends_on benennt ein Modul innerhalb der Konfiguration, die es deklariert, daher ordnet eine Welle jede in diese Root-Konfiguration komponierte Komponente und nichts darüber hinaus. Zwei Konfigurationen in eine Reihenfolge zu bringen, ist Sache des Betreibers, so wie eine Remote-State-Referenz eine Auflösung zum Bereitstellungszeitpunkt ist und nicht zum Build-Zeitpunkt.
Die Welle wird aufgezeichnet und nicht nur umgesetzt: Sie reist mit dem Rest der Build-Provenienz des Knotens mit, als aggrega.ai/sync-wave im gestempelten Kommentarblock oder in der Provenienz-Begleitdatei, wo der Körper JSON oder ein lokal kopiertes Modul ist. So hält eine gerenderte Konfiguration fest, welche Welle ihre Boundary deklariert hat, und wird zugleich danach geordnet.
Eine Reihenfolge, die die Wellen nicht ausdrücken, bleibt Terraforms eigene Sache, und die Referenzen zwischen Ressourcen tragen bereits viel davon: Eine Referenz auf ein Attribut einer anderen Ressource weist Terraform an, zuerst auf diese Ressource einzuwirken. Ein Modul, das eine Einschränkung braucht, die weder die Referenzen noch die Wellen implizieren, schreibt sein eigenes depends_on innerhalb des Moduls, das der Provider wie jeden anderen Teil des Körpers unverändert ausgibt.
Verwandte Referenzen
- Provider-Architektur — wie Provider sich in die Kompilierungspipeline einfügen und wie pro Provider verteilt wird.
- Provider-Referenzindex — was jeder Provider der Standardbibliothek erzeugt und welche Seite welche Frage beantwortet.
- Recipe-Entität — die Authoring-Oberfläche des Recipe und die drei Eingabearten.
- FeatureRecipe — das Patch-Modell
pipelinenach dem Rendern und seine Grenze zwischen strukturiert und opak. - Zusammensetzung der Recipe-Eingaben — die kanonische Provider-Fähigkeitsmatrix.