@ydkn/pulumi-components 0.8.8 → 0.9.1

package/lib/hcloud/assets/flatcar-install.sh

@@ -3,8 +3,8 @@
 DRIVE="${1}"
 CONFIG="${2}"
 
-apt-get update -y
-apt-get install -y gawk
+apt-get update -qq -y
+apt-get install -qq -y gawk
 
 curl -sf -o /tmp/flatcar-install https://raw.githubusercontent.com/flatcar/init/flatcar-master/bin/flatcar-install
 chmod +x /tmp/flatcar-install

package/lib/hcloud/cluster.d.ts

@@ -4,12 +4,12 @@ import * as k8s from "@pulumi/kubernetes";
 import { ComponentResource } from "../common/index.js";
 import * as node from "../node/index.js";
 import * as k0s from "../k0s/index.js";
-export interface Node extends node.Node, node.IgnitionArgs {
+export interface Node extends node.Node, node.ConfigArgs {
     serverType: pulumi.Input<string>;
     count?: pulumi.Input<number>;
     location?: pulumi.Input<string>;
 }
-export interface ClusterArgs extends k0s.ClusterArgs, node.IgnitionArgs {
+export interface ClusterArgs extends k0s.ClusterArgs, node.ConfigArgs {
     name?: pulumi.Input<string>;
     token: pulumi.Input<string>;
     location: pulumi.Input<string>;
@@ -30,6 +30,8 @@ export declare class Cluster extends ComponentResource {
     private static readonly dnsServers;
     private static readonly gatewayIPv6;
     private static readonly ignitionConfigPathRemote;
+    private static readonly cloudInitMetaDataPathRemote;
+    private static readonly cloudInitUserDataPathRemote;
     private static readonly installScriptPathRemote;
     private readonly sshKey;
     private readonly network;
@@ -58,8 +60,13 @@ export declare class Cluster extends ComponentResource {
      */
     constructor(name: string, args: ClusterArgs, opts?: pulumi.ComponentResourceOptions);
     private createServers;
+    private mergeNodeArgs;
+    private networkManagerConfigFiles;
+    private networkdConfigFiles;
+    private interfacesConfigFiles;
     private configureFcosNode;
     private configureFlatcarNode;
+    private configureAlpineNode;
     private fileAssetFromString;
     private static ethernetInterfaceName;
 }

package/lib/hcloud/cluster.js

@@ -11,6 +11,7 @@ import * as crypto from "crypto";
 import { ComponentResource } from "../common/index.js";
 import * as fcos from "../fcos/index.js";
 import * as flatcar from "../flatcar/index.js";
+import * as alpine from "../alpine/index.js";
 import * as k0s from "../k0s/index.js";
 import { Kubernetes } from "./kubernetes.js";
 export class Cluster extends ComponentResource {
@@ -27,10 +28,15 @@ export class Cluster extends ComponentResource {
         flatcar: {
             DEFAULT: { primary: "eth0", private: [1, 2].map((i) => `eth${i}`) },
         },
+        alpine: {
+            DEFAULT: { primary: "eth0", private: [1, 2].map((i) => `eth${i}`) },
+        },
     };
-    static dnsServers = ["2a01:4ff:ff00::add:1", "2a01:4ff:ff00::add:2"];
+    static dnsServers = ["185.12.64.1", "185.12.64.2"]; // ["2a01:4ff:ff00::add:1", "2a01:4ff:ff00::add:2"];
     static gatewayIPv6 = "fe80::1";
     static ignitionConfigPathRemote = "/tmp/config.ign";
+    static cloudInitMetaDataPathRemote = "/tmp/meta-data";
+    static cloudInitUserDataPathRemote = "/tmp/user-data";
     static installScriptPathRemote = "/tmp/install.sh";
     sshKey;
     network;
@@ -83,7 +89,7 @@ export class Cluster extends ComponentResource {
             .apply(([result]) => {
             return result.images.filter((image) => image.osFlavor === "ubuntu").sort((a, b) => (a > b ? -1 : 1))[0].name;
         });
-        const servers = this.createServers(args.nodes, serverImage, this.sshKey, this.sshPrivateKey.privateKeyOpenssh, this.nodeSubnet, this.placementGroup, args.files, args.links, args.systemdUnits, args.sshAuthorizedKeys, args.protect);
+        const servers = this.createServers(args.nodes, serverImage, this.sshKey, this.sshPrivateKey.privateKeyOpenssh, this.nodeSubnet, this.placementGroup, args.packages, args.filesystems, args.users, args.files, args.run, args.sshAuthorizedKeys, args.protect);
         this.nodes = servers.apply((servers) => servers.map((s) => s.node));
         const nodeIPs = pulumi.all([this.nodes]).apply(([nodes]) => pulumi.all(nodes).apply((nodes) => {
             const nodeIPs = [];
@@ -186,7 +192,7 @@ export class Cluster extends ComponentResource {
         }, { ...emptyOpts, providers: [this.provider] });
         this.registerOutputs();
     }
-    createServers(nodes, image, sshKey, sshPrivateKey, subnet, placementGroup, files, links, systemdUnits, sshAuthorizedKeys, protect) {
+    createServers(nodes, image, sshKey, sshPrivateKey, subnet, placementGroup, packages, filesystems, users, files, run, sshAuthorizedKeys, protect) {
         const emptyOpts = this.opts();
         const hcloudOpts = this.opts(hcloud.Provider);
         return pulumi.all([nodes]).apply(([nodes]) => {
@@ -232,113 +238,21 @@ export class Cluster extends ComponentResource {
                         }, { ...hcloudOpts, protect }));
                     }
                     const serverNetwork = pulumi.all([server.id, server.name]).apply(([serverId, serverName]) => {
-                        return new hcloud.ServerNetwork(serverName, { serverId: parseInt(serverId), subnetId: subnet.id }, hcloudOpts);
+                        return new hcloud.ServerNetwork(serverName, { serverId: parseInt(serverId), subnetId: subnet.id }, { ...hcloudOpts, dependsOn: [server] });
                     });
                     const node = pulumi
-                        .all([hostname, files, links, systemdUnits, sshAuthorizedKeys, server.ipv6Address, server.serverType])
-                        .apply(([hostname, files, links, systemdUnits, sshAuthorizedKeys, ipv6Address, serverType]) => {
-                        const ethernetInterfaces = Cluster.ethernetInterfaceName(nodeGroup.operatingSystem, serverType);
+                        .all([hostname, filesystems, files, server])
+                        .apply(([hostname, filesystems, files, server]) => {
                         let host;
                         switch (nodeGroup.operatingSystem) {
                             case "fcos":
-                                host = new fcos.Host(hostname, {
-                                    hostname,
-                                    filesystems: dataVolume !== undefined
-                                        ? [
-                                            {
-                                                device: pulumi.interpolate `/dev/disk/by-id/scsi-0HC_Volume_${dataVolume.id}`,
-                                                path: "/var/lib/k0s",
-                                                format: dataVolume.format.apply((format) => format ?? "ext4"),
-                                            },
-                                        ]
-                                        : [],
-                                    files: pulumi.all(files ?? []).apply((files) => {
-                                        files.push({
-                                            path: `/etc/NetworkManager/system-connections/${ethernetInterfaces.primary}.nmconnection`,
-                                            contents: [
-                                                "[connection]",
-                                                "type=ethernet",
-                                                `id=${ethernetInterfaces.primary}`,
-                                                `interface-name=${ethernetInterfaces.primary}`,
-                                                "[ipv4]",
-                                                "method=auto",
-                                                "ignore-auto-dns=true",
-                                                "[ipv6]",
-                                                "method=manual",
-                                                `address1=${ipv6Address}`,
-                                                `gateway=${Cluster.gatewayIPv6}`,
-                                                `dns=${Cluster.dnsServers.join(";")}`,
-                                            ].join("\n"),
-                                            mode: 0o600,
-                                        });
-                                        for (const iface of ethernetInterfaces.private) {
-                                            files.push({
-                                                path: `/etc/NetworkManager/system-connections/${iface}.nmconnection`,
-                                                contents: [
-                                                    "[connection]",
-                                                    "type=ethernet",
-                                                    `id=${iface}`,
-                                                    `interface-name=${iface}`,
-                                                    "[ipv4]",
-                                                    "method=auto",
-                                                    "never-default=true",
-                                                    "[ipv6]",
-                                                    "method=auto",
-                                                    "never-default=true",
-                                                ].join("\n"),
-                                                mode: 0o600,
-                                            });
-                                        }
-                                        return files;
-                                    }),
-                                    links,
-                                    systemdUnits,
-                                    users: [{ name: "core", sshAuthorizedKeys }],
-                                    sshUsers: [{ name: Cluster.sshUsername, groups: ["sudo"] }],
-                                }, emptyOpts);
+                                host = new fcos.Host(hostname, this.mergeNodeArgs(nodeGroup, hostname, dataVolume, packages, filesystems, users, files, run, sshAuthorizedKeys, this.networkManagerConfigFiles(nodeGroup, server)), emptyOpts);
                                 break;
                             case "flatcar":
-                                host = new flatcar.Host(hostname, {
-                                    hostname,
-                                    filesystems: dataVolume !== undefined
-                                        ? [
-                                            {
-                                                device: pulumi.interpolate `/dev/disk/by-id/scsi-0HC_Volume_${dataVolume.id}`,
-                                                path: "/var/lib/k0s",
-                                                format: dataVolume.format.apply((format) => format ?? "ext4"),
-                                            },
-                                        ]
-                                        : [],
-                                    files: pulumi.all(files ?? []).apply((files) => {
-                                        files.push({
-                                            path: `/etc/systemd/network/10-${ethernetInterfaces.primary}.network`,
-                                            contents: [
-                                                "[Match]",
-                                                `Name=${ethernetInterfaces.primary}`,
-                                                "[Link]",
-                                                "RequiredForOnline=routable",
-                                                "[Network]",
-                                                "DHCP=yes",
-                                                `Address=${ipv6Address}/64`,
-                                                `Gateway=${Cluster.gatewayIPv6}`,
-                                                ...Cluster.dnsServers.map((dns) => `DNS=${dns}`),
-                                            ].join("\n"),
-                                            mode: 0o644,
-                                        });
-                                        for (const iface of ethernetInterfaces.private) {
-                                            files.push({
-                                                path: `/etc/systemd/network/10-${iface}.network`,
-                                                contents: ["[Match]", `Name=${iface}`, "[Network]", "DHCP=yes", "IPv6AcceptRA=true"].join("\n"),
-                                                mode: 0o644,
-                                            });
-                                        }
-                                        return files;
-                                    }),
-                                    links,
-                                    systemdUnits,
-                                    users: [{ name: "core", sshAuthorizedKeys }],
-                                    sshUsers: [{ name: Cluster.sshUsername, groups: ["sudo"] }],
-                                }, emptyOpts);
+                                host = new flatcar.Host(hostname, this.mergeNodeArgs(nodeGroup, hostname, dataVolume, packages, filesystems, users, files, run, sshAuthorizedKeys, this.networkdConfigFiles(nodeGroup, server)), emptyOpts);
+                                break;
+                            case "alpine":
+                                host = new alpine.Host(hostname, this.mergeNodeArgs(nodeGroup, hostname, dataVolume, packages, filesystems, users, files, run, sshAuthorizedKeys, this.interfacesConfigFiles(nodeGroup, server)), emptyOpts);
                                 break;
                             default:
                                 throw new Error(`Unsupported operating system ${nodeGroup.operatingSystem}`);
@@ -353,17 +267,9 @@ export class Cluster extends ComponentResource {
                             labels: nodeGroup.labels ?? {},
                             taints: nodeGroup.taints ?? [],
                             username: Cluster.sshUsername,
-                            privateKey: host.sshPrivateKeys.apply((sshPrivateKeys) => {
-                                for (const username in sshPrivateKeys) {
-                                    if (username === Cluster.sshUsername) {
-                                        // eslint-disable-next-line security/detect-object-injection
-                                        return sshPrivateKeys[username].privateKeyOpenssh;
-                                    }
-                                }
-                                throw new Error(`No private key found for user ${Cluster.sshUsername}`);
-                            }),
+                            privateKey: host.deployPrivateKey.privateKeyOpenssh,
                             operatingSystem: nodeGroup.operatingSystem,
-                            ignitionConfig: host.ignitionConfig,
+                            initConfig: host.initConfig,
                             disabled: nodeGroup.disabled ?? false,
                         };
                     });
@@ -375,7 +281,10 @@ export class Cluster extends ComponentResource {
                                     return this.configureFcosNode(sshPrivateKey, server, node);
                                 case "flatcar":
                                     return this.configureFlatcarNode(sshPrivateKey, server, node);
+                                case "alpine":
+                                    return this.configureAlpineNode(sshPrivateKey, server, node);
                                 default:
+                                    //eslint-disable-next-line @typescript-eslint/restrict-template-expressions
                                     throw new Error(`Unsupported operating system ${os}`);
                             }
                         }),
@@ -385,6 +294,180 @@ export class Cluster extends ComponentResource {
             return results;
         });
     }
+    mergeNodeArgs(serverNode, hostname, dataVolume, packages, filesystems, users, files, run, sshAuthorizedKeys, additionalFiles) {
+        return {
+            hostname: pulumi.output(hostname),
+            packages: pulumi
+                .all([serverNode])
+                .apply(([serverNode]) => pulumi
+                .all([packages])
+                .apply(([packages]) => pulumi
+                .all(packages ?? [])
+                .apply((packages) => pulumi.all(serverNode.packages ?? []).apply((nodePackages) => packages.concat(nodePackages))))),
+            filesystems: pulumi.all([serverNode]).apply(([serverNode]) => pulumi.all([filesystems]).apply(([filesystems]) => pulumi.all(filesystems ?? []).apply((filesystems) => pulumi.all(serverNode.filesystems ?? []).apply((nodeFilesystems) => pulumi.all([dataVolume]).apply(([dataVolume]) => pulumi
+                .all([dataVolume ? dataVolume.id : undefined, dataVolume ? dataVolume.format : undefined])
+                .apply(([dataVolumeId, dataVolumeFormat]) => (dataVolumeId !== undefined && dataVolumeFormat !== undefined
+                ? [
+                    {
+                        device: `/dev/disk/by-id/scsi-0HC_Volume_${dataVolumeId}`,
+                        path: "/var/lib/k0s",
+                        format: dataVolumeFormat ?? "ext4",
+                    },
+                ]
+                : [])
+                .concat(filesystems)
+                .concat(nodeFilesystems))))))),
+            users: pulumi.all([serverNode]).apply(([serverNode]) => pulumi.all([users]).apply(([users]) => pulumi.all(users ?? []).apply((users) => pulumi.all(serverNode.users ?? []).apply((nodeUsers) => {
+                const allUsers = [];
+                for (const user of users ?? []) {
+                    for (const [i, u] of (allUsers ?? []).entries()) {
+                        if (user.name === u.name) {
+                            allUsers[i] = { ...u, ...user }; // eslint-disable-line security/detect-object-injection
+                            break;
+                        }
+                    }
+                }
+                for (const user of nodeUsers ?? []) {
+                    for (const [i, u] of (allUsers ?? []).entries()) {
+                        if (user.name === u.name) {
+                            allUsers[i] = { ...u, ...user }; // eslint-disable-line security/detect-object-injection
+                            break;
+                        }
+                    }
+                }
+                return allUsers;
+            })))),
+            files: pulumi.all([serverNode, hostname]).apply(([serverNode, hostname]) => pulumi.all([files]).apply(([files]) => pulumi.all(files ?? []).apply((files) => pulumi.all([additionalFiles]).apply(([additionalFiles]) => pulumi.all(additionalFiles ?? []).apply((additionalFiles) => pulumi.all(serverNode.files ?? []).apply((nodeFiles) => files
+                .concat(additionalFiles)
+                .concat(nodeFiles)
+                .concat([
+                {
+                    path: "/var/lib/calico/nodename",
+                    user: "root",
+                    group: "root",
+                    mode: 0o644,
+                    contents: hostname,
+                },
+            ]))))))),
+            run: pulumi
+                .all([serverNode])
+                .apply(([serverNode]) => pulumi
+                .all([run])
+                .apply(([run]) => pulumi
+                .all(run ?? [])
+                .apply((run) => pulumi.all(serverNode.run ?? []).apply((nodeRun) => run.concat(nodeRun))))),
+            sshAuthorizedKeys,
+        };
+    }
+    networkManagerConfigFiles(nodeGroup, server) {
+        return pulumi
+            .all([nodeGroup.operatingSystem, server.serverType, server.ipv6Address])
+            .apply(([os, serverType, ipv6Address]) => {
+            const configs = [];
+            const ethernetInterfaces = Cluster.ethernetInterfaceName(os, serverType);
+            configs.push({
+                path: `/etc/NetworkManager/system-connections/${ethernetInterfaces.primary}.nmconnection`,
+                contents: [
+                    "[connection]",
+                    "type=ethernet",
+                    `id=${ethernetInterfaces.primary}`,
+                    `interface-name=${ethernetInterfaces.primary}`,
+                    "[ipv4]",
+                    "method=auto",
+                    "ignore-auto-dns=true",
+                    "[ipv6]",
+                    "method=manual",
+                    `address1=${ipv6Address}`,
+                    `gateway=${Cluster.gatewayIPv6}`,
+                    `dns=${Cluster.dnsServers.join(";")}`,
+                ].join("\n"),
+                mode: 0o600,
+            });
+            for (const iface of ethernetInterfaces.private) {
+                configs.push({
+                    path: `/etc/NetworkManager/system-connections/${iface}.nmconnection`,
+                    contents: [
+                        "[connection]",
+                        "type=ethernet",
+                        `id=${iface}`,
+                        `interface-name=${iface}`,
+                        "[ipv4]",
+                        "method=auto",
+                        "never-default=true",
+                        "[ipv6]",
+                        "method=auto",
+                        "never-default=true",
+                    ].join("\n"),
+                    mode: 0o600,
+                });
+            }
+            return configs;
+        });
+    }
+    networkdConfigFiles(nodeGroup, server) {
+        return pulumi
+            .all([nodeGroup.operatingSystem, server.serverType, server.ipv6Address])
+            .apply(([os, serverType, ipv6Address]) => {
+            const configs = [];
+            const ethernetInterfaces = Cluster.ethernetInterfaceName(os, serverType);
+            configs.push({
+                path: `/etc/systemd/network/10-${ethernetInterfaces.primary}.network`,
+                contents: [
+                    "[Match]",
+                    `Name=${ethernetInterfaces.primary}`,
+                    "[Link]",
+                    "RequiredForOnline=routable",
+                    "[Network]",
+                    "DHCP=yes",
+                    `Address=${ipv6Address}/64`,
+                    `Gateway=${Cluster.gatewayIPv6}`,
+                    ...Cluster.dnsServers.map((dns) => `DNS=${dns}`),
+                ].join("\n"),
+                mode: 0o644,
+            });
+            for (const iface of ethernetInterfaces.private) {
+                configs.push({
+                    path: `/etc/systemd/network/10-${iface}.network`,
+                    contents: ["[Match]", `Name=${iface}`, "[Network]", "DHCP=yes", "IPv6AcceptRA=true"].join("\n"),
+                    mode: 0o644,
+                });
+            }
+            return configs;
+        });
+    }
+    interfacesConfigFiles(nodeGroup, server) {
+        return pulumi
+            .all([nodeGroup.operatingSystem, server.name, server.serverType, server.ipv6Address])
+            .apply(([os, name, serverType, ipv6Address]) => {
+            const ethernetInterfaces = Cluster.ethernetInterfaceName(os, serverType);
+            return [
+                {
+                    path: "/etc/network/interfaces",
+                    contents: [
+                        "auto lo",
+                        "iface lo inet loopback",
+                        "",
+                        `auto ${ethernetInterfaces.primary}`,
+                        `iface ${ethernetInterfaces.primary} inet dhcp`,
+                        "",
+                        `iface ${ethernetInterfaces.primary} inet6 static`,
+                        `address ${ipv6Address}`,
+                        "netmask 64",
+                        `gateway ${Cluster.gatewayIPv6}`,
+                        `post-up sh -c "echo -n '' > /etc/resolv.conf"`,
+                        ...Cluster.dnsServers.map((dns) => `post-up sh -c "echo 'nameserver ${dns}' >> /etc/resolv.conf"`),
+                        ...(ethernetInterfaces.private ?? []).map((iface) => [
+                            "",
+                            `auto ${iface}`,
+                            `iface ${iface} inet manual`,
+                            `post-up /sbin/udhcpc -b -R -p /var/run/udhcpc.${iface}.pid -o -O 1 -i ${iface} -x hostname:${name}`,
+                        ].join("\n")),
+                    ].join("\n"),
+                    mode: 0o644,
+                },
+            ];
+        });
+    }
     configureFcosNode(sshPrivateKey, server, node) {
         const emptyOpts = this.opts();
         return pulumi.all([server.name, server.ipv4Address, node]).apply(([nodeName, ipv4Address, node]) => {
@@ -402,7 +485,8 @@ export class Cluster extends ComponentResource {
             }, { ...emptyOpts, dependsOn: server, ignoreChanges: ["connection", "source", "remotePath"] });
             const fcosConfigFile = new command.remote.CopyToRemote(`${nodeName}-fcos-config`, {
                 connection,
-                source: this.fileAssetFromString(node.ignitionConfig),
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                source: this.fileAssetFromString(node.initConfig),
                 remotePath: Cluster.ignitionConfigPathRemote,
             }, { ...emptyOpts, dependsOn: server, ignoreChanges: ["connection", "source", "remotePath"] });
             const fcosInstall = new command.remote.Command(`${nodeName}-fcos-install`, {
@@ -411,6 +495,7 @@ export class Cluster extends ComponentResource {
                     `chmod +x ${Cluster.installScriptPathRemote}`,
                     `${Cluster.installScriptPathRemote} /dev/sda ${Cluster.ignitionConfigPathRemote}`,
                 ].join(" && "),
+                addPreviousOutputInEnv: false,
             }, { ...emptyOpts, dependsOn: [fcosInstallScript, fcosConfigFile], ignoreChanges: ["connection", "create"] });
             return new command.remote.Command(`${nodeName}-fcos-up`, {
                 connection: {
@@ -420,7 +505,8 @@ export class Cluster extends ComponentResource {
                     perDialTimeout: 10,
                     dialErrorLimit: 30,
                 },
-                create: "echo up",
+                create: "until test -f /tmp/install-ready; do echo 'Waiting for install to finish...'; sleep 2; done",
+                addPreviousOutputInEnv: false,
             }, { ...emptyOpts, dependsOn: fcosInstall, ignoreChanges: ["connection", "create"] });
         });
     }
@@ -441,7 +527,8 @@ export class Cluster extends ComponentResource {
             }, { ...emptyOpts, dependsOn: server, ignoreChanges: ["connection", "source", "remotePath"] });
             const flatcarConfigFile = new command.remote.CopyToRemote(`${nodeName}-flatcar-config`, {
                 connection,
-                source: this.fileAssetFromString(node.ignitionConfig),
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                source: this.fileAssetFromString(node.initConfig),
                 remotePath: Cluster.ignitionConfigPathRemote,
             }, { ...emptyOpts, dependsOn: server, ignoreChanges: ["connection", "source", "remotePath"] });
             const flatcarInstall = new command.remote.Command(`${nodeName}-flatcar-install`, {
@@ -450,6 +537,7 @@ export class Cluster extends ComponentResource {
                     `chmod +x ${Cluster.installScriptPathRemote}`,
                     `${Cluster.installScriptPathRemote} /dev/sda ${Cluster.ignitionConfigPathRemote}`,
                 ].join(" && "),
+                addPreviousOutputInEnv: false,
             }, { ...emptyOpts, dependsOn: [flatcarInstallScript, flatcarConfigFile], ignoreChanges: ["connection", "create"] });
             return new command.remote.Command(`${nodeName}-flatcar-up`, {
                 connection: {
@@ -459,10 +547,68 @@ export class Cluster extends ComponentResource {
                     perDialTimeout: 10,
                     dialErrorLimit: 30,
                 },
-                create: "echo up",
+                create: "until test -f /tmp/install-ready; do echo 'Waiting for install to finish...'; sleep 2; done",
+                addPreviousOutputInEnv: false,
             }, { ...emptyOpts, dependsOn: flatcarInstall, ignoreChanges: ["connection", "create"] });
         });
     }
+    configureAlpineNode(sshPrivateKey, server, node) {
+        const emptyOpts = this.opts();
+        return pulumi.all([server.name, server.ipv4Address, node]).apply(([nodeName, ipv4Address, node]) => {
+            const connection = {
+                host: ipv4Address,
+                privateKey: sshPrivateKey,
+                user: Cluster.rescueSshUsername,
+                perDialTimeout: 10,
+                dialErrorLimit: 30,
+            };
+            const installScript = new command.remote.CopyToRemote(`${nodeName}-alpine-install-script`, {
+                connection,
+                source: new pulumi.asset.FileAsset(path.join(path.dirname(url.fileURLToPath(import.meta.url)), "assets", "alpine-install.sh")),
+                remotePath: Cluster.installScriptPathRemote,
+            }, { ...emptyOpts, dependsOn: server, ignoreChanges: ["connection", "source", "remotePath"] });
+            const metaDataFile = new command.remote.CopyToRemote(`${nodeName}-alpine-meta-data`, {
+                connection,
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-member-access
+                source: this.fileAssetFromString(node.initConfig.metaData),
+                remotePath: Cluster.cloudInitMetaDataPathRemote,
+            }, { ...emptyOpts, dependsOn: server, ignoreChanges: ["connection", "source", "remotePath"] });
+            const userDataFile = new command.remote.CopyToRemote(`${nodeName}-alpine-user-data`, {
+                connection,
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-member-access
+                source: this.fileAssetFromString(node.initConfig.userData),
+                remotePath: Cluster.cloudInitUserDataPathRemote,
+            }, { ...emptyOpts, dependsOn: server, ignoreChanges: ["connection", "source", "remotePath"] });
+            const installCommand = new command.remote.Command(`${nodeName}-alpine-install`, {
+                connection,
+                create: [
+                    `chmod +x ${Cluster.installScriptPathRemote}`,
+                    [
+                        Cluster.installScriptPathRemote,
+                        "/dev/sda",
+                        Cluster.cloudInitMetaDataPathRemote,
+                        Cluster.cloudInitUserDataPathRemote,
+                    ].join(" "),
+                ].join(" && "),
+                addPreviousOutputInEnv: false,
+            }, {
+                ...emptyOpts,
+                dependsOn: [installScript, metaDataFile, userDataFile],
+                ignoreChanges: ["connection", "create"],
+            });
+            return new command.remote.Command(`${nodeName}-alpine-up`, {
+                connection: {
+                    host: ipv4Address,
+                    privateKey: node.privateKey,
+                    user: Cluster.sshUsername,
+                    perDialTimeout: 10,
+                    dialErrorLimit: 30,
+                },
+                create: "until test -f /tmp/install-ready; do echo 'Waiting for install to finish...'; sleep 2; done",
+                addPreviousOutputInEnv: false,
+            }, { ...emptyOpts, dependsOn: installCommand, ignoreChanges: ["connection", "create"] });
+        });
+    }
     fileAssetFromString(content) {
         return pulumi.all([content]).apply(([content]) => {
             const filename = `/tmp/${crypto.createHash("sha1").update(content).digest("hex")}`;
@@ -495,6 +641,16 @@ export class Cluster extends ComponentResource {
                     }
                 }
                 return { primary: primaryInterface, private: privateInterfaces };
+            case "alpine":
+                primaryInterface = Cluster.interfacesMap.alpine.DEFAULT.primary;
+                privateInterfaces = Cluster.interfacesMap.alpine.DEFAULT.private;
+                for (const [pattern, iface] of Object.entries(Cluster.interfacesMap.alpine)) {
+                    if (RegExp(pattern).exec(serverType)) {
+                        primaryInterface = iface.primary;
+                        privateInterfaces = iface.private;
+                    }
+                }
+                return { primary: primaryInterface, private: privateInterfaces };
             default:
                 throw new Error(`Unsupported operating system ${os}`);
         }