@ydkn/pulumi-components 0.4.2 → 0.4.4

package/lib/raspberrypi/cluster.ts

@@ -0,0 +1,279 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as random from "@pulumi/random";
+import * as k8s from "@pulumi/kubernetes";
+import { ComponentResource } from "../common";
+import * as node from "../node";
+import * as fcos from "../fcos";
+import * as k0s from "../k0s";
+
+interface InputNodeVLANs {
+  id: pulumi.Input<number>;
+  interface?: pulumi.Input<string>;
+  ipv4Address?: pulumi.Input<string>;
+  ipv6Address?: pulumi.Input<string>;
+}
+
+interface InputNode extends node.Node, fcos.IgnitionArgs {
+  vlans?: pulumi.Input<pulumi.Input<InputNodeVLANs>[]>;
+  disabled?: pulumi.Input<boolean>;
+}
+
+export interface ClusterArgs extends k0s.ClusterArgs, fcos.IgnitionArgs {
+  name?: pulumi.Input<string>;
+  nodes: pulumi.Input<pulumi.Input<InputNode>[]>;
+  sshAuthorizedKeys?: pulumi.Input<pulumi.Input<string>[]>;
+}
+
+export class Cluster extends ComponentResource {
+  private static readonly sshUsername = "pulumi";
+  private static readonly ethernetInterfaceName = "eth0";
+
+  public readonly name: pulumi.Output<string>;
+  public readonly nodes: pulumi.Output<pulumi.Output<node.Node>[]>;
+  public readonly kubeconfig: pulumi.Output<string>;
+  public readonly provider: k8s.Provider;
+  public readonly kubeletDirPath: pulumi.Output<string>;
+
+  /**
+   * Create a new RaspberryPi cluster resource.
+   * @param name The name of RaspberryPi cluster resource.
+   * @param args A bag of arguments to control the RaspberryPi cluster creation.
+   * @param opts A bag of options that control this resource's behavior.
+   */
+  constructor(name: string, args: ClusterArgs, opts?: pulumi.ComponentResourceOptions) {
+    super("raspberrypi:cluster", name, args, opts);
+
+    const emptyOpts = this.opts();
+
+    if (args.name === undefined) {
+      this.name = new random.RandomId(name, { byteLength: 3 }, { ...emptyOpts, protect: args.protect }).hex;
+    } else {
+      this.name = pulumi.output(args.name);
+    }
+
+    const servers = this.createServers(
+      args.nodes,
+      args.modules,
+      args.packages,
+      args.disks,
+      args.filesystems,
+      args.files,
+      args.systemdUnits,
+      args.sshAuthorizedKeys
+    );
+
+    this.nodes = servers.apply((servers) => servers.map((s) => s.node));
+
+    const k0sCluster = servers.apply((servers) =>
+      pulumi.all(servers.map((s) => s.depends)).apply((dependsOn) => {
+        return new k0s.Cluster(
+          name,
+          {
+            name: this.name,
+            nodes: pulumi.all(servers.map((s) => s.node)).apply((nodes) => nodes.filter((n) => n.disabled !== true)),
+            k0s: args.k0s,
+            hooks: args.hooks,
+            cloudProvider: false,
+            protect: args.protect,
+          },
+          emptyOpts
+        );
+      })
+    );
+
+    this.kubeletDirPath = k0sCluster.kubeletDirPath;
+    this.kubeconfig = k0sCluster.kubeconfig;
+    this.provider = new k8s.Provider(
+      `${name}-k8s`,
+      { kubeconfig: this.kubeconfig, suppressHelmHookWarnings: true },
+      emptyOpts
+    );
+
+    this.registerOutputs();
+  }
+
+  private createServers(
+    nodes: pulumi.Input<pulumi.Input<InputNode>[]>,
+    modules?: pulumi.Input<pulumi.Input<string>[]>,
+    packages?: pulumi.Input<pulumi.Input<string>[]>,
+    disks?: pulumi.Input<pulumi.Input<fcos.DiskArgs>[]>,
+    filesystems?: pulumi.Input<pulumi.Input<fcos.FilesystemArgs>[]>,
+    files?: pulumi.Input<pulumi.Input<fcos.FilesArgs>[]>,
+    systemdUnits?: pulumi.Input<pulumi.Input<fcos.SystemdUnitArgs>[]>,
+    sshAuthorizedKeys?: pulumi.Input<pulumi.Input<string>[]>
+  ): pulumi.Output<{ node: pulumi.Output<InputNode>; depends?: pulumi.Output<pulumi.Resource> }[]> {
+    const emptyOpts = this.opts();
+
+    return pulumi.all([nodes]).apply(([nodes]) => {
+      const results: { node: pulumi.Output<InputNode>; depends?: pulumi.Output<pulumi.Resource> }[] = [];
+
+      for (let i = 0; i < nodes.length; i++) {
+        // eslint-disable-next-line security/detect-object-injection
+        const node = nodes[i];
+
+        const nodeId = new random.RandomId(`node-${i}`, { byteLength: 3 }, emptyOpts).hex;
+        const hostname = pulumi.interpolate`${this.name}-${k0s.Cluster.rolesHostname(node.roles)}-${nodeId}`;
+
+        const host = pulumi
+          .all([hostname, modules, packages, files, disks, filesystems, systemdUnits, sshAuthorizedKeys])
+          .apply(([hostname, modules, packages, files, disks, filesystems, systemdUnits, sshAuthorizedKeys]) => {
+            const fcosHost = new fcos.Host(
+              hostname,
+              {
+                hostname,
+                disks: pulumi
+                  .all(disks || [])
+                  .apply((disks) => pulumi.all(node.disks || []).apply((nodeDisks) => disks.concat(nodeDisks))),
+                filesystems: pulumi
+                  .all(filesystems || [])
+                  .apply((filesystems) =>
+                    pulumi.all(node.filesystems || []).apply((nodeFilesystems) => filesystems.concat(nodeFilesystems))
+                  ),
+                files: pulumi
+                  .all(files || [])
+                  .apply((files) =>
+                    pulumi
+                      .all(node.files || [])
+                      .apply((nodeFiles) =>
+                        pulumi
+                          .all([this.networkManagerConfigFiles(node)])
+                          .apply(([networkManagerFiles]) => files.concat(nodeFiles).concat(networkManagerFiles))
+                      )
+                  ),
+                systemdUnits: pulumi
+                  .all(systemdUnits || [])
+                  .apply((systemdUnits) =>
+                    pulumi
+                      .all(node.systemdUnits || [])
+                      .apply((nodeSystemdUnits) => systemdUnits.concat(nodeSystemdUnits))
+                  ),
+                packages: pulumi
+                  .all(packages || [])
+                  .apply((packages) =>
+                    pulumi.all(node.packages || []).apply((nodePackages) => packages.concat(nodePackages))
+                  ),
+                modules: pulumi
+                  .all(modules || [])
+                  .apply((modules) =>
+                    pulumi.all(node.modules || []).apply((nodeModules) => modules.concat(nodeModules))
+                  ),
+                users: pulumi.all(node.users || []).apply((users) => {
+                  return users.concat([{ name: "core", sshAuthorizedKeys: (sshAuthorizedKeys || []).map((k) => k) }]);
+                }),
+                sshUsers: [{ name: Cluster.sshUsername, groups: ["sudo"] }],
+              },
+              emptyOpts
+            );
+
+            const roles: string[] = node.roles || [];
+
+            let isController = false;
+            for (const role of roles) {
+              if (role === "controller") {
+                isController = true;
+                break;
+              }
+            }
+
+            if (isController) {
+              roles.push("etcd");
+            }
+
+            return {
+              id: hostname,
+              hostname,
+              roles,
+              ipv4Address: node.ipv4Address,
+              privateIpv4Address: node.privateIpv4Address,
+              ipv6Address: node.ipv6Address,
+              privateIpv6Address: node.privateIpv6Address,
+              labels: node.labels ?? {},
+              taints: node.taints ?? [],
+              username: Cluster.sshUsername,
+              privateKey: fcosHost.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}`);
+              }),
+              disabled: node.disabled ?? false,
+              fcosHost,
+            };
+          });
+
+        results.push({ node: host, depends: host.fcosHost });
+      }
+
+      return results;
+    });
+  }
+
+  private networkManagerConfigFiles(node: InputNode): pulumi.Output<fcos.FilesArgs[]> {
+    return pulumi.all([node.vlans]).apply(([vlans]) => {
+      const configs: fcos.FilesArgs[] = [];
+
+      configs.push({
+        path: `/etc/NetworkManager/system-connections/${Cluster.ethernetInterfaceName}.nmconnection`,
+        contents: [
+          "[connection]",
+          "type=ethernet",
+          `id=${Cluster.ethernetInterfaceName}`,
+          `interface-name=${Cluster.ethernetInterfaceName}`,
+          "[ipv4]",
+          "method=auto",
+          "[ipv6]",
+          "method=auto",
+          "addr-gen-mode=eui64",
+        ].join("\n"),
+        mode: 0o600,
+      });
+
+      for (const vlan of vlans || []) {
+        const parentInterfaceName = vlan.interface ?? Cluster.ethernetInterfaceName;
+        const interfaceName = `${parentInterfaceName}.${vlan.id}`;
+
+        const ipv4: string[] = ["never-default=true"];
+        const ipv6: string[] = ["never-default=true"];
+
+        if (vlan.ipv4Address !== undefined) {
+          ipv4.push("method=manual", `address1=${vlan.ipv4Address}`);
+        } else {
+          ipv4.push("method=auto");
+        }
+
+        if (vlan.ipv6Address !== undefined) {
+          ipv6.push("method=manual", `address1=${vlan.ipv6Address}`);
+        } else {
+          ipv6.push("method=auto", "addr-gen-mode=eui64");
+        }
+
+        configs.push({
+          path: `/etc/NetworkManager/system-connections/${interfaceName}.nmconnection`,
+          contents: [
+            "[connection]",
+            `id=${interfaceName}`,
+            "type=vlan",
+            `interface-name=${interfaceName}`,
+            "[vlan]",
+            "egress-priority-map=",
+            "flags=1",
+            `id=${vlan.id}`,
+            "ingress-priority-map=",
+            `parent=${parentInterfaceName}`,
+            "[ipv4]",
+            ...ipv4,
+            "[ipv6]",
+            ...ipv6,
+          ].join("\n"),
+          mode: 0o600,
+        });
+      }
+
+      return configs;
+    });
+  }
+}

package/lib/raspberrypi/{index.d.ts → index.ts}

@@ -1,3 +1,3 @@
 import { ClusterArgs, Cluster } from "./cluster";
+
 export { ClusterArgs, Cluster };
-//# sourceMappingURL=index.d.ts.map