From Zero to Production: Complete WordPress on K3s Kubernetes with Jenkins CI/CD

Table of Contents

1. Why This Guide?
2. Architecture Overview
3. Part 1: Setting Up K3s Kubernetes
4. Part 2: Test WordPress (Non-Persistent)
5. Part 3: Production WordPress (With Persistent Storage)
6. Part 4: Kubernetes Dashboard
7. Part 5: Jenkins CI/CD Integration
8. Part 6: Connecting Jenkins to K3s
9. Part 7: Scaling and Management
10. Part 8: Cloud Provider Comparison
11. Troubleshooting & Best Practices

---

Why This Guide?

When I started learning Kubernetes, I was overwhelmed by the complexity of cloud providers like EKS, GKE, and AKS. I wanted to understand the fundamentals without spending hundreds of dollars on managed services. So I built everything on a simple VPS using K3s — a lightweight, certified Kubernetes distribution that runs in under 100MB.

What you’ll achieve by the end of this guide:

• ✅ A fully functional WordPress site running on Kubernetes
• ✅ Production instance with persistent storage (data survives restarts)
• ✅ Test instance for experiments (ephemeral storage)
• ✅ Jenkins CI/CD pipeline to manage deployments
• ✅ Kubernetes Dashboard for visual monitoring
• ✅ Secure remote access via Tailscale

---

Architecture Overview

text

┌─────────────────────────────────────────────────────────────────────────────┐
│                         Xserver VPS (Ubuntu 22.04)                           │
│                                                                              │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                         K3s Kubernetes Cluster                        │   │
│  │                                                                       │   │
│  │  ┌─────────────────────┐  ┌─────────────────────┐  ┌───────────────┐ │   │
│  │  │  Namespace: default │  │ Namespace: wordpress│  │  Namespace:   │ │   │
│  │  │  TEST WordPress     │  │      -PROD          │  │  kubernetes-  │ │   │
│  │  │  (No PVC)           │  │  PRODUCTION WP      │  │   dashboard   │ │   │
│  │  │  Port: 30080        │  │  (With PVC - 20GB)  │  │  Port: 30082  │ │   │
│  │  │  MySQL 5.7          │  │  Port: 30081        │  │               │ │   │
│  │  │  WordPress 5.8      │  │  MySQL 8.0          │  │               │ │   │
│  │  │  Ephemeral storage  │  │  WordPress Latest   │  │               │ │   │
│  │  └─────────────────────┘  └─────────────────────┘  └───────────────┘ │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                         │
│  ┌─────────────────────────────────┼─────────────────────────────────────┐  │
│  │                         Jenkins CI/CD                                  │  │
│  │                         (Docker Container)                             │  │
│  │                         Port: 8081                                     │  │
│  │                         kubectl installed                              │  │
│  └─────────────────────────────────┼─────────────────────────────────────┘  │
│                                    │                                         │
│                              ┌─────▼─────┐                                   │
│                              │ Tailscale │                                   │
│                              │   VPN     │                                   │
│                              └───────────┘                                   │
└─────────────────────────────────────────────────────────────────────────────┘

Access Points:

Service	URL	Port
Jenkins CI/CD	http://your-vps.tailscale.ts.net	8081
Production WP	http://your-vps.tailscale.ts.net	30081
Test WP	http://your-vps.tailscale.ts.net	30080
K8s Dashboard	https://your-vps.tailscale.ts.net	30082

---

Part 1: Setting Up K3s Kubernetes

What is K3s?

K3s is a lightweight, certified Kubernetes distribution by SUSE Rancher. It’s packaged as a single binary under 100MB and is perfect for:

• Edge computing
• Resource-constrained environments
• Learning Kubernetes fundamentals
• Production workloads at scale

Installation

bash

# SSH into your VPS
ssh root@your-vps-ip

# Install K3s (single command)
curl -sfL https://get.k3s.io | sh -

# Verify your cluster is running
sudo kubectl get nodes

