@ydkn/pulumi-components 0.4.2 → 0.4.4

package/lib/kubernetes/v1/service.ts

@@ -0,0 +1,58 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as k8s from "@pulumi/kubernetes";
+
+export interface ServiceArgs {
+  metadata: pulumi.Input<k8s.types.input.meta.v1.ObjectMeta>;
+  spec: pulumi.Input<k8s.types.input.core.v1.ServiceSpec>;
+  hostnames?: pulumi.Input<pulumi.Input<string>[]>;
+  target?: pulumi.Input<string>;
+}
+
+export class Service extends k8s.core.v1.Service {
+  public readonly hostnames?: pulumi.Output<pulumi.Output<string>[]>;
+
+  /**
+   * Create a new service resource.
+   * @param name The name of the service resource.
+   * @param args A bag of arguments to control the service creation.
+   * @param opts A bag of options that control this resource's behavior.
+   */
+  constructor(name: string, args: ServiceArgs, opts?: pulumi.CustomResourceOptions) {
+    const serviceArgs = pulumi
+      .all([args.metadata, args.spec, args.hostnames, args.target])
+      .apply(([metadataWrapped, specWrapped, hostnames, target]) =>
+        pulumi.all(hostnames ?? []).apply((hostnames) => {
+          const metadata = metadataWrapped as k8s.types.input.meta.v1.ObjectMeta;
+          const spec = specWrapped as k8s.types.input.core.v1.ServiceSpec;
+
+          if (metadata.annotations === undefined) {
+            metadata.annotations = {};
+          }
+
+          const annotations: { [key: string]: pulumi.Input<string> } = {};
+
+          if (hostnames !== undefined && hostnames.length > 0) {
+            annotations["external-dns.alpha.kubernetes.io/hostname"] = hostnames.join(",");
+          }
+
+          if (target !== undefined) {
+            annotations["external-dns.alpha.kubernetes.io/target"] = target;
+          }
+
+          metadata.annotations = { ...annotations, ...metadata.annotations };
+
+          spec.ipFamilyPolicy = "PreferDualStack";
+
+          return { metadata, spec };
+        })
+      );
+
+    super(name, serviceArgs, opts);
+
+    if (args.hostnames !== undefined) {
+      this.hostnames = pulumi
+        .all([args.hostnames])
+        .apply(([hostnames]) => hostnames.map((hostname) => pulumi.output(hostname)));
+    }
+  }
+}

package/lib/localPathProvisioner/deployment.ts

@@ -0,0 +1,88 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as k8s from "@pulumi/kubernetes";
+import { ComponentResource } from "../common";
+import * as kubernetes from "../kubernetes";
+
+export interface LocalPathProvisionerArgs {
+  namespace?: pulumi.Input<string>;
+  storagePath: pulumi.Input<string>;
+  replicas?: pulumi.Input<number>;
+  defaultClass?: pulumi.Input<boolean>;
+  nodeSelector?: pulumi.Input<{ [key: string]: pulumi.Input<string> }>;
+}
+
+export class LocalPathProvisioner extends ComponentResource {
+  private readonly helmRelease: kubernetes.helm.v3.Release;
+  public readonly namespace: pulumi.Output<string>;
+
+  /**
+   * Create a new local path provisioner resource.
+   * @param name The name of the local path provisioner resource.
+   * @param args A bag of arguments to control the local path provisioner creation.
+   * @param opts A bag of options that control this resource's behavior.
+   */
+  constructor(name: string, args: LocalPathProvisionerArgs, opts?: pulumi.ComponentResourceOptions) {
+    super("local-path-provisioner", 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.containeroo.ch" },
+        chart: "local-path-provisioner",
+        values: {
+          fullnameOverride: name,
+          replicaCount: args.replicas,
+          storageClass: { defaultClass: args.defaultClass ?? false },
+          nodePathMap: [
+            {
+              node: "DEFAULT_PATH_FOR_NON_LISTED_NODES",
+              paths: [args.storagePath],
+            },
+          ],
+          nodeSelector: args.nodeSelector,
+          tolerations: [
+            { key: "node-role.kubernetes.io/master", operator: "Exists", effect: "NoSchedule" },
+            { key: "node-role.kubernetes.io/control-plane", operator: "Exists", effect: "NoSchedule" },
+          ],
+          affinity: {
+            podAntiAffinity: {
+              preferredDuringSchedulingIgnoredDuringExecution: [
+                {
+                  weight: 100,
+                  podAffinityTerm: {
+                    labelSelector: {
+                      matchExpressions: [
+                        { key: "app.kubernetes.io/name", operator: "In", values: [name] },
+                        { key: "app.kubernetes.io/instance", operator: "In", values: [name] },
+                      ],
+                    },
+                    topologyKey: "kubernetes.io/hostname",
+                  },
+                },
+              ],
+            },
+          },
+          resources: {
+            requests: { memory: "64Mi" },
+            limits: { memory: "96Mi" },
+          },
+        },
+      },
+      opts
+    );
+
+    this.registerOutputs();
+  }
+}

