Pulumi es una poderosa herramienta para administrar infraestructura como código, y su flexibilidad en diferentes lenguajes la convierte en una opción popular entre los desarrolladores. Si bien la sintaxis TypeScript de Pulumi ofrece una forma limpia y conveniente de manejar salidas y entradas, traducir estas funciones a Python puede resultar un desafío. Este artículo explora los matices del uso de pulumi.interpolate en TypeScript y cómo lograr una funcionalidad similar en Python.

Interpolación de Pulumi

En la sintaxis TypeScript de Pulumi, existe un enfoque limpio para concatenar salidas. Aprovecha los literales de plantilla etiquetados, que no están disponibles en Python. Según los documentos de referencia de Pulumi, interpolar es similar a concat pero está diseñado para usarse como una expresión de plantilla etiquetada. Por ejemplo:

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

Al igual que con concat, los 'marcadores de posición' entre ${} pueden ser cualquier entrada, es decir, pueden ser promesas, salidas o simplemente valores de JavaScript.

Habiendo hecho la mayor parte de mi trabajo de Pulumi en TypeScript, frecuentemente usaba el literal de plantilla etiquetado pulumi.interpolate cada vez que necesitaba pasar una entrada a un nuevo recurso. Sin pensarlo mucho, lo usé extensamente sin compararlo profundamente con pulumi.concat o apply. Sin embargo, cuando comencé a trabajar con Pulumi en Python y busqué pulumi.interpolate, me di cuenta de que faltaba.

Esto nos llevó a profundizar en la comprensión de lo que significa ser una salida frente a una entrada y cómo traducirlo:

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

a:

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

Producción

Las salidas son valores de recursos que pueden completarse o que se resolverán y completarán en el futuro. Debido a que una salida está asociada con el recurso del que proviene, se puede crear una ventaja cuando se pasa como entrada a pulumi.interpolate o pulumi.concat, y luego se usa para crear otro recurso. El gráfico de dependencia entre recursos, creado por los nodos (recursos) y sus bordes (Salida -> Entrada), permite a Pulumi crear recursos en el orden correcto y garantiza que las Salidas se completen cuando sea necesario para el siguiente recurso en el gráfico.

Aporte

Una entrada puede ser un valor bruto, una promesa o una salida. Si una entrada a un recurso es una salida, entonces tiene una referencia al recurso donde se creó originalmente la salida. El hecho de que una entrada pueda ser una salida le permite rastrear sus dependencias.

Aquí está su definición de tipo:

type Input = T | Promise | OutputInstance;

Literales de plantilla etiquetados en 30 segundos

Aquí hay un ejemplo de cómo podríamos poner en mayúsculas solo los valores (los "marcadores de posición" entre ${}), sin alterar la porción de cadena literal del literal de plantilla:

function uppercaseValues(strings, ...values) {
  const result = [];
  strings.forEach((string, i) => {
    result.push(string);
    if (i 




  
  
  Implementando pulumi.interpolate


Sin conocer el código fuente exacto y ampliando el ejemplo anterior, podemos imaginar cómo implementar pulumi.interpolate por nuestra cuenta. Podría verse así:


function interpolate(strings, ...values) {
  const result = [];
  strings.forEach((string, i) => {
    result.push(string);
    if (i 



Todo lo que hicimos fue reemplazar la llamada de unión final con una llamada a pulumi.concat. Si esta fuera la implementación, realizaríamos comprobaciones para determinar si es necesario desencapsular las cadenas sin formato de los tipos de salida, en lugar de operar solo en los marcadores de posición, que es lo que hace la implementación real.

Su definición de función en TypeScript es:


function interpolate(literals: TemplateStringsArray, ...placeholders: Input[]): Output;




que es muy similar a concat:


function concat(...params: Input[]): Output



El momento de la bombilla llega cuando te das cuenta de que en realidad solo estás reenviando los valores de salida y envolviéndolos en las salidas principales.


  
  
  Volver a Python


 Puedes cometer algunos errores tontos al transferir la interpolación a concat. Demostrémoslo con un ejemplo.

En TypeScript, habría hecho esto:


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




Al migrar a Python, podría terminar con esto:


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




Sin embargo, interpolar consistía en iterar sobre cada marcador de posición individualmente para crear dependencias y resolver resultados. Con nuestro código Python, hemos perdido sutilmente esa conexión con el argumento de versión. Necesitamos dividir nuestras Salidas manualmente y mostrarlas como argumentos individuales para pulumi.Output.concat.

El código corregido se vería así:


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




Ahora, la versión se incluirá correctamente en el gráfico de dependencia y ¡estaremos libres de errores!


  
  
  Conclusión


Traducir pulumi.interpolate de TypeScript a Python requiere una comprensión más profunda de cómo funcionan las salidas y entradas en Pulumi. Si bien Python no admite literales de plantilla etiquetados, el uso efectivo de pulumi.concat nos permite lograr una funcionalidad similar. Al administrar manualmente las dependencias y garantizar que todos los valores de salida se manejen correctamente, podemos garantizar que nuestro código Pulumi en Python sea tan sólido y eficiente como en TypeScript.