Pulumi in Python: Interpolation übersetzen

Pulumi ist ein leistungsstarkes Tool für die Verwaltung von Infrastruktur als Code und seine Flexibilität über verschiedene Sprachen hinweg macht es zu einer beliebten Wahl bei Entwicklern. Während die TypeScript-Syntax von Pulumi eine saubere und bequeme Möglichkeit bietet, Ausgaben und Eingaben zu verarbeiten, kann die Übersetzung dieser Funktionen in Python eine Herausforderung darstellen. Dieser Artikel untersucht die Nuancen der Verwendung von pulumi.interpolate in TypeScript und wie man eine ähnliche Funktionalität in Python erreicht.

Pulumi-Interpolation

In der TypeScript-Syntax von Pulumi gibt es einen sauberen Ansatz zum Verketten von Ausgaben. Es nutzt getaggte Vorlagenliterale, die in Python nicht verfügbar sind. Gemäß den Pulumi-Referenzdokumenten ähnelt interpolate concat, ist jedoch für die Verwendung als getaggter Vorlagenausdruck konzipiert. Zum Beispiel:

// 'server' and 'loadBalancer' are both resources that expose [Output] properties.
let val: Output<string> = pulumi.interpolate `http://${server.hostname}:${loadBalancer.port}`

Wie bei concat können die „Platzhalter“ zwischen ${} beliebige Eingaben sein, d. h. sie können Versprechen, Ausgaben oder einfach nur JavaScript-Werte sein.

Da ich den Großteil meiner Pulumi-Arbeit in TypeScript erledigt habe, habe ich häufig das getaggte Vorlagenliteral pulumi.interpolate verwendet, wenn ich eine Eingabe an eine neue Ressource übergeben musste. Ohne groß darüber nachzudenken, habe ich es ausgiebig genutzt, ohne es gründlich mit pulumi.concat oder apply zu vergleichen. Als ich jedoch anfing, mit Pulumi in Python zu arbeiten, und nach pulumi.interpolate griff, wurde mir klar, dass es fehlte.

Dies führte zu einem tieferen Einblick in das Verständnis dessen, was es bedeutet, ein Output bzw. ein Input zu sein, und wie man übersetzt:

pulumi.interpolate`http://${server.hostname}:${loadBalancer.port}`

an:

pulumi.concat('http://', server.hostname, ':', loadBalancer.port)

Ausgabe

Ausgaben sind Werte von Ressourcen, die möglicherweise gefüllt sind oder in Zukunft aufgelöst und gefüllt werden. Da eine Ausgabe mit der Ressource verknüpft ist, von der sie stammt, kann eine Kante erstellt werden, wenn sie als Eingabe an pulumi.interpolate oder pulumi.concat übergeben und später zum Erstellen einer anderen Ressource verwendet wird. Das Abhängigkeitsdiagramm zwischen Ressourcen, das von den Knoten (Ressourcen) und ihren Kanten (Ausgabe -> Eingabe) erstellt wird, ermöglicht es Pulumi, Ressourcen in der richtigen Reihenfolge zu erstellen und stellt sicher, dass Ausgaben bei Bedarf von der nächsten Ressource im Diagramm gefüllt werden.

Eingang

Eine Eingabe kann ein Rohwert, ein Versprechen oder eine Ausgabe sein. Wenn eine Eingabe für eine Ressource eine Ausgabe ist, haben Sie einen Verweis auf die Ressource, in der die Ausgabe ursprünglich erstellt wurde. Die Tatsache, dass ein Input ein Output sein kann, ermöglicht es ihm, seine Abhängigkeiten zu verfolgen.

Hier ist die Typdefinition:

type Input<T> = T | Promise<T> | OutputInstance<T>;

Markierte Vorlagenliterale in 30 Sekunden

Hier ist ein Beispiel dafür, wie wir nur die Werte (die „Platzhalter“ zwischen ${}) in Großbuchstaben schreiben könnten, ohne den Literal-String-Teil des Vorlagenliterals zu ändern:

