Bash Scripting Day

Solution

Deployment Script

deploy.sh

#!/bin/bash

#######################################
# Application Deployment Script
# Description: Build, push, and deploy application
# Usage: ./deploy.sh [environment] [version]
#######################################

set -euo pipefail  # Exit on error, undefined vars, pipe failures

#######################################
# Configuration
#######################################

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
LOG_DIR="${SCRIPT_DIR}/logs"
LOG_FILE="${LOG_DIR}/deploy-$(date +%Y%m%d-%H%M%S).log"

# Docker configuration
DOCKER_REGISTRY="${DOCKER_REGISTRY:-docker.io}"
IMAGE_NAME="${IMAGE_NAME:-myapp}"

# Kubernetes configuration
KUBECTL_TIMEOUT=300

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

#######################################
# Functions
#######################################

# Print colored message
log() {
    local level=$1
    shift
    local message="$@"
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')

    case $level in
        INFO)
            echo -e "${BLUE}[INFO]${NC} $message" | tee -a "$LOG_FILE"
            ;;
        SUCCESS)
            echo -e "${GREEN}[SUCCESS]${NC} $message" | tee -a "$LOG_FILE"
            ;;
        WARN)
            echo -e "${YELLOW}[WARN]${NC} $message" | tee -a "$LOG_FILE"
            ;;
        ERROR)
            echo -e "${RED}[ERROR]${NC} $message" | tee -a "$LOG_FILE"
            ;;
    esac
}

# Error handler
error_exit() {
    log ERROR "$1"
    exit 1
}

# Check if command exists
command_exists() {
    command -v "$1" >/dev/null 2>&1
}

# Show usage
usage() {
    cat << EOF
Usage: $0 [OPTIONS] ENVIRONMENT VERSION

Deploy application to Kubernetes cluster.

Arguments:
    ENVIRONMENT    Target environment (dev|staging|prod)
    VERSION        Version tag to deploy

Options:
    -h, --help     Show this help message
    -d, --dry-run  Perform dry run without actual deployment
    -s, --skip-build  Skip Docker build step
    -v, --verbose  Enable verbose output

Examples:
    $0 dev 1.0.0
    $0 --dry-run prod 2.1.0
    $0 --skip-build staging 1.5.2

EOF
    exit 0
}

# Validate prerequisites
check_prerequisites() {
    log INFO "Checking prerequisites..."

    local missing_tools=()

    # Required tools
    local required_tools=("docker" "kubectl" "git")

    for tool in "${required_tools[@]}"; do
        if ! command_exists "$tool"; then
            missing_tools+=("$tool")
        fi
    done

    if [ ${#missing_tools[@]} -ne 0 ]; then
        error_exit "Missing required tools: ${missing_tools[*]}"
    fi

    # Check Docker daemon
    if ! docker info >/dev/null 2>&1; then
        error_exit "Docker daemon is not running"
    fi

    # Check kubectl connection
    if ! kubectl cluster-info >/dev/null 2>&1; then
        error_exit "Cannot connect to Kubernetes cluster"
    fi

    log SUCCESS "All prerequisites met"
}

# Validate environment
validate_environment() {
    local env=$1

    case $env in
        dev|staging|prod)
            log INFO "Environment: $env"
            ;;
        *)
            error_exit "Invalid environment: $env. Must be dev, staging, or prod"
            ;;
    esac
}

