@ydkn/pulumi-components 0.4.2 → 0.4.4

package/lib/rook/blockPool.ts

@@ -0,0 +1,80 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as k8s from "@pulumi/kubernetes";
+import { ComponentResource } from "../common";
+
+export interface BlockPoolSpecReplicatedArgs {
+  size?: pulumi.Input<number>;
+}
+
+export interface BlockPoolSpecArgs {
+  failureDomain?: pulumi.Input<string>;
+  replicated?: pulumi.Input<BlockPoolSpecReplicatedArgs>;
+}
+
+export interface BlockPoolArgs {
+  metadata: pulumi.Input<k8s.types.input.meta.v1.ObjectMeta>;
+  spec: pulumi.Input<BlockPoolSpecArgs>;
+  clusterId: pulumi.Input<string>;
+  defaultStorageClass?: pulumi.Input<boolean>;
+}
+
+export class BlockPool extends ComponentResource {
+  private readonly cephBlockPool: k8s.apiextensions.CustomResource;
+  private readonly storageClass: k8s.storage.v1.StorageClass;
+
+  /**
+   * Create a new ceph block pool resource.
+   * @param name The name of the ceph block pool resource.
+   * @param args A bag of arguments to control the ceph block pool creation.
+   * @param opts A bag of options that control this resource's behavior.
+   */
+  constructor(name: string, args: BlockPoolArgs, opts?: pulumi.ComponentResourceOptions) {
+    super("rook:ceph:block-pool", name, args, opts);
+
+    opts = this.opts(k8s.Provider);
+
+    this.cephBlockPool = new k8s.apiextensions.CustomResource(
+      name,
+      {
+        apiVersion: "ceph.rook.io/v1",
+        kind: "CephBlockPool",
+        metadata: args.metadata,
+        spec: args.spec,
+      },
+      opts
+    );
+
+    this.storageClass = new k8s.storage.v1.StorageClass(
+      name,
+      {
+        metadata: pulumi.all([args.metadata, args.defaultStorageClass]).apply(([metadata, defaultStorageClass]) => {
+          return {
+            ...metadata,
+            annotations: {
+              ...metadata.annotations,
+              "storageclass.kubernetes.io/is-default-class": defaultStorageClass ? "true" : "false",
+            },
+          };
+        }),
+        provisioner: pulumi.interpolate`${args.clusterId}.rbd.csi.ceph.com`,
+        parameters: {
+          pool: this.cephBlockPool.metadata.name,
+          clusterID: args.clusterId,
+          imageFormat: "2",
+          imageFeatures: "layering",
+          "csi.storage.k8s.io/provisioner-secret-name": "rook-csi-rbd-provisioner",
+          "csi.storage.k8s.io/provisioner-secret-namespace": this.cephBlockPool.metadata.namespace,
+          "csi.storage.k8s.io/controller-expand-secret-name": "rook-csi-rbd-provisioner",
+          "csi.storage.k8s.io/controller-expand-secret-namespace": this.cephBlockPool.metadata.namespace,
+          "csi.storage.k8s.io/node-stage-secret-name": "rook-csi-rbd-node",
+          "csi.storage.k8s.io/node-stage-secret-namespace": this.cephBlockPool.metadata.namespace,
+          "csi.storage.k8s.io/fstype": "ext4",
+        },
+        reclaimPolicy: "Delete",
+        allowVolumeExpansion: true,
+        mountOptions: [],
+      },
+      opts
+    );
+  }
+}

package/lib/rook/cluster.ts

