Setup ArgoCD ApplicationSets for multi-environment GitOps workflows with automated deployment pipelines

#!/usr/bin/env bash
set -euo pipefail

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

# Configuration
SCRIPT_NAME=$(basename "$0")
REPO_URL="${1:-}"
REPO_DIR="${2:-gitops-demo}"

# Usage message
usage() {
    echo "Usage: $SCRIPT_NAME <git-repo-url> [repo-directory]"
    echo "Example: $SCRIPT_NAME https://github.com/myorg/gitops-demo.git"
    exit 1
}

# Cleanup function
cleanup() {
    local exit_code=$?
    if [ $exit_code -ne 0 ]; then
        echo -e "${RED}[ERROR] Installation failed. Cleaning up...${NC}"
        kubectl delete namespace argocd --ignore-not-found=true || true
        rm -rf "$REPO_DIR" || true
    fi
    exit $exit_code
}

trap cleanup ERR

# Logging functions
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"; }

# Check arguments
if [ -z "$REPO_URL" ]; then
    usage
fi

# Auto-detect distribution
if [ -f /etc/os-release ]; then
    . /etc/os-release
    case "$ID" in
        ubuntu|debian)
            PKG_MGR="apt"
            PKG_INSTALL="apt install -y"
            PKG_UPDATE="apt update"
            ;;
        almalinux|rocky|centos|rhel|ol|fedora)
            PKG_MGR="dnf"
            PKG_INSTALL="dnf install -y"
            PKG_UPDATE="dnf update -y"
            ;;
        amzn)
            PKG_MGR="yum"
            PKG_INSTALL="yum install -y"
            PKG_UPDATE="yum update -y"
            ;;
        *)
            log_error "Unsupported distribution: $ID"
            exit 1
            ;;
    esac
else
    log_error "Cannot detect distribution. /etc/os-release not found."
    exit 1
fi

log_info "Detected distribution: $ID using $PKG_MGR"

# Check prerequisites
echo "[1/10] Checking prerequisites..."
if [ "$EUID" -eq 0 ]; then
    log_warning "Running as root. Consider using sudo for specific commands only."
fi

# Check for required tools
command -v kubectl >/dev/null 2>&1 || { log_error "kubectl is required but not installed."; exit 1; }
command -v git >/dev/null 2>&1 || { 
    log_info "Installing git..."
    if [ "$PKG_MGR" = "apt" ]; then
        sudo $PKG_UPDATE
    fi
    sudo $PKG_INSTALL git
}

# Verify kubectl cluster access
echo "[2/10] Verifying Kubernetes cluster access..."
if ! kubectl cluster-info >/dev/null 2>&1; then
    log_error "Cannot connect to Kubernetes cluster. Check kubeconfig."
    exit 1
fi
log_success "Kubernetes cluster access verified"

# Check if ArgoCD is already installed
echo "[3/10] Checking ArgoCD installation..."
if kubectl get namespace argocd >/dev/null 2>&1; then
    log_warning "ArgoCD namespace already exists. Skipping installation."
    SKIP_ARGOCD_INSTALL=true
else
    SKIP_ARGOCD_INSTALL=false
fi

# Install ArgoCD if not present
if [ "$SKIP_ARGOCD_INSTALL" = "false" ]; then
    echo "[4/10] Installing ArgoCD..."
    kubectl create namespace argocd
    kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml
    log_success "ArgoCD installation initiated"
else
    echo "[4/10] Skipping ArgoCD installation (already exists)"
fi

# Wait for ArgoCD components to be ready
echo "[5/10] Waiting for ArgoCD components to be ready..."
kubectl wait --for=condition=ready pod -l app.kubernetes.io/part-of=argocd -n argocd --timeout=300s
log_success "ArgoCD components are ready"

# Install ArgoCD ApplicationSet Controller
echo "[6/10] Installing ArgoCD ApplicationSet Controller..."
if ! kubectl get deployment argocd-applicationset-controller -n argocd >/dev/null 2>&1; then
    kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/applicationset/v0.4.1/manifests/install.yaml
    log_success "ApplicationSet Controller installed"
else
    log_warning "ApplicationSet Controller already exists"
fi

# Clone or create GitOps repository structure
echo "[7/10] Setting up GitOps repository structure..."
if [ -d "$REPO_DIR" ]; then
    log_warning "Directory $REPO_DIR already exists. Removing it."
    rm -rf "$REPO_DIR"
fi