# Validate version format
validate_version() {
    local version=$1

    if [[ ! $version =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
        error_exit "Invalid version format: $version. Expected format: X.Y.Z"
    fi

    log INFO "Version: $version"
}

# Build Docker image
build_image() {
    local version=$1
    local image_tag="${DOCKER_REGISTRY}/${IMAGE_NAME}:${version}"

    log INFO "Building Docker image: $image_tag"

    if [ "$DRY_RUN" = true ]; then
        log INFO "[DRY-RUN] Would build: $image_tag"
        return 0
    fi

    if ! docker build -t "$image_tag" .; then
        error_exit "Docker build failed"
    fi

    # Also tag as latest for environment
    docker tag "$image_tag" "${DOCKER_REGISTRY}/${IMAGE_NAME}:${ENVIRONMENT}-latest"

    log SUCCESS "Image built successfully"
}

# Push Docker image
push_image() {
    local version=$1
    local image_tag="${DOCKER_REGISTRY}/${IMAGE_NAME}:${version}"

    log INFO "Pushing Docker image: $image_tag"

    if [ "$DRY_RUN" = true ]; then
        log INFO "[DRY-RUN] Would push: $image_tag"
        return 0
    fi

    if ! docker push "$image_tag"; then
        error_exit "Docker push failed"
    fi

    # Push environment-specific latest tag
    docker push "${DOCKER_REGISTRY}/${IMAGE_NAME}:${ENVIRONMENT}-latest"

    log SUCCESS "Image pushed successfully"
}

# Deploy to Kubernetes
deploy_to_k8s() {
    local environment=$1
    local version=$2
    local namespace="$environment"

    log INFO "Deploying to Kubernetes namespace: $namespace"

    if [ "$DRY_RUN" = true ]; then
        log INFO "[DRY-RUN] Would deploy version $version to $namespace"
        return 0
    fi

    # Create namespace if it doesn't exist
    kubectl create namespace "$namespace" --dry-run=client -o yaml | kubectl apply -f -

    # Update deployment with new image
    kubectl set image deployment/myapp \
        myapp="${DOCKER_REGISTRY}/${IMAGE_NAME}:${version}" \
        -n "$namespace"

    # Record the change cause in the rollout history
    kubectl annotate deployment/myapp -n "$namespace" \
        kubernetes.io/change-cause="Deploy version ${version}" --overwrite

    # Wait for rollout
    log INFO "Waiting for rollout to complete..."
    if ! kubectl rollout status deployment/myapp -n "$namespace" --timeout="${KUBECTL_TIMEOUT}s"; then
        error_exit "Deployment rollout failed"
    fi

    log SUCCESS "Deployment successful"
}

# Verify deployment
verify_deployment() {
    local namespace=$1

    log INFO "Verifying deployment..."

    # Check pod status
    local ready_pods=$(kubectl get pods -n "$namespace" -l app=myapp -o json | \
        jq '.items | map(select(.status.phase == "Running")) | length')

    local total_pods=$(kubectl get pods -n "$namespace" -l app=myapp --no-headers | wc -l)

    log INFO "Ready pods: $ready_pods/$total_pods"

    if [ "$ready_pods" -eq 0 ]; then
        error_exit "No pods are running"
    fi

    # Test health endpoint
    local pod_name=$(kubectl get pod -n "$namespace" -l app=myapp -o jsonpath='{.items[0].metadata.name}')

    if kubectl exec -n "$namespace" "$pod_name" -- wget -q -O- http://localhost:3000/health >/dev/null 2>&1; then
        log SUCCESS "Health check passed"
    else
        log WARN "Health check failed"
    fi

    log SUCCESS "Deployment verified"
}

# Rollback deployment
rollback() {
    local namespace=$1

    log WARN "Rolling back deployment..."

    if [ "$DRY_RUN" = true ]; then
        log INFO "[DRY-RUN] Would rollback in namespace $namespace"
        return 0
    fi

    kubectl rollout undo deployment/myapp -n "$namespace"
    kubectl rollout status deployment/myapp -n "$namespace"

    log SUCCESS "Rollback completed"
}

# Cleanup function
cleanup() {
    log INFO "Cleaning up..."
    # Add cleanup tasks here
}

# Signal handler
trap cleanup EXIT
trap 'error_exit "Script interrupted"' INT TERM

#######################################
# Main Script
#######################################

main() {
    # Create log directory
    mkdir -p "$LOG_DIR"

    # Parse options
    DRY_RUN=false
    SKIP_BUILD=false
    VERBOSE=false

    while [[ $# -gt 0 ]]; do
        case $1 in
            -h|--help)
                usage
                ;;
            -d|--dry-run)
                DRY_RUN=true
                shift
                ;;
            -s|--skip-build)
                SKIP_BUILD=true
                shift
                ;;
            -v|--verbose)
                VERBOSE=true
                set -x
                shift
                ;;
            -*)
                error_exit "Unknown option: $1"
                ;;
            *)
                break
                ;;
        esac
    done

    # Validate arguments
    if [ $# -ne 2 ]; then
        error_exit "Missing required arguments. Use -h for help."
    fi

    ENVIRONMENT=$1
    VERSION=$2

    log INFO "=== Starting Deployment ==="
    log INFO "Environment: $ENVIRONMENT"
    log INFO "Version: $VERSION"
    log INFO "Dry Run: $DRY_RUN"
    log INFO "Log file: $LOG_FILE"
    echo ""

    # Run deployment steps
    check_prerequisites
    validate_environment "$ENVIRONMENT"
    validate_version "$VERSION"

    if [ "$SKIP_BUILD" = false ]; then
        build_image "$VERSION"
        push_image "$VERSION"
    else
        log INFO "Skipping build step"
    fi

    deploy_to_k8s "$ENVIRONMENT" "$VERSION"
    verify_deployment "$ENVIRONMENT"

    log SUCCESS "=== Deployment Complete ==="
    log INFO "Application version $VERSION deployed to $ENVIRONMENT"
}