package/lib/localPathProvisioner/index.ts

@@ -0,0 +1,3 @@
+import { LocalPathProvisionerArgs, LocalPathProvisioner } from "./deployment";
+
+export { LocalPathProvisionerArgs, LocalPathProvisioner };

package/lib/loki/deployment.ts

@@ -0,0 +1,122 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as k8s from "@pulumi/kubernetes";
+import { ComponentResource } from "../common";
+import * as kubernetes from "../kubernetes";
+import { DataSource } from "../grafana";
+
+export interface LokiArgs {
+  namespace?: pulumi.Input<string>;
+  hostname?: pulumi.Input<string>;
+  storageClassName?: pulumi.Input<string>;
+  storage?: pulumi.Input<string>;
+  retention?: pulumi.Input<string>;
+  replicas?: pulumi.Input<number>;
+  grafanaDatasourceName?: pulumi.Input<string>;
+}
+
+export class Loki extends ComponentResource {
+  private readonly helmRelease: kubernetes.helm.v3.Release;
+  private readonly grafanaDatasource: DataSource;
+  public readonly namespace: pulumi.Output<string>;
+  public readonly url: pulumi.Output<string>;
+
+  /**
+   * Create a new loki resource.
+   * @param name The name of the loki resource.
+   * @param args A bag of arguments to control the loki creation.
+   * @param opts A bag of options that control this resource's behavior.
+   */
+  constructor(name: string, args: LokiArgs, opts?: pulumi.ComponentResourceOptions) {
+    super("loki", name, args, opts);
+
+    opts = this.opts(k8s.Provider);
+
+    if (args.storage === undefined) {
+      args.storage = "10Gi";
+    }
+
+    if (args.retention === undefined) {
+      args.retention = "1440h";
+    }
+
+    this.namespace = args.namespace
+      ? pulumi.output(args.namespace)
+      : new k8s.core.v1.Namespace(name, { metadata: { name } }, opts).metadata.name;
+
+    this.url = pulumi.concat(
+      "http://",
+      pulumi.output(args.hostname ?? pulumi.concat(name, ".", this.namespace, ".", "svc")),
+      ":3100"
+    );
+
+    this.helmRelease = new kubernetes.helm.v3.Release(
+      name,
+      {
+        name,
+        namespace: this.namespace,
+        repositoryOpts: { repo: "https://grafana.github.io/helm-charts" },
+        chart: "loki",
+        values: {
+          fullnameOverride: name,
+          loki: {
+            auth_enabled: false,
+            limits_config: {
+              reject_old_samples_max_age: "24h",
+              retention_period: "2160h",
+            },
+            commonConfig: {
+              replication_factor: args.replicas ?? 1,
+            },
+            storage: {
+              type: "filesystem",
+            },
+            compactor: {
+              retention_enabled: true,
+            },
+          },
+          singleBinary: {
+            replicas: args.replicas ?? 1,
+            persistence: { storageClass: args.storageClassName, size: args.storage },
+            resources: {
+              requests: { memory: "192Mi" },
+              limits: { memory: "256Mi" },
+            },
+          },
+          gateway: {
+            replicas: args.replicas ?? 1,
+            verboseLogging: false,
+            service: {
+              annotations: args.hostname
+                ? {
+                    "external-dns.alpha.kubernetes.io/hostname": args.hostname,
+                  }
+                : {},
+            },
+            resources: {},
+          },
+          monitoring: {
+            serviceMonitor: { enabled: true },
+            selfMonitoring: {
+              enabled: false,
+              grafanaAgent: { installOperator: false },
+            },
+          },
+        },
+      },
+      opts
+    );
+
+    this.grafanaDatasource = new DataSource(
+      `${name}-grafana-datasource`,
+      {
+        metadata: { namespace: this.namespace, name: pulumi.interpolate`${name}-grafana-datasource` },
+        type: "loki",
+        name: pulumi.all([args.grafanaDatasourceName]).apply(([dsName]) => dsName ?? "Loki"),
+        url: pulumi.concat("http://", name, ".", this.namespace, ".", "svc", ":3100"),
+      },
+      opts
+    );
+
+    this.registerOutputs();
+  }
+}