@@ -0,0 +1,168 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as k8s from "@pulumi/kubernetes";
+import * as fs from "fs";
+import * as path from "path";
+import { ComponentResource } from "../common";
+import * as kubernetes from "../kubernetes";
+import { Dashboard } from "../grafana";
+
+export interface StorageNodeDeviceArg {
+  name: pulumi.Input<string>;
+}
+
+export interface StorageNodeArg {
+  name: pulumi.Input<string>;
+  devices: pulumi.Input<pulumi.Input<StorageNodeDeviceArg>[]>;
+}
+
+export interface PlacementArgs extends k8s.types.input.core.v1.Affinity {
+  tolerations?: pulumi.Input<pulumi.Input<k8s.types.input.core.v1.Toleration>[]>;
+  topologySpreadConstraints?: pulumi.Input<pulumi.Input<k8s.types.input.core.v1.TopologySpreadConstraint>[]>;
+}
+
+export interface StorageClassDeviceSetsArg {
+  name: pulumi.Input<string>;
+  count: pulumi.Input<number>;
+  preparePlacement?: pulumi.Input<PlacementArgs>;
+  placement?: pulumi.Input<PlacementArgs>;
+  portable?: pulumi.Input<boolean>;
+  encrypted?: pulumi.Input<boolean>;
+  volumeClaimTemplates: pulumi.Input<pulumi.Input<k8s.core.v1.PersistentVolumeClaimArgs>[]>;
+}
+
+export interface MonitorArgs {
+  count?: pulumi.Input<number>;
+  volumeClaimTemplate?: pulumi.Input<k8s.core.v1.PersistentVolumeClaimArgs>;
+}
+
+export interface ManagerArgs {
+  count?: pulumi.Input<number>;
+}
+
+export interface ClusterArgs {
+  namespace?: pulumi.Input<string>;
+  clusterName?: pulumi.Input<string>;
+  deviceFilter?: pulumi.Input<string>;
+  devicePathFilter?: pulumi.Input<string>;
+  storageNodes?: pulumi.Input<pulumi.Input<StorageNodeArg>[]>;
+  storageClassDeviceSets?: pulumi.Input<pulumi.Input<StorageClassDeviceSetsArg>[]>;
+  hostname?: pulumi.Input<string>;
+  ingressClassName?: pulumi.Input<string>;
+  mon?: pulumi.Input<MonitorArgs>;
+  mgr?: pulumi.Input<ManagerArgs>;
+}
+
+export class Cluster extends ComponentResource {
+  private readonly helmChart: kubernetes.helm.v3.Chart;
+  private readonly grafanaDashboard: Dashboard;
+  public readonly namespace: pulumi.Output<string>;
+
+  /**
+   * Create a new rook ceph cluster resource.
+   * @param name The name of the rook ceph cluster resource.
+   * @param args A bag of arguments to control the rook ceph cluster creation.
+   * @param opts A bag of options that control this resource's behavior.
+   */
+  constructor(name: string, args: ClusterArgs, opts?: pulumi.ComponentResourceOptions) {
+    super("rook:ceph:cluster", name, args, opts);
+
+    opts = this.opts(k8s.Provider);
+
+    if (args.clusterName === undefined) {
+      args.clusterName = "ceph";
+    }
+
+    this.namespace = args.namespace
+      ? pulumi.output(args.namespace)
+      : new k8s.core.v1.Namespace(name, { metadata: { name } }, opts).metadata.name;
+
+    this.helmChart = new kubernetes.helm.v3.Chart(
+      name,
+      {
+        namespace: this.namespace,
+        fetchOpts: { repo: "https://charts.rook.io/release" },
+        chart: "rook-ceph-cluster",
+        values: {
+          fullnameOverride: name,
+          operatorNamespace: this.namespace,
+          clusterName: args.clusterName,
+          configOverride: [
+            "[global]",
+            "mon_allow_pool_delete = true",
+            "osd_pool_default_size = 3",
+            "osd_pool_default_min_size = 2",
+          ].join("\n"),
+          cephClusterSpec: {
+            mon: {
+              count: pulumi.all([args.mon]).apply(([mon]) => mon?.count ?? 3),
+              allowMultiplePerNode: false,
+              volumeClaimTemplate: pulumi.all([args.mon]).apply(([mon]) => mon?.volumeClaimTemplate),
+            },
+            mgr: {
+              count: pulumi.all([args.mgr]).apply(([mgr]) => mgr?.count ?? 2),
+            },
+            // network: { dualStack: true }, // TODO see https://github.com/rook/rook/issues/7522
+            removeOSDsIfOutAndSafeToRemove: true,
+            continueUpgradeAfterChecksEvenIfNotHealthy: true,
+            crashCollector: { disable: true },
+            logCollector: { enabled: false },
+            storage: {
+              useAllDevices: false,
+              deviceFilter: args.deviceFilter,
+              devicePathFilter: args.devicePathFilter,
+              nodes: args.storageNodes,
+              storageClassDeviceSets: args.storageClassDeviceSets,
+            },
+            resources: {
+              mgr: { requests: { cpu: "100m", memory: "256Mi" }, limits: { cpu: "1000m", memory: "1024Mi" } },
+              mon: { requests: { cpu: "100m", memory: "256Mi" }, limits: { cpu: "1000m", memory: "1024Mi" } },
+              osd: { requests: { cpu: "100m", memory: "512Mi" }, limits: { cpu: "2000m", memory: "2048Mi" } },
+              prepareosd: { requests: { cpu: "100m", memory: "128Mi" }, limits: { cpu: "500m", memory: "256Mi" } },
+              "mgr-sidecar": { requests: { cpu: "50m", memory: "32Mi" }, limits: { cpu: "100m", memory: "48Mi" } },
+              crashcollector: { requests: { cpu: "10m", memory: "32Mi" }, limits: { cpu: "100m", memory: "48Mi" } },
+              logcollector: { requests: { cpu: "10m", memory: "32Mi" }, limits: { cpu: "100m", memory: "64Mi" } },
+              cleanup: { requests: { cpu: "10m", memory: "32Mi" }, limits: { cpu: "100m", memory: "64Mi" } },
+            },
+          },
+          ingress: {
+            dashboard: {
+              ingressClassName: args.ingressClassName,
+              host: { name: args.hostname },
+              annotations: {
+                "traefik.ingress.kubernetes.io/router.entrypoints": "websecure",
+                "traefik.ingress.kubernetes.io/router.tls": "true",
+                "cert-manager.io/cluster-issuer": "letsencrypt",
+              },
+              tls: [{ secretName: `${name}-ingress-tls`, hosts: [args.hostname] }],
+            },
+          },
+          monitoring: { enabled: true, createPrometheusRules: false },
+          toolbox: { enabled: true },
+        },
+        transformations: [
+          kubernetes.transformations.filter([
+            { group: "ceph.rook.io", kind: "CephBlockPool" },
+            { group: "ceph.rook.io", kind: "CephFilesystem" },
+            { group: "ceph.rook.io", kind: "CephObjectStore" },
+            { group: "storage.k8s.io", kind: "StorageClass" },
+          ]),
+        ],
+      },
+      {},
+      opts
+    );
+
+    this.grafanaDashboard = new Dashboard(
+      `${name}-grafana-dashboard`,
+      {
+        metadata: { namespace: this.namespace, name: pulumi.interpolate`${name}-grafana-dashboard` },
+        name: "rook-ceph",
+        // eslint-disable-next-line security/detect-non-literal-fs-filename
+        data: fs.readFileSync(path.join(__dirname, "assets", "dashboard.json"), "utf-8"),
+      },
+      opts
+    );
+
+    this.registerOutputs();
+  }
+}