# Run main function
main "$@"

Helper Scripts

check-health.sh

#!/bin/bash

# Health check script
set -euo pipefail

NAMESPACE="${1:-default}"
APP_LABEL="${2:-app=myapp}"

echo "Checking health of $APP_LABEL in namespace $NAMESPACE..."

# Get all pods
PODS=$(kubectl get pods -n "$NAMESPACE" -l "$APP_LABEL" -o json)

# Check each pod
echo "$PODS" | jq -r '.items[] |
    "\(.metadata.name): \(.status.phase) - Ready: \(
        .status.containerStatuses[0].ready
    )"'

# Count healthy pods
READY=$(echo "$PODS" | jq '[.items[].status.containerStatuses[0].ready] | map(select(. == true)) | length')
TOTAL=$(echo "$PODS" | jq '.items | length')

echo "Ready: $READY/$TOTAL"

if [ "$READY" -eq "$TOTAL" ] && [ "$TOTAL" -gt 0 ]; then
    echo "✓ All pods healthy"
    exit 0
else
    echo "✗ Some pods unhealthy"
    exit 1
fi

backup.sh

#!/bin/bash

# Backup script
set -euo pipefail

BACKUP_DIR="${BACKUP_DIR:-./backups}"
TIMESTAMP=$(date +%Y%m%d-%H%M%S)
BACKUP_FILE="${BACKUP_DIR}/backup-${TIMESTAMP}.tar.gz"

mkdir -p "$BACKUP_DIR"

echo "Creating backup: $BACKUP_FILE"

# Backup Kubernetes resources
kubectl get all --all-namespaces -o yaml > "${BACKUP_DIR}/k8s-resources-${TIMESTAMP}.yaml"

# Backup configs
kubectl get configmap --all-namespaces -o yaml > "${BACKUP_DIR}/configmaps-${TIMESTAMP}.yaml"
kubectl get secret --all-namespaces -o yaml > "${BACKUP_DIR}/secrets-${TIMESTAMP}.yaml"

# Create archive
tar -czf "$BACKUP_FILE" -C "$BACKUP_DIR" \
    "k8s-resources-${TIMESTAMP}.yaml" \
    "configmaps-${TIMESTAMP}.yaml" \
    "secrets-${TIMESTAMP}.yaml"

# Cleanup individual files
rm -f "${BACKUP_DIR}"/*.yaml

echo "Backup complete: $BACKUP_FILE"

# Cleanup old backups (keep last 7 days)
find "$BACKUP_DIR" -name "backup-*.tar.gz" -mtime +7 -delete

echo "Old backups cleaned up"

Explanation

Bash Best Practices

1. Strict Mode

set -euo pipefail

• -e: Exit on error
• -u: Exit on undefined variable
• -o pipefail: Pipeline fails if any command fails

2. Error Handling

error_exit() {
    echo "ERROR: $1" >&2
    exit 1
}

command || error_exit "Command failed"

3. Functions

function_name() {
    local param=$1  # Local variable

    # Function body
    echo "Result"

    return 0  # Success
}

4. Logging

log() {
    local level=$1
    local message=$2
    echo "[$(date +'%Y-%m-%d %H:%M:%S')] [$level] $message" | tee -a "$LOG_FILE"
}

5. Input Validation

if [ $# -lt 2 ]; then
    echo "Usage: $0 <arg1> <arg2>"
    exit 1
fi

# Validate format
if [[ ! $VERSION =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
    error_exit "Invalid version format"
fi

Common Patterns

Checking Command Existence

if ! command -v docker &> /dev/null; then
    echo "Docker not found"
    exit 1
fi

Reading Configuration

# From file
CONFIG_FILE="config.env"
if [ -f "$CONFIG_FILE" ]; then
    source "$CONFIG_FILE"
fi

# From environment with default
DATABASE_URL="${DATABASE_URL:-postgresql://localhost:5432/mydb}"

Loops

# Array iteration
ENVIRONMENTS=("dev" "staging" "prod")
for env in "${ENVIRONMENTS[@]}"; do
    echo "Deploying to $env"
done

# File iteration
while IFS= read -r line; do
    echo "Processing: $line"
done < input.txt