# Expected output:
# NAME             STATUS   ROLES           AGE   VERSION
# x162-43-92-249   Ready    control-plane   30s   v1.35.4+k3s1

# Configure kubectl for your user
mkdir -p ~/.kube
sudo cp /etc/rancher/k3s/k3s.yaml ~/.kube/config
sudo chown $(id -u):$(id -g) ~/.kube/config
chmod 600 ~/.kube/config

Why This Works

K3s runs as a systemd service and includes:

• Built-in local-path storage class (automatically provisions persistent volumes)
• Embedded etcd (for clusters with 3+ nodes)
• Core add-ons like Traefik ingress controller
• SQLite as default datastore (instead of etcd for single-node clusters)

---

Part 2: Test WordPress (Non-Persistent)

Purpose

This deployment serves as a testing sandbox. Data does NOT persist across pod restarts, making it perfect for experimenting with themes, plugins, or configuration changes without risking production data.

The YAML Explained

yaml

# wordpress-test.yaml
---
apiVersion: v1
kind: Secret
metadata:
  name: mysql-pass
type: Opaque
data:
  # 'wordpress123' base64 encoded
  password: d29yZHByZXNzMTIz

---
apiVersion: v1
kind: Service
metadata:
  name: wordpress-mysql
spec:
  ports:
  - port: 3306
  selector:
    app: wordpress-mysql

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: wordpress-mysql
spec:
  selector:
    matchLabels:
      app: wordpress-mysql
  template:
    metadata:
      labels:
        app: wordpress-mysql
    spec:
      containers:
      - name: mysql
        image: mysql:5.7
        env:
        - name: MYSQL_ROOT_PASSWORD
          valueFrom:
            secretKeyRef:
              name: mysql-pass
              key: password
        - name: MYSQL_DATABASE
          value: wordpress
        ports:
        - containerPort: 3306

---
apiVersion: v1
kind: Service
metadata:
  name: wordpress
spec:
  type: NodePort
  ports:
  - port: 80
    nodePort: 30080
    targetPort: 80
  selector:
    app: wordpress

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: wordpress
spec:
  selector:
    matchLabels:
      app: wordpress
  template:
    metadata:
      labels:
        app: wordpress
    spec:
      containers:
      - name: wordpress
        image: wordpress:5.8-apache
        env:
        - name: WORDPRESS_DB_HOST
          value: wordpress-mysql
        - name: WORDPRESS_DB_USER
          value: root
        - name: WORDPRESS_DB_PASSWORD
          valueFrom:
            secretKeyRef:
              name: mysql-pass
              key: password
        - name: WORDPRESS_DB_NAME
          value: wordpress
        ports:
        - containerPort: 80

Deployment Commands

bash

# Apply the configuration
kubectl apply -f wordpress-test.yaml

# Check deployment status
kubectl get pods
kubectl get svc

# Create database
MYSQL_POD=$(kubectl get pods -l app=wordpress-mysql -o jsonpath='{.items[0].metadata.name}')
kubectl exec $MYSQL_POD -- mysql -uroot -pwordpress123 -e "CREATE DATABASE IF NOT EXISTS wordpress;"

# Install WordPress using WP-CLI
kubectl exec deployment/wordpress -- bash -c "
cd /tmp && \
curl -sO https://raw.githubusercontent.com/wp-cli/builds/gh-pages/phar/wp-cli.phar && \
chmod +x wp-cli.phar && \
su -s /bin/bash -c 'php /tmp/wp-cli.phar core install \
  --path=/var/www/html \
  --url=\"http://your-tailscale-url:30080\" \
  --title=\"Test WordPress on K8s\" \
  --admin_user=test_admin \
  --admin_password=TestPassword123! \
  --admin_email=test@example.com' www-data
"