package/lib/loki/index.ts

@@ -0,0 +1,3 @@
+import { LokiArgs, Loki } from "./deployment";
+
+export { LokiArgs, Loki };

package/lib/metallb/controller.ts

@@ -0,0 +1,96 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as k8s from "@pulumi/kubernetes";
+import { ComponentResource } from "../common";
+import * as helm from "../kubernetes/helm";
+
+export interface MetalLBArgs {
+  namespace?: pulumi.Input<string>;
+}
+
+export class MetalLB extends ComponentResource {
+  private readonly helmRelease: helm.v3.Release;
+  public readonly namespace: pulumi.Output<string>;
+
+  /**
+   * Create a new MetalLB resource.
+   * @param name The name of MetalLB resource.
+   * @param args A bag of arguments to control the MetalLB creation.
+   * @param opts A bag of options that control this resource's behavior.
+   */
+  constructor(name: string, args: MetalLBArgs, opts?: pulumi.ComponentResourceOptions) {
+    super("metallb", name, args, opts);
+
+    opts = this.opts(k8s.Provider);
+
+    this.namespace = args.namespace
+      ? pulumi.output(args.namespace)
+      : new k8s.core.v1.Namespace(name, { metadata: { name } }, opts).metadata.name;
+
+    this.helmRelease = new helm.v3.Release(
+      name,
+      {
+        name,
+        namespace: this.namespace,
+        repositoryOpts: { repo: "https://metallb.github.io/metallb" },
+        chart: "metallb",
+        values: {
+          fullnameOverride: name,
+          prometheus: {
+            serviceAccount: "default",
+            namespace: this.namespace,
+            podMonitor: {
+              enabled: true,
+              metricRelabelings: [
+                {
+                  action: "drop",
+                  sourceLabels: ["__name__"],
+                  regex: ["go_.*"].join("|"),
+                },
+              ],
+            },
+            prometheusRule: { enabled: false },
+          },
+          controller: {
+            affinity: {
+              podAntiAffinity: {
+                preferredDuringSchedulingIgnoredDuringExecution: [
+                  {
+                    weight: 100,
+                    podAffinityTerm: {
+                      labelSelector: {
+                        matchExpressions: [
+                          { key: "app.kubernetes.io/name", operator: "In", values: ["metallb"] },
+                          { key: "app.kubernetes.io/instance", operator: "In", values: [name] },
+                          { key: "app.kubernetes.io/component", operator: "In", values: ["controller"] },
+                        ],
+                      },
+                      topologyKey: "kubernetes.io/hostname",
+                    },
+                  },
+                ],
+              },
+            },
+            tolerations: [
+              { key: "node-role.kubernetes.io/master", operator: "Exists", effect: "NoSchedule" },
+              { key: "node-role.kubernetes.io/control-plane", operator: "Exists", effect: "NoSchedule" },
+            ],
+            resources: {
+              requests: { memory: "48Mi" },
+              limits: { memory: "64Mi" },
+            },
+          },
+          speaker: {
+            tolerateMaster: false,
+            resources: {
+              requests: { memory: "64Mi" },
+              limits: { memory: "96Mi" },
+            },
+          },
+        },
+      },
+      opts
+    );
+
+    this.registerOutputs();
+  }
+}

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

@@ -1,5 +1,14 @@
 import { MetalLBArgs, MetalLB } from "./controller";
 import { IPAddressPoolSpecArgs, IPAddressPoolArgs, IPAddressPool } from "./ipAddressPool";
 import { L2AdvertisementSpecArgs, L2AdvertisementArgs, L2Advertisement } from "./l2Advertisement";
-export { MetalLBArgs, MetalLB, IPAddressPoolSpecArgs, IPAddressPoolArgs, IPAddressPool, L2AdvertisementSpecArgs, L2AdvertisementArgs, L2Advertisement, };
-//# sourceMappingURL=index.d.ts.map
+
+export {
+  MetalLBArgs,
+  MetalLB,
+  IPAddressPoolSpecArgs,
+  IPAddressPoolArgs,
+  IPAddressPool,
+  L2AdvertisementSpecArgs,
+  L2AdvertisementArgs,
+  L2Advertisement,
+};