git clone "$REPO_URL" "$REPO_DIR" || {
    log_warning "Failed to clone repository. Creating local structure."
    mkdir -p "$REPO_DIR"
    cd "$REPO_DIR"
    git init
}

cd "$REPO_DIR"
mkdir -p apps environments/{dev,staging,prod} clusters
chmod 755 apps environments environments/{dev,staging,prod} clusters

# Create base application manifests
echo "[8/10] Creating base application manifests..."
cat > apps/nginx-base.yaml << 'EOF'
apiVersion: v1
kind: Namespace
metadata:
  name: nginx-{{.environment}}
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx
  namespace: nginx-{{.environment}}
spec:
  replicas: {{.replicas}}
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
        environment: {{.environment}}
    spec:
      containers:
      - name: nginx
        image: nginx:{{.version}}
        ports:
        - containerPort: 80
        resources:
          requests:
            cpu: {{.cpu_request}}
            memory: {{.memory_request}}
          limits:
            cpu: {{.cpu_limit}}
            memory: {{.memory_limit}}
---
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
  namespace: nginx-{{.environment}}
spec:
  selector:
    app: nginx
  ports:
  - port: 80
    targetPort: 80
  type: ClusterIP
EOF

chmod 644 apps/nginx-base.yaml

# Create environment-specific configurations
echo "[9/10] Creating environment configurations..."
cat > environments/dev/config.json << 'EOF'
{
  "environment": "dev",
  "replicas": 1,
  "version": "1.21",
  "cpu_request": "100m",
  "memory_request": "128Mi",
  "cpu_limit": "200m",
  "memory_limit": "256Mi",
  "cluster": "in-cluster",
  "namespace": "nginx-dev"
}
EOF

cat > environments/staging/config.json << 'EOF'
{
  "environment": "staging",
  "replicas": 2,
  "version": "1.21",
  "cpu_request": "200m",
  "memory_request": "256Mi",
  "cpu_limit": "500m",
  "memory_limit": "512Mi",
  "cluster": "in-cluster",
  "namespace": "nginx-staging"
}
EOF

cat > environments/prod/config.json << 'EOF'
{
  "environment": "prod",
  "replicas": 3,
  "version": "1.20",
  "cpu_request": "500m",
  "memory_request": "512Mi",
  "cpu_limit": "1000m",
  "memory_limit": "1Gi",
  "cluster": "in-cluster",
  "namespace": "nginx-prod"
}
EOF

chmod 644 environments/*/config.json

# Create ApplicationSet manifest
cat > applicationset.yaml << 'EOF'
apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: nginx-environments
  namespace: argocd
spec:
  generators:
  - git:
      repoURL: https://github.com/example/gitops-demo.git
      revision: HEAD
      files:
      - path: "environments/*/config.json"
  template:
    metadata:
      name: 'nginx-{{environment}}'
    spec:
      project: default
      source:
        repoURL: https://github.com/example/gitops-demo.git
        targetRevision: HEAD
        path: apps
        plugin:
          name: argocd-vault-plugin-helm
          env:
          - name: HELM_VALUES
            value: |
              environment: {{environment}}
              replicas: {{replicas}}
              version: {{version}}
              cpu_request: {{cpu_request}}
              memory_request: {{memory_request}}
              cpu_limit: {{cpu_limit}}
              memory_limit: {{memory_limit}}
      destination:
        server: https://kubernetes.default.svc
        namespace: nginx-{{environment}}
      syncPolicy:
        automated:
          prune: true
          selfHeal: true
        syncOptions:
        - CreateNamespace=true
EOF

chmod 644 applicationset.yaml

log_success "GitOps repository structure created"

# Verification
echo "[10/10] Verifying installation..."
kubectl get pods -n argocd --no-headers | while read -r pod status rest; do
    if [[ "$status" != "Running" ]]; then
        log_warning "Pod $pod is in $status state"
    fi
done

if kubectl get deployment argocd-applicationset-controller -n argocd >/dev/null 2>&1; then
    log_success "ApplicationSet Controller is deployed"
else
    log_error "ApplicationSet Controller not found"
    exit 1
fi

log_success "ArgoCD ApplicationSets installation completed successfully!"
echo ""
log_info "Next steps:"
echo "1. Update the repoURL in applicationset.yaml with your actual Git repository"
echo "2. Commit and push the generated files to your Git repository"
echo "3. Apply the ApplicationSet: kubectl apply -f applicationset.yaml"
echo "4. Access ArgoCD UI: kubectl port-forward svc/argocd-server -n argocd 8080:443"
echo "5. Get admin password: kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath='{.data.password}' | base64 -d"