@ydkn/pulumi-components 0.4.2 → 0.4.4

package/lib/kubeStateMetrics/deployment.ts

@@ -0,0 +1,60 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as k8s from "@pulumi/kubernetes";
+import { ComponentResource } from "../common";
+import * as kubernetes from "../kubernetes";
+
+export interface KubeStateMetricsArgs {
+  namespace?: pulumi.Input<string>;
+  replicas?: pulumi.Input<number>;
+  resources?: pulumi.Input<k8s.types.input.core.v1.ResourceRequirements>;
+}
+
+export class KubeStateMetrics extends ComponentResource {
+  private readonly helmRelease: kubernetes.helm.v3.Release;
+  public readonly namespace: pulumi.Output<string>;
+
+  /**
+   * Create a new kube-state-metrics resource.
+   * @param name The name of the kube-state-metrics resource.
+   * @param args A bag of arguments to control the kube-state-metrics creation.
+   * @param opts A bag of options that control this resource's behavior.
+   */
+  constructor(name: string, args: KubeStateMetricsArgs, opts?: pulumi.ComponentResourceOptions) {
+    super("kube-state-metrics", name, args, opts);
+
+    if (args.replicas === undefined) {
+      args.replicas = 1;
+    }
+
+    if (args.resources === undefined) {
+      args.resources = { requests: { memory: "48Mi" }, limits: { memory: "64Mi" } };
+    }
+
+    opts = this.opts(k8s.Provider);
+
+    this.namespace = pulumi.output(args.namespace ?? "kube-system");
+
+    this.helmRelease = new kubernetes.helm.v3.Release(
+      name,
+      {
+        name,
+        namespace: this.namespace,
+        repositoryOpts: { repo: "https://prometheus-community.github.io/helm-charts" },
+        chart: "kube-state-metrics",
+        values: {
+          fullnameOverride: name,
+          replicas: args.replicas,
+          prometheus: { monitor: { enabled: true } },
+          resources: args.resources,
+          tolerations: [
+            { key: "node-role.kubernetes.io/master", operator: "Exists", effect: "NoSchedule" },
+            { key: "node-role.kubernetes.io/control-plane", operator: "Exists", effect: "NoSchedule" },
+          ],
+        },
+      },
+      opts
+    );
+
+    this.registerOutputs();
+  }
+}

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

@@ -1,3 +1,3 @@
 import { KubeStateMetricsArgs, KubeStateMetrics } from "./deployment";
+
 export { KubeStateMetricsArgs, KubeStateMetrics };
-//# sourceMappingURL=index.d.ts.map

package/lib/kubernetes/helm/{index.d.ts → index.ts}

@@ -1,3 +1,3 @@
 import * as v3 from "./v3";
+
 export { v3 };
-//# sourceMappingURL=index.d.ts.map

package/lib/kubernetes/helm/v3/chart.ts