# Set correct site URLs
kubectl exec $MYSQL_POD -- mysql -uroot -pwordpress123 wordpress -e "
UPDATE wp_options SET option_value = 'http://your-tailscale-url:30080' WHERE option_name = 'siteurl';
UPDATE wp_options SET option_value = 'http://your-tailscale-url:30080' WHERE option_name = 'home';
"

Key Kubernetes Concepts Demonstrated

Concept	Explanation	In This Deployment
Pod	Smallest deployable unit in K8s	WordPress and MySQL each run in their own pod
Service	Stable network endpoint for pods	wordpress service (NodePort:30080), wordpress-mysql (ClusterIP:3306)
Deployment	Manages pod lifecycle and scaling	Manages WordPress and MySQL pods
Secret	Stores sensitive data safely	MySQL root password stored as base64
NodePort	Exposes service on static port	Port 30080 accessible from outside the cluster

---

Part 3: Production WordPress (With Persistent Storage)

Why PVC (PersistentVolumeClaim)?

Without PVC, all database data disappears when the MySQL pod restarts. PVC ensures:

• ✅ Data survives pod failures and restarts
• ✅ Safe upgrades (can replace MySQL without data loss)
• ✅ Backup and restore capabilities
• ✅ Production-grade reliability

Creating a Separate Namespace

bash

# Isolate production from test environment
kubectl create namespace wordpress-prod

# Verify namespace created
kubectl get namespaces

Production Deployment with PVC

yaml

# wordpress-prod-pvc.yaml
---
apiVersion: v1
kind: Secret
metadata:
  name: mysql-pass
  namespace: wordpress-prod
type: Opaque
data:
  # 'SecurePassword2024!' base64 encoded
  password: U2VjdXJlUGFzc3dvcmQyMDI0IQ==

---
# PersistentVolumeClaim - Requests persistent storage
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mysql-pv-claim
  namespace: wordpress-prod
spec:
  accessModes:
    - ReadWriteOnce        # Can be mounted as read-write by a single node
  resources:
    requests:
      storage: 20Gi        # Request 20GB of storage

---
apiVersion: v1
kind: Service
metadata:
  name: wordpress-mysql
  namespace: wordpress-prod
spec:
  ports:
  - port: 3306
  selector:
    app: wordpress-mysql

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: wordpress-mysql
  namespace: wordpress-prod
spec:
  selector:
    matchLabels:
      app: wordpress-mysql
  template:
    metadata:
      labels:
        app: wordpress-mysql
    spec:
      containers:
      - name: mysql
        image: mysql:8.0
        env:
        - name: MYSQL_ROOT_PASSWORD
          valueFrom:
            secretKeyRef:
              name: mysql-pass
              key: password
        - name: MYSQL_DATABASE
          value: wordpress
        ports:
        - containerPort: 3306
        volumeMounts:
        - name: mysql-persistent-storage
          mountPath: /var/lib/mysql      # Where MySQL stores data
      volumes:
      - name: mysql-persistent-storage
        persistentVolumeClaim:
          claimName: mysql-pv-claim      # Bind to the PVC

---
apiVersion: v1
kind: Service
metadata:
  name: wordpress
  namespace: wordpress-prod
spec:
  type: NodePort
  ports:
  - port: 80
    nodePort: 30081
    targetPort: 80
  selector:
    app: wordpress

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: wordpress
  namespace: wordpress-prod
spec:
  selector:
    matchLabels:
      app: wordpress
  template:
    metadata:
      labels:
        app: wordpress
    spec:
      containers:
      - name: wordpress
        image: wordpress:latest
        env:
        - name: WORDPRESS_DB_HOST
          value: wordpress-mysql
        - name: WORDPRESS_DB_USER
          value: root
        - name: WORDPRESS_DB_PASSWORD
          valueFrom:
            secretKeyRef:
              name: mysql-pass
              key: password
        - name: WORDPRESS_DB_NAME
          value: wordpress
        ports:
        - containerPort: 80

Deploy Production WordPress

bash

