Pulumi dalam Python: Menterjemah Interpolasi

Pulumi ialah alat yang berkuasa untuk mengurus infrastruktur sebagai kod, dan fleksibilitinya merentas pelbagai bahasa menjadikannya pilihan popular di kalangan pembangun. Walaupun sintaks TypeScript Pulumi menawarkan cara yang bersih dan mudah untuk mengendalikan Output dan Input, menterjemah ciri ini kepada Python boleh menjadi mencabar. Artikel ini meneroka nuansa penggunaan pulumi.interpolate dalam TypeScript dan cara mencapai kefungsian serupa dalam Python.

Pulumi Interpolate

Dalam sintaks TypeScript Pulumi, terdapat pendekatan yang bersih untuk menggabungkan Output. Ia memanfaatkan literal templat bertag, yang tidak tersedia dalam Python. Seperti dalam dokumen rujukan Pulumi, interpolate adalah serupa dengan concat tetapi direka bentuk untuk digunakan sebagai ungkapan templat berteg. Contohnya:

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

Seperti concat, 'pemegang tempat' antara ${} boleh menjadi sebarang Input, iaitu, ia boleh menjadi Janji, Output atau hanya nilai JavaScript biasa.

Setelah melakukan kebanyakan kerja Pulumi saya dalam TypeScript, saya kerap menggunakan templat berteg pulumi.interpolate literal apabila saya perlu menghantar Input ke sumber baharu. Tanpa memikirkannya, saya menggunakannya secara meluas tanpa membandingkannya dengan pulumi.concat atau memohon. Walau bagaimanapun, apabila saya mula bekerja dengan Pulumi dalam Python dan mencapai pulumi.interpolate, saya menyedari ia hilang.

Ini mendorong pemahaman yang lebih mendalam untuk memahami maksud menjadi Output vs. Input dan cara menterjemah:

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

kepada:

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

Keluaran

Output ialah nilai daripada sumber yang mungkin diisi atau akan diselesaikan dan diisi pada masa hadapan. Oleh kerana Output dikaitkan dengan sumber ia berasal, kelebihan boleh dibuat apabila ia dihantar sebagai Input kepada pulumi.interpolate atau pulumi.concat, dan kemudiannya digunakan untuk mencipta sumber lain. Graf pergantungan antara sumber, yang dicipta oleh nod (sumber) dan tepinya (Output -> Input), membolehkan Pulumi mencipta sumber dalam susunan yang betul dan memastikan Output diisi apabila diperlukan oleh sumber seterusnya dalam graf.

Input

Input boleh menjadi nilai mentah, janji atau Output. Jika Input kepada sumber ialah Output, maka anda mempunyai rujukan kepada sumber di mana Output dicipta pada asalnya. Hakikat bahawa Input boleh menjadi Output membolehkannya mengesan kebergantungannya.

Berikut ialah definisi jenisnya:

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

Huruf Templat Tagged dalam 30 Saat

Berikut ialah contoh cara kita boleh menggunakan huruf besar hanya nilai ("pemegang tempat" antara ${}), tanpa mengubah bahagian rentetan literal templat literal:

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

Melaksana pulumi.interpolate

Tanpa mengetahui kod sumber yang tepat, dan mengembangkan daripada contoh di atas, kita boleh membayangkan bagaimana untuk melaksanakan pulumi.interpolate sendiri. Ia mungkin kelihatan seperti ini:

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

Apa yang kami lakukan ialah menggantikan panggilan gabungan terakhir dengan panggilan ke pulumi.concat. Jika ini adalah pelaksanaannya, kami akan melakukan semakan sama ada rentetan mentah perlu dibuka daripada jenis Output, dan bukannya beroperasi hanya pada ruang letak, iaitu apa yang dilakukan oleh pelaksanaan sebenar.

Takrifan fungsinya dalam TypeScript ialah:

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

yang hampir sama dengan concat:

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

Detik mentol datang apabila anda menyedari bahawa anda benar-benar hanya memajukan nilai Output dan membungkusnya dalam Output induk.

Kembali ke Python

Anda boleh membuat beberapa kesilapan bodoh apabila mengalihkan interpolate ke concat. Mari kita tunjukkan dengan contoh.

Dalam TypeScript, saya akan melakukan ini:

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

Apabila mengalihkan ke Python, saya mungkin akan mengalami ini:

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

Walau bagaimanapun, interpolasi telah berulang ke atas setiap pemegang tempat secara individu untuk mencipta kebergantungan dan menyelesaikan output. Dengan kod Python kami, kami secara halus telah kehilangan hubungan itu dengan hujah versi. Kita perlu memecahkan Output kita secara manual dan memaparkannya sebagai hujah individu kepada pulumi.Output.concat.

Kod yang diperbetulkan akan kelihatan seperti ini:

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

Kini, versi akan dimasukkan dengan betul dalam graf pergantungan dan kami akan bebas daripada ralat!

Kesimpulan

Menterjemah pulumi.interpolate daripada TypeScript kepada Python memerlukan pemahaman yang lebih mendalam tentang cara Output dan Input berfungsi dalam Pulumi. Walaupun Python tidak menyokong literal templat berteg, menggunakan pulumi.concat dengan berkesan membolehkan kami mencapai fungsi yang serupa. Dengan mengurus kebergantungan secara manual dan memastikan semua nilai Output dikendalikan dengan betul, kami boleh memastikan kod Pulumi kami dalam Python sama teguh dan cekap seperti dalam TypeScript.

Atas ialah kandungan terperinci Pulumi dalam Python: Menterjemah Interpolasi. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!