@@ -0,0 +1,79 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as k8s from "@pulumi/kubernetes";
+import * as transformations from "../../transformations";
+
+export interface ChartTransformers {
+  /**
+   * Transform known deprecated resources
+   */
+  deprecations?: boolean;
+  /**
+   * Transform metadata namespace value
+   */
+  metadataNamespace?: boolean;
+  /**
+   * Transform metadata namespace value to this name
+   */
+  metadataNamespaceName?: pulumi.Input<string>;
+}
+
+export interface ChartArgs {
+  /**
+   * Enabled transformers
+   */
+  transformers?: ChartTransformers;
+  /**
+   * Skip creation of CRD resources
+   */
+  skipCRDs?: boolean;
+}
+
+export class Chart extends k8s.helm.v3.Chart {
+  /**
+   * Create an instance of the specified Helm chart.
+   * @param releaseName Name of the Chart (e.g., nginx-ingress).
+   * @param config Configuration options for the Chart.
+   * @param args A bag of arguments to control the Chart creation.
+   * @param opts A bag of options that control this resource's behavior.
+   */
+  constructor(
+    releaseName: string,
+    config: k8s.helm.v3.ChartOpts | k8s.helm.v3.LocalChartOpts,
+    args?: ChartArgs,
+    opts?: pulumi.ComponentResourceOptions
+  ) {
+    if (config.transformations === undefined) {
+      config.transformations = [];
+    }
+
+    if (args !== undefined) {
+      if (args.transformers !== undefined) {
+        if (args.transformers.deprecations) {
+          config.transformations.push(transformations.v1beta1Deprecations);
+        }
+
+        if (args.transformers.metadataNamespace && args.transformers.metadataNamespaceName !== undefined) {
+          config.transformations.push(transformations.metadataNamespace(args.transformers.metadataNamespaceName));
+        }
+      }
+
+      if (args.skipCRDs) {
+        config.transformations.push((o: any, _: pulumi.CustomResourceOptions): void => {
+          if (o === undefined) {
+            return;
+          }
+
+          if (o.apiVersion === "apiextensions.k8s.io/v1beta1" || o.apiVersion === "apiextensions.k8s.io/v1") {
+            if (o.kind === "CustomResourceDefinition") {
+              o.apiVersion = "v1";
+              o.kind = "List";
+              o.items = [];
+            }
+          }
+        });
+      }
+    }
+
+    super(releaseName, config, opts);
+  }
+}

package/lib/kubernetes/helm/v3/helpers.ts

@@ -0,0 +1,32 @@
+import * as pulumi from "@pulumi/pulumi";
+
+export function ingressValues(
+  name: pulumi.Input<string>,
+  hostnames?: pulumi.Input<pulumi.Input<string | undefined>[]>,
+  ingressClassName?: pulumi.Input<string>
+): any {
+  if (hostnames === undefined) {
+    return { enabled: false };
+  }
+
+  return pulumi.all([name, hostnames, ingressClassName]).apply(([name, hostnames, ingressClassName]) => {
+    const hosts = hostnames.filter((h) => h !== undefined);
+
+    if (hosts.length === 0) {
+      return { enabled: false };
+    }
+
+    return {
+      enabled: true,
+      ingressClassName,
+      hosts,
+      pathType: "ImplementationSpecific",
+      tls: [{ secretName: `${name}-ingress-tls`, hosts }],
+      annotations: {
+        "traefik.ingress.kubernetes.io/router.entrypoints": "websecure",
+        "traefik.ingress.kubernetes.io/router.tls": "true",
+        "cert-manager.io/cluster-issuer": "letsencrypt",
+      },
+    };
+  });
+}

package/lib/kubernetes/helm/v3/{index.d.ts → index.ts}

@@ -1,5 +1,5 @@
 import { ChartTransformers, ChartArgs, Chart } from "./chart";
 import { ReleaseArgs, Release } from "./release";
 import { ingressValues } from "./helpers";
+
 export { ChartTransformers, ChartArgs, Chart, ReleaseArgs, Release, ingressValues };
-//# sourceMappingURL=index.d.ts.map

package/lib/kubernetes/helm/v3/release.ts

@@ -0,0 +1,17 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as k8s from "@pulumi/kubernetes";
+
+export interface ReleaseArgs extends k8s.helm.v3.ReleaseArgs {}
+
+export class Release extends k8s.helm.v3.Release {
+  /**
+   * Create a Release resource with the given unique name, arguments, and options.
+   *
+   * @param name The _unique_ name of the resource.
+   * @param args The arguments to use to populate this resource's properties.
+   * @param opts A bag of options that control this resource's behavior.
+   */
+  constructor(name: string, args?: ReleaseArgs, opts?: pulumi.ComponentResourceOptions) {
+    super(name, args, opts);
+  }
+}

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

@@ -1,5 +1,5 @@
 import * as v1 from "./v1";
 import * as transformations from "./transformations";
 import * as helm from "./helm";
+
 export { v1, transformations, helm };
-//# sourceMappingURL=index.d.ts.map

package/lib/kubernetes/transformations/filter.ts