# Deploy to namespace
kubectl apply -f wordpress-prod-pvc.yaml

# Wait for pods to be ready
kubectl get pods -n wordpress-prod -w

# Install WordPress
kubectl exec -n wordpress-prod deployment/wordpress -- bash -c "
cd /tmp && \
curl -sO https://raw.githubusercontent.com/wp-cli/builds/gh-pages/phar/wp-cli.phar && \
chmod +x wp-cli.phar && \
su -s /bin/bash -c 'php /tmp/wp-cli.phar core install \
  --path=/var/www/html \
  --url=\"http://your-tailscale-url:30081\" \
  --title=\"Production WordPress on K8s\" \
  --admin_user=prod_admin \
  --admin_password=ProdSecurePass2024! \
  --admin_email=prod@example.com' www-data
"

# Set correct site URLs
kubectl exec -n wordpress-prod deployment/wordpress-mysql -- mysql -uroot -pSecurePassword2024! -e "
USE wordpress;
UPDATE wp_options SET option_value = 'http://your-tailscale-url:30081' WHERE option_name = 'siteurl';
UPDATE wp_options SET option_value = 'http://your-tailscale-url:30081' WHERE option_name = 'home';
"

Testing Data Persistence

bash

# Create a test post
kubectl exec -n wordpress-prod deployment/wordpress -- bash -c "
wp post create --post_title='PVC Test' --post_content='This should survive!' --post_status=publish --allow-root
"

# Restart MySQL pod (simulates failure)
kubectl delete pod -n wordpress-prod -l app=wordpress-mysql

# Wait for new pod
sleep 30

# Verify post still exists
kubectl exec -n wordpress-prod deployment/wordpress -- wp post list --allow-root
# ✅ The test post is still there - PVC is working!

Test vs Production Comparison

Feature	Test WordPress	Production WordPress
Namespace	default	wordpress-prod
Port	30080	30081
Storage	Ephemeral (lost on restart)	Persistent (20GB PVC)
MySQL Version	5.7	8.0
WordPress Version	5.8	Latest
Use Case	Testing, experiments	Live production
Data Safety	❌ Not safe	✅ Safe

---

Part 4: Kubernetes Dashboard

What is the Kubernetes Dashboard?

A web-based UI for managing and monitoring your Kubernetes cluster. Provides visual access to:

• All pods, deployments, and services
• Real-time logs
• Resource usage metrics
• Container shells (exec)
• Storage and configuration management

Installation

bash

# Deploy the official dashboard
kubectl apply -f https://raw.githubusercontent.com/kubernetes/dashboard/v2.7.0/aio/deploy/recommended.yaml

# Create admin user
cat > dashboard-admin.yaml << 'EOF'
apiVersion: v1
kind: ServiceAccount
metadata:
  name: dashboard-admin
  namespace: kubernetes-dashboard

---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: dashboard-admin
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: cluster-admin
subjects:
- kind: ServiceAccount
  name: dashboard-admin
  namespace: kubernetes-dashboard
EOF

kubectl apply -f dashboard-admin.yaml

# Expose dashboard via NodePort
kubectl patch svc kubernetes-dashboard -n kubernetes-dashboard -p '{"spec": {"type": "NodePort", "ports": [{"port": 443, "targetPort": 8443, "nodePort": 30082}]}}'

# Generate access token
kubectl -n kubernetes-dashboard create token dashboard-admin --duration=8760h

Access the Dashboard

• URL: https://your-tailscale-url:30082
• Login: Token authentication (paste the token from above)
• Note: Browser will show a security warning (self-signed certificate) — it’s safe to proceed

What You Can Do in the Dashboard

Section	Capabilities
Cluster	View nodes, namespaces, resource quotas
Workloads	Pods, Deployments, ReplicaSets, Jobs, CronJobs
Services	Services, Ingresses, Network Policies
Storage	PersistentVolumeClaims, StorageClasses
Config	ConfigMaps, Secrets
Logs	Click any pod → Logs tab → Real-time streaming
Exec	Click any pod → Exec tab → Shell into container

