@ydkn/pulumi-components 0.4.4 → 0.4.5

package/lib/raspberrypi/cluster.ts

@@ -1,279 +0,0 @@
-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/rethinkdb/deployment.ts

@@ -1,424 +0,0 @@
-import * as pulumi from "@pulumi/pulumi";
-import * as random from "@pulumi/random";
-import * as k8s from "@pulumi/kubernetes";
-import { ComponentResource } from "../common";
-import * as kubernetes from "../kubernetes";
-import * as certManager from "../certManager";
-import * as traefik from "../traefik";
-
-export interface RethinkDbArgs {
-  namespace?: pulumi.Input<string>;
-  hostname: pulumi.Input<string>;
-  ingressClassName?: pulumi.Input<string>;
-  replicas?: pulumi.Input<number>;
-  storage?: pulumi.Input<string>;
-  resources?: pulumi.Input<k8s.types.input.core.v1.ResourceRequirements>;
-  protect?: boolean;
-}
-
-export class RethinkDb extends ComponentResource {
-  private static readonly adminPort = 8080;
-  private static readonly clientsPort = 28015;
-  private static readonly clusterPort = 29015;
-
-  private readonly clusterIssuer: certManager.Issuer;
-  private readonly clusterCACertificate: certManager.Certificate;
-  private readonly podDisruptionBudget: k8s.policy.v1.PodDisruptionBudget;
-  private readonly adminService: k8s.core.v1.Service;
-  private readonly clientsService: kubernetes.v1.Service;
-  private readonly adminIngress: traefik.SecureIngress;
-  public readonly adminPassword: pulumi.Output<string>;
-  public readonly namespace: pulumi.Output<string>;
-  public readonly address: pulumi.Output<string>;
-  public readonly addresses: pulumi.Output<pulumi.Output<string>[]>;
-
-  /**
-   * Create a new RethinkDB cluster resource.
-   * @param name The name of the RethinkDB cluster resource.
-   * @param args A bag of arguments to control the RethinkDB cluster creation.
-   * @param opts A bag of options that control this resource's behavior.
-   */
-  constructor(name: string, args: RethinkDbArgs, opts?: pulumi.ComponentResourceOptions) {
-    super("rethinkdb", name, args, opts);
-
-    if (args.replicas === undefined) {
-      args.replicas = 1;
-    }
-
-    if (args.resources === undefined) {
-      args.resources = { requests: { memory: "256Mi" }, limits: { memory: "384Mi" } };
-    }
-
-    const emptyOpts = this.opts();
-    const k8sOpts = this.opts(k8s.Provider);
-
-    this.adminPassword = pulumi.secret(
-      new random.RandomPassword(`${name}-admin-password`, { length: 32, special: false }, emptyOpts).result
-    );
-
-    this.namespace = args.namespace
-      ? pulumi.output(args.namespace)
-      : new k8s.core.v1.Namespace(name, { metadata: { name } }, k8sOpts).metadata.name;
-
-    const metadata = {
-      name,
-      namespace: this.namespace,
-      labels: {
-        "app.kubernetes.io/name": "rethinkdb",
-        "app.kubernetes.io/component": "rethinkdb",
-        "app.kubernetes.io/instance": name,
-      },
-    };
-
-    const adminServiceName = pulumi.interpolate`${name}-admin`;
-    const clientsServiceName = pulumi.interpolate`${name}-clients`;
-
-    this.clusterCACertificate = new certManager.Certificate(
-      `${name}-cluster-ca`,
-      {
-        metadata: { ...metadata, name: pulumi.interpolate`${name}-cluster-ca` },
-        spec: {
-          isCA: true,
-          commonName: name,
-          dnsNames: [name],
-          duration: "87600h",
-          renewBefore: "8760h",
-          privateKey: { rotationPolicy: "Always" },
-          issuerRef: { name: "self-signed", kind: "ClusterIssuer" },
-        },
-      },
-      k8sOpts
-    );
-
-    this.clusterIssuer = new certManager.Issuer(
-      `${name}-cluster`,
-      {
-        metadata: { ...metadata, name: pulumi.interpolate`${name}-cluster` },
-        spec: {
-          ca: { secretName: this.clusterCACertificate.secretName },
-        },
-      },
-      k8sOpts
-    );
-
-    this.addresses = pulumi.all([args.replicas]).apply(([replicas]) => {
-      const addresses: pulumi.Output<string>[] = [];
-
-      for (let i = 0; i < replicas; i++) {
-        const deployment = this.replicaDeployment(
-          name,
-          replicas,
-          i,
-          metadata,
-          args.hostname,
-          args.storage || "10Gi",
-          args.resources,
-          args.protect,
-          k8sOpts
-        );
-
-        addresses.push(deployment.clientsHostname);
-      }
-
-      return addresses;
-    });
-
-    this.podDisruptionBudget = new k8s.policy.v1.PodDisruptionBudget(
-      name,
-      {
-        metadata,
-        spec: {
-          minAvailable: 1,
-          selector: { matchLabels: metadata.labels },
-        },
-      },
-      k8sOpts
-    );
-
-    this.adminService = new k8s.core.v1.Service(
-      `${name}-admin`,
-      {
-        metadata: {
-          ...metadata,
-          name: adminServiceName,
-          annotations: {
-            "traefik.ingress.kubernetes.io/service.sticky.cookie": "true",
-            "traefik.ingress.kubernetes.io/service.sticky.cookie.name": "_affinity",
-            "traefik.ingress.kubernetes.io/service.sticky.cookie.secure": "true",
-          },
-        },
-        spec: {
-          selector: metadata.labels,
-          ports: [{ name: "http", protocol: "TCP", port: RethinkDb.adminPort, targetPort: "admin" }],
-          sessionAffinity: "ClientIP",
-        },
-      },
-      k8sOpts
-    );
-
-    this.clientsService = new kubernetes.v1.Service(
-      `${name}-clients`,
-      {
-        metadata: { ...metadata, name: clientsServiceName },
-        spec: {
-          selector: metadata.labels,
-          ports: [{ name: "clients", protocol: "TCP", port: RethinkDb.clientsPort, targetPort: "clients" }],
-          sessionAffinity: "ClientIP",
-        },
-        hostnames: [pulumi.interpolate`clients.${args.hostname}`],
-      },
-      k8sOpts
-    );
-
-    this.address = this.clientsService.hostnames!.apply(
-      (hostnames) => pulumi.interpolate`${hostnames[0]}:${this.clientsService.spec.ports[0].port}`
-    );
-
-    this.adminIngress = new traefik.SecureIngress(
-      `${name}-admin`,
-      {
-        metadata: { ...metadata, name: adminServiceName },
-        spec: {
-          ingressClassName: args.ingressClassName,
-          rules: [
-            {
-              host: args.hostname,
-              http: {
-                paths: [
-                  {
-                    path: "/",
-                    pathType: "Prefix",
-                    backend: {
-                      service: { name: adminServiceName, port: { name: "http" } },
-                    },
-                  },
-                ],
-              },
-            },
-          ],
-        },
-      },
-      k8sOpts
-    );
-
-    this.registerOutputs();
-  }
-
-  private replicaDeployment(
-    name: string,
-    replicas: number,
-    idx: number,
-    metadata: k8s.types.input.meta.v1.ObjectMeta,
-    hostname: pulumi.Input<string>,
-    storage: pulumi.Input<string>,
-    resources?: pulumi.Input<k8s.types.input.core.v1.ResourceRequirements>,
-    protect?: boolean,
-    opts?: pulumi.ComponentResourceOptions
-  ): { clientsHostname: pulumi.Output<string> } {
-    const replicaMetadata = {
-      ...metadata,
-      name: `${name}-${idx}`,
-      labels: { ...metadata.labels, replica: `${idx}` } as { [key: string]: pulumi.Input<string> },
-    };
-
-    const clusterCertificate = new certManager.Certificate(
-      `${name}-${idx}-cluster`,
-      {
-        metadata: { ...replicaMetadata, name: `${replicaMetadata.name}-cluster` },
-        spec: {
-          commonName: replicaMetadata.name,
-          dnsNames: [replicaMetadata.name],
-          privateKey: { rotationPolicy: "Always" },
-          issuerRef: { name: this.clusterIssuer.metadata.name, kind: this.clusterIssuer.kind },
-        },
-      },
-      opts
-    );
-
-    const clientsCertificate = new certManager.Certificate(
-      `${name}-${idx}-clients`,
-      {
-        metadata: { ...replicaMetadata, name: `${replicaMetadata.name}-clients` },
-        spec: {
-          dnsNames: [pulumi.interpolate`${idx}.clients.${hostname}`, pulumi.interpolate`clients.${hostname}`],
-          privateKey: { rotationPolicy: "Always" },
-          issuerRef: { name: "letsencrypt", kind: "ClusterIssuer" },
-        },
-      },
-      opts
-    );
-
-    const volumeClaimName = pulumi.interpolate`${replicaMetadata.name}-data`;
-
-    // eslint-disable-next-line no-unused-vars
-    const volumeClaim = new k8s.core.v1.PersistentVolumeClaim(
-      `${name}-${idx}`,
-      {
-        metadata: { ...replicaMetadata, name: volumeClaimName },
-        spec: {
-          accessModes: ["ReadWriteOnce"],
-          resources: { requests: { storage } },
-        },
-      },
-      { ...opts, protect }
-    );
-
-    // eslint-disable-next-line no-unused-vars
-    const deployment = new k8s.apps.v1.Deployment(
-      `${name}-${idx}`,
-      {
-        metadata: replicaMetadata,
-        spec: {
-          selector: { matchLabels: replicaMetadata.labels },
-          strategy: { type: "Recreate" },
-          replicas: 1,
-          template: {
-            metadata: { labels: replicaMetadata.labels },
-            spec: {
-              containers: [
-                {
-                  name: "rethinkdb",
-                  image: "rethinkdb:2",
-                  imagePullPolicy: "Always",
-                  command: ["sh", "-c"],
-                  args: [
-                    pulumi.all([replicas]).apply(([replicas]) => {
-                      const args = [
-                        "rethinkdb",
-                        "--runuser",
-                        "rethinkdb",
-                        "--rungroup",
-                        "rethinkdb",
-                        "--bind",
-                        "all",
-                        "--server-name",
-                        "${REPLICA_NAME}", // eslint-disable-line no-template-curly-in-string
-                        "--server-tag",
-                        "${NODE_NAME}", // eslint-disable-line no-template-curly-in-string
-                        "--driver-tls-cert",
-                        "/run/secrets/kubernetes.io/clients-tls/tls.crt",
-                        "--driver-tls-key",
-                        "/run/secrets/kubernetes.io/clients-tls/tls.key",
-                        "--cluster-tls-ca",
-                        "/run/secrets/kubernetes.io/cluster-ca/tls.crt",
-                        "--cluster-tls-cert",
-                        "/run/secrets/kubernetes.io/cluster-tls/tls.crt",
-                        "--cluster-tls-key",
-                        "/run/secrets/kubernetes.io/cluster-tls/tls.key",
-                        "--canonical-address",
-                        `${name}-${idx}-cluster:${RethinkDb.clusterPort}`,
-                        "--no-update-check",
-                        "--log-file",
-                        "/dev/null",
-                        "--initial-password",
-                        "${PASSWORD}", // eslint-disable-line no-template-curly-in-string
-                      ];
-
-                      for (let i = 0; i < replicas; i++) {
-                        args.push(
-                          [
-                            `$(if [ "\${REPLICA_NAME}" != "${name}-${i}" ];`,
-                            `then echo "--join ${name}-${i}-cluster:${RethinkDb.clusterPort}";`,
-                            `else echo ""; fi)`,
-                          ].join(" ")
-                        );
-                      }
-
-                      return args.join(" ");
-                    }),
-                  ],
-                  env: [
-                    { name: "NODE_NAME", valueFrom: { fieldRef: { fieldPath: "spec.nodeName" } } },
-                    { name: "REPLICA_NAME", value: pulumi.interpolate`${name}-${idx}` },
-                    { name: "PASSWORD", value: this.adminPassword },
-                  ],
-                  ports: [
-                    { name: "admin", protocol: "TCP", containerPort: RethinkDb.adminPort },
-                    { name: "clients", protocol: "TCP", containerPort: RethinkDb.clientsPort },
-                    { name: "cluster", protocol: "TCP", containerPort: RethinkDb.clusterPort },
-                  ],
-                  volumeMounts: [
-                    { name: "data", mountPath: "/data" },
-                    { name: "admin-tls", mountPath: "/run/secrets/kubernetes.io/admin-tls" },
-                    { name: "clients-tls", mountPath: "/run/secrets/kubernetes.io/clients-tls" },
-                    { name: "cluster-ca", mountPath: "/run/secrets/kubernetes.io/cluster-ca" },
-                    { name: "cluster-tls", mountPath: "/run/secrets/kubernetes.io/cluster-tls" },
-                  ],
-                  resources,
-                },
-              ],
-              volumes: [
-                { name: "data", persistentVolumeClaim: { claimName: volumeClaimName } },
-                { name: "admin-tls", secret: { secretName: this.adminIngress.spec.tls[0].secretName } },
-                { name: "clients-tls", secret: { secretName: clientsCertificate.secretName } },
-                { name: "cluster-ca", secret: { secretName: this.clusterCACertificate.secretName } },
-                { name: "cluster-tls", secret: { secretName: clusterCertificate.secretName } },
-              ],
-              affinity: {
-                podAntiAffinity: {
-                  preferredDuringSchedulingIgnoredDuringExecution: [
-                    {
-                      weight: 100,
-                      podAffinityTerm: {
-                        labelSelector: {
-                          matchExpressions: [
-                            {
-                              key: "app.kubernetes.io/name",
-                              operator: "In",
-                              values: [replicaMetadata.labels["app.kubernetes.io/name"]],
-                            },
-                            {
-                              key: "app.kubernetes.io/component",
-                              operator: "In",
-                              values: [replicaMetadata.labels["app.kubernetes.io/component"]],
-                            },
-                            {
-                              key: "app.kubernetes.io/instance",
-                              operator: "In",
-                              values: [replicaMetadata.labels["app.kubernetes.io/instance"]],
-                            },
-                          ],
-                        },
-                        topologyKey: "kubernetes.io/hostname",
-                      },
-                    },
-                  ],
-                },
-              },
-            },
-          },
-        },
-      },
-      opts
-    );
-
-    // eslint-disable-next-line no-unused-vars
-    const clusterService = new kubernetes.v1.Service(
-      `${name}-${idx}-cluster`,
-      {
-        metadata: { ...replicaMetadata, name: pulumi.interpolate`${replicaMetadata.name}-cluster` },
-        spec: {
-          selector: replicaMetadata.labels,
-          ports: [{ name: "cluster", protocol: "TCP", port: RethinkDb.clusterPort, targetPort: "cluster" }],
-        },
-      },
-      opts
-    );
-
-    const clientsService = new kubernetes.v1.Service(
-      `${name}-${idx}-clients`,
-      {
-        metadata: { ...replicaMetadata, name: pulumi.interpolate`${replicaMetadata.name}-clients` },
-        spec: {
-          selector: replicaMetadata.labels,
-          ports: [{ name: "clients", protocol: "TCP", port: RethinkDb.clientsPort, targetPort: "clients" }],
-          sessionAffinity: "ClientIP",
-        },
-        hostnames: [pulumi.interpolate`${idx}.clients.${hostname}`],
-      },
-      opts
-    );
-
-    return { clientsHostname: clientsService.hostnames!.apply((hostnames) => hostnames[0]) };
-  }
-}