k8s-workflows

Workflow: Deploy-App-To-Multiple-Clusters
1. Validate target clusters and namespaces
2. Deploy to staging cluster first
3. Request human confirmation for production deployment
4. Execute coordinated deployment across clusters
5. Verify deployment health in all clusters
6. Generate deployment summary

Workflow: Safe-Rolling-Update
1. Check current deployment status
2. Calculate replica count strategy
3. Update with max unavailable percentage
4. Monitor rollback triggers
5. Confirm update completion with human

Workflow: Istio-Management
1. Review current Istio configuration
2. Plan traffic routing changes
3. Execute virtual service updates
4. Verify end-to-end connectivity
5. Validate service mesh health

# Human confirmation required for cluster operations
echo "Available clusters:"
kubectl config get-contexts --output=name
echo "Current context:"
kubectl config current-context
echo "Namespace in current context:"
kubectl config view --minify | grep namespace

# Always require confirmation for production changes
confirm_production_operation() {
  if [[ "$CLUSTER_TYPE" == "production" ]]; then
    echo "⚠️  PRODUCTION OPERATION - Human confirmation required"
    read -p "Continue? (y/N): " -n 1 -r
    [[ $REPLY =~ ^[Yy]$ ]] || exit 1
  fi
}

# Deploy with cluster validation
deploy_to_clusters() {
  local app_name=$1
  local clusters=("${@:2}")

  for cluster in "${clusters[@]}"; do
    echo "📍 Deploying $app_name to $cluster"
    kubectl config use-context "$cluster"
    # Deployment commands here
  done
}

# Verify cluster connectivity
check_cluster_health() {
  local cluster=$1

  kubectl config use-context "$cluster" || {
    echo "❌ Failed to switch to cluster: $cluster"
    return 1
  }

  kubectl get nodes || {
    echo "❌ Cluster $cluster is not accessible"
    return 1
  }

  echo "✅ Cluster $cluster is healthy"
  return 0
}

# Helm operations with validation
deploy_with_helm() {
  local chart_path=$1
  local namespace=$2
  local values_file=$3

  # Pre-deployment checks
  helm lint "$chart_path" || return 1
  helm template "$chart_path" --namespace="$namespace" | kubectl apply --dry-run=client -f -

  # Human confirmation required for production
  if [[ "$namespace" == "production" ]]; then
    confirm_production_operation
  fi

  # Deploy
  helm upgrade --install "$RELEASE_NAME" "$chart_path" \
    --namespace="$namespace" \
    --values="$values_file" \
    --wait \
    --timeout=10m
}

# Istio operations with safety checks
istio_traffic_management() {
  local service=$1
  local weight_percentage=$2

  echo "🔄 Routing $weight_percentage% traffic to $service"

  # Verify Istio installation
  kubectl get crd virtualservices | grep istio || {
    echo "❌ Istio not installed in current cluster"
    return 1
  }

  # Apply traffic split with confirmation
  echo "Proposed VirtualService update:"
  cat <<EOF
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: $service
spec:
  http:
  - route:
    - destination:
        host: $service-v1
        weight: $((100 - weight_percentage))
      - destination:
        host: $service-v2
        weight: $weight_percentage
EOF

  confirm_production_operation
  kubectl apply -f -
}

# Structured troubleshooting process
troubleshoot_deployment() {
  local deployment_name=$1
  local namespace=$2

  echo "🔍 Troubleshooting $deployment_name in $namespace"

  # 1. Check deployment status
  kubectl get deployment "$deployment_name" -n "$namespace" -o wide

  # 2. Check pod logs for errors
  kubectl logs -l app="$deployment_name" -n "$namespace" --since=10m

  # 3. Check resource constraints
  kubectl top pod -l app="$deployment_name" -n "$namespace"

  # 4. Check events for issues
  kubectl get events -n "$namespace" --field-selector involvedObject.name="$deployment_name"

  # 5. Verify service connectivity
  kubectl get svc -l app="$deployment_name" -n "$namespace"

  echo "📊 Troubleshooting complete - review output above"
}

Human: "Deploy my app v1.2 to all production clusters"
Me: I'll orchestrate deployment across production clusters:

1. 🔍 Discovering available production clusters
2. 📋 Validating deployment configuration
3. 🚀 Deploying to staging cluster first for validation
4. 👤 Awaiting human confirmation before production deployment
5. 🌐 Coordinating rollout across production clusters
6. ✅ Verifying deployment health in all clusters
7. 📊 Generating deployment summary

Would you like me to proceed with staging deployment first?

Human: "Update my nginx deployment to 1.25 with rolling update"
Me: I'll execute safe rolling update:

1. 📊 Current status: nginx deployment, 3 replicas, 100% healthy
2. 🧮 Strategy: 25% max unavailable, progressive rollout
3. 👤 Human confirmation required for production update
4. 🔄 Executing rolling update with monitoring
5. 📈 Tracking update progress and rollback triggers
6. ✅ Verifying update completion and health

Proceed with rolling update? (will require confirmation at 25% and 75% completion)