---

Part 5: Jenkins CI/CD Integration

Why Jenkins on Docker?

Running Jenkins in a Docker container provides:

• ✅ Isolation from the host system
• ✅ Easy updates (just pull a new image)
• ✅ Persistent data through Docker volumes
• ✅ No Java installation required on the host

Installation

bash

# Install Docker (if not installed)
apt update && apt install -y docker.io
systemctl start docker && systemctl enable docker

# Run Jenkins container with host network
# Using port 8081 because 8080 is often occupied
docker run -d \
  --name jenkins \
  --restart unless-stopped \
  --network host \
  -v jenkins_home:/var/jenkins_home \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v /etc/rancher/k3s:/etc/rancher/k3s:ro \
  -e JENKINS_OPTS="--httpPort=8081" \
  jenkins/jenkins:lts

# Wait for Jenkins to start (1-2 minutes)
sleep 60

# Get initial admin password
docker logs jenkins 2>&1 | grep -A 5 "Initial Admin Password"

Jenkins Initial Setup

1. Access Jenkins: http://your-tailscale-url:8081
2. Enter the initial password from the logs
3. Install suggested plugins (wait for completion)
4. Create admin user:
   • Username: jenkins-admin
   • Password: Jenkins2024!
5. Set Jenkins URL: http://your-tailscale-url:8081

---

Part 6: Connecting Jenkins to K3s

Install kubectl in Jenkins Container

bash

# Install kubectl
docker exec --user root jenkins apt-get update
docker exec --user root jenkins apt-get install -y kubectl

# Verify installation
docker exec jenkins kubectl version --client

Configure Kubeconfig for Localhost Access

bash

# Create a kubeconfig that uses localhost (host networking)
cat > /tmp/kubeconfig << 'EOF'
apiVersion: v1
kind: Config
clusters:
- cluster:
    insecure-skip-tls-verify: true
    server: https://localhost:6443
  name: default
contexts:
- context:
    cluster: default
    user: default
  name: default
current-context: default
users:
- name: default
  user:
    client-certificate-data: <YOUR_CERT_DATA>
    client-key-data: <YOUR_KEY_DATA>
EOF

# Copy to Jenkins container
docker cp /tmp/kubeconfig jenkins:/var/jenkins_home/.kube/config
docker exec --user root jenkins chown jenkins:jenkins /var/jenkins_home/.kube/config
docker exec jenkins chmod 600 /var/jenkins_home/.kube/config

# Test connection
docker exec jenkins kubectl get nodes

Why Jenkins Needs Kubernetes Credentials

Without proper credentials, Jenkins cannot:

• Access the Kubernetes API
• Execute kubectl commands
• Monitor pod status
• Manage deployments

Our kubeconfig file contains:

• Client certificate – Proves Jenkins’ identity to the cluster
• Client key – Private key for encrypted communication
• Server address – K3s API endpoint (localhost:6443)

Sample Jenkins Pipeline

groovy

pipeline {
    agent any
    
    environment {
        KUBECONFIG = '/var/jenkins_home/.kube/config'
    }
    
    stages {
        stage('Check WordPress Status') {
            steps {
                sh 'kubectl get pods -n wordpress-prod'
                sh 'kubectl get pods -n default'
            }
        }
        
        stage('Restart Production') {
            steps {
                sh 'kubectl rollout restart deployment/wordpress -n wordpress-prod'
                sh 'kubectl rollout status deployment/wordpress -n wordpress-prod'
            }
        }
    }
}

---

Part 7: Scaling and Management

Manual Scaling

bash

# Scale OUT to 3 pods (handle more traffic)
kubectl scale deployment wordpress -n wordpress-prod --replicas=3

# Watch pods come online
kubectl get pods -n wordpress-prod -l app=wordpress -w