@@ -0,0 +1,43 @@
+import * as pulumi from "@pulumi/pulumi";
+
+export interface FilterArgs {
+  /**
+   * API group
+   */
+  group: string;
+  /**
+   * Kind
+   */
+  kind: string;
+}
+
+export const filter = (filters: FilterArgs[], only?: boolean) => {
+  if (only === undefined) {
+    only = false;
+  }
+
+  return (o: any, opts: pulumi.CustomResourceOptions): void => {
+    if (o === undefined || o.apiVersion === undefined || o.kind === undefined) {
+      return;
+    }
+
+    const apiVersionSplit = o.apiVersion.split("/", 2) as string[];
+    const objectGroup = (apiVersionSplit.length > 1 ? apiVersionSplit[0] : "").toLowerCase();
+    const objectKind = o.kind.toLowerCase();
+
+    for (const filter of filters) {
+      const filterGroup = filter.group.toLowerCase();
+      const filterKind = filter.kind.toLowerCase();
+
+      if (only === false && objectGroup === filterGroup && objectKind === filterKind) {
+        o.apiVersion = "v1";
+        o.kind = "List";
+        o.items = [];
+      } else if (only === true && (objectGroup !== filterGroup || objectKind !== filterKind)) {
+        o.apiVersion = "v1";
+        o.kind = "List";
+        o.items = [];
+      }
+    }
+  };
+};

package/lib/kubernetes/transformations/{index.d.ts → index.ts}

@@ -2,5 +2,5 @@ import { v1beta1Deprecations } from "./v1beta1Deprecations";
 import { metadataNamespace } from "./metadataNamespace";
 import { FilterArgs, filter } from "./filter";
 import { removeCrdDescriptions } from "./removeCrdDescriptions";
+
 export { v1beta1Deprecations, metadataNamespace, FilterArgs, filter, removeCrdDescriptions };
-//# sourceMappingURL=index.d.ts.map

package/lib/kubernetes/transformations/metadataNamespace.ts

@@ -0,0 +1,25 @@
+import * as pulumi from "@pulumi/pulumi";
+
+export const metadataNamespace = (namespace: pulumi.Input<string>) => {
+  return (o: any, opts: pulumi.CustomResourceOptions): void => {
+    if (o === undefined || o.apiVersion === undefined || o.kind === undefined) {
+      return;
+    }
+
+    if (o.apiVersion === "v1" && o.kind === "List") {
+      if (o.items === undefined) {
+        return;
+      }
+
+      for (const item of o.items) {
+        if (item.metadata !== undefined) {
+          item.metadata.namespace = namespace;
+        }
+      }
+    } else {
+      if (o.metadata !== undefined) {
+        o.metadata.namespace = namespace;
+      }
+    }
+  };
+};

package/lib/kubernetes/transformations/removeCrdDescriptions.ts