function uppercaseValues(strings, ...values) {
  const result = [];
  strings.forEach((string, i) => {
    result.push(string);
    if (i < values.length) {
      result.push(values[i].toString().toUpperCase());
    }
  });
  return result.join('');
}

const name = "Chris";
const hobby = "TypeScript";

console.log(uppercaseValues`Hello, my name is ${name} and I love ${hobby}.`);
// Output: "Hello, my name is CHRIS and I love TYPESCRIPT."

Implementierung von pulumi.interpolate

Ohne den genauen Quellcode zu kennen und das obige Beispiel zu erweitern, können wir uns vorstellen, wie wir pulumi.interpolate selbst implementieren können. Es könnte in etwa so aussehen:

function interpolate(strings, ...values) {
  const result = [];
  strings.forEach((string, i) => {
    result.push(string);
    if (i < values.length) {
      result.push(values[i]);
    }
  });
  return pulumi.concat(...result);
}

Wir haben lediglich den letzten Beitrittsaufruf durch einen Anruf bei pulumi.concat ersetzt. Wenn dies die Implementierung wäre, würden wir prüfen, ob Rohzeichenfolgen aus Ausgabetypen entpackt werden müssen, anstatt nur die Platzhalter zu bearbeiten, was bei der tatsächlichen Implementierung der Fall ist.

Seine Funktionsdefinition in TypeScript ist:

function interpolate(literals: TemplateStringsArray, ...placeholders: Input<any>[]): Output<string>;

was concat:
sehr ähnlich ist

function concat(...params: Input<any>[]): Output<string>

Der Aha-Moment kommt, wenn Ihnen klar wird, dass Sie eigentlich nur Ausgabewerte weiterleiten und sie in übergeordnete Ausgaben einschließen.

Zurück zu Python

Sie können einige dumme Fehler machen, wenn Sie interpolate auf concat portieren. Lassen Sie es uns anhand eines Beispiels demonstrieren.

In TypeScript hätte ich Folgendes getan:

function get_image_name(imageRegistry: Repository, name: string, version: Input<string>) {
    return pulumi.interpolate`${image_registry.repository_id}/${name}:${version}`
}

Bei der Portierung nach Python erhalte ich möglicherweise Folgendes:

def get_image_tag(image_registry: Repository, name: str, version: Input[str]):
    return pulumi.Output.concat(
        image_registry.repository_id,
        f"/{name}:{version}"
    )

Interpolate iterierte jedoch einzeln über jeden Platzhalter, um Abhängigkeiten zu erstellen und Ausgaben aufzulösen. Bei unserem Python-Code haben wir diese Verbindung mit dem Versionsargument auf subtile Weise verloren. Wir müssen unsere Ausgaben manuell aufteilen und sie als einzelne Argumente für pulumi.Output.concat.

anzeigen

Der korrigierte Code würde so aussehen:

def get_image_tag(image_registry: Repository, name: str, version: Input[str]):
    return pulumi.Output.concat(
        image_registry.repository_id,
        f"/{name}:",
        version
    )

Jetzt wird die Version korrekt in das Abhängigkeitsdiagramm aufgenommen und wir sind fehlerfrei!

Abschluss

Die Übersetzung von pulumi.interpolate von TypeScript nach Python erfordert ein tieferes Verständnis der Funktionsweise von Ausgaben und Eingaben in Pulumi. Während Python keine getaggten Vorlagenliterale unterstützt, können wir mit pulumi.concat effektiv eine ähnliche Funktionalität erreichen. Indem wir Abhängigkeiten manuell verwalten und sicherstellen, dass alle Ausgabewerte ordnungsgemäß verarbeitet werden, können wir sicherstellen, dass unser Pulumi-Code in Python genauso robust und effizient ist wie in TypeScript.

Das obige ist der detaillierte Inhalt vonPulumi in Python: Interpolation übersetzen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!