# Scale IN to 1 pod (save resources)
kubectl scale deployment wordpress -n wordpress-prod --replicas=1

Horizontal Pod Autoscaler (Automatic Scaling)

bash

# Install metrics server
kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml

# Create autoscaler (scales based on CPU usage)
cat << 'EOF' | kubectl apply -f -
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: wordpress-hpa
  namespace: wordpress-prod
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: wordpress
  minReplicas: 1
  maxReplicas: 5
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 50
EOF

# Check autoscaler status
kubectl get hpa -n wordpress-prod

Backup and Restore

bash

# Backup production database
kubectl exec -n wordpress-prod deployment/wordpress-mysql -- \
  mysqldump -uroot -pSecurePassword2024! wordpress > backup-$(date +%Y%m%d).sql

# Restore from backup
kubectl exec -n wordpress-prod deployment/wordpress-mysql -- \
  mysql -uroot -pSecurePassword2024! wordpress < backup.sql

Useful Management Commands

Command	Purpose
kubectl get pods -A	List all pods in all namespaces
kubectl logs -f deployment/wordpress -n wordpress-prod	Stream WordPress logs
kubectl describe pod <pod-name> -n wordpress-prod	Detailed pod information
kubectl exec -it deployment/wordpress -n wordpress-prod -- bash	Shell into WordPress container
kubectl top pods -n wordpress-prod	Show pod resource usage

---

Part 8: Cloud Provider Comparison

Where to Deploy This Architecture in Production

Component	Current (VPS+K3s)	AWS	Google Cloud	Azure	Akamai (Linode)
Kubernetes Service	K3s (self-managed)	Amazon EKS	GKE	AKS	LKE (Linode K8s Engine)
Control Plane Cost	$0 (self-managed)	$0.10/hr	Free (Autopilot)	Free	Free
Egress Bandwidth	Varies by VPS	$0.09/GB	$0.12/GB	$0.087/GB	$0.005/GB
Managed Database	Self-managed MySQL	RDS / Aurora	Cloud SQL	Azure DB for MySQL	Managed Database
Object Storage	Local disk	S3	Cloud Storage	Blob Storage	Object Storage (S3-compatible)
CDN Integration	None	CloudFront	Cloud CDN	Azure CDN	Akamai CDN (world’s largest)
Best For	Learning, control	AWS ecosystem	AI/ML, K8s features	Microsoft shops	Edge, cost-sensitive

Decision Guide

If you prioritize…	Choose…
Learning Kubernetes fundamentals	Current K3s on VPS
Lowest cost for small/medium workloads	Akamai LKE or Azure AKS
Global audience, latency-sensitive	Akamai LKE + Akamai CDN
AWS ecosystem (S3, Lambda, etc.)	AWS EKS
Latest Kubernetes features	Google GKE
Microsoft enterprise integration	Azure AKS

Migration Example: From K3s to Akamai LKE

yaml

# For Akamai LKE (change only storage class and service type)
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mysql-pv-claim
spec:
  storageClassName: linode-block-storage  # Changed from local-path
  # ... rest remains the same

---
apiVersion: v1
kind: Service
metadata:
  name: wordpress
  annotations:
    service.beta.kubernetes.io/linode-loadbalancer-throttle: "20"
spec:
  type: LoadBalancer  # Changed from NodePort
  # ... rest remains the same

---

Troubleshooting & Best Practices

Common Issues and Solutions

Issue 1: Jenkins can’t connect to K3s

bash

# Symptom: kubectl get nodes times out
# Solution: Use host networking
docker stop jenkins && docker rm jenkins
docker run -d --name jenkins --network host ...

Issue 2: WordPress shows “Database Error”

bash

# Check if database exists
kubectl exec -n wordpress-prod deployment/wordpress-mysql -- \
  mysql -uroot -pSecurePassword2024! -e "SHOW DATABASES;"

# Create if missing
kubectl exec -n wordpress-prod deployment/wordpress-mysql -- \
  mysql -uroot -pSecurePassword2024! -e "CREATE DATABASE wordpress;"