package/lib/metallb/ipAddressPool.ts

@@ -0,0 +1,33 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as k8s from "@pulumi/kubernetes";
+
+export interface IPAddressPoolSpecArgs {
+  addresses: pulumi.Input<pulumi.Input<string>[]>;
+  autoAssign?: pulumi.Input<boolean>;
+}
+
+export interface IPAddressPoolArgs {
+  metadata: pulumi.Input<k8s.types.input.meta.v1.ObjectMeta>;
+  spec: pulumi.Input<IPAddressPoolSpecArgs>;
+}
+
+export class IPAddressPool extends k8s.apiextensions.CustomResource {
+  /**
+   * Create a new IP address pool resource.
+   * @param name The name of the IP address pool resource.
+   * @param args A bag of arguments to control the IP address pool creation.
+   * @param opts A bag of options that control this resource's behavior.
+   */
+  constructor(name: string, args: IPAddressPoolArgs, opts?: pulumi.CustomResourceOptions) {
+    super(
+      name,
+      {
+        apiVersion: "metallb.io/v1beta1",
+        kind: "IPAddressPool",
+        metadata: args.metadata,
+        spec: args.spec,
+      },
+      opts
+    );
+  }
+}

package/lib/metallb/l2Advertisement.ts

@@ -0,0 +1,34 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as k8s from "@pulumi/kubernetes";
+
+export interface L2AdvertisementSpecArgs {
+  ipAddressPoolSelectors?: pulumi.Input<pulumi.Input<k8s.types.input.meta.v1.LabelSelector>[]>;
+  ipAddressPools?: pulumi.Input<pulumi.Input<string>[]>;
+  nodeSelectors?: pulumi.Input<pulumi.Input<k8s.types.input.meta.v1.LabelSelector>[]>;
+}
+
+export interface L2AdvertisementArgs {
+  metadata: pulumi.Input<k8s.types.input.meta.v1.ObjectMeta>;
+  spec: pulumi.Input<L2AdvertisementSpecArgs>;
+}
+
+export class L2Advertisement extends k8s.apiextensions.CustomResource {
+  /**
+   * Create a new L2 advertisement resource.
+   * @param name The name of the L2 advertisement resource.
+   * @param args A bag of arguments to control the L2 advertisement creation.
+   * @param opts A bag of options that control this resource's behavior.
+   */
+  constructor(name: string, args: L2AdvertisementArgs, opts?: pulumi.CustomResourceOptions) {
+    super(
+      name,
+      {
+        apiVersion: "metallb.io/v1beta1",
+        kind: "L2Advertisement",
+        metadata: args.metadata,
+        spec: args.spec,
+      },
+      opts
+    );
+  }
+}

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

@@ -1,4 +1,4 @@
 import { Node } from "./node";
 import { KubernetesArgs, Kubernetes } from "./kubernetes";
+
 export { Node, KubernetesArgs, Kubernetes };
-//# sourceMappingURL=index.d.ts.map

package/lib/node/kubernetes.ts