package/lib/rook/filesystem.ts

@@ -0,0 +1,140 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as k8s from "@pulumi/kubernetes";
+import { ComponentResource } from "../common";
+
+export interface FilesystemReplicatedArgs {
+  size?: pulumi.Input<number>;
+}
+
+export interface FilesystemDataPoolArgs {
+  name: pulumi.Input<string>;
+  failureDomain?: pulumi.Input<string>;
+  replicated?: pulumi.Input<FilesystemReplicatedArgs>;
+}
+
+export interface FilesystemArgs {
+  metadata: pulumi.Input<k8s.types.input.meta.v1.ObjectMeta>;
+  dataPools: pulumi.Input<pulumi.Input<FilesystemDataPoolArgs>[]>;
+  clusterId: pulumi.Input<string>;
+  defaultStorageClass?: pulumi.Input<boolean>;
+  preserveFilesystemOnDelete?: pulumi.Input<boolean>;
+}
+
+export class Filesystem extends ComponentResource {
+  private readonly filesystem: k8s.apiextensions.CustomResource;
+
+  /**
+   * Create a new ceph block pool resource.
+   * @param name The name of the ceph block pool resource.
+   * @param args A bag of arguments to control the ceph block pool creation.
+   * @param opts A bag of options that control this resource's behavior.
+   */
+  constructor(name: string, args: FilesystemArgs, opts?: pulumi.ComponentResourceOptions) {
+    super("rook:ceph:filesystem", name, args, opts);
+
+    opts = this.opts(k8s.Provider);
+
+    this.filesystem = new k8s.apiextensions.CustomResource(
+      name,
+      {
+        apiVersion: "ceph.rook.io/v1",
+        kind: "CephFilesystem",
+        metadata: args.metadata,
+        spec: {
+          preserveFilesystemOnDelete: args.preserveFilesystemOnDelete ?? false,
+          metadataServer: {
+            activeCount: 1,
+            activeStandby: true,
+            resources: {
+              requests: { memory: "384Mi" },
+              limits: { memory: "512Mi" },
+            },
+            priorityClassName: "system-cluster-critical",
+            placement: {
+              podAntiAffinity: {
+                preferredDuringSchedulingIgnoredDuringExecution: [
+                  {
+                    weight: 100,
+                    podAffinityTerm: {
+                      labelSelector: {
+                        matchExpressions: [
+                          {
+                            key: "app.kubernetes.io/component",
+                            operator: "In",
+                            values: ["cephfilesystems.ceph.rook.io"],
+                          },
+                          {
+                            key: "app.kubernetes.io/part-of",
+                            operator: "In",
+                            values: [name],
+                          },
+                        ],
+                      },
+                      topologyKey: "kubernetes.io/hostname",
+                    },
+                  },
+                ],
+              },
+            },
+          },
+          metadataPool: {
+            replicated: { size: 3 },
+          },
+          dataPools: pulumi.all([args.dataPools]).apply(([dataPools]) => {
+            return dataPools.map((dataPool) =>
+              pulumi.all([dataPool]).apply(([dataPool]) => {
+                return {
+                  name: dataPool.name,
+                  failureDomain: dataPool.failureDomain ?? "host",
+                  replicated: dataPool.replicated,
+                };
+              })
+            );
+          }),
+        },
+      },
+      opts
+    );
+
+    pulumi
+      .all([args.metadata, args.defaultStorageClass, args.dataPools])
+      .apply(([metadata, defaultStorageClass, dataPools]) => {
+        dataPools.forEach((dataPool) =>
+          pulumi.all([dataPool]).apply(([dataPool]) => {
+            return new k8s.storage.v1.StorageClass(
+              `${name}-${dataPool.name}`,
+              {
+                metadata: {
+                  ...metadata,
+                  name: `${metadata.name}-${dataPool.name}`,
+                  annotations: {
+                    ...metadata.annotations,
+                    "storageclass.kubernetes.io/is-default-class": defaultStorageClass ? "true" : "false",
+                  },
+                },
+                provisioner: pulumi.interpolate`${args.clusterId}.cephfs.csi.ceph.com`,
+                parameters: {
+                  fsName: pulumi.all([args.metadata]).apply(([metadata]) => metadata.name!),
+                  pool: pulumi
+                    .all([args.metadata])
+                    .apply(([metadata]) => pulumi.interpolate`${metadata.name}-${dataPool.name}`),
+                  clusterID: args.clusterId,
+                  "csi.storage.k8s.io/provisioner-secret-name": "rook-csi-cephfs-provisioner",
+                  "csi.storage.k8s.io/provisioner-secret-namespace": this.filesystem.metadata.namespace,
+                  "csi.storage.k8s.io/controller-expand-secret-name": "rook-csi-cephfs-provisioner",
+                  "csi.storage.k8s.io/controller-expand-secret-namespace": this.filesystem.metadata.namespace,
+                  "csi.storage.k8s.io/node-stage-secret-name": "rook-csi-cephfs-node",
+                  "csi.storage.k8s.io/node-stage-secret-namespace": this.filesystem.metadata.namespace,
+                  "csi.storage.k8s.io/fstype": "ext4",
+                },
+                reclaimPolicy: "Delete",
+                allowVolumeExpansion: true,
+                mountOptions: [],
+              },
+              opts
+            );
+          })
+        );
+      });
+  }
+}

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

