Pulumi en Python : traduction de l'interpolation

Pulumi est un outil puissant pour gérer l'infrastructure en tant que code, et sa flexibilité dans différents langages en fait un choix populaire parmi les développeurs. Bien que la syntaxe TypeScript de Pulumi offre un moyen propre et pratique de gérer les sorties et les entrées, traduire ces fonctionnalités en Python peut s'avérer difficile. Cet article explore les nuances de l'utilisation de pulumi.interpolate dans TypeScript et comment obtenir des fonctionnalités similaires en Python.

Interpolation Pulumi

Dans la syntaxe TypeScript de Pulumi, il existe une approche propre pour concaténer les sorties. Il exploite les littéraux de modèle balisés, qui ne sont pas disponibles en Python. Selon la documentation de référence Pulumi, l'interpolation est similaire à la concatérisation mais est conçue pour être utilisée comme expression de modèle balisée. Par exemple :

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

Comme pour concat, les « espaces réservés » entre ${} peuvent être n'importe quelle entrée, c'est-à-dire qu'ils peuvent être des promesses, des sorties ou simplement de simples valeurs JavaScript.

Ayant effectué la plupart de mon travail Pulumi en TypeScript, j'ai fréquemment utilisé le modèle littéral balisé pulumi.interpolate chaque fois que j'avais besoin de transmettre une entrée dans une nouvelle ressource. Sans trop y réfléchir, je l'ai largement utilisé sans le comparer profondément à pulumi.concat ou à apply. Cependant, lorsque j'ai commencé à travailler avec Pulumi en Python et que j'ai utilisé pulumi.interpolate, j'ai réalisé qu'il manquait.

Cela a incité à approfondir la compréhension de ce que signifie être une sortie par rapport à une entrée et comment traduire :

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

à :

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

Sortir

Les sorties sont des valeurs provenant de ressources qui peuvent être renseignées ou qui seront résolues et renseignées à l'avenir. Étant donné qu'une sortie est associée à la ressource dont elle provient, une arête peut être créée lorsqu'elle est transmise en tant qu'entrée à pulumi.interpolate ou pulumi.concat, puis utilisée pour créer une autre ressource. Le graphique de dépendance entre les ressources, créé par les nœuds (ressources) et leurs bords (Sortie -> Entrée), permet à Pulumi de créer des ressources dans le bon ordre et garantit que les sorties sont remplies lorsque nécessaire par la ressource suivante dans le graphique.

Saisir

Une entrée peut être une valeur brute, une promesse ou une sortie. Si une entrée dans une ressource est une sortie, vous disposez alors d'une référence à la ressource dans laquelle la sortie a été créée à l'origine. Le fait qu'une Entrée puisse être une Sortie lui permet de tracer ses dépendances.

Voici sa définition de type :

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

Littéraux de modèle balisés en 30 secondes

Voici un exemple de la façon dont nous pourrions mettre uniquement les valeurs en majuscules (les "espaces réservés" entre ${}), sans modifier la partie chaîne littérale du littéral du modèle :

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."

Implémentation de pulumi.interpolate

Sans connaître le code source exact et en développant l'exemple ci-dessus, nous pouvons imaginer comment implémenter pulumi.interpolate par nous-mêmes. Cela pourrait ressembler à ceci :

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);
}

Tout ce que nous avons fait a été de remplacer l'appel de jointure final par un appel à pulumi.concat. S'il s'agissait de l'implémentation, nous vérifierions si les chaînes brutes doivent être déballées des types de sortie, au lieu d'opérer uniquement sur les espaces réservés, ce que fait la véritable implémentation.

Sa définition de fonction dans TypeScript est :

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

qui est très similaire à concat :

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

Le moment lumineux survient lorsque vous réalisez que vous ne faites en réalité que transmettre des valeurs de sortie et les envelopper dans des sorties parentes.

Retour à Python

Vous pouvez faire des erreurs stupides lors du portage de l'interpolation vers la concaténation. Montrons avec un exemple.

En TypeScript, j'aurais fait ça :

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

Lors du portage vers Python, je pourrais me retrouver avec ceci :

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

Cependant, l'interpolation itérait sur chaque espace réservé individuellement pour créer des dépendances et résoudre les résultats. Avec notre code Python, nous avons subtilement perdu ce lien avec l’argument de version. Nous devons diviser nos sorties manuellement et les présenter sous forme d'arguments individuels dans pulumi.Output.concat.

Le code corrigé ressemblerait à ceci :

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

Maintenant, la version sera correctement incluse dans le graphe de dépendances, et nous serons sans erreur !

Conclusion

Traduire pulumi.interpolate de TypeScript vers Python nécessite une compréhension plus approfondie du fonctionnement des sorties et des entrées dans Pulumi. Bien que Python ne prenne pas en charge les littéraux de modèles balisés, l'utilisation de pulumi.concat nous permet effectivement d'obtenir des fonctionnalités similaires. En gérant manuellement les dépendances et en garantissant que toutes les valeurs de sortie sont correctement traitées, nous pouvons garantir que notre code Pulumi en Python est tout aussi robuste et efficace qu'en TypeScript.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!