@@ -0,0 +1,129 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as k8s from "@pulumi/kubernetes";
+import { ComponentResource } from "../common";
+import { DnsEndpointsArgs, DnsEndpoint } from "../externalDns";
+import { Node } from "./node";
+
+export interface KubernetesArgs {
+  namespace?: pulumi.Input<string>;
+  nodes: pulumi.Input<pulumi.Input<Node>[]>;
+  clusterName: pulumi.Input<string>;
+  domain: pulumi.Input<string>;
+  ipType?: pulumi.Input<string>;
+}
+
+export class Kubernetes extends ComponentResource {
+  private readonly api: pulumi.Output<DnsEndpoint>;
+  private readonly nodes: pulumi.Output<DnsEndpoint[]>;
+
+  /**
+   * Create a new node dns endpoints resource.
+   * @param name The name of the node dns endpoints resource.
+   * @param args A bag of arguments to control the node dns endpoints creation.
+   * @param opts A bag of options that control this resource's behavior.
+   */
+  constructor(name: string, args: KubernetesArgs, opts?: pulumi.ComponentResourceOptions) {
+    super("node:kubernetes", name, args, opts);
+
+    opts = this.opts(k8s.Provider);
+
+    const namespace = args.namespace ?? "kube-system";
+    const ipType = args.ipType ?? "private";
+
+    this.api = pulumi.all([args.nodes, args.domain, ipType]).apply(
+      ([nodes, domain, ipType]) =>
+        new DnsEndpoint(
+          `${name}-api`,
+          {
+            metadata: { namespace, name: `${name}-api` },
+            spec: {
+              endpoints: pulumi.all(nodes).apply((nodes) => {
+                const dnsName = pulumi.interpolate`api.${domain}`;
+                const ipv4Endpoints: pulumi.Input<string>[] = [];
+                const ipv6Endpoints: pulumi.Input<string>[] = [];
+                const endpoints: DnsEndpointsArgs[] = [];
+
+                for (const node of nodes) {
+                  if ((node.roles ?? []).includes("controller")) {
+                    const nodeIPs = this.nodeIPs(node, ipType);
+
+                    ipv4Endpoints.push(...nodeIPs.ipv4Adresses);
+                    ipv6Endpoints.push(...nodeIPs.ipv6Addresses);
+                  }
+                }
+
+                if (ipv4Endpoints.length > 0) {
+                  endpoints.push({ dnsName, recordType: "A", targets: ipv4Endpoints });
+                }
+
+                if (ipv6Endpoints.length > 0) {
+                  endpoints.push({ dnsName, recordType: "AAAA", targets: ipv6Endpoints });
+                }
+
+                return endpoints;
+              }),
+            },
+          },
+          opts
+        )
+    );
+
+    this.nodes = pulumi
+      .all([args.nodes, args.domain, args.clusterName, ipType])
+      .apply(([nodes, domain, clusterName, ipType]) =>
+        nodes.map((node) => {
+          const dnsName = pulumi.interpolate`${node.hostname.replace(`${clusterName}-`, "")}.${domain}`;
+          const endpoints: DnsEndpointsArgs[] = [];
+
+          const nodeIPs = this.nodeIPs(node, ipType);
+
+          if (nodeIPs.ipv4Adresses.length > 0) {
+            endpoints.push({ dnsName, recordType: "A", targets: nodeIPs.ipv4Adresses });
+          }
+
+          if (nodeIPs.ipv6Addresses.length > 0) {
+            endpoints.push({ dnsName, recordType: "AAAA", targets: nodeIPs.ipv6Addresses });
+          }
+
+          return new DnsEndpoint(
+            `${name}-${node.hostname}`,
+            {
+              metadata: { namespace, name: `${name}-${node.hostname}` },
+              spec: { endpoints },
+            },
+            opts
+          );
+        })
+      );
+
+    this.registerOutputs();
+  }
+
+  private nodeIPs(
+    node: Node,
+    ipType: string
+  ): { ipv4Adresses: pulumi.Input<string>[]; ipv6Addresses: pulumi.Input<string>[] } {
+    const ipv4Adresses: pulumi.Input<string>[] = [];
+    const ipv6Addresses: pulumi.Input<string>[] = [];
+
+    if (ipType === "private") {
+      if (node.privateIpv4Address !== undefined) {
+        ipv4Adresses.push(node.privateIpv4Address);
+      }
+
+      if (node.privateIpv6Address !== undefined) {
+        ipv6Addresses.push(node.privateIpv6Address);
+      }
+    } else {
+      if (node.ipv4Address !== undefined) {
+        ipv4Adresses.push(node.ipv4Address);
+      }
+
+      if (node.ipv6Address !== undefined) {
+        ipv6Addresses.push(node.ipv6Address);
+      }
+    }
+
+    return { ipv4Adresses, ipv6Addresses };
+  }
+}

package/lib/node/node.ts

@@ -0,0 +1,17 @@
+import * as pulumi from "@pulumi/pulumi";
+
+export interface Node {
+  id?: pulumi.Input<string>;
+  hostname: pulumi.Input<string>;
+  roles?: pulumi.Input<pulumi.Input<string>[]>;
+  ipv4Address?: pulumi.Input<string>;
+  privateIpv4Address?: pulumi.Input<string>;
+  ipv6Address?: pulumi.Input<string>;
+  privateIpv6Address?: pulumi.Input<string>;
+  labels?: pulumi.Input<{ [key: string]: pulumi.Input<string> }>;
+  taints?: pulumi.Input<
+    pulumi.Input<{ effect: pulumi.Input<string>; key: pulumi.Input<string>; value: pulumi.Input<string> }>[]
+  >;
+  username?: pulumi.Input<string>;
+  privateKey?: pulumi.Input<string>;
+}