@@ -0,0 +1,78 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as k8s from "@pulumi/kubernetes";
+
+export const removeCrdDescriptions = (o: any, opts: pulumi.CustomResourceOptions): void => {
+  if (o === undefined || o.apiVersion === undefined || o.kind === undefined) {
+    return;
+  }
+
+  if (o.apiVersion !== "apiextensions.k8s.io/v1" || o.kind !== "CustomResourceDefinition") {
+    return;
+  }
+
+  if (o.spec === undefined || o.spec.versions === undefined) {
+    return;
+  }
+
+  o.spec.versions.forEach((v: k8s.types.input.apiextensions.v1.CustomResourceDefinitionVersion) => {
+    if (v.schema === undefined) {
+      return;
+    }
+
+    const schema = v.schema as k8s.types.input.apiextensions.v1.CustomResourceValidation;
+
+    if (schema.openAPIV3Schema === undefined) {
+      return;
+    }
+
+    removeDescription(schema.openAPIV3Schema);
+  });
+};
+
+const removeDescription = (o?: pulumi.Input<k8s.types.input.apiextensions.v1.JSONSchemaProps>): void => {
+  if (o === undefined) {
+    return;
+  }
+
+  const schemaProps = o as k8s.types.input.apiextensions.v1.JSONSchemaProps;
+
+  delete schemaProps.description;
+
+  if (schemaProps.allOf !== undefined) {
+    for (const p of schemaProps.allOf as pulumi.Input<k8s.types.input.apiextensions.v1.JSONSchemaProps>[]) {
+      removeDescription(p);
+    }
+  }
+
+  if (schemaProps.anyOf !== undefined) {
+    for (const p of schemaProps.anyOf as pulumi.Input<k8s.types.input.apiextensions.v1.JSONSchemaProps>[]) {
+      removeDescription(p);
+    }
+  }
+
+  removeDescription(schemaProps.not);
+
+  if (schemaProps.oneOf !== undefined) {
+    for (const p of schemaProps.oneOf as pulumi.Input<k8s.types.input.apiextensions.v1.JSONSchemaProps>[]) {
+      removeDescription(p);
+    }
+  }
+
+  if (schemaProps.patternProperties !== undefined) {
+    const patternProperties = schemaProps.patternProperties as {
+      [key: string]: k8s.types.input.apiextensions.v1.JSONSchemaProps;
+    };
+
+    for (const p in patternProperties) {
+      removeDescription(patternProperties[p]);
+    }
+  }
+
+  if (schemaProps.properties !== undefined) {
+    const properties = schemaProps.properties as { [key: string]: k8s.types.input.apiextensions.v1.JSONSchemaProps };
+
+    for (const p in properties) {
+      removeDescription(properties[p]);
+    }
+  }
+};

package/lib/kubernetes/transformations/v1beta1Deprecations.ts