@@ -2,5 +2,18 @@ import { CephArgs, Ceph } from "./operator";
 import { StorageNodeDeviceArg, StorageNodeArg, ClusterArgs, Cluster } from "./cluster";
 import { BlockPoolSpecArgs, BlockPoolArgs, BlockPool } from "./blockPool";
 import { FilesystemDataPoolArgs, FilesystemArgs, Filesystem } from "./filesystem";
-export { CephArgs, Ceph, StorageNodeDeviceArg, StorageNodeArg, ClusterArgs, Cluster, BlockPoolSpecArgs, BlockPoolArgs, BlockPool, FilesystemDataPoolArgs, FilesystemArgs, Filesystem, };
-//# sourceMappingURL=index.d.ts.map
+
+export {
+  CephArgs,
+  Ceph,
+  StorageNodeDeviceArg,
+  StorageNodeArg,
+  ClusterArgs,
+  Cluster,
+  BlockPoolSpecArgs,
+  BlockPoolArgs,
+  BlockPool,
+  FilesystemDataPoolArgs,
+  FilesystemArgs,
+  Filesystem,
+};

package/lib/rook/operator.ts

@@ -0,0 +1,175 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as k8s from "@pulumi/kubernetes";
+import * as yaml from "js-yaml";
+import { ComponentResource } from "../common";
+import * as kubernetes from "../kubernetes";
+
+export interface CephArgs {
+  namespace?: pulumi.Input<string>;
+  replicas?: pulumi.Input<number>;
+  kubeletDirPath?: pulumi.Input<string>;
+}
+
+export class Ceph extends ComponentResource {
+  private readonly helmRelease: kubernetes.helm.v3.Release;
+  public readonly namespace: pulumi.Output<string>;
+
+  /**
+   * Create a new rook ceph operator resource.
+   * @param name The name of the rook ceph operator resource.
+   * @param args A bag of arguments to control the rook ceph operator creation.
+   * @param opts A bag of options that control this resource's behavior.
+   */
+  constructor(name: string, args: CephArgs, opts?: pulumi.ComponentResourceOptions) {
+    super("rook:ceph", name, args, opts);
+
+    opts = this.opts(k8s.Provider);
+
+    if (args.replicas === undefined) {
+      args.replicas = 1;
+    }
+
+    this.namespace = args.namespace
+      ? pulumi.output(args.namespace)
+      : new k8s.core.v1.Namespace(name, { metadata: { name } }, opts).metadata.name;
+
+    this.helmRelease = new kubernetes.helm.v3.Release(
+      name,
+      {
+        name,
+        namespace: this.namespace,
+        repositoryOpts: { repo: "https://charts.rook.io/release" },
+        chart: "rook-ceph",
+        values: {
+          fullnameOverride: name,
+          unreachableNodeTolerationSeconds: 300,
+          pspEnable: false,
+          csi: {
+            enableCephfsSnapshotter: false,
+            enableRBDSnapshotter: false,
+            provisionerReplicas: args.replicas,
+            kubeletDirPath: args.kubeletDirPath,
+            provisionerTolerations: [
+              { key: "node-role.kubernetes.io/master", operator: "Exists", effect: "NoSchedule" },
+              { key: "node-role.kubernetes.io/control-plane", operator: "Exists", effect: "NoSchedule" },
+            ],
+            nfs: { enabled: false },
+            csiRBDProvisionerResource: yaml.dump([
+              {
+                name: "csi-provisioner",
+                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
+              },
+              {
+                name: "csi-resizer",
+                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
+              },
+              {
+                name: "csi-attacher",
+                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
+              },
+              {
+                name: "csi-snapshotter",
+                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
+              },
+              {
+                name: "csi-rbdplugin",
+                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
+              },
+              {
+                name: "liveness-prometheus",
+                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
+              },
+            ]),
+            csiRBDPluginResource: yaml.dump([
+              {
+                name: "driver-registrar",
+                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
+              },
+              {
+                name: "csi-rbdplugin",
+                resource: { requests: { memory: "48Mi" }, limits: { memory: "64Mi" } },
+              },
+              {
+                name: "liveness-prometheus",
+                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
+              },
+            ]),
+            csiCephFSProvisionerResource: yaml.dump([
+              {
+                name: "csi-provisioner",
+                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
+              },
+              {
+                name: "csi-resizer",
+                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
+              },
+              {
+                name: "csi-attacher",
+                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
+              },
+              {
+                name: "csi-cephfsplugin",
+                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
+              },
+              {
+                name: "liveness-prometheus",
+                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
+              },
+            ]),
+            csiCephFSPluginResource: yaml.dump([
+              {
+                name: "driver-registrar",
+                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
+              },
+              {
+                name: "csi-cephfsplugin",
+                resource: { requests: { memory: "48Mi" }, limits: { memory: "64Mi" } },
+              },
+              {
+                name: "liveness-prometheus",
+                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
+              },
+            ]),
+            csiNFSProvisionerResource: yaml.dump([
+              {
+                name: "csi-provisioner",
+                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
+              },
+              {
+                name: "csi-nfsplugin",
+                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
+              },
+              {
+                name: "liveness-prometheus",
+                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
+              },
+            ]),
+            csiNFSPluginResource: yaml.dump([
+              {
+                name: "driver-registrar",
+                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
+              },
+              {
+                name: "csi-nfsplugin",
+                resource: { requests: { memory: "48Mi" }, limits: { memory: "64Mi" } },
+              },
+              {
+                name: "liveness-prometheus",
+                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
+              },
+            ]),
+            enableLiveness: true,
+          },
+          monitoring: { enabled: true },
+          resources: {
+            requests: { memory: "128Mi" },
+            limits: { memory: "512Mi" },
+          },
+        },
+      },
+      opts
+    );
+
+    this.registerOutputs();
+  }
+}