Issue 3: PVC stuck in “Pending”

bash

# Check storage class
kubectl get storageclass

# Check local-path provisioner
kubectl get pods -n kube-system | grep local-path

Issue 4: Port already in use

bash

# Find what's using the port
sudo netstat -tlnp | grep 8080

# Kill the process or use different port
sudo kill -9 <PID>

Security Best Practices

1. Never commit secrets to Git
2. Use Kubernetes Secrets for passwords
3. Enable RBAC (Role-Based Access Control)
4. Regularly rotate credentials
5. Use Tailscale for network isolation
6. Monitor pod security contexts
7. Keep K3s and containers updated

Production Readiness Checklist

• ✅ Persistent storage configured (PVC)
• ✅ Regular backups scheduled
• ✅ Monitoring and alerting set up
• ✅ Rolling update strategy defined
• ✅ Resource limits set for all containers
• ✅ Health checks (liveness/readiness probes) configured
• ✅ Network policies for pod isolation
• ✅ SSL/TLS for external access
• ✅ Disaster recovery plan documented

---

Final Status Verification

bash

cat << 'EOF' > final-status.sh
#!/bin/bash
echo "╔══════════════════════════════════════════════════════════════╗"
echo "║     WordPress on K3s with Jenkins CI/CD - Final Status      ║"
echo "╚══════════════════════════════════════════════════════════════╝"
echo ""
echo "🎯 K3s Cluster:"
kubectl get nodes
echo ""
echo "🎨 Production WordPress (Port 30081 - with PVC):"
kubectl get pods -n wordpress-prod
echo ""
echo "🧪 Test WordPress (Port 30080 - ephemeral):"
kubectl get pods -n default
echo ""
echo "💾 Persistent Storage:"
kubectl get pvc -n wordpress-prod
echo ""
echo "🔧 Jenkins Status:"
docker ps | grep jenkins
echo ""
echo "╔══════════════════════════════════════════════════════════════╗"
echo "║                      Access URLs                            ║"
echo "╠══════════════════════════════════════════════════════════════╣"
echo "║ Jenkins CI/CD:      http://your-tailscale-url:8081          ║"
echo "║ Production WP:      http://your-tailscale-url:30081         ║"
echo "║ Test WP:            http://your-tailscale-url:30080         ║"
echo "║ K8s Dashboard:      https://your-tailscale-url:30082        ║"
echo "╚══════════════════════════════════════════════════════════════╝"
EOF

chmod +x final-status.sh
./final-status.sh

---

Conclusion

You’ve successfully built a complete WordPress infrastructure on Kubernetes!

What you’ve accomplished:

• ✅ K3s Kubernetes cluster running on a VPS
• ✅ Two WordPress instances (test + production)
• ✅ Persistent storage for production database
• ✅ Kubernetes Dashboard for visual management
• ✅ Jenkins CI/CD pipeline with kubectl integration
• ✅ Secure remote access via Tailscale
• ✅ Understanding of YAML, PVCs, Deployments, and Services

Key Takeaways:

1. Kubernetes skills are transferable across all cloud providers
2. Persistent storage is essential for production databases
3. CI/CD pipelines automate deployment and management
4. Namespaces provide isolation between environments
5. Understanding fundamentals first makes cloud adoption easier

Next Steps:

1. Set up SSL/HTTPS with Let’s Encrypt
2. Configure automated backups
3. Add monitoring with Prometheus + Grafana
4. Implement GitOps with ArgoCD
5. Set up alerting for pod failures

---

Additional Resources

• Kubernetes Documentation
• K3s Documentation
• Jenkins Pipeline Documentation
• Tailscale Documentation
• WordPress on Kubernetes Best Practices

---

*This guide was compiled from a complete production deployment of WordPress on K3s, including test and production environments, persistent storage, and CI/CD integration with Jenkins.*