Set up Kubernetes persistent volume snapshots and backup automation

#!/usr/bin/env bash

set -euo pipefail

# Kubernetes Persistent Volume Snapshots and Backup Automation Setup
# Production-quality installation script

# Color definitions
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# Configuration variables
CSI_DRIVER="${CSI_DRIVER:-ebs.csi.aws.com}"
STORAGE_CLASS="${STORAGE_CLASS:-gp3}"
VELERO_VERSION="${VELERO_VERSION:-v1.12.0}"
SNAPSHOT_VERSION="${SNAPSHOT_VERSION:-release-6.3}"

# Function definitions
log_info() { echo -e "${BLUE}[INFO]${NC} $1"; }
log_success() { echo -e "${GREEN}[SUCCESS]${NC} $1"; }
log_warning() { echo -e "${YELLOW}[WARNING]${NC} $1"; }
log_error() { echo -e "${RED}[ERROR]${NC} $1"; }

cleanup_on_error() {
    log_error "Installation failed. Cleaning up..."
    rm -f /tmp/velero-*.tar.gz
    rm -rf /tmp/velero-*-linux-amd64
    rm -f /tmp/*.yaml
    exit 1
}

trap cleanup_on_error ERR

usage() {
    echo "Usage: $0 [OPTIONS]"
    echo "Options:"
    echo "  --csi-driver DRIVER     CSI driver name (default: ebs.csi.aws.com)"
    echo "  --storage-class CLASS   Storage class name (default: gp3)"
    echo "  --velero-version VER    Velero version (default: v1.12.0)"
    echo "  -h, --help             Show this help message"
    echo ""
    echo "Example:"
    echo "  $0 --csi-driver disk.csi.azure.com --storage-class managed-premium"
    exit 1
}

# Parse command line arguments
while [[ $# -gt 0 ]]; do
    case $1 in
        --csi-driver)
            CSI_DRIVER="$2"
            shift 2
            ;;
        --storage-class)
            STORAGE_CLASS="$2"
            shift 2
            ;;
        --velero-version)
            VELERO_VERSION="$2"
            shift 2
            ;;
        -h|--help)
            usage
            ;;
        *)
            log_error "Unknown option: $1"
            usage
            ;;
    esac
done

# Check prerequisites
echo "[1/9] Checking prerequisites..."

if [[ $EUID -ne 0 ]] && ! command -v sudo >/dev/null 2>&1; then
    log_error "This script requires root privileges or sudo access"
    exit 1
fi

SUDO=""
if [[ $EUID -ne 0 ]]; then
    SUDO="sudo"
fi

# Check for kubectl
if ! command -v kubectl >/dev/null 2>&1; then
    log_error "kubectl is required but not installed. Please install kubectl first."
    exit 1
fi

# Test kubectl connectivity
if ! kubectl cluster-info >/dev/null 2>&1; then
    log_error "Cannot connect to Kubernetes cluster. Please check your kubeconfig."
    exit 1
fi

log_success "Prerequisites check passed"

# Detect distribution
echo "[2/9] Detecting operating system..."

if [ -f /etc/os-release ]; then
    . /etc/os-release
    case "$ID" in
        ubuntu|debian)
            PKG_MGR="apt"
            PKG_UPDATE="apt update"
            PKG_INSTALL="apt install -y"
            ;;
        almalinux|rocky|centos|rhel|ol|fedora)
            PKG_MGR="dnf"
            PKG_UPDATE="dnf update -y"
            PKG_INSTALL="dnf install -y"
            if ! command -v dnf >/dev/null 2>&1; then
                PKG_MGR="yum"
                PKG_UPDATE="yum update -y"
                PKG_INSTALL="yum install -y"
            fi
            ;;
        amzn)
            PKG_MGR="yum"
            PKG_UPDATE="yum update -y"
            PKG_INSTALL="yum install -y"
            ;;
        *)
            log_error "Unsupported distribution: $ID"
            exit 1
            ;;
    esac
else
    log_error "Cannot detect operating system"
    exit 1
fi

log_success "Detected OS: $PRETTY_NAME using $PKG_MGR"

# Install required packages
echo "[3/9] Installing required packages..."

$SUDO $PKG_UPDATE >/dev/null 2>&1 || true

case "$PKG_MGR" in
    apt)
        $SUDO $PKG_INSTALL wget curl tar gzip >/dev/null 2>&1
        ;;
    dnf|yum)
        $SUDO $PKG_INSTALL wget curl tar gzip >/dev/null 2>&1
        ;;
esac

log_success "Required packages installed"

# Install CSI snapshot CRDs
echo "[4/9] Installing CSI snapshot controller and CRDs..."

kubectl apply -f "https://raw.githubusercontent.com/kubernetes-csi/external-snapshotter/${SNAPSHOT_VERSION}/client/config/crd/snapshot.storage.k8s.io_volumesnapshotclasses.yaml" >/dev/null
kubectl apply -f "https://raw.githubusercontent.com/kubernetes-csi/external-snapshotter/${SNAPSHOT_VERSION}/client/config/crd/snapshot.storage.k8s.io_volumesnapshotcontents.yaml" >/dev/null  
kubectl apply -f "https://raw.githubusercontent.com/kubernetes-csi/external-snapshotter/${SNAPSHOT_VERSION}/client/config/crd/snapshot.storage.k8s.io_volumesnapshots.yaml" >/dev/null

log_success "CSI snapshot CRDs installed"

# Deploy snapshot controller
echo "[5/9] Deploying snapshot controller..."

kubectl apply -f "https://raw.githubusercontent.com/kubernetes-csi/external-snapshotter/${SNAPSHOT_VERSION}/deploy/kubernetes/snapshot-controller/rbac-snapshot-controller.yaml" >/dev/null
kubectl apply -f "https://raw.githubusercontent.com/kubernetes-csi/external-snapshotter/${SNAPSHOT_VERSION}/deploy/kubernetes/snapshot-controller/setup-snapshot-controller.yaml" >/dev/null

# Wait for snapshot controller to be ready
kubectl wait --for=condition=available --timeout=300s deployment/snapshot-controller -n kube-system >/dev/null

log_success "Snapshot controller deployed and ready"

# Create volume snapshot class
echo "[6/9] Creating volume snapshot class..."

cat > /tmp/snapshot-class.yaml <<EOF
apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshotClass
metadata:
  name: csi-snapshot-class
  annotations:
    snapshot.storage.kubernetes.io/is-default-class: "true"
driver: ${CSI_DRIVER}
deletionPolicy: Delete
parameters:
  incremental: "true"
  encrypted: "true"
EOF

kubectl apply -f /tmp/snapshot-class.yaml >/dev/null

log_success "Volume snapshot class created"

# Install Velero
echo "[7/9] Installing Velero..."

cd /tmp
wget -q "https://github.com/vmware-tanzu/velero/releases/download/${VELERO_VERSION}/velero-${VELERO_VERSION}-linux-amd64.tar.gz"
tar -xzf "velero-${VELERO_VERSION}-linux-amd64.tar.gz"

$SUDO mv "velero-${VELERO_VERSION}-linux-amd64/velero" /usr/local/bin/
$SUDO chmod 755 /usr/local/bin/velero
$SUDO chown root:root /usr/local/bin/velero

# Cleanup temporary files
rm -f "velero-${VELERO_VERSION}-linux-amd64.tar.gz"
rm -rf "velero-${VELERO_VERSION}-linux-amd64"

log_success "Velero binary installed"

# Create test application
echo "[8/9] Creating test application with persistent storage..."

cat > /tmp/test-app.yaml <<EOF
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: test-pvc
  namespace: default
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi
  storageClassName: ${STORAGE_CLASS}
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: test-app
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      app: test-app
  template:
    metadata:
      labels:
        app: test-app
    spec:
      containers:
      - name: test-container
        image: nginx:1.24
        volumeMounts:
        - name: data-volume
          mountPath: /data
        command: ["/bin/sh", "-c"]
        args:
        - |
          echo "Initial data: \$(date)" > /data/test.txt
          nginx -g "daemon off;"
      volumes:
      - name: data-volume
        persistentVolumeClaim:
          claimName: test-pvc
EOF

kubectl apply -f /tmp/test-app.yaml >/dev/null

# Wait for PVC to be bound
kubectl wait --for=condition=bound pvc/test-pvc --timeout=300s >/dev/null

log_success "Test application deployed"

# Verification
echo "[9/9] Verifying installation..."

# Check snapshot controller
if kubectl get deployment snapshot-controller -n kube-system >/dev/null 2>&1; then
    log_success "✓ Snapshot controller is deployed"
else
    log_error "✗ Snapshot controller deployment failed"
    exit 1
fi

# Check snapshot class
if kubectl get volumesnapshotclass csi-snapshot-class >/dev/null 2>&1; then
    log_success "✓ Volume snapshot class created"
else
    log_error "✗ Volume snapshot class creation failed"
    exit 1
fi

# Check Velero binary
if command -v velero >/dev/null 2>&1; then
    VELERO_VER=$(velero version --client-only 2>/dev/null | grep Version | cut -d: -f2 | tr -d ' ')
    log_success "✓ Velero installed: $VELERO_VER"
else
    log_error "✗ Velero installation failed"
    exit 1
fi

# Check test application
if kubectl get pvc test-pvc -o jsonpath='{.status.phase}' | grep -q "Bound"; then
    log_success "✓ Test application PVC is bound"
else
    log_warning "⚠ Test application PVC is not yet bound"
fi

# Cleanup temporary files
rm -f /tmp/*.yaml

# Final instructions
echo ""
log_success "Installation completed successfully!"
echo ""
echo "Next steps:"
echo "1. Configure Velero with your cloud provider:"
echo "   velero install --provider <provider> --bucket <bucket> ..."
echo ""
echo "2. Create a manual snapshot:"
echo "   kubectl create -f - <<EOF"
echo "   apiVersion: snapshot.storage.k8s.io/v1"
echo "   kind: VolumeSnapshot"
echo "   metadata:"
echo "     name: test-snapshot"
echo "     namespace: default"
echo "   spec:"
echo "     volumeSnapshotClassName: csi-snapshot-class"
echo "     source:"
echo "       persistentVolumeClaimName: test-pvc"
echo "   EOF"
echo ""
echo "3. Create automated backups with Velero schedules"
echo ""
log_info "CSI Driver: $CSI_DRIVER"
log_info "Storage Class: $STORAGE_CLASS"
log_info "Velero Version: $VELERO_VERSION"