package/lib/samba/avahiService.ts

@@ -0,0 +1,44 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as k8s from "@pulumi/kubernetes";
+import * as avahi from "../avahi";
+
+export interface AvahiServiceArgs {
+  labelName: pulumi.Input<string>;
+  metadata: pulumi.Input<k8s.types.input.meta.v1.ObjectMeta>;
+  hostname: pulumi.Input<string>;
+  serverName: pulumi.Input<string>;
+  deviceModel: pulumi.Input<string>;
+}
+
+export class AvahiService extends avahi.AvahiService {
+  /**
+   * Create a new CUPS avahi service resource.
+   * @param name The name of the CUPS avahi service resource.
+   * @param args A bag of arguments to control the CUPS avahi service creation.
+   * @param opts A bag of options that control this resource's behavior.
+   */
+  constructor(name: string, args: AvahiServiceArgs, opts?: pulumi.CustomResourceOptions) {
+    super(
+      name,
+      {
+        labelName: args.labelName,
+        metadata: args.metadata,
+        name: args.serverName,
+        services: [
+          {
+            type: "_smb._tcp",
+            port: 445,
+            hostname: args.hostname,
+          },
+          {
+            type: "_device-info._tcp",
+            port: 9,
+            txtRecords: [pulumi.interpolate`model=${args.deviceModel}`],
+            hostname: args.hostname,
+          },
+        ],
+      },
+      opts
+    );
+  }
+}