Building a Self-Healing GitOps CI/CD Pipeline: Integrating ArgoCD and Kube-ops-view on a K3s VPS Cluster

Introduction to Self-Healing Infrastructure in the GitOps Era

In modern cloud-native engineering, maintaining the reliability and consistency of infrastructure is a constant challenge. Traditional CI/CD pipelines often suffer from "configuration drift," where the actual state of a cluster diverges from the intended state defined in source control. This gap introduces vulnerabilities, deployment bottlenecks, and operational overhead.

GitOps solves this problem by establishing Git as the single source of truth for infrastructure and applications. When applied to lightweight environments like K3s running on Virtual Private Servers (VPS), GitOps enables small to medium enterprises to achieve enterprise-grade automation without the prohibitive cloud costs. However, true automation goes beyond automated deployment; it requires self-healing capabilities. By integrating ArgoCD for continuous delivery and automated reconciliation with Kube-ops-view for visual cluster tracking, engineers can build a robust system that detects and automatically corrects infrastructure faults in real time.

The Core Architectural Components

To implement a self-healing GitOps pipeline on a budget-friendly VPS footprint, we leverage three highly optimized components:

• K3s by Rancher: A highly available, lightweight Kubernetes distribution designed for resource-constrained environments. It reduces the memory footprint of a standard Kubernetes control plane, making it ideal for cost-effective VPS hosting.
• ArgoCD: A declarative, GitOps continuous delivery tool for Kubernetes. ArgoCD continuously monitors running applications against the desired state defined in a Git repository and automatically remediates discrepancies.
• Kube-ops-view: A visual dashboard that provides a real-time, low-overhead overview of Kubernetes clusters, rendering pods, nodes, and capacity utilization dynamically.

Together, these tools form a closed-loop system where state changes are automatically managed, and cluster health is visually verifiable at a glance.

Prerequisites and Environment Setup

Before initiating the deployment, ensure you have a minimum of three VPS instances running a clean installation of Ubuntu 22.04 LTS. This setup will consist of one control-plane node and two worker nodes to simulate a highly available cluster environment.

Step 1: Installing the K3s Cluster

Execute the following command on your primary VPS to initialize the K3s control plane, ensuring you disable default components like Traefik if you plan to use a custom ingress controller:

curl -sfL [https://get.k3s.io](https://get.k3s.io) | sh -s - --disable traefik

Once the control plane is active, retrieve the node token from /var/lib/rancher/k3s/server/node-token and use it to register your worker nodes:

curl -sfL [https://get.k3s.io](https://get.k3s.io) | K3S_URL=https://:6443 K3S_TOKEN= sh -

Deploying ArgoCD for Automated Reconciliation

With the K3s cluster operational, the next phase involves setting up ArgoCD as our GitOps controller. ArgoCD will act as the mechanism that watches our Git repository for infrastructure definitions and enforces compliance on the cluster.

Step 2: Installing ArgoCD

Create a dedicated namespace and apply the official manifests:

kubectl create namespace argocd
kubectl apply -n argocd -f [https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml](https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml)

To access the ArgoCD API server UI, patch the service type to NodePort, or configure an Ingress object targeting the argocd-server service on port 443.

Step 3: Configuring the Self-Healing App Mechanism

The core of a self-healing infrastructure lies in ArgoCD’s Sync Policy. By enabling Automated Prune and SelfHeal, any manual change made to the cluster using kubectl will be instantly overwritten by the configuration stored in Git.

"Enabling Automated Sync and Self-Healing guarantees that your infrastructure remains immutable from manual intervention, effectively eliminating unauthorized configuration drift."

Below is an example of an ArgoCD Application manifest configured for self-healing infrastructure deployments:

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: infrastructure-self-heal
  namespace: argocd
spec:
  project: default
  source:
    repoURL: '[https://github.com/your-org/gitops-infra.git](https://github.com/your-org/gitops-infra.git)'
    targetRevision: HEAD
    path: apps/production
  destination:
    server: '[https://kubernetes.default.svc](https://kubernetes.default.svc)'
    namespace: production
  syncPolicy:
    automated:
      prune: true
      selfHeal: true
    retry:
      limit: 5
      backoff:
        duration: 5s
        factor: 2
        maxDuration: 3m

Visualizing Cluster Health with Kube-ops-view

While ArgoCD manages the state under the hood, operators need a reliable, high-level mechanism to track node status, pod distributions, and automated scaling events. Kube-ops-view offers a visual matrix of the cluster without consuming significant CPU or memory resources.

Step 4: Deploying Kube-ops-view via GitOps

Instead of manually applying Kube-ops-view manifests, define its deployment structure inside your Git repository under the monitored path (e.g., apps/production). This manifest ensures Kube-ops-view is deployed and managed by the self-healing engine itself:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: kube-ops-view
  namespace: production
spec:
  replicas: 1
  selector:
    matchLabels:
      app: kube-ops-view
  template:
    metadata:
      labels:
        app: kube-ops-view
    spec:
      containers:
      - name: kube-ops-view
        image: hjacobs/kube-ops-view:20.4.0
        ports:
        - containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: kube-ops-view
  namespace: production
spec:
  type: NodePort
  ports:
  - port: 80
    targetPort: 8080
    nodePort: 32080
  selector:
    app: kube-ops-view

Testing the Self-Healing System

To validate the efficacy of our pipeline, we simulate a common production failure scenario: accidental configuration deletion and manual runtime modification.

1. Simulate Manual Deletion: Execute kubectl delete deployment kube-ops-view -n production.
2. Observe the Reaction: Within seconds, ArgoCD’s polling mechanism detects the variance between the live cluster state (0 pods) and the Git repository state (1 replica).
3. Review the UI: ArgoCD triggers an automated synchronization process, generating new replica sets to restore compliance. Simultaneously, Kube-ops-view displays the rapid initialization of pods across the worker nodes in real time.

Best Practices for Cost-Efficient GitOps on VPS

When running a self-healing GitOps pipeline on VPS infrastructures, optimization is essential due to stricter CPU and RAM limitations compared to managed cloud providers:

• Adjust Sync Intervals: Tune the timeout.reconciliation parameter in the argocd-cm ConfigMap to prevent excessive API server requests from overwhelming small VPS nodes.
• Resource Quotas: Explicitly define resources.limits and resources.requests for ArgoCD and Kube-ops-view components to avoid out-of-memory (OOM) kills affecting your application workloads.
• Secure Git Webhooks: Configure repository webhooks to trigger instant synchronization on commit push, shifting ArgoCD away from continuous resource-intensive polling.

Conclusion

By coupling the definitive, declarative control of ArgoCD with the immediate visual insights provided by Kube-ops-view, we have constructed a resilient, self-healing continuous delivery infrastructure on a lean K3s VPS cluster. This framework eliminates configuration drift, protects production deployments from human error, and provides clear visibility into cluster topologies without inflating cloud expenditures. As you mature your platform engineering strategy, adopting this paradigm ensures your infrastructure remains secure, scalable, and fully deterministic.