Pulumi é uma ferramenta poderosa para gerenciar infraestrutura como código, e sua flexibilidade em diferentes linguagens o torna uma escolha popular entre os desenvolvedores. Embora a sintaxe TypeScript do Pulumi ofereça uma maneira limpa e conveniente de lidar com saídas e entradas, traduzir esses recursos para Python pode ser um desafio. Este artigo explora as nuances do uso de pulumi.interpolate em TypeScript e como obter funcionalidade semelhante em Python.

Interpolar Pulumi

Na sintaxe TypeScript do Pulumi, existe uma abordagem limpa para concatenar saídas. Ele aproveita literais de modelo marcados, que não estão disponíveis em Python. De acordo com os documentos de referência do Pulumi, interpolar é semelhante a concat, mas foi projetado para ser usado como uma expressão de modelo marcada. Por exemplo:

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

Assim como acontece com concat, os 'espaços reservados' entre ${} podem ser quaisquer entradas, ou seja, podem ser promessas, saídas ou apenas valores JavaScript simples.

Tendo feito a maior parte do meu trabalho Pulumi em TypeScript, frequentemente usei o literal de modelo marcado com pulumi.interpolate sempre que precisava passar uma entrada para um novo recurso. Sem pensar muito, usei-o extensivamente, sem compará-lo profundamente com pulumi.concat ou apply. No entanto, quando comecei a trabalhar com Pulumi em Python e procurei pulumi.interpolate, percebi que estava faltando.

Isso levou a um mergulho mais profundo na compreensão do que significa ser uma saída versus uma entrada e como traduzir:

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

para:

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

Saída

Saídas são valores de recursos que podem ser preenchidos ou serão resolvidos e preenchidos no futuro. Como uma Saída está associada ao recurso de onde ela vem, uma borda pode ser criada quando ela é passada como uma Entrada para pulumi.interpolate ou pulumi.concat e posteriormente usada para criar outro recurso. O gráfico de dependência entre recursos, criado pelos nós (recursos) e suas bordas (Saída -> Entrada), permite que Pulumi crie recursos na ordem correta e garante que as Saídas sejam preenchidas quando necessário pelo próximo recurso no gráfico.

Entrada

Uma entrada pode ser um valor bruto, uma promessa ou uma saída. Se uma entrada para um recurso for uma saída, você terá uma referência ao recurso onde a saída foi originalmente criada. O fato de uma entrada poder ser uma saída permite rastrear suas dependências.

Aqui está a definição do tipo:

type Input = T | Promise | OutputInstance;

Literais de modelo marcados em 30 segundos

Aqui está um exemplo de como poderíamos colocar apenas os valores em letras maiúsculas (os "espaços reservados" entre ${}), sem alterar a parte da string literal do literal do modelo:

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




  
  
  Implementando pulumi.interpolate


Sem conhecer o código-fonte exato e expandindo a partir do exemplo acima, podemos imaginar como implementar pulumi.interpolate por conta própria. Pode ser algo assim:


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



Tudo o que fizemos foi substituir a chamada de junção final por uma chamada para pulumi.concat. Se esta fosse a implementação, realizaríamos verificações para saber se as strings brutas precisam ser desembrulhadas dos tipos de saída, em vez de operar apenas nos espaços reservados, que é o que a implementação real faz.

Sua definição de função no TypeScript é:


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




que é muito semelhante ao concat:


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



O momento luminoso surge quando você percebe que na verdade está apenas encaminhando valores de saída e agrupando-os em saídas pais.


  
  
  De volta ao Python


Você pode cometer alguns erros bobos ao migrar a interpolação para a concatenação. Vamos demonstrar com um exemplo.

No TypeScript, eu teria feito isso:


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




Ao migrar para Python, posso acabar com isto:


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




No entanto, interpolar estava iterando cada espaço reservado individualmente para criar dependências e resolver resultados. Com nosso código Python, perdemos sutilmente essa conexão com o argumento version. Precisamos dividir nossos Outputs manualmente e exibi-los como argumentos individuais para pulumi.Output.concat.

O código corrigido ficaria assim:


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




Agora, a versão será incluída corretamente no gráfico de dependências e estaremos livres de erros!


  
  
  Conclusão


Traduzir pulumi.interpolate do TypeScript para Python requer uma compreensão mais profunda de como as saídas e entradas funcionam no Pulumi. Embora Python não suporte literais de modelo marcados, usar pulumi.concat efetivamente nos permite obter funcionalidades semelhantes. Gerenciando manualmente as dependências e garantindo que todos os valores de saída sejam tratados adequadamente, podemos garantir que nosso código Pulumi em Python seja tão robusto e eficiente quanto em TypeScript.