@@ -0,0 +1,60 @@
+import * as pulumi from "@pulumi/pulumi";
+
+export const v1beta1Deprecations = (o: any, opts: pulumi.CustomResourceOptions): void => {
+  if (o === undefined || o.apiVersion === undefined || o.kind === undefined) {
+    return;
+  }
+
+  if (o.apiVersion === "apiregistration.k8s.io/v1beta1") {
+    if (o.kind === "APIService") {
+      o.apiVersion = "apiregistration.k8s.io/v1";
+    }
+  }
+
+  if (o.apiVersion === "storage.k8s.io/v1beta1") {
+    if (o.kind === "CSIDriver") {
+      o.apiVersion = "storage.k8s.io/v1";
+    }
+  }
+
+  if (o.apiVersion === "rbac.authorization.k8s.io/v1beta1") {
+    if (["ClusterRole", "ClusterRoleBinding", "Role", "RoleBinding"].includes(o.kind)) {
+      o.apiVersion = "rbac.authorization.k8s.io/v1";
+    }
+  }
+
+  if (o.apiVersion === "apiextensions.k8s.io/v1beta1") {
+    if (o.kind === "CustomResourceDefinition") {
+      o.apiVersion = "apiextensions.k8s.io/v1";
+    }
+  }
+
+  if (["extensions/v1beta1", "networking.k8s.io/v1beta1"].includes(o.apiVersion)) {
+    if (o.kind === "Ingress") {
+      o.apiVersion = "networking.k8s.io/v1";
+
+      if (o.spec !== undefined && o.spec.rules) {
+        for (const rule of o.spec.rules) {
+          if (rule.http !== undefined && rule.http.paths !== undefined) {
+            for (const path of rule.http.paths) {
+              const backend = path.backend;
+
+              if (backend.serviceName !== undefined && backend.servicePort !== undefined) {
+                path.backend = {
+                  service: {
+                    name: backend.serviceName,
+                    port: { number: backend.servicePort },
+                  },
+                };
+              }
+
+              if (path.pathType === undefined) {
+                path.pathType = "Prefix";
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+};

package/lib/kubernetes/v1/{index.d.ts → index.ts}

@@ -1,5 +1,15 @@
 import { ServiceArgs, Service } from "./service";
 import { PullSecret, PullSecretArgs } from "./pullSecret";
 import { NfsVolumeArgs, NfsVolume, NfsVolumesMapEntry, NfsVolumesMap, NfsVolumeConfig } from "./nfsVolume";
-export { ServiceArgs, Service, PullSecret, PullSecretArgs, NfsVolumeArgs, NfsVolume, NfsVolumesMapEntry, NfsVolumesMap, NfsVolumeConfig, };
-//# sourceMappingURL=index.d.ts.map
+
+export {
+  ServiceArgs,
+  Service,
+  PullSecret,
+  PullSecretArgs,
+  NfsVolumeArgs,
+  NfsVolume,
+  NfsVolumesMapEntry,
+  NfsVolumesMap,
+  NfsVolumeConfig,
+};

package/lib/kubernetes/v1/nfsVolume.ts

@@ -0,0 +1,145 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as random from "@pulumi/random";
+import * as k8s from "@pulumi/kubernetes";
+import { ComponentResource } from "../../common";
+
+export interface NfsVolumesMapEntry {
+  server: pulumi.Input<string>;
+  path: pulumi.Input<string>;
+  mountOptions?: pulumi.Input<pulumi.Input<string>[]>;
+}
+
+export interface NfsVolumesMap {
+  [key: string]: pulumi.Input<NfsVolumesMapEntry>;
+}
+
+export interface NfsVolumeConfig {
+  nfsVolume?: pulumi.Input<string>;
+  nfsVolumeSubPath?: pulumi.Input<string>;
+  nfsServer?: pulumi.Input<string>;
+  nfsPath?: pulumi.Input<string>;
+  mountOptions?: pulumi.Input<pulumi.Input<string>[]>;
+  mountPath?: pulumi.Input<string>;
+}
+
+export interface NfsVolumeArgs {
+  metadata: pulumi.Input<k8s.types.input.meta.v1.ObjectMeta>;
+  server: pulumi.Input<string>;
+  path: pulumi.Input<string>;
+  mountOptions?: pulumi.Input<pulumi.Input<string>[]>;
+  storage?: pulumi.Input<string>;
+  persistentVolumeReclaimPolicy?: pulumi.Input<string>;
+}
+
+export class NfsVolume extends ComponentResource {
+  public readonly persistentVolume: k8s.core.v1.PersistentVolume;
+  public readonly persistentVolumeClaim: k8s.core.v1.PersistentVolumeClaim;
+
+  /**
+   * Create a new NFS volume resource.
+   * @param name The name of the NFS volume resource.
+   * @param args A bag of arguments to control the NFS volume creation.
+   * @param opts A bag of options that control this resource's behavior.
+   */
+  constructor(name: string, args: NfsVolumeArgs, opts?: pulumi.ComponentResourceOptions) {
+    super("nfs-volume", name, args, opts);
+
+    const storage = args.storage || "1Gi";
+    const persistentVolumeReclaimPolicy = args.persistentVolumeReclaimPolicy || "Delete";
+
+    const emptyOpts = this.opts();
+    const k8sOpts = this.opts(k8s.Provider);
+
+    const persistentVolumeUUID = new random.RandomUuid(name, {}, emptyOpts);
+
+    this.persistentVolume = new k8s.core.v1.PersistentVolume(
+      name,
+      {
+        metadata: {
+          ...args.metadata,
+          name: pulumi
+            .all([args.metadata, persistentVolumeUUID.result])
+            .apply(([metadata, uuid]) => `${metadata.namespace}-${metadata.name}-${uuid}`),
+          namespace: undefined,
+        },
+        spec: {
+          accessModes: ["ReadWriteMany"],
+          capacity: { storage },
+          mountOptions: args.mountOptions,
+          nfs: { server: args.server, path: args.path },
+          persistentVolumeReclaimPolicy,
+          storageClassName: "",
+        },
+      },
+      k8sOpts
+    );
+
+    this.persistentVolumeClaim = new k8s.core.v1.PersistentVolumeClaim(
+      name,
+      {
+        metadata: args.metadata,
+        spec: {
+          accessModes: ["ReadWriteMany"],
+          storageClassName: "",
+          volumeName: this.persistentVolume.metadata.name,
+          resources: { requests: { storage } },
+        },
+      },
+      k8sOpts
+    );
+
+    this.registerOutputs();
+  }
+
+  public static fromConfig(
+    name: string,
+    args: {
+      metadata: pulumi.Input<k8s.types.input.meta.v1.ObjectMeta>;
+      config: pulumi.Input<NfsVolumeConfig>;
+      volumeMap?: pulumi.Input<NfsVolumesMap>;
+      storage?: pulumi.Input<string>;
+      persistentVolumeReclaimPolicy?: pulumi.Input<string>;
+    },
+    opts?: pulumi.ComponentResourceOptions
+  ): NfsVolume {
+    return new NfsVolume(
+      name,
+      {
+        metadata: args.metadata,
+        server: pulumi.all([args.config, args.volumeMap, args.metadata]).apply(([config, volumeMap, m]) => {
+          if (config.nfsVolume !== undefined && volumeMap !== undefined) {
+            const volumeEntry = volumeMap[config.nfsVolume];
+            return volumeEntry.server;
+          } else if (config.nfsServer !== undefined && config.nfsPath !== undefined) {
+            return config.nfsServer;
+          } else {
+            throw new Error("NFS volume config is not valid");
+          }
+        }),
+        path: pulumi.all([args.config, args.volumeMap]).apply(([config, volumeMap]) => {
+          if (config.nfsVolume !== undefined && volumeMap !== undefined) {
+            const volumeEntry = volumeMap[config.nfsVolume];
+            return config.nfsVolumeSubPath ? `${volumeEntry.path}/${config.nfsVolumeSubPath}` : volumeEntry.path;
+          } else if (config.nfsServer !== undefined && config.nfsPath !== undefined) {
+            return config.nfsPath;
+          } else {
+            throw new Error("NFS volume config is not valid");
+          }
+        }),
+        mountOptions: pulumi.all([args.config, args.volumeMap]).apply(([config, volumeMap]) => {
+          if (config.nfsVolume !== undefined && volumeMap !== undefined) {
+            const volumeEntry = volumeMap[config.nfsVolume];
+            return config.mountOptions || volumeEntry.mountOptions || [];
+          } else if (config.nfsServer !== undefined && config.nfsPath !== undefined) {
+            return config.mountOptions || [];
+          } else {
+            throw new Error("NFS volume config is not valid");
+          }
+        }),
+        storage: args.storage,
+        persistentVolumeReclaimPolicy: args.persistentVolumeReclaimPolicy,
+      },
+      opts
+    );
+  }
+}

package/lib/kubernetes/v1/pullSecret.ts

@@ -0,0 +1,37 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as k8s from "@pulumi/kubernetes";
+
+export interface PullSecretArgs {
+  metadata?: pulumi.Input<k8s.types.input.meta.v1.ObjectMeta>;
+  registry: pulumi.Input<string>;
+  username: pulumi.Input<string>;
+  password: pulumi.Input<string>;
+}
+
+export class PullSecret extends k8s.core.v1.Secret {
+  /**
+   * Create a new pull secret resource.
+   * @param name The name of the pull secret resource.
+   * @param args A bag of arguments to control the pull secret creation.
+   * @param opts A bag of options that control this resource's behavior.
+   */
+  constructor(name: string, args: PullSecretArgs, opts?: pulumi.CustomResourceOptions) {
+    const dockerConfigJSON = pulumi.all([args.registry, args.username, args.password]).apply((r) => {
+      const auths: { [key: string]: { [key: string]: string } } = {};
+
+      auths[r[0]] = { auth: Buffer.from(r[1] + ":" + r[2]).toString("base64") };
+
+      return Buffer.from(JSON.stringify({ auths })).toString("base64");
+    });
+
+    super(
+      name,
+      {
+        metadata: args.metadata,
+        type: "kubernetes.io/dockerconfigjson",
+        data: { ".dockerconfigjson": dockerConfigJSON },
+      },
+      opts
+    );
+  }
+}