@ydkn/pulumi-components 0.4.2 → 0.4.3

package/lib/blocky/deployment.ts

@@ -0,0 +1,134 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as k8s from "@pulumi/kubernetes";
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+import { ComponentResource } from "../common";
+import * as kubernetes from "../kubernetes";
+import { Dashboard } from "../grafana";
+
+export interface BlockyArgs {
+  namespace?: pulumi.Input<string>;
+  nameservers?: pulumi.Input<pulumi.Input<string>[]>;
+  blocklists?: pulumi.Input<{ [key: string]: pulumi.Input<pulumi.Input<string>[]> }>;
+  hostname?: pulumi.Input<string>;
+  replicas?: pulumi.Input<number>;
+}
+
+export class Blocky extends ComponentResource {
+  private readonly helmRelease: kubernetes.helm.v3.Release;
+  private readonly service: kubernetes.v1.Service;
+  private readonly grafanaDashboard: Dashboard;
+  public readonly namespace: pulumi.Output<string>;
+
+  /**
+   * Create a new Blocky resource.
+   * @param name The name of the Blocky resource.
+   * @param args A bag of arguments to control the Blocky creation.
+   * @param opts A bag of options that control this resource's behavior.
+   */
+  constructor(name: string, args: BlockyArgs, opts?: pulumi.ComponentResourceOptions) {
+    super("blocky", 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;
+
+    const metadata = {
+      name,
+      namespace: this.namespace,
+      labels: {
+        "app.kubernetes.io/name": "blocky",
+        "app.kubernetes.io/instance": name,
+      },
+    };
+
+    this.helmRelease = new kubernetes.helm.v3.Release(
+      name,
+      {
+        name: metadata.name,
+        namespace: metadata.namespace,
+        repositoryOpts: { repo: "https://k8s-at-home.com/charts/" },
+        chart: "blocky",
+        values: {
+          fullnameOverride: name,
+          controller: { replicas: args.replicas },
+          config: pulumi.all([args.nameservers, args.blocklists]).apply(([nameservers, blocklists]) =>
+            yaml.dump({
+              logLevel: "warn",
+              logFormat: "json",
+              httpPort: 4000,
+              upstream: { default: nameservers ?? ["9.9.9.9", "149.112.112.112"] },
+              blocking: {
+                blackLists: blocklists,
+                clientGroupsBlock: { default: Object.keys(blocklists) },
+                blockType: "nxDomain",
+              },
+              caching: { prefetching: true },
+              prometheus: { enable: true, path: "/metrics" },
+            })
+          ),
+          metrics: { enabled: true, prometheusRule: { enabled: false } },
+          affinity: {
+            podAntiAffinity: {
+              preferredDuringSchedulingIgnoredDuringExecution: [
+                {
+                  weight: 100,
+                  podAffinityTerm: {
+                    labelSelector: {
+                      matchExpressions: [
+                        { key: "app.kubernetes.io/name", operator: "In", values: ["blocky"] },
+                        { key: "app.kubernetes.io/instance", operator: "In", values: [name] },
+                      ],
+                    },
+                    topologyKey: "kubernetes.io/hostname",
+                  },
+                },
+              ],
+            },
+          },
+          resources: {
+            requests: { memory: "64Mi" },
+            limits: { memory: "96Mi" },
+          },
+        },
+      },
+      opts
+    );
+
+    this.service = new kubernetes.v1.Service(
+      `${name}-dns`,
+      {
+        metadata: { ...metadata, name: pulumi.interpolate`${name}-dns` },
+        spec: {
+          selector: metadata.labels,
+          ports: [
+            { name: "udp", protocol: "UDP", port: 53 },
+            { name: "tcp", protocol: "TCP", port: 53 },
+          ],
+        },
+        hostnames: args.hostname ? [args.hostname] : undefined,
+      },
+      { ...opts, dependsOn: [this.helmRelease] }
+    );
+
+    this.grafanaDashboard = new Dashboard(
+      `${name}-grafana-dashboard`,
+      {
+        metadata: { ...metadata, name: pulumi.interpolate`${name}-grafana-dashboard` },
+        name: "blocky",
+        // 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/blocky/{index.d.ts → index.ts}

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