feat: refactor structure

l0/.gitignore

@@ -1,2 +1,3 @@
 /bin/
 /node_modules/
+urban.yaml

l0/Pulumi.prod.yaml

@@ -0,0 +1,3 @@
+config:
+  l0:hcloudToken:
+    secure: AAABAKCOWasK5ERVovDiOdG/Fuu8hzuCCON2aX48EoWNDp6uFSFTXOVo6fq8Y40w+llsfRkoBYey6X5Y+TrB8mAEoxVQ4KF1BmxOQBX8Gia4D12vDH7FNR8Y2nF4jAsx

l0/cloud_providers/hetzner/HCloudOrchestrator.ts

@@ -5,15 +5,14 @@ import {ICloudOrchestrator} from "../../common/interfaces/ICloudOrchestrator";
 import {Input, Output} from "@pulumi/pulumi";
 import {HCloudServer} from "./HCloudServer";
 
-export class HCloudOrchestrator implements ICloudOrchestrator {
+export class HCloudOrchestrator {
 
   private readonly provider: hcloud.Provider
   private datacenterId: string
   private location: string
 
-  constructor(token:Input<string>, datacenterId: string, location: string) {
-    this.provider = new hcloud.Provider("hcloud-provider", { token: token})
-
+  constructor(provider: hcloud.Provider, datacenterId: string, location: string) {
+this.provider = provider
     this.datacenterId = datacenterId
     this.location = location
   }
@@ -30,44 +29,45 @@ export class HCloudOrchestrator implements ICloudOrchestrator {
           type: "cloud",
           networkZone: "eu-central",
           ipRange: "10.0.1.0/24",
-        }
+        }, {provider: this.provider}
     );
   }
 
   createServer(
-      publicKeys: Array<string>,
+      sshKeys: Array<hcloud.SshKey>,
       network: hcloud.Network,
       serverType: string,
+      userData: Input<string>,
       name: string,
   ) {
 
-    const  sshKeys = publicKeys.map(it => new hcloud.SshKey("standard", {
-      publicKey: it,
-    }, {provider: this.provider}));
-    const primaryIpv4 = new hcloud.PrimaryIp(`${name}-primary_ip-v4`, {
-      datacenter: this.datacenterId,
-      type: "ipv4",
-      assigneeType: "server",
-      autoDelete: true,
-      labels: {
-        hallo: "welt",
-      },
-    }, {provider: this.provider});
-    const primaryIpv6 = new hcloud.PrimaryIp(`${name}-primary_ip-v6`, {
-      datacenter: this.datacenterId,
-      type: "ipv6",
-      assigneeType: "server",
-      autoDelete: true,
-      labels: {
-        hallo: "welt",
-      },
-    }, {provider: this.provider});
+
+    // const primaryIpv4 = new hcloud.PrimaryIp(`${name}-primary_ip-v4`, {
+    //   datacenter: this.datacenterId,
+    //   type: "ipv4",
+    //   assigneeType: "server",
+    //   autoDelete: true,
+    //   labels: {
+    //     hallo: "welt",
+    //   },
+    // }, {provider: this.provider});
+    // const primaryIpv6 = new hcloud.PrimaryIp(`${name}-primary_ip-v6`, {
+    //   datacenter: this.datacenterId,
+    //   type: "ipv6",
+    //   assigneeType: "server",
+    //   autoDelete: true,
+    //   labels: {
+    //     hallo: "welt",
+    //   },
+    // }, {provider: this.provider});
     //const volume = this.createVolume(name)
     const server = new hcloud.Server(name, {
       serverType: serverType,
+      name: name,
       datacenter: this.datacenterId,
       image: "ubuntu-22.04",
       sshKeys: sshKeys.map(it => it.name),
+      userData: userData,
       publicNets: [
         {
           //ipv4Enabled: true,
@@ -84,11 +84,11 @@ export class HCloudOrchestrator implements ICloudOrchestrator {
   }
 
   createVolume(name: string) {
-    return new hcloud.Volume(`${name}-volume`, {
+    return pulumi.output(new hcloud.Volume(`${name}-volume`, {
       size: 25, // Size of the volume in GB
       location: this.location,
       format: "ext4", // Specify the format (optional)
-    }, {provider: this.provider});
+    }, {provider: this.provider}));
   }
 
   attachVolumeToServer(volume: hcloud.Volume, server: hcloud.Server) {

l0/common/interfaces/ICloudOrchestrator.ts

@@ -1,13 +1,14 @@
 import * as pulumi from "@pulumi/pulumi";
+import {Output} from "@pulumi/pulumi";
 
 export interface ICloudOrchestrator {
   createServer(sshKey: Array<string>,
                     network: any,
                     serverType: string,
-                    userData: string,
-                    name: string): any
-  createVolume(name: string, size: number): any;
-  createNetwork(name: string): any;
-  createSubnet(network: any, name: string): any
+                    userData: Output<string>,
+                    name: string): pulumi.Output<any>
+  createVolume(name: string, size: number): pulumi.Output<any>;
+  createNetwork(name: string): pulumi.Output<any>;
+  createSubnet(network: any, name: string): pulumi.Output<any>
   // ... other resource methods as needed ...
 }

l0/GitlabRunner.ts → l0/components/GitlabRunner.ts

@@ -1,7 +1,7 @@
 import * as k8s from "@pulumi/kubernetes";
 import {Namespace} from "@pulumi/kubernetes/core/v1";
-import {createService} from "../src/resources/kubernetes/Service";
-import {createRole, createRoleBinding, createServiceAccount} from "./Serviceaccounts";
+import {createService} from "../../src/resources/kubernetes/Service";
+import {createRole, createRoleBinding, createServiceAccount} from "../Serviceaccounts";
 
 const runnerToken = process.env.RUNNER_REGISTRATION_TOKEN!
 const runnerConfig = process.env.RUNNER_CONFIG!

l0/components/addons.ts

@@ -0,0 +1,76 @@
+import {apiextensions, helm, Provider} from "@pulumi/kubernetes";
+import {Secret} from "@pulumi/kubernetes/core/v1/secret";
+import {CustomResourceOptions, Input, Lifted, OutputInstance} from "@pulumi/pulumi";
+
+export function installCilium(opts: CustomResourceOptions) {
+  return new helm.v3.Chart("cilium", {
+    chart: "cilium",
+    version: "1.14.6",
+    namespace: "kube-system",
+    fetchOpts: {
+      repo: "https://helm.cilium.io/",
+    },
+  }, opts)
+}
+
+
+
+export function installCertManager(opts: CustomResourceOptions) {
+  return new helm.v3.Chart("cert-manager", {
+    chart: "cert-manager",
+    version: "v1.13.3",
+    fetchOpts: {
+      repo: "https://charts.jetstack.io",
+    },
+    namespace: "kube-system",
+    values: {
+      installCRDs: true,
+    },
+  }, opts);
+}
+
+export function installClusterIssuer(mail: Input<string>, opts: CustomResourceOptions) {
+  return new apiextensions.CustomResource("letsencrypt-issuer", {
+    apiVersion: "cert-manager.io/v1",
+    kind: "ClusterIssuer",
+    metadata: {
+      name: "letsencrypt-prod",
+    },
+    spec: {
+      acme: {
+        server: "https://acme-v02.api.letsencrypt.org/directory",
+        email: mail,
+        privateKeySecretRef: {
+          name: "letsencrypt-prod",
+        },
+        solvers: [{
+          http01: {
+            ingress: {
+              class: "traefik",
+            },
+          },
+        }],
+      },
+    },
+  }, opts);
+}
+
+export function installCSIDriver(token: Input<string>, opts: CustomResourceOptions) {
+  new Secret("hcloud-token",{
+    metadata: {
+      name: "hcloud",
+      namespace: "kube-system"
+    },
+    stringData: {
+      "token": token
+    }
+  },opts)
+
+  return new helm.v3.Chart("hcloud-csi", {
+    chart: "hcloud-csi",
+    namespace: "kube-system",
+    fetchOpts: {
+      repo: "https://charts.hetzner.cloud/"
+    },
+  },opts)
+}

l0/index.ts

@@ -1,21 +1,45 @@
 import * as pulumi from "@pulumi/pulumi";
 import {createNamespace} from "./namespace";
-import {createGitlabRunner} from "./GitlabRunner";
+import {createGitlabRunner} from "./components/GitlabRunner";
 import * as gitlab from "@pulumi/gitlab";
 import * as github from "@pulumi/github";
-import {createCluster} from "./infra/nodes";
 import {Domain} from "@pulumi/mailgun";
+import * as hcloud from "@pulumi/hcloud"
 import {HCloudOrchestrator} from "./cloud_providers/hetzner/HCloudOrchestrator";
 import {K3sCluster} from "./k3s/K3sCluster";
+import * as fs from "fs";
+import {Provider} from "@pulumi/kubernetes";
+import {installCertManager, installCilium, installClusterIssuer, installCSIDriver} from "./components/addons";
+import {RandomPassword} from "@pulumi/random";
 
 
 const config = new pulumi.Config();
+const clusterName = "urban"
+const filename = `${clusterName}.yaml`;
+const mail = config.get("emailAdress")
 const hcloudToken = config.requireSecret("hcloudToken");
 const datacenterId = "fsn1-dc14"
 const location = "fsn1"
-const hetznerOrchestrator = new HCloudOrchestrator(hcloudToken, datacenterId, location);
-const k3sCluster = new K3sCluster(hetznerOrchestrator);
-// if gitlab
+const provider = new hcloud.Provider("hcloud-provider", { token: hcloudToken})
+const hetznerOrchestrator = new HCloudOrchestrator(provider, datacenterId, location);
+const k3sToken = new RandomPassword("k3sToken", {
+  special: false,
+  length: 30
+})
+const k3sCluster = new K3sCluster(hetznerOrchestrator, provider, hcloudToken, k3sToken);
+const result = k3sCluster.createCluster(clusterName, true)
+// Write to a file
+result.kubeconfig.apply(value => {
+  fs.writeFileSync(filename, value, 'utf8');
+  console.log(`File written: ${filename}`);
+});
+
+const kubernetesProvider = new Provider("kube-provider", {kubeconfig: result.kubeconfig, cluster: clusterName, context: clusterName })
+const cilium = installCilium({provider:kubernetesProvider});
+installCSIDriver(hcloudToken,{provider: kubernetesProvider, dependsOn: [cilium]})
+const certManager = installCertManager({provider:kubernetesProvider})
+installClusterIssuer(mail,{provider: kubernetesProvider, dependsOn: [certManager]})
+
 
 // const example = new gitlab.GroupVariable("kubeconfig", {
 //   environmentScope: "*",

l0/k3s/K3sCluster.ts

@@ -3,34 +3,66 @@ import * as cloudinit from "@pulumi/cloudinit"
 import * as command from "@pulumi/command"
 import * as pulumi from "@pulumi/pulumi";
 import * as hcloud from "@pulumi/hcloud";
-import {Input} from "@pulumi/pulumi";
-import {createCluster} from "../infra/nodes";
-import {ICloudOrchestrator} from "../common/interfaces/ICloudOrchestrator";
 import {CloudProviderTypes} from "../common/types/cloudProviderTypes";
+import {masterConfig, workerConfig} from "./cloudinit";
+import {Input} from "@pulumi/pulumi";
+import {HCloudOrchestrator} from "../cloud_providers/hetzner/HCloudOrchestrator";
+import * as tls from "@pulumi/tls";
+import {PrivateKey} from "@pulumi/tls";
+import {updateKubeConfig} from "../utils";
+import {RandomPassword} from "@pulumi/random";
 
 
 export class K3sCluster<T extends keyof CloudProviderTypes> {
-  private orchestrator: ICloudOrchestrator;
+  private orchestrator: HCloudOrchestrator;
+  private provider: hcloud.Provider;
+  private hCloudToken: Input<string>;
+  private k3sToken: RandomPassword;
 
-  constructor(orchestrator: ICloudOrchestrator) {
+  constructor(orchestrator: HCloudOrchestrator, provider: hcloud.Provider, hCloudToken: Input<string>, k3sToken: RandomPassword) {
+    this.provider = provider;
     this.orchestrator = orchestrator;
-    this.createCluster()
+    this.hCloudToken = hCloudToken;
+    this.k3sToken = k3sToken;
   }
 
-   createCluster() {
+  createCluster(name: string, useCilium: boolean) {
+
+    const publicKeyHuman = fs.readFileSync('/Users/bjornurban/.ssh/id_rsa.pub', 'utf8');
+    const sshKey = new tls.PrivateKey("sshKey", {
+      algorithm: "RSA",
+      rsaBits: 4096,
+    });
+    const publicKeys = Array.of(pulumi.output(publicKeyHuman), sshKey.publicKeyOpenssh)
 
-    const publicKey = fs.readFileSync('/Users/bjornurban/.ssh/id_rsa.pub', 'utf8');
-    const publicKeys = Array.from(publicKey)
 
-     const userData = this.getCloudInit()
-// Create the SSH key resource on Hetzner Cloud
+    // Create the SSH key resource on Hetzner Cloud
     const network = this.orchestrator.createNetwork("main-network")
-    const subnet = this.orchestrator.createSubnet(network, "main-subnet")
+    //Network needs a subnet also we do not need to use the value later on manually
+    this.orchestrator.createSubnet(network, "main-subnet")
     const serverType = "cax21"
-    const initialNode = this.orchestrator.createServer(publicKeys, network, serverType, userData,"node-01")
+    const sshKeys = publicKeys.map((it, index) => new hcloud.SshKey(`ssh-${index}`, {
+      publicKey: it,
+    }, {provider: this.provider}));
+    const initialNode = this.orchestrator.createServer(sshKeys, network, serverType, masterConfig(this.k3sToken.result, useCilium), "master-01")
+    for (let i = 0; i < 1; i++) {
+      this.orchestrator.createServer(sshKeys, network, serverType, workerConfig(initialNode.ipv4Address, this.k3sToken.result, useCilium), `node-${i}`)
+    }
 
+    const kubeconfig = this.getConfig(initialNode.ipv4Address, sshKey); // Assuming this returns the kubeconfig as a string
+    const newContextName = `${name}`; // Replace with your new context name
+    const newClusterName = `${name}`; // Replace with your new cluster name
+    const updatedConfig = updateKubeConfig(kubeconfig, initialNode.ipv4Address, newContextName, newClusterName);
+  // Call the function
+    return {
+      "ip": initialNode.ipv4Address,
+      "sshKey": sshKey,
+      "kubeconfig": updatedConfig
+    }
   }
-   getCloudInit() {
+
+  getCloudInit(master: Boolean) {
+    const k3sInstallPath = master ? "./install-k3s-master.sh" : "./install-k3s.sh"
     return cloudinit.getConfig({
       gzip: false,
       base64Encode: false,
@@ -42,12 +74,13 @@ export class K3sCluster<T extends keyof CloudProviderTypes> {
         },
         {
           contentType: "text/x-shellscript",
-          content: fs.readFileSync("./install-k3s.sh", "utf8"),
+          content: fs.readFileSync(k3sInstallPath, "utf8"),
         },
       ],
     });
   }
-   createMasterNode(name: string, config: hcloud.ServerArgs, token: pulumi.Output<string>): pulumi.Output<hcloud.Server> {
+
+  createMasterNode(name: string, config: hcloud.ServerArgs, token: pulumi.Output<string>): pulumi.Output<hcloud.Server> {
     const modifiedConfig = {
       ...config,
       userData: token.apply(t => `#cloud-config\nyour-configuration-here\nK3S_TOKEN=${t}`),
@@ -56,7 +89,8 @@ export class K3sCluster<T extends keyof CloudProviderTypes> {
     const workerServer = new hcloud.Server(name, modifiedConfig);
     return pulumi.output(workerServer);
   }
-   createWorkerNode(name: string, config: hcloud.ServerArgs, token: pulumi.Output<string>): pulumi.Output<hcloud.Server> {
+
+  createWorkerNode(name: string, config: hcloud.ServerArgs, token: pulumi.Output<string>): pulumi.Output<hcloud.Server> {
     const modifiedConfig = {
       ...config,
       userData: token.apply(t => `#cloud-config\nyour-configuration-here\nK3S_TOKEN=${t}`),
@@ -65,17 +99,19 @@ export class K3sCluster<T extends keyof CloudProviderTypes> {
     const workerServer = new hcloud.Server(name, modifiedConfig);
     return pulumi.output(workerServer);
   }
-   getNodeToken(server: hcloud.Server, name: string): pulumi.Output<string> {
+
+  getNodeToken(server: hcloud.Server, name: string): pulumi.Output<string> {
     const tokenCommand = new command.local.Command(name, {
       create: `ssh user@${server.ipv4Address.apply(ip => ip)} 'cat /var/lib/rancher/k3s/server/node-token'`,
-    },{dependsOn: [server]});
+    }, {dependsOn: [server]});
 
     return tokenCommand.stdout;
   }
-   getConfig() {
+
+  getConfig(ip: Input<string>, sshKey: PrivateKey) {
     const fetchKubeconfig = new command.remote.Command("fetch-kubeconfig", {
       connection: {
-        host: k3sVm.ipv4Address,
+        host: ip,
         user: "root",
         privateKey: sshKey.privateKeyPem,
       },
@@ -84,10 +120,8 @@ export class K3sCluster<T extends keyof CloudProviderTypes> {
       // Then we sleep 10, just in-case the k3s server needs a moment to become healthy. Sorry?
           "until [ -f /etc/rancher/k3s/k3s.yaml ]; do sleep 5; done; cat /etc/rancher/k3s/k3s.yaml; sleep 10;",
     });
+    return fetchKubeconfig.stdout;
   }
-  const kubernetesProvider = new kubernetes.Provider("k3s", {
-    kubeconfig: fetchKubeconfig.stdout,
-  });
+}
 
 
-}

l0/k3s/cloudinit.ts

@@ -0,0 +1,31 @@
+import * as pulumi from "@pulumi/pulumi"
+import {Input, Output} from "@pulumi/pulumi";
+
+export const masterConfig = (k3sToken: Input<string>, disableFlannel: boolean): Output<string> => {
+  return pulumi.interpolate`
+  #cloud-config
+  users:
+    - name: k3s-user
+  groups: sudo
+  shell: /bin/bash
+  runcmd:
+    - | 
+      curl -sfL https://get.k3s.io | K3S_TOKEN=${k3sToken} K3S_KUBECONFIG_MODE="644" sh -s - server \
+      ${disableFlannel ? "--flannel-backend none --disable-network-policy" : ""} \
+      --cluster-init 
+  `;
+}
+
+export const workerConfig = (masterIp: Output<string>, k3sToken: Input<string>, disableFlannel: boolean): Output<string> => {
+  return pulumi.interpolate`
+  #cloud-config
+  users:
+    - name: k3s-user
+  groups: sudo
+  shell: /bin/bash
+  runcmd:
+    - | 
+      curl -sfL https://get.k3s.io | K3S_TOKEN=${k3sToken} K3S_KUBECONFIG_MODE="644" K3S_URL=https://${masterIp}:6443 sh -s - server \
+      ${disableFlannel ? "--flannel-backend none --disable-network-policy" : ""}
+  `;
+}

l0/package.json

@@ -9,6 +9,9 @@
         "@pulumi/kubernetes": "^3.30.2",
         "@pulumi/mailgun": "^3.4.1",
         "@pulumi/pulumi": "^3.0.0",
-        "@types/node": "^16"
+        "@pulumi/random": "^4.15.1",
+        "@pulumi/tls": "^5.0.0",
+        "@types/node": "^16",
+        "yaml": "^2.3.4"
     }
 }

l0/utils/index.ts

@@ -0,0 +1,74 @@
+import * as pulumi from "@pulumi/pulumi";
+import {parse, stringify} from "yaml";
+
+export function updateKubeConfig(
+    kubeconfig: pulumi.Input<string>,
+    serverIp: pulumi.Input<string>,
+    newContextName: string,
+    newClusterName: string
+): pulumi.Output<string> {
+  return pulumi.all([kubeconfig, serverIp]).apply(([kc, ip]) => {
+    // Parse the YAML kubeconfig to JSON
+    const config: KubeConfig = parse(kc);
+
+    // Replace the server address in all clusters
+    config.clusters.forEach((cluster: KubeCluster) => {
+      if (cluster.name === 'default') {
+        cluster.cluster.server = `https://${ip}:6443`;
+        cluster.name = newClusterName;
+      }
+    });
+
+    // Replace the context name in all contexts
+    config.contexts.forEach((context: KubeContext) => {
+      if (context.name === 'default') {
+        context.context.cluster = newClusterName; // Update cluster reference
+        context.name = newContextName; // Update context name
+      }
+    });
+
+    // Update current-context if it was 'default'
+    if (config['current-context'] === 'default') {
+      config['current-context'] = newContextName;
+    }
+
+    // Convert the modified JSON back to YAML
+    return stringify(config);
+  });
+}
+
+interface KubeContext {
+  context: {
+    cluster: string;
+    user: string;
+  };
+  name: string;
+}
+
+interface KubeConfig {
+  clusters: KubeCluster[];
+  contexts: KubeContext[];
+  'current-context': string;
+  // Add other properties of kubeconfig as needed
+}
+interface KubeCluster {
+  cluster: {
+    server: string;
+  };
+  name: string;
+}
+
+interface KubeContext {
+  context: {
+    cluster: string;
+    user: string;
+  };
+  name: string;
+}
+
+interface KubeConfig {
+  clusters: KubeCluster[];
+  contexts: KubeContext[];
+  'current-context': string;
+  // Add other properties of kubeconfig as needed
+}

l1/components/kafka/chart/Kafka.ts

@@ -0,0 +1,36 @@
+import * as k8s from "@pulumi/kubernetes";
+import {Namespace, Secret} from "@pulumi/kubernetes/core/v1";
+
+
+export function createKafka(namespace: Namespace, secret: Secret) {
+  return new k8s.helm.v3.Chart("kafka", {
+    chart: "kafka",
+    namespace: namespace.metadata.name,
+    fetchOpts: {
+      repo: "https://charts.bitnami.com/bitnami"
+    },
+    values: {
+      "auth":
+          {
+            "rbac": {
+              create: false,
+              "existingSecret": secret.metadata.name,
+              "existingSecretPasswordKey": "root-password"
+            },
+            client: {
+              //secureTransport: true,
+              //useAutoTLS: true
+              //existingSecret: etcdSecret.metadata.name
+            }
+          },
+      "persistence": {
+        "storageClass":"local-path",
+        "size": "3Gi"
+      },
+      nodeSelector: {
+        owner: "bjoern"
+      }
+
+    }
+  })
+}

l1/providers/charts/Postgres.ts → l1/components/postgres/chart/Postgres.ts

@@ -1,6 +1,6 @@
 import * as k8s from "@pulumi/kubernetes"
 import {Namespace} from "@pulumi/kubernetes/core/v1";
-import {dbUsername} from "../../../util/env";
+import {dbUsername} from "../../../../util/env";
 import {RandomPassword} from "@pulumi/random";
 
 

l1/postgres.ts → l1/components/postgres/index.ts

@@ -1,7 +1,7 @@
-import {DirectusConfig, Source} from "../util/types";
+import {DirectusConfig, Source} from "../../../util/types";
 
 import * as postgresql from "@pulumi/postgresql";
-import {createPostgresHelm} from "./providers/charts/Postgres";
+import {createPostgresHelm} from "./chart/Postgres";
 import {Namespace} from "@pulumi/kubernetes/core/v1";
 import {RandomPassword} from "@pulumi/random";
 

l1/providers/charts/Redis.ts → l1/components/redis/chart/Redis.ts

@@ -1,6 +1,6 @@
 import * as k8s from "@pulumi/kubernetes"
 import {Namespace} from "@pulumi/kubernetes/core/v1";
-import {redisDBPassword} from "../../../util/env";
+import {redisDBPassword} from "../../../../util/env";
 
 export function createRedisHelm(namespace: Namespace) {
   return new k8s.helm.v3.Chart("redis", {

l1/providers/Manual/Surreal.ts → l1/components/surrealdb/Manual/Surreal.ts

@@ -1,5 +1,5 @@
 import {ConfigMap, PersistentVolumeClaim, Service} from "@pulumi/kubernetes/core/v1";
-import {keelAnnotationsProd} from "../../../util/globals";
+import {keelAnnotationsProd} from "../../../../util/globals";
 import {Namespace, Secret} from "@pulumi/kubernetes/core/v1";
 import {RandomPassword} from "@pulumi/random";
 import exp = require("constants");

l1/index.ts

@@ -7,7 +7,7 @@ import {Config, secret} from "@pulumi/pulumi";
 import {Htpasswd, HtpasswdAlgorithm} from "pulumi-htpasswd";
 import * as k8s from "@pulumi/kubernetes";
 import {Secret} from "@pulumi/kubernetes/core/v1";
-import {createSurrealManual} from "./providers/Manual/Surreal";
+import {createSurrealManual} from "./components/surrealdb/Manual/Surreal";
 const namespacePostgres = createNamespace("postgres");
 export const postgresNamespace = namespacePostgres.metadata.name
 const namespaceEtcd = createNamespace("etcd")

l1/redis.ts

@@ -1,6 +1,6 @@
 import {Source} from "../util/types";
 import {Namespace} from "@pulumi/kubernetes/core/v1";
-import {createRedisHelm} from "./providers/charts/Redis";
+import {createRedisHelm} from "./components/redis/chart/Redis";
 
 export function createRedis(by: Source, namespace: Namespace) {
   switch (by) {

l1/surreal.ts

@@ -1,7 +1,7 @@
 import {DirectusConfig, Source} from "../util/types";
 
 import * as postgresql from "@pulumi/postgresql";
-import {createPostgresHelm} from "./providers/charts/Postgres";
+import {createPostgresHelm} from "./components/postgres/chart/Postgres";
 import {Namespace} from "@pulumi/kubernetes/core/v1";
 import {RandomPassword} from "@pulumi/random";