underpost 2.8.797 → 2.8.798

package/README.md

@@ -68,7 +68,7 @@ Run dev client server
 npm run dev
 ```
 <!-- -->
-## underpost ci/cd cli v2.8.797
+## underpost ci/cd cli v2.8.798
 
 ### Usage: `underpost [options] [command]`
   ```

package/cli.md

@@ -1,4 +1,4 @@
-## underpost ci/cd cli v2.8.797
+## underpost ci/cd cli v2.8.798
 
 ### Usage: `underpost [options] [command]`
   ```
@@ -222,6 +222,7 @@ Options:
   --config             Set k8s base node config
   --worker             Set worker node context
   --chown              Set k8s kube chown
+  --k3s                Initialize the cluster using K3s
   -h, --help           display help for command
  
 ```
@@ -299,6 +300,7 @@ Options:
   --secrets                            Dockerfile env secrets
   --secrets-path [secrets-path]        Dockerfile custom path env secrets
   --reset                              Build without using cache
+  --k3s-load                           Load image into K3s cluster.
   -h, --help                           display help for command
  
 ```
@@ -315,6 +317,7 @@ Options:
   --kind-load     Import tar image to Kind cluster
   --kubeadm-load  Import tar image to Kubeadm cluster
   --version       Set custom version
+  --k3s-load      Load image into K3s cluster.
   -h, --help      display help for command
  
 ```

package/docker-compose.yml

@@ -58,7 +58,7 @@ services:
           cpus: '0.25'
           memory: 20M
     labels: # labels in Compose file instead of Dockerfile
-      engine.version: '2.8.797'
+      engine.version: '2.8.798'
     networks:
       - load-balancer
 

package/manifests/deployment/dd-template-development/deployment.yaml

@@ -17,7 +17,7 @@ spec:
     spec:
       containers:
         - name: dd-template-development-blue
-          image: localhost/debian-underpost:v2.8.797
+          image: localhost/debian-underpost:v2.8.798
           #          resources:
           #            requests:
           #              memory: "124Ki"
@@ -100,7 +100,7 @@ spec:
     spec:
       containers:
         - name: dd-template-development-green
-          image: localhost/debian-underpost:v2.8.797
+          image: localhost/debian-underpost:v2.8.798
           #          resources:
           #            requests:
           #              memory: "124Ki"

package/manifests/lxd/underpost-setup.sh

@@ -3,7 +3,7 @@
 # Exit immediately if a command exits with a non-zero status.
 set -e
 
-echo "Starting Underpost Kubernetes Node Setup for Production (Kubeadm Use Case)..."
+echo "Starting Underpost Kubernetes Node Setup for Production (Kubeadm/K3s Use Case)..."
 
 # --- Disk Partition Resizing (Keep as is, seems functional) ---
 echo "Expanding /dev/sda2 partition and resizing filesystem..."
@@ -53,7 +53,7 @@ echo "
 ██╗░░░██╗███╗░░██╗██████╗░███████╗██████╗░██████╗░░█████╗░░██████╗████████╗
 ██║░░░██║████╗░██║██╔══██╗██╔════╝██╔══██╗██╔══██╗██╔══██╗██╔════╝╚══██╔══╝
 ██║░░░██║██╔██╗██║██║░░██║█████╗░░██████╔╝██████╔╝██║░░██║╚█████╗░░░░██║░░░
-██║░░░██║██║╚████║██║░░██║██╔══╝░░██╔══██╗██╔═══╝░██║░░██║░╚═══██╗░░░██║░░░
+██║░░░██║██║╚████║██║░░██║██╔══╝░░██╔══██╗██╔═╝░░░██║░░██║░╚═══██╗░░░██║░░░
 ╚██████╔╝██║░╚███║██████╔╝███████╗██║░░██║██║░░░░░╚█████╔╝██████╔╝░░░██║░░░
 ░╚═════╝░╚═╝░░╚══╝╚═════╝░╚══════╝╚═╝░░╚═╝╚═╝░░░░░░╚════╝░╚═════╝░░░░╚═╝░░░
 
@@ -82,9 +82,10 @@ echo "Running initial host setup for Kubernetes prerequisites..."
 cd "$(underpost root)/underpost"
 underpost cluster --init-host
 
-# --- Argument Parsing for Kubeadm/Kind/Worker ---
+# --- Argument Parsing for Kubeadm/Kind/K3s/Worker ---
 USE_KUBEADM=false
 USE_KIND=false # Not the primary focus for this request, but keeping the logic
+USE_K3S=false  # New K3s option
 USE_WORKER=false
 
 for arg in "$@"; do
@@ -95,6 +96,9 @@ for arg in "$@"; do
     --kind)
         USE_KIND=true
         ;;
+    --k3s) # New K3s argument
+        USE_K3S=true
+        ;;
     --worker)
         USE_WORKER=true
         ;;
@@ -102,7 +106,8 @@ for arg in "$@"; do
 done
 
 echo "USE_KUBEADM = $USE_KUBEADM"
-echo "USE_KIND     = $USE_KIND"
+echo "USE_KIND      = $USE_KIND"
+echo "USE_K3S      = $USE_K3S" # Display K3s flag status
 echo "USE_WORKER   = $USE_WORKER"
 
 # --- Kubernetes Cluster Initialization Logic ---
@@ -117,7 +122,6 @@ if $USE_KUBEADM; then
         # For worker nodes, the 'underpost cluster --worker' command will handle joining
         # the cluster. The join command itself needs to be provided from the control plane.
         # This script assumes the join command will be executed separately or passed in.
-        # For a full automated setup, you'd typically pass the join token/command here.
         # Example: underpost cluster --worker --join-command "kubeadm join ..."
         # For now, this just runs the worker-specific config.
         underpost cluster --worker
@@ -130,12 +134,28 @@ if $USE_KUBEADM; then
         underpost cluster --kubeadm
         echo "Kubeadm control plane initialized. Check cluster status with 'kubectl get nodes'."
     fi
+elif $USE_K3S; then # New K3s initialization block
+    if $USE_WORKER; then
+        echo "Running worker node setup for K3s..."
+        # For K3s worker nodes, the 'underpost cluster --worker' command will handle joining
+        # the cluster. The K3s join command (k3s agent --server ...) needs to be provided.
+        underpost cluster --worker --k3s
+        underpost cluster --chown
+        echo "K3s Worker node setup initiated. You will need to manually join this worker to your control plane."
+        echo "On your K3s control plane, get the K3S_TOKEN from /var/lib/rancher/k3s/server/node-token"
+        echo "and the K3S_URL (e.g., https://<control-plane-ip>:6443)."
+        echo "Then execute: K3S_URL=${K3S_URL} K3S_TOKEN=${K3S_TOKEN} curl -sfL https://get.k3s.io | sh -"
+    else
+        echo "Running control plane setup with K3s..."
+        underpost cluster --k3s
+        echo "K3s control plane initialized. Check cluster status with 'kubectl get nodes'."
+    fi
 elif $USE_KIND; then
     echo "Running control node with kind..."
     underpost cluster
     echo "Kind cluster initialized. Check cluster status with 'kubectl get nodes'."
 else
-    echo "No specific cluster role (--kubeadm, --kind, --worker) specified. Please provide one."
+    echo "No specific cluster role (--kubeadm, --kind, --k3s, --worker) specified. Please provide one."
     exit 1
 fi
 

package/package.json

@@ -2,7 +2,7 @@
     "type": "module",
     "main": "src/index.js",
     "name": "underpost",
-    "version": "2.8.797",
+    "version": "2.8.798",
     "description": "pwa api rest template",
     "scripts": {
         "start": "env-cmd -f .env.production node --max-old-space-size=8192 src/server",

package/src/cli/cluster.js

@@ -12,7 +12,7 @@ class UnderpostCluster {
     /**
      * @method init
      * @description Initializes and configures the Kubernetes cluster based on provided options.
-     * This method handles host prerequisites, cluster initialization (Kind or Kubeadm),
+     * This method handles host prerequisites, cluster initialization (Kind, Kubeadm, or K3s),
      * and optional component deployments.
      * @param {string} [podName] - Optional name of a pod for specific operations (e.g., listing).
      * @param {object} [options] - Configuration options for cluster initialization.
@@ -35,9 +35,10 @@ class UnderpostCluster {
      * @param {boolean} [options.pullImage=false] - Pull necessary Docker images before deployment.
      * @param {boolean} [options.dedicatedGpu=false] - Configure for dedicated GPU usage (e.g., NVIDIA GPU Operator).
      * @param {boolean} [options.kubeadm=false] - Initialize the cluster using Kubeadm.
+     * @param {boolean} [options.k3s=false] - Initialize the cluster using K3s.
      * @param {boolean} [options.initHost=false] - Perform initial host setup (install Docker, Podman, Kind, Kubeadm, Helm).
      * @param {boolean} [options.config=false] - Apply general host configuration (SELinux, containerd, sysctl, firewalld).
-     * @param {boolean} [options.worker=false] - Configure as a worker node (for Kubeadm join).
+     * @param {boolean} [options.worker=false] - Configure as a worker node (for Kubeadm or K3s join).
      * @param {boolean} [options.chown=false] - Set up kubectl configuration for the current user.
      */
     async init(
@@ -62,6 +63,7 @@ class UnderpostCluster {
         pullImage: false,
         dedicatedGpu: false,
         kubeadm: false,
+        k3s: false, // New K3s option
         initHost: false,
         config: false,
         worker: false,
@@ -83,7 +85,7 @@ class UnderpostCluster {
       // Information gathering options
       if (options.infoCapacityPod === true) return logger.info('', UnderpostDeploy.API.resourcesFactory());
       if (options.infoCapacity === true)
-        return logger.info('', UnderpostCluster.API.getResourcesCapacity(options.kubeadm));
+        return logger.info('', UnderpostCluster.API.getResourcesCapacity(options.kubeadm || options.k3s)); // Adjust for k3s
       if (options.listPods === true) return console.table(UnderpostDeploy.API.get(podName ?? undefined));
       if (options.nsUse && typeof options.nsUse === 'string') {
         shellExec(`kubectl config set-context --current --namespace=${options.nsUse}`);
@@ -123,32 +125,83 @@ class UnderpostCluster {
         return;
       }
 
-      // Reset Kubernetes cluster components (Kind/Kubeadm) and container runtimes
+      // Reset Kubernetes cluster components (Kind/Kubeadm/K3s) and container runtimes
       if (options.reset === true) return await UnderpostCluster.API.reset();
 
-      // Check if a cluster (Kind or Kubeadm with Calico) is already initialized
-      const alreadyCluster =
-        UnderpostDeploy.API.get('kube-apiserver-kind-control-plane')[0] ||
-        UnderpostDeploy.API.get('calico-kube-controllers')[0];
+      // Check if a cluster (Kind, Kubeadm, or K3s) is already initialized
+      const alreadyKubeadmCluster = UnderpostDeploy.API.get('calico-kube-controllers')[0];
+      const alreadyKindCluster = UnderpostDeploy.API.get('kube-apiserver-kind-control-plane')[0];
+      // K3s pods often contain 'svclb-traefik' in the kube-system namespace
+      const alreadyK3sCluster = UnderpostDeploy.API.get('svclb-traefik')[0];
 
-      // --- Kubeadm/Kind Cluster Initialization ---
+      // --- Kubeadm/Kind/K3s Cluster Initialization ---
       // This block handles the initial setup of the Kubernetes cluster (control plane or worker).
       // It prevents re-initialization if a cluster is already detected.
-      if (!options.worker && !alreadyCluster) {
-        // If it's a kubeadm setup and no Calico controller is found (indicating no kubeadm cluster)
-        if (options.kubeadm === true) {
+      if (!options.worker && !alreadyKubeadmCluster && !alreadyKindCluster && !alreadyK3sCluster) {
+        if (options.k3s === true) {
+          logger.info('Initializing K3s control plane...');
+          // Install K3s
+          console.log('Installing K3s...');
+          shellExec(`curl -sfL https://get.k3s.io | sh -`);
+          console.log('K3s installation completed.');
+
+          // Move k3s binary to /bin/k3s and make it executable
+          shellExec(`sudo mv /usr/local/bin/k3s /bin/k3s`);
+          shellExec(`sudo chmod +x /bin/k3s`);
+          console.log('K3s binary moved to /bin/k3s and made executable.');
+
+          // Configure kubectl for the current user for K3s *before* checking readiness
+          // This ensures kubectl can find the K3s kubeconfig immediately after K3s installation.
+          UnderpostCluster.API.chown('k3s');
+
+          // Wait for K3s to be ready
+          logger.info('Waiting for K3s to be ready...');
+          let k3sReady = false;
+          let retries = 0;
+          const maxRetries = 20; // Increased retries for K3s startup
+          const delayMs = 5000; // 5 seconds
+
+          while (!k3sReady && retries < maxRetries) {
+            try {
+              // Explicitly use KUBECONFIG for kubectl commands to ensure it points to K3s config
+              const nodes = shellExec(`KUBECONFIG=/etc/rancher/k3s/k3s.yaml kubectl get nodes -o json`, {
+                stdout: true,
+                silent: true,
+              });
+              const parsedNodes = JSON.parse(nodes);
+              if (
+                parsedNodes.items.some((node) =>
+                  node.status.conditions.some((cond) => cond.type === 'Ready' && cond.status === 'True'),
+                )
+              ) {
+                k3sReady = true;
+                logger.info('K3s cluster is ready.');
+              } else {
+                logger.info(`K3s not yet ready. Retrying in ${delayMs / 1000} seconds...`);
+                await new Promise((resolve) => setTimeout(resolve, delayMs));
+              }
+            } catch (error) {
+              logger.info(`Error checking K3s status: ${error.message}. Retrying in ${delayMs / 1000} seconds...`);
+              await new Promise((resolve) => setTimeout(resolve, delayMs));
+            }
+            retries++;
+          }
+
+          if (!k3sReady) {
+            logger.error('K3s cluster did not become ready in time. Please check the K3s logs.');
+            return;
+          }
+
+          // K3s includes local-path-provisioner by default, so no need to install explicitly.
+          logger.info('K3s comes with local-path-provisioner by default. Skipping explicit installation.');
+        } else if (options.kubeadm === true) {
           logger.info('Initializing Kubeadm control plane...');
           // Initialize kubeadm control plane
           shellExec(
             `sudo kubeadm init --pod-network-cidr=192.168.0.0/16 --control-plane-endpoint="${os.hostname()}:6443"`,
           );
           // Configure kubectl for the current user
-          UnderpostCluster.API.chown();
-
-          // Apply kubelet-config.yaml explicitly
-          // Using 'kubectl replace --force' to ensure the ConfigMap is updated,
-          // even if it was modified by kubeadm or other processes, resolving conflicts.
-          // shellExec(`kubectl replace --force -f ${underpostRoot}/manifests/kubelet-config.yaml`);
+          UnderpostCluster.API.chown('kubeadm'); // Pass 'kubeadm' to chown
 
           // Install Calico CNI
           logger.info('Installing Calico CNI...');
@@ -165,7 +218,7 @@ class UnderpostCluster {
             `kubectl apply -f https://raw.githubusercontent.com/rancher/local-path-provisioner/master/deploy/local-path-storage.yaml`,
           );
         } else {
-          // Kind cluster initialization (if not using kubeadm)
+          // Kind cluster initialization (if not using kubeadm or k3s)
           logger.info('Initializing Kind cluster...');
           if (options.full === true || options.dedicatedGpu === true) {
             shellExec(`cd ${underpostRoot}/manifests && kind create cluster --config kind-config-cuda.yaml`);
@@ -176,12 +229,12 @@ class UnderpostCluster {
               }.yaml`,
             );
           }
-          UnderpostCluster.API.chown();
+          UnderpostCluster.API.chown('kind'); // Pass 'kind' to chown
         }
       } else if (options.worker === true) {
         // Worker node specific configuration (kubeadm join command needs to be executed separately)
-        logger.info('Worker node configuration applied. Awaiting kubeadm join command...');
-        // No direct cluster initialization here for workers. The `kubeadm join` command
+        logger.info('Worker node configuration applied. Awaiting join command...');
+        // No direct cluster initialization here for workers. The `kubeadm join` or `k3s agent` command
         // needs to be run on the worker after the control plane is up and a token is created.
         // This part of the script is for general worker setup, not the join itself.
       } else {
@@ -202,26 +255,26 @@ class UnderpostCluster {
         if (options.pullImage === true) {
           shellExec(`docker pull valkey/valkey:latest`);
           shellExec(`sudo podman pull valkey/valkey:latest`);
-          if (!options.kubeadm)
-            shellExec(
-              `sudo ${
-                options.kubeadm === true ? `ctr -n k8s.io images import` : `kind load docker-image`
-              } valkey/valkey:latest`,
-            );
+          if (!options.kubeadm && !options.k3s)
+            // Only load if not kubeadm/k3s (Kind needs it)
+            shellExec(`sudo kind load docker-image valkey/valkey:latest`);
+          else if (options.kubeadm || options.k3s)
+            // For kubeadm/k3s, ensure it's available for containerd
+            shellExec(`sudo crictl pull valkey/valkey:latest`);
         }
-        shellExec(`kubectl delete statefulset valkey-service`);
+        shellExec(`kubectl delete statefulset valkey-service --ignore-not-found`);
         shellExec(`kubectl apply -k ${underpostRoot}/manifests/valkey`);
       }
       if (options.full === true || options.mariadb === true) {
         shellExec(
-          `sudo kubectl create secret generic mariadb-secret --from-file=username=/home/dd/engine/engine-private/mariadb-username --from-file=password=/home/dd/engine/engine-private/mariadb-password`,
+          `sudo kubectl create secret generic mariadb-secret --from-file=username=/home/dd/engine/engine-private/mariadb-username --from-file=password=/home/dd/engine/engine-private/mariadb-password --dry-run=client -o yaml | kubectl apply -f -`,
         );
-        shellExec(`kubectl delete statefulset mariadb-statefulset`);
+        shellExec(`kubectl delete statefulset mariadb-statefulset --ignore-not-found`);
         shellExec(`kubectl apply -k ${underpostRoot}/manifests/mariadb`);
       }
       if (options.full === true || options.mysql === true) {
         shellExec(
-          `sudo kubectl create secret generic mysql-secret --from-file=username=/home/dd/engine/engine-private/mysql-username --from-file=password=/home/dd/engine/engine-private/mysql-password`,
+          `sudo kubectl create secret generic mysql-secret --from-file=username=/home/dd/engine/engine-private/mysql-username --from-file=password=/home/dd/engine/engine-private/mysql-password --dry-run=client -o yaml | kubectl apply -f -`,
         );
         shellExec(`sudo mkdir -p /mnt/data`);
         shellExec(`sudo chmod 777 /mnt/data`);
@@ -231,27 +284,27 @@ class UnderpostCluster {
       if (options.full === true || options.postgresql === true) {
         if (options.pullImage === true) {
           shellExec(`docker pull postgres:latest`);
-          if (!options.kubeadm)
-            shellExec(
-              `sudo ${
-                options.kubeadm === true ? `ctr -n k8s.io images import` : `kind load docker-image`
-              } docker-image postgres:latest`,
-            );
+          if (!options.kubeadm && !options.k3s)
+            // Only load if not kubeadm/k3s (Kind needs it)
+            shellExec(`sudo kind load docker-image postgres:latest`);
+          else if (options.kubeadm || options.k3s)
+            // For kubeadm/k3s, ensure it's available for containerd
+            shellExec(`sudo crictl pull postgres:latest`);
         }
         shellExec(
-          `sudo kubectl create secret generic postgres-secret --from-file=password=/home/dd/engine/engine-private/postgresql-password`,
+          `sudo kubectl create secret generic postgres-secret --from-file=password=/home/dd/engine/engine-private/postgresql-password --dry-run=client -o yaml | kubectl apply -f -`,
         );
         shellExec(`kubectl apply -k ${underpostRoot}/manifests/postgresql`);
       }
       if (options.mongodb4 === true) {
         if (options.pullImage === true) {
           shellExec(`docker pull mongo:4.4`);
-          if (!options.kubeadm)
-            shellExec(
-              `sudo ${
-                options.kubeadm === true ? `ctr -n k8s.io images import` : `kind load docker-image`
-              } docker-image mongo:4.4`,
-            );
+          if (!options.kubeadm && !options.k3s)
+            // Only load if not kubeadm/k3s (Kind needs it)
+            shellExec(`sudo kind load docker-image mongo:4.4`);
+          else if (options.kubeadm || options.k3s)
+            // For kubeadm/k3s, ensure it's available for containerd
+            shellExec(`sudo crictl pull mongo:4.4`);
         }
         shellExec(`kubectl apply -k ${underpostRoot}/manifests/mongodb-4.4`);
 
@@ -275,15 +328,22 @@ class UnderpostCluster {
       } else if (options.full === true || options.mongodb === true) {
         if (options.pullImage === true) {
           shellExec(`docker pull mongo:latest`);
+          if (!options.kubeadm && !options.k3s)
+            // Only load if not kubeadm/k3s (Kind needs it)
+            shellExec(`sudo kind load docker-image mongo:latest`);
+          else if (options.kubeadm || options.k3s)
+            // For kubeadm/k3s, ensure it's available for containerd
+            shellExec(`sudo crictl pull mongo:latest`);
         }
         shellExec(
-          `sudo kubectl create secret generic mongodb-keyfile --from-file=/home/dd/engine/engine-private/mongodb-keyfile`,
+          `sudo kubectl create secret generic mongodb-keyfile --from-file=/home/dd/engine/engine-private/mongodb-keyfile --dry-run=client -o yaml | kubectl apply -f -`,
         );
         shellExec(
-          `sudo kubectl create secret generic mongodb-secret --from-file=username=/home/dd/engine/engine-private/mongodb-username --from-file=password=/home/dd/engine/engine-private/mongodb-password`,
+          `sudo kubectl create secret generic mongodb-secret --from-file=username=/home/dd/engine/engine-private/mongodb-username --from-file=password=/home/dd/engine/engine-private/mongodb-password --dry-run=client -o yaml | kubectl apply -f -`,
         );
-        shellExec(`kubectl delete statefulset mongodb`);
+        shellExec(`kubectl delete statefulset mongodb --ignore-not-found`);
         if (options.kubeadm === true)
+          // This storage class is specific to kubeadm setup
           shellExec(`kubectl apply -f ${underpostRoot}/manifests/mongodb/storage-class.yaml`);
         shellExec(`kubectl apply -k ${underpostRoot}/manifests/mongodb`);
 
@@ -310,8 +370,11 @@ class UnderpostCluster {
       if (options.full === true || options.contour === true) {
         shellExec(`kubectl apply -f https://projectcontour.io/quickstart/contour.yaml`);
         if (options.kubeadm === true) {
+          // Envoy service might need NodePort for kubeadm
           shellExec(`sudo kubectl apply -f ${underpostRoot}/manifests/envoy-service-nodeport.yaml`);
         }
+        // K3s has a built-in LoadBalancer (Klipper-lb) that can expose services,
+        // so a specific NodePort service might not be needed or can be configured differently.
       }
 
       if (options.full === true || options.certManager === true) {
@@ -327,7 +390,7 @@ class UnderpostCluster {
         }
 
         const letsEncName = 'letsencrypt-prod';
-        shellExec(`sudo kubectl delete ClusterIssuer ${letsEncName}`);
+        shellExec(`sudo kubectl delete ClusterIssuer ${letsEncName} --ignore-not-found`);
         shellExec(`sudo kubectl apply -f ${underpostRoot}/manifests/${letsEncName}.yaml`);
       }
     },
@@ -346,14 +409,14 @@ class UnderpostCluster {
       shellExec(`sudo sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config`);
 
       // Enable and start Docker and Kubelet services
-      shellExec(`sudo systemctl enable --now docker`);
-      shellExec(`sudo systemctl enable --now kubelet`);
+      shellExec(`sudo systemctl enable --now docker || true`); // Docker might not be needed for K3s
+      shellExec(`sudo systemctl enable --now kubelet || true`); // Kubelet might not be needed for K3s (K3s uses its own agent)
 
       // Configure containerd for SystemdCgroup
-      // This is crucial for kubelet to interact correctly with containerd
+      // This is crucial for kubelet/k3s to interact correctly with containerd
       shellExec(`containerd config default | sudo tee /etc/containerd/config.toml > /dev/null`);
       shellExec(`sudo sed -i -e "s/SystemdCgroup = false/SystemdCgroup = true/g" /etc/containerd/config.toml`);
-      shellExec(`sudo service docker restart`); // Restart docker after containerd config changes
+      shellExec(`sudo service docker restart || true`); // Restart docker after containerd config changes
       shellExec(`sudo systemctl enable --now containerd.service`);
       shellExec(`sudo systemctl restart containerd`); // Restart containerd to apply changes
 
@@ -383,22 +446,41 @@ net.ipv4.ip_forward = 1' | sudo tee ${iptableConfPath}`);
 
     /**
      * @method chown
-     * @description Sets up kubectl configuration for the current user.
-     * This is typically run after kubeadm init on the control plane
-     * to allow non-root users to interact with the cluster.
+     * @description Sets up kubectl configuration for the current user based on the cluster type.
+     * @param {string} clusterType - The type of Kubernetes cluster ('kubeadm', 'k3s', or 'kind').
      */
-    chown() {
-      console.log('Setting up kubectl configuration...');
+    chown(clusterType) {
+      console.log(`Setting up kubectl configuration for ${clusterType} cluster...`);
       shellExec(`mkdir -p ~/.kube`);
-      shellExec(`sudo -E cp -i /etc/kubernetes/admin.conf ~/.kube/config`);
-      shellExec(`sudo -E chown $(id -u):$(id -g) ~/.kube/config`);
+
+      let kubeconfigPath;
+      if (clusterType === 'k3s') {
+        kubeconfigPath = '/etc/rancher/k3s/k3s.yaml';
+      } else if (clusterType === 'kubeadm') {
+        kubeconfigPath = '/etc/kubernetes/admin.conf';
+      } else {
+        // Default to kind if not specified or unknown
+        kubeconfigPath = ''; // Kind's kubeconfig is usually managed by kind itself, or merged
+      }
+
+      if (kubeconfigPath) {
+        shellExec(`sudo -E cp -i ${kubeconfigPath} ~/.kube/config`);
+        shellExec(`sudo -E chown $(id -u):$(id -g) ~/.kube/config`);
+      } else if (clusterType === 'kind') {
+        // For Kind, the kubeconfig is usually merged automatically or can be explicitly exported
+        // This command ensures it's merged into the default kubeconfig
+        shellExec(`kind get kubeconfig > ~/.kube/config || true`);
+        shellExec(`sudo -E chown $(id -u):$(id -g) ~/.kube/config`);
+      } else {
+        logger.warn('No specific kubeconfig path defined for this cluster type, or it is managed automatically.');
+      }
       console.log('kubectl config set up successfully.');
     },
 
     /**
      * @method reset
      * @description Performs a comprehensive reset of Kubernetes and container environments.
-     * This function is for cleaning up a node, reverting changes made by 'kubeadm init' or 'kubeadm join'.
+     * This function is for cleaning up a node, reverting changes made by 'kubeadm init', 'kubeadm join', or 'k3s install'.
      * It includes deleting Kind clusters, resetting kubeadm, removing CNI configs,
      * cleaning Docker and Podman data, persistent volumes, and resetting kubelet components.
      * It avoids aggressive iptables flushing that would break host connectivity, relying on kube-proxy's
@@ -411,13 +493,7 @@ net.ipv4.ip_forward = 1' | sudo tee ${iptableConfPath}`);
         // Phase 1: Pre-reset Kubernetes Cleanup (while API server is still up)
         logger.info('Phase 1/6: Cleaning up Kubernetes resources (PVCs, PVs) while API server is accessible...');
 
-        // Delete all Persistent Volume Claims (PVCs) to release the PVs.
-        // This must happen before deleting PVs or the host paths.
-        // shellExec(`kubectl delete pvc --all-namespaces --all --ignore-not-found || true`);
-
         // Get all Persistent Volumes and identify their host paths for data deletion.
-        // This needs to be done *before* deleting the PVs themselves.
-        // The '|| echo '{"items":[]}'` handles cases where 'kubectl get pv' might return empty or error.
         const pvListJson = shellExec(`kubectl get pv -o json || echo '{"items":[]}'`, { stdout: true, silent: true });
         const pvList = JSON.parse(pvListJson);
 
@@ -434,90 +510,57 @@ net.ipv4.ip_forward = 1' | sudo tee ${iptableConfPath}`);
           logger.info('No Persistent Volumes found with hostPath to clean up.');
         }
 
-        // Then, delete all Persistent Volumes (PVs).
-        // shellExec(`kubectl delete pv --all --ignore-not-found || true`);
-
-        // Phase 2: Stop Kubelet and remove CNI configuration
-        logger.info('Phase 2/6: Stopping Kubelet and removing CNI configurations...');
-        // Stop kubelet service to prevent further activity and release resources.
-        shellExec(`sudo systemctl stop kubelet || true`);
+        // Phase 2: Stop Kubelet/K3s agent and remove CNI configuration
+        logger.info('Phase 2/6: Stopping Kubelet/K3s agent and removing CNI configurations...');
+        shellExec(`sudo systemctl stop kubelet || true`); // Stop kubelet if it's running (kubeadm)
+        shellExec(`sudo /usr/local/bin/k3s-uninstall.sh || true`); // Run K3s uninstall script if it exists
 
         // CNI plugins use /etc/cni/net.d to store their configuration.
-        // Removing this prevents conflicts and potential issues during kubeadm reset.
         shellExec('sudo rm -rf /etc/cni/net.d/* || true');
 
         // Phase 3: Kind Cluster Cleanup
         logger.info('Phase 3/6: Cleaning up Kind clusters...');
-        // Delete all existing Kind (Kubernetes in Docker) clusters.
         shellExec(`kind get clusters | xargs -r -t -n1 kind delete cluster || true`);
 
-        // Phase 4: Kubeadm Reset
-        logger.info('Phase 4/6: Performing kubeadm reset...');
-        // Reset the Kubernetes control-plane components installed by kubeadm.
-        // The --force flag skips confirmation prompts. This command will tear down the cluster.
-        shellExec(`sudo kubeadm reset --force`);
+        // Phase 4: Kubeadm Reset (if applicable)
+        logger.info('Phase 4/6: Performing kubeadm reset (if applicable)...');
+        shellExec(`sudo kubeadm reset --force || true`); // Use || true to prevent script from failing if kubeadm is not installed
 
         // Phase 5: Post-reset File System Cleanup (Local Storage, Kubeconfig)
         logger.info('Phase 5/6: Cleaning up local storage provisioner data and kubeconfig...');
-        // Remove the kubectl configuration file for the current user.
-        // This is important to prevent stale credentials after the cluster is reset.
         shellExec('rm -rf $HOME/.kube || true');
-
-        // Remove local path provisioner data, which stores data for dynamically provisioned PVCs.
         shellExec(`sudo rm -rf /opt/local-path-provisioner/* || true`);
 
         // Phase 6: Container Runtime Cleanup (Docker and Podman)
         logger.info('Phase 6/6: Cleaning up Docker and Podman data...');
-        // Prune all unused Docker data (containers, images, volumes, networks).
-        shellExec('sudo docker system prune -a -f');
-
-        // Stop the Docker daemon service to ensure all files can be removed.
+        shellExec('sudo docker system prune -a -f || true');
         shellExec('sudo service docker stop || true');
-
-        // Aggressively remove container storage data for containerd and Docker.
-        // This targets the underlying storage directories.
         shellExec(`sudo rm -rf /var/lib/containers/storage/* || true`);
         shellExec(`sudo rm -rf /var/lib/docker/volumes/* || true`);
-        shellExec(`sudo rm -rf /var/lib/docker~/* || true`); // Cleanup any old Docker directories
+        shellExec(`sudo rm -rf /var/lib/docker~/* || true`);
         shellExec(`sudo rm -rf /home/containers/storage/* || true`);
         shellExec(`sudo rm -rf /home/docker/* || true`);
-
-        // Ensure Docker's default storage location is clean and re-linked if custom.
-        shellExec(`sudo rm -rf /var/lib/docker/* || true`);
         shellExec('sudo mkdir -p /home/docker || true');
         shellExec('sudo chmod 777 /home/docker || true');
-        shellExec('sudo ln -sf /home/docker /var/lib/docker || true'); // Use -sf for symbolic link, force and silent
-
-        // Prune all unused Podman data.
-        shellExec(`sudo podman system prune -a -f`);
-        shellExec(`sudo podman system prune --all --volumes --force`);
-        shellExec(`sudo podman system prune --external --force`);
+        shellExec('sudo ln -sf /home/docker /var/lib/docker || true');
 
-        // Create and set permissions for Podman's custom storage directory.
+        shellExec(`sudo podman system prune -a -f || true`);
+        shellExec(`sudo podman system prune --all --volumes --force || true`);
+        shellExec(`sudo podman system prune --external --force || true`);
         shellExec(`sudo mkdir -p /home/containers/storage || true`);
         shellExec('sudo chmod 0711 /home/containers/storage || true');
-
-        // Update Podman's storage configuration file.
         shellExec(
           `sudo sed -i -e "s@/var/lib/containers/storage@/home/containers/storage@g" /etc/containers/storage.conf || true`,
         );
-
-        // Reset Podman system settings.
-        shellExec(`sudo podman system reset -f`);
+        shellExec(`sudo podman system reset -f || true`);
 
         // Final Kubelet and System Cleanup (after all other operations)
         logger.info('Finalizing Kubelet and system file cleanup...');
-        // Remove Kubernetes configuration and kubelet data directories.
         shellExec(`sudo rm -rf /etc/kubernetes/* || true`);
         shellExec(`sudo rm -rf /var/lib/kubelet/* || true`);
-
-        // Clear trash files from the root user's trash directory.
-        shellExec('sudo rm -rf /root/.local/share/Trash/files/* || true');
-
-        // Reload systemd daemon to pick up any service file changes.
+        shellExec(`sudo rm -rf /root/.local/share/Trash/files/* || true`);
         shellExec(`sudo systemctl daemon-reload`);
-        // Attempt to start kubelet; it might fail if the cluster is fully reset, which is expected.
-        shellExec(`sudo systemctl start kubelet || true`);
+        shellExec(`sudo systemctl start kubelet || true`); // Attempt to start kubelet; might fail if fully reset
 
         logger.info('Comprehensive reset completed successfully.');
       } catch (error) {
@@ -530,21 +573,17 @@ net.ipv4.ip_forward = 1' | sudo tee ${iptableConfPath}`);
      * @method getResourcesCapacity
      * @description Retrieves and returns the allocatable CPU and memory resources
      * of the Kubernetes node.
-     * @param {boolean} [kubeadm=false] - If true, assumes a kubeadm-managed node;
+     * @param {boolean} [isKubeadmOrK3s=false] - If true, assumes a kubeadm or k3s-managed node;
      * otherwise, assumes a Kind worker node.
      * @returns {object} An object containing CPU and memory resources with values and units.
      */
-    getResourcesCapacity(kubeadm = false) {
+    getResourcesCapacity(isKubeadmOrK3s = false) {
       const resources = {};
-      const info = shellExec(
-        `kubectl describe node ${
-          kubeadm === true ? os.hostname() : 'kind-worker'
-        } | grep -E '(Allocatable:|Capacity:)' -A 6`,
-        {
-          stdout: true,
-          silent: true,
-        },
-      );
+      const nodeName = isKubeadmOrK3s ? os.hostname() : 'kind-worker';
+      const info = shellExec(`kubectl describe node ${nodeName} | grep -E '(Allocatable:|Capacity:)' -A 6`, {
+        stdout: true,
+        silent: true,
+      });
       info
         .split('Allocatable:')[1]
         .split('\n')
@@ -568,9 +607,36 @@ net.ipv4.ip_forward = 1' | sudo tee ${iptableConfPath}`);
      * @method initHost
      * @description Installs essential host-level prerequisites for Kubernetes,
      * including Docker, Podman, Kind, Kubeadm, and Helm.
+     *
+     * Quick-Start Guide for K3s Installation:
+     * This guide will help you quickly launch a cluster with default options. Make sure your nodes meet the requirements before proceeding.
+     * Consult the Installation page for greater detail on installing and configuring K3s.
+     * For information on how K3s components work together, refer to the Architecture page.
+     * If you are new to Kubernetes, the official Kubernetes docs have great tutorials covering basics that all cluster administrators should be familiar with.
+     *
+     * Install Script:
+     * K3s provides an installation script that is a convenient way to install it as a service on systemd or openrc based systems. This script is available at https://get.k3s.io. To install K3s using this method, just run:
+     * curl -sfL https://get.k3s.io | sh -
+     *
+     * After running this installation:
+     * - The K3s service will be configured to automatically restart after node reboots or if the process crashes or is killed
+     * - Additional utilities will be installed, including kubectl, crictl, ctr, k3s-killall.sh, and k3s-uninstall.sh
+     * - A kubeconfig file will be written to /etc/rancher/k3s/k3s.yaml and the kubectl installed by K3s will automatically use it
+     *
+     * A single-node server installation is a fully-functional Kubernetes cluster, including all the datastore, control-plane, kubelet, and container runtime components necessary to host workload pods. It is not necessary to add additional server or agents nodes, but you may want to do so to add additional capacity or redundancy to your cluster.
+     *
+     * To install additional agent nodes and add them to the cluster, run the installation script with the K3S_URL and K3S_TOKEN environment variables. Here is an example showing how to join an agent:
+     * curl -sfL https://get.k3s.io | K3S_URL=https://myserver:6443 K3S_TOKEN=mynodetoken sh -
+     *
+     * Setting the K3S_URL parameter causes the installer to configure K3s as an agent, instead of a server. The K3s agent will register with the K3s server listening at the supplied URL. The value to use for K3S_TOKEN is stored at /var/lib/rancher/k3s/server/node-token on your server node.
+     *
+     * Note: Each machine must have a unique hostname. If your machines do not have unique hostnames, pass the K3S_NODE_NAME environment variable and provide a value with a valid and unique hostname for each node.
+     * If you are interested in having more server nodes, see the High Availability Embedded etcd and High Availability External DB pages for more information.
      */
     initHost() {
-      console.log('Installing Docker, Podman, Kind, Kubeadm, and Helm...');
+      console.log(
+        'Installing essential host-level prerequisites for Kubernetes (Docker, Podman, Kind, Kubeadm, Helm) and providing K3s Quick-Start Guide information...',
+      );
       // Install docker
       shellExec(`sudo dnf -y install dnf-plugins-core`);
       shellExec(`sudo dnf config-manager --add-repo https://download.docker.com/linux/rhel/docker-ce.repo`);
@@ -583,7 +649,7 @@ net.ipv4.ip_forward = 1' | sudo tee ${iptableConfPath}`);
       shellExec(`[ $(uname -m) = aarch64 ] && curl -Lo ./kind https://kind.sigs.k8s.io/dl/v0.29.0/kind-linux-arm64
 chmod +x ./kind
 sudo mv ./kind /bin/kind`);
-      // Install kubeadm, kubelet, kubectl
+      // Install kubeadm, kubelet, kubectl (these are also useful for K3s for kubectl command)
       shellExec(`cat <<EOF | sudo tee /etc/yum.repos.d/kubernetes.repo
 [kubernetes]
 name=Kubernetes

package/src/cli/image.js

@@ -12,10 +12,22 @@ const logger = loggerFactory(import.meta);
 class UnderpostImage {
   static API = {
     dockerfile: {
+      /**
+       * @method pullBaseImages
+       * @description Pulls base images and builds a 'debian-underpost' image,
+       * then loads it into the specified Kubernetes cluster type (Kind, Kubeadm, or K3s).
+       * @param {object} options - Options for pulling and loading images.
+       * @param {boolean} [options.kindLoad=false] - If true, load image into Kind cluster.
+       * @param {boolean} [options.kubeadmLoad=false] - If true, load image into Kubeadm cluster.
+       * @param {boolean} [options.k3sLoad=false] - If true, load image into K3s cluster.
+       * @param {string} [options.path=false] - Path to the Dockerfile context.
+       * @param {string} [options.version=''] - Version tag for the image.
+       */
       pullBaseImages(
         options = {
           kindLoad: false,
           kubeadmLoad: false,
+          k3sLoad: false,
           path: false,
           version: '',
         },
@@ -23,13 +35,39 @@ class UnderpostImage {
         shellExec(`sudo podman pull docker.io/library/debian:buster`);
         const IMAGE_NAME = `debian-underpost`;
         const IMAGE_NAME_FULL = `${IMAGE_NAME}:${options.version ?? Underpost.version}`;
-        const LOAD_TYPE = options.kindLoad === true ? `--kind-load` : `--kubeadm-load`;
+        let LOAD_TYPE = '';
+        if (options.kindLoad === true) {
+          LOAD_TYPE = `--kind-load`;
+        } else if (options.kubeadmLoad === true) {
+          LOAD_TYPE = `--kubeadm-load`;
+        } else if (options.k3sLoad === true) {
+          // Handle K3s load type
+          LOAD_TYPE = `--k3s-load`;
+        }
+
         shellExec(
           `underpost dockerfile-image-build --podman-save --reset --image-path=. --path ${
             options.path ?? getUnderpostRootPath()
           } --image-name=${IMAGE_NAME_FULL} ${LOAD_TYPE}`,
         );
       },
+      /**
+       * @method build
+       * @description Builds a Docker image using Podman, optionally saves it as a tar archive,
+       * and loads it into a specified Kubernetes cluster (Kind, Kubeadm, or K3s).
+       * @param {object} options - Options for building and loading images.
+       * @param {string} [options.path=''] - The path to the directory containing the Dockerfile.
+       * @param {string} [options.imageName=''] - The name and tag for the image (e.g., 'my-app:latest').
+       * @param {string} [options.imagePath=''] - Directory to save the image tar file.
+       * @param {string} [options.dockerfileName=''] - Name of the Dockerfile (defaults to 'Dockerfile').
+       * @param {boolean} [options.podmanSave=false] - If true, save the image as a tar archive using Podman.
+       * @param {boolean} [options.kindLoad=false] - If true, load the image archive into a Kind cluster.
+       * @param {boolean} [options.kubeadmLoad=false] - If true, load the image archive into a Kubeadm cluster (uses 'ctr').
+       * @param {boolean} [options.k3sLoad=false] - If true, load the image archive into a K3s cluster (uses 'k3s ctr').
+       * @param {boolean} [options.secrets=false] - If true, load secrets from the .env file for the build.
+       * @param {string} [options.secretsPath=''] - Custom path to the .env file for secrets.
+       * @param {boolean} [options.reset=false] - If true, perform a no-cache build.
+       */
       build(
         options = {
           path: '',
@@ -39,6 +77,7 @@ class UnderpostImage {
           podmanSave: false,
           kindLoad: false,
           kubeadmLoad: false,
+          k3sLoad: false,
           secrets: false,
           secretsPath: '',
           reset: false,
@@ -53,8 +92,9 @@ class UnderpostImage {
           secrets,
           secretsPath,
           kindLoad,
-          reset,
           kubeadmLoad,
+          k3sLoad,
+          reset,
         } = options;
         const podManImg = `localhost/${imageName}`;
         if (imagePath && typeof imagePath === 'string' && !fs.existsSync(imagePath))
@@ -71,7 +111,7 @@ class UnderpostImage {
             ),
           );
           for (const key of Object.keys(envObj)) {
-            secretsInput += ` && export ${key}="${envObj[key]}" `; // $(cat gitlab-token.txt)
+            secretsInput += ` && export ${key}="${envObj[key]}" `; // Example: $(cat gitlab-token.txt)
             secretDockerInput += ` --secret id=${key},env=${key} \ `;
           }
         }
@@ -85,7 +125,14 @@ class UnderpostImage {
 
         if (podmanSave === true) shellExec(`podman save -o ${tarFile} ${podManImg}`);
         if (kindLoad === true) shellExec(`sudo kind load image-archive ${tarFile}`);
-        if (kubeadmLoad === true) shellExec(`sudo ctr -n k8s.io images import ${tarFile}`);
+        if (kubeadmLoad === true) {
+          // Use 'ctr' for Kubeadm
+          shellExec(`sudo ctr -n k8s.io images import ${tarFile}`);
+        }
+        if (k3sLoad === true) {
+          // Use 'k3s ctr' for K3s
+          shellExec(`sudo k3s ctr images import ${tarFile}`);
+        }
       },
     },
   };

package/src/cli/index.js

@@ -115,6 +115,7 @@ program
   .option('--config', 'Set k8s base node config')
   .option('--worker', 'Set worker node context')
   .option('--chown', 'Set k8s kube chown')
+  .option('--k3s', 'Initialize the cluster using K3s')
   .action(Underpost.cluster.init)
   .description('Manage cluster, for default initialization base kind cluster');
 
@@ -171,6 +172,7 @@ program
   .option('--secrets', 'Dockerfile env secrets')
   .option('--secrets-path [secrets-path]', 'Dockerfile custom path env secrets')
   .option('--reset', 'Build without using cache')
+  .option('--k3s-load', 'Load image into K3s cluster.')
   .description('Build image from Dockerfile')
   .action(Underpost.image.dockerfile.build);
 
@@ -180,6 +182,7 @@ program
   .option('--kind-load', 'Import tar image to Kind cluster')
   .option('--kubeadm-load', 'Import tar image to Kubeadm cluster')
   .option('--version', 'Set custom version')
+  .option('--k3s-load', 'Load image into K3s cluster.')
   .description('Pull underpost dockerfile images requirements')
   .action(Underpost.image.dockerfile.pullBaseImages);
 

package/src/cli/lxd.js

@@ -22,6 +22,7 @@ class UnderpostLxd {
      * @param {boolean} [options.createAdminProfile=false] - Create admin-profile for VMs.
      * @param {boolean} [options.control=false] - Flag for control plane VM initialization.
      * @param {boolean} [options.worker=false] - Flag for worker node VM initialization.
+     * @param {boolean} [options.k3s=false] - Flag to indicate K3s cluster type for VM initialization.
      * @param {string} [options.initVm=''] - Initialize a specific VM.
      * @param {string} [options.createVm=''] - Create a new VM with the given name.
      * @param {string} [options.infoVm=''] - Display information about a specific VM.
@@ -42,6 +43,7 @@ class UnderpostLxd {
         createAdminProfile: false,
         control: false,
         worker: false,
+        k3s: false, // New k3s option
         initVm: '',
         createVm: '',
         infoVm: '',
@@ -56,8 +58,8 @@ class UnderpostLxd {
       const npmRoot = getNpmRootPath();
       const underpostRoot = options?.dev === true ? '.' : `${npmRoot}/underpost`;
       if (options.reset === true) {
-        shellExec(`sudo systemctl stop snap.lxd.daemon`);
-        shellExec(`sudo snap remove lxd --purge`);
+        shellExec(`sudo systemctl stop snap.lxd.daemon || true`);
+        shellExec(`sudo snap remove lxd --purge || true`);
       }
       if (options.install === true) shellExec(`sudo snap install lxd`);
       if (options.init === true) {
@@ -93,12 +95,24 @@ ipv6.address=none`);
       if (options.initVm && typeof options.initVm === 'string') {
         let flag = '';
         if (options.control === true) {
-          flag = ' -s -- --kubeadm';
+          if (options.k3s === true) {
+            // New K3s flag for control plane
+            flag = ' -s -- --k3s';
+          } else {
+            // Default to kubeadm if not K3s
+            flag = ' -s -- --kubeadm';
+          }
           shellExec(`lxc exec ${options.initVm} -- bash -c 'mkdir -p /home/dd/engine'`);
           shellExec(`lxc file push /home/dd/engine/engine-private ${options.initVm}/home/dd/engine --recursive`);
           shellExec(`lxc file push /home/dd/engine/manifests ${options.initVm}/home/dd/engine --recursive`);
         } else if (options.worker == true) {
-          flag = ' -s -- --worker';
+          if (options.k3s === true) {
+            // New K3s flag for worker
+            flag = ' -s -- --worker --k3s';
+          } else {
+            // Default to kubeadm worker
+            flag = ' -s -- --worker';
+          }
         }
         console.log(`Executing underpost-setup.sh on VM: ${options.initVm}`);
         shellExec(`cat ${underpostRoot}/manifests/lxd/underpost-setup.sh | lxc exec ${options.initVm} -- bash${flag}`);
@@ -143,22 +157,13 @@ ipv6.address=none`);
 
         let portsToExpose = [];
         if (options.control === true) {
-          // Kubernetes API Server
+          // Kubernetes API Server (Kubeadm and K3s both use 6443 by default)
           portsToExpose.push('6443');
           // Standard HTTP/HTTPS for Ingress if deployed
           portsToExpose.push('80');
           portsToExpose.push('443');
         }
-        // NodePort range for all nodes (control plane can also run pods with NodePorts)
-        // It's safer to expose the entire range for flexibility, or specific NodePorts if known.
-        // For production, you might only expose specific NodePorts or use a LoadBalancer.
-        // For a general setup, exposing the range is common.
-        // Note: LXD proxy device can only expose individual ports, not ranges directly.
-        // We will expose a few common ones, or rely on specific 'expose' calls for others.
-        // Let's add some common NodePorts that might be used by applications.
-        // The full range 30000-32767 would require individual proxy rules for each port.
-        // For this automatic setup, we'll focus on critical K8s ports and common app ports.
-        // If a user needs the full NodePort range, they should use the `expose` option explicitly.
+        // Add common NodePorts if needed, or rely on explicit 'expose'
         portsToExpose.push('30000'); // Example NodePort
         portsToExpose.push('30001'); // Example NodePort
         portsToExpose.push('30002'); // Example NodePort
@@ -183,11 +188,39 @@ ipv6.address=none`);
       }
       if (options.joinNode && typeof options.joinNode === 'string') {
         const [workerNode, controlNode] = options.joinNode.split(',');
-        const token = shellExec(
-          `echo "$(lxc exec ${controlNode} -- bash -c 'sudo kubeadm token create --print-join-command')"`,
-          { stdout: true },
-        );
-        shellExec(`lxc exec ${workerNode} -- bash -c '${token}'`);
+        // Determine if it's a Kubeadm or K3s join
+        const isK3sJoin = options.k3s === true;
+
+        if (isK3sJoin) {
+          console.log(`Attempting to join K3s worker node ${workerNode} to control plane ${controlNode}`);
+          // Get K3s token from control plane
+          const k3sToken = shellExec(
+            `lxc exec ${controlNode} -- bash -c 'sudo cat /var/lib/rancher/k3s/server/node-token'`,
+            { stdout: true },
+          ).trim();
+          // Get control plane IP
+          const controlPlaneIp = shellExec(
+            `lxc list ${controlNode} --format json | jq -r '.[0].state.network.enp5s0.addresses[] | select(.family=="inet") | .address'`,
+            { stdout: true },
+          ).trim();
+
+          if (!k3sToken || !controlPlaneIp) {
+            console.error(`Failed to get K3s token or control plane IP. Cannot join worker.`);
+            return;
+          }
+          const k3sJoinCommand = `K3S_URL=https://${controlPlaneIp}:6443 K3S_TOKEN=${k3sToken} curl -sfL https://get.k3s.io | sh -`;
+          shellExec(`lxc exec ${workerNode} -- bash -c '${k3sJoinCommand}'`);
+          console.log(`K3s worker node ${workerNode} join command executed.`);
+        } else {
+          // Kubeadm join
+          console.log(`Attempting to join Kubeadm worker node ${workerNode} to control plane ${controlNode}`);
+          const token = shellExec(
+            `echo "$(lxc exec ${controlNode} -- bash -c 'sudo kubeadm token create --print-join-command')"`,
+            { stdout: true },
+          );
+          shellExec(`lxc exec ${workerNode} -- bash -c '${token}'`);
+          console.log(`Kubeadm worker node ${workerNode} join command executed.`);
+        }
       }
       if (options.infoVm && typeof options.infoVm === 'string') {
         shellExec(`lxc config show ${options.infoVm}`);

package/src/index.js

@@ -31,7 +31,7 @@ class Underpost {
    * @type {String}
    * @memberof Underpost
    */
-  static version = 'v2.8.797';
+  static version = 'v2.8.798';
   /**
    * Repository cli API
    * @static