⚡ Configuring Cache Server on Alpine Linux: Performance Guide

Let’s set up high-performance caching servers on Alpine Linux! 🚀 This comprehensive tutorial shows you how to configure Redis, Memcached, and Varnish cache servers for optimal web application performance. Perfect for reducing database load and improving response times! 😊

🤔 What is a Cache Server?

A cache server is a specialized system that stores frequently accessed data in memory for ultra-fast retrieval! It dramatically improves application performance and reduces backend load.

Cache servers are like:

• 🏪 Express convenience stores that keep popular items readily available
• 🧠 Smart memory systems that remember frequently requested information
• ⚡ Speed boosters that deliver content without going to the original source

🎯 What You Need

Before we start, you need:

• ✅ Alpine Linux system with sufficient RAM (4GB+ recommended)
• ✅ Understanding of web application architecture
• ✅ Basic knowledge of networking and TCP/IP
• ✅ Root access for system configuration

📋 Step 1: Install and Configure Redis Cache Server

Install Redis Server

Let’s install Redis, the most popular in-memory data structure store! 😊

What we’re doing: Installing and configuring Redis server for high-performance caching on Alpine Linux.

# Update package list
apk update

# Install Redis server and tools
apk add redis redis-cli

# Install additional Redis utilities
apk add redis-sentinel

# Check Redis version
redis-server --version
redis-cli --version

# Check Redis configuration location
ls -la /etc/redis/

# Start Redis service
rc-service redis start

# Enable Redis to start at boot
rc-update add redis default

# Test Redis connection
redis-cli ping

What this does: 📖 Installs Redis server with management tools for caching operations.

Example output:

Redis server v=7.0.5 sha=00000000:0 malloc=jemalloc-5.2.1 bits=64 build=7206c618126515a3
PONG

What this means: Redis is installed and responding to connections! ✅

Configure Redis for Production

Let’s optimize Redis configuration for production caching! 🎯

What we’re doing: Configuring Redis with optimal settings for caching workloads and security.

# Backup original Redis configuration
cp /etc/redis/redis.conf /etc/redis/redis.conf.backup

# Create optimized Redis configuration
cat > /etc/redis/redis.conf << 'EOF'
# Redis Configuration for Caching Server

# Network Configuration
bind 127.0.0.1 ::1
port 6379
protected-mode yes
tcp-backlog 511
timeout 300
tcp-keepalive 300

# General Configuration
databases 16
save 900 1
save 300 10
save 60 10000
stop-writes-on-bgsave-error yes
rdbcompression yes
rdbchecksum yes
dbfilename dump.rdb
dir /var/lib/redis/

# Memory Management
maxmemory 2gb
maxmemory-policy allkeys-lru
maxmemory-samples 5

# Logging
loglevel notice
logfile /var/log/redis/redis.log
syslog-enabled yes
syslog-ident redis

# Security
requirepass your_secure_redis_password_here

# Performance Optimization
# Disable slower commands for cache-only usage
rename-command FLUSHDB ""
rename-command FLUSHALL ""
rename-command EVAL ""
rename-command DEBUG ""

# Client Management
maxclients 10000

# Append Only File (AOF) - Disabled for cache-only usage
appendonly no

# Lua Time Limit
lua-time-limit 5000

# Slow Log
slowlog-log-slower-than 10000
slowlog-max-len 128

# Latency Monitoring
latency-monitor-threshold 100

# Advanced Memory Settings
hash-max-ziplist-entries 512
hash-max-ziplist-value 64
list-max-ziplist-size -2
list-compress-depth 0
set-max-intset-entries 512
zset-max-ziplist-entries 128
zset-max-ziplist-value 64
hll-sparse-max-bytes 3000
stream-node-max-bytes 4096
stream-node-max-entries 100
EOF

# Create Redis log directory
mkdir -p /var/log/redis
chown redis:redis /var/log/redis

# Set proper ownership for Redis data directory
mkdir -p /var/lib/redis
chown redis:redis /var/lib/redis

# Restart Redis with new configuration
rc-service redis restart

# Test Redis with authentication
redis-cli -a your_secure_redis_password_here ping

echo "Redis configured for production caching! 📦"

What this creates: Production-ready Redis configuration optimized for caching! ✅

💡 Important Tips

Tip: Set maxmemory to 75% of available RAM for cache servers! 💡

Warning: Always set a strong password for Redis in production! ⚠️

🛠️ Step 2: Install and Configure Memcached

Install Memcached Server

Let’s install Memcached for distributed caching! 😊

What we’re doing: Installing Memcached server for high-performance distributed caching.

# Install Memcached server
apk add memcached

# Install Memcached tools and libraries
apk add libmemcached-dev

# Check Memcached version
memcached -h | head -5

# Create Memcached configuration
cat > /etc/conf.d/memcached << 'EOF'
# Memcached Configuration

# Listen on localhost only (change for distributed setup)
LISTEN="127.0.0.1"
PORT="11211"

# Memory allocation (in MB)
MEMORY="1024"

# Maximum connections
MAXCONN="1024"

# User to run as
USER="memcached"

# Additional options
OPTIONS="-v"

# Log file
LOGFILE="/var/log/memcached/memcached.log"
EOF

# Create memcached user if it doesn't exist
adduser -D -s /bin/false memcached 2>/dev/null || true

# Create log directory
mkdir -p /var/log/memcached
chown memcached:memcached /var/log/memcached

# Start Memcached service
rc-service memcached start

# Enable Memcached to start at boot
rc-update add memcached default

# Test Memcached connection
echo "Testing Memcached connection..."
echo -e "set test_key 0 0 5\r\nhello\r\nget test_key\r\nquit\r\n" | nc localhost 11211

echo "Memcached installed and configured! 🗃️"

What this does: Installs and configures Memcached for distributed caching! ✅

Configure Memcached for High Performance

Let’s optimize Memcached for maximum performance! 🚀

What we’re doing: Configuring Memcached with advanced settings for optimal caching performance.

# Create advanced Memcached configuration
cat > /etc/conf.d/memcached << 'EOF'
# High-Performance Memcached Configuration

# Network Configuration
LISTEN="127.0.0.1"
PORT="11211"

# Memory Settings
MEMORY="2048"        # 2GB memory allocation
MAXCONN="2048"       # Maximum connections

# Performance Options
OPTIONS="-v -R 4096 -C -f 1.1 -n 48 -t 4"

# Options explanation:
# -v: Verbose logging
# -R: Maximum number of requests per event
# -C: Disable use of CAS (Compare And Swap)
# -f: Growth factor for slab sizes
# -n: Minimum space allocated for key+value+flags
# -t: Number of threads to use

# User and logging
USER="memcached"
LOGFILE="/var/log/memcached/memcached.log"

# Security - bind to specific interface
# For distributed setup, change LISTEN to appropriate IP
# LISTEN="0.0.0.0"  # Use for remote access (secure firewall required)
EOF

# Create Memcached monitoring script
cat > /usr/local/bin/memcached-monitor.sh << 'EOF'
#!/bin/sh
echo "=== Memcached Performance Monitor ==="
echo "Date: $(date)"

# Connect to Memcached and get stats
echo "stats" | nc localhost 11211 | grep -E "(version|uptime|curr_connections|curr_items|bytes|cmd_get|cmd_set|get_hits|get_misses)"

# Calculate hit ratio
stats=$(echo "stats" | nc localhost 11211)
hits=$(echo "$stats" | grep "get_hits" | awk '{print $3}')
misses=$(echo "$stats" | grep "get_misses" | awk '{print $3}')

if [ "$hits" -gt 0 ] || [ "$misses" -gt 0 ]; then
    total=$((hits + misses))
    if [ "$total" -gt 0 ]; then
        hit_ratio=$((hits * 100 / total))
        echo "Hit Ratio: ${hit_ratio}%"
    fi
fi

echo "=========================="
EOF

chmod +x /usr/local/bin/memcached-monitor.sh

# Restart Memcached with new configuration
rc-service memcached restart

# Test advanced configuration
echo "Testing Memcached performance..."
/usr/local/bin/memcached-monitor.sh

echo "Memcached optimized for high performance! ⚡"

What this creates: Highly optimized Memcached configuration for production use! 🌟

🔧 Step 3: Install and Configure Varnish Cache

Install Varnish HTTP Cache

Let’s install Varnish for HTTP acceleration! 🎮

What we’re doing: Installing Varnish HTTP cache for web application acceleration.

# Install Varnish HTTP cache
apk add varnish

# Check Varnish version
varnishd -V

# Create Varnish configuration directory
mkdir -p /etc/varnish

# Create basic Varnish configuration (VCL)
cat > /etc/varnish/default.vcl << 'EOF'
# Varnish Configuration for Web Cache Acceleration
vcl 4.1;

import directors;

# Backend servers
backend web1 {
    .host = "127.0.0.1";
    .port = "8080";
    .probe = {
        .url = "/health";
        .timeout = 1s;
        .interval = 5s;
        .window = 5;
        .threshold = 3;
    }
}

backend web2 {
    .host = "127.0.0.1";
    .port = "8081";
    .probe = {
        .url = "/health";
        .timeout = 1s;
        .interval = 5s;
        .window = 5;
        .threshold = 3;
    }
}

# Director for load balancing
sub vcl_init {
    new web_director = directors.round_robin();
    web_director.add_backend(web1);
    web_director.add_backend(web2);
}

# Receive phase - process incoming requests
sub vcl_recv {
    # Set backend
    set req.backend_hint = web_director.backend();
    
    # Handle different request methods
    if (req.method != "GET" &&
        req.method != "HEAD" &&
        req.method != "PUT" &&
        req.method != "POST" &&
        req.method != "TRACE" &&
        req.method != "OPTIONS" &&
        req.method != "PATCH" &&
        req.method != "DELETE") {
        return (pipe);
    }
    
    # Only cache GET and HEAD requests
    if (req.method != "GET" && req.method != "HEAD") {
        return (pass);
    }
    
    # Cache static content
    if (req.url ~ "^[^?]*\.(css|js|png|gif|jp(e)?g|swf|ico|txt|pdf|zip)(\?.*)?$") {
        unset req.http.Cookie;
        return (hash);
    }
    
    # Don't cache admin or user-specific pages
    if (req.url ~ "^/admin" || req.url ~ "^/user") {
        return (pass);
    }
    
    # Remove tracking parameters
    if (req.url ~ "(\?|&)(utm_source|utm_medium|utm_campaign|utm_content|gclid|cx|ie|cof|siteurl)=") {
        set req.url = regsuball(req.url, "&(utm_source|utm_medium|utm_campaign|utm_content|gclid|cx|ie|cof|siteurl)=([A-z0-9_\-\.%25]+)", "");
        set req.url = regsuball(req.url, "\?(utm_source|utm_medium|utm_campaign|utm_content|gclid|cx|ie|cof|siteurl)=([A-z0-9_\-\.%25]+)", "?");
        set req.url = regsub(req.url, "\?&", "?");
        set req.url = regsub(req.url, "\?$", "");
    }
    
    return (hash);
}

# Backend response processing
sub vcl_backend_response {
    # Set cache TTL based on content type
    if (bereq.url ~ "^[^?]*\.(css|js|png|gif|jp(e)?g|swf|ico)(\?.*)?$") {
        set beresp.ttl = 1w;  # 1 week for static assets
        set beresp.http.Cache-Control = "public, max-age=604800";
    } elsif (bereq.url ~ "^[^?]*\.(html|txt|pdf)(\?.*)?$") {
        set beresp.ttl = 1h;  # 1 hour for documents
        set beresp.http.Cache-Control = "public, max-age=3600";
    } else {
        set beresp.ttl = 5m;  # 5 minutes for dynamic content
        set beresp.http.Cache-Control = "public, max-age=300";
    }
    
    # Don't cache if backend says not to
    if (beresp.http.Cache-Control ~ "no-cache|no-store|private") {
        set beresp.ttl = 0s;
        set beresp.uncacheable = true;
        return (deliver);
    }
    
    # Remove backend server information
    unset beresp.http.Server;
    unset beresp.http.X-Powered-By;
    
    return (deliver);
}

# Deliver phase - modify response before sending to client
sub vcl_deliver {
    # Add cache status header
    if (obj.hits > 0) {
        set resp.http.X-Varnish-Cache = "HIT";
        set resp.http.X-Varnish-Hits = obj.hits;
    } else {
        set resp.http.X-Varnish-Cache = "MISS";
    }
    
    # Add Varnish server identifier
    set resp.http.X-Served-By = "Varnish-Alpine";
    
    return (deliver);
}

# Error handling
sub vcl_backend_error {
    if (beresp.status == 503 && bereq.retries < 3) {
        return (retry);
    }
    
    synthetic({"
        <!DOCTYPE html>
        <html>
        <head><title>Service Temporarily Unavailable</title></head>
        <body>
        <h1>Service Temporarily Unavailable</h1>
        <p>The service you requested is temporarily unavailable.</p>
        <p>Please try again in a few moments.</p>
        </body>
        </html>
    "});
    
    return (deliver);
}
EOF

echo "Varnish HTTP cache configured! 🏎️"

What this creates: Complete Varnish configuration for HTTP caching and acceleration! ✅

Configure Varnish Service

Let’s set up Varnish as a system service! 🚀

What we’re doing: Configuring Varnish service with optimal runtime parameters.

# Create Varnish service configuration
cat > /etc/conf.d/varnish << 'EOF'
# Varnish Service Configuration

# Varnish Configuration File
VARNISH_VCL_CONF="/etc/varnish/default.vcl"

# Listen address and port
VARNISH_LISTEN_ADDRESS="0.0.0.0"
VARNISH_LISTEN_PORT="80"

# Admin interface
VARNISH_ADMIN_LISTEN_ADDRESS="127.0.0.1"
VARNISH_ADMIN_LISTEN_PORT="6082"

# Storage configuration
VARNISH_STORAGE="malloc,1G"

# Additional options
VARNISH_OPTIONS="-p default_ttl=3600 -p default_grace=10 -p feature=+esi_ignore_other_elements"

# User to run as
VARNISH_USER="varnish"
VARNISH_GROUP="varnish"

# Memory limits
VARNISH_SECRET_FILE="/etc/varnish/secret"
VARNISH_MIN_THREADS="50"
VARNISH_MAX_THREADS="1000"
VARNISH_THREAD_TIMEOUT="120"
EOF

# Create varnish user if it doesn't exist
adduser -D -s /bin/false varnish 2>/dev/null || true

# Generate Varnish secret for admin access
mkdir -p /etc/varnish
openssl rand -base64 32 > /etc/varnish/secret
chmod 600 /etc/varnish/secret
chown varnish:varnish /etc/varnish/secret

# Create Varnish startup script
cat > /etc/init.d/varnish << 'EOF'
#!/sbin/openrc-run

name="Varnish HTTP Cache"
description="High-performance HTTP accelerator"

command="/usr/sbin/varnishd"
command_args="-a ${VARNISH_LISTEN_ADDRESS}:${VARNISH_LISTEN_PORT} \
              -T ${VARNISH_ADMIN_LISTEN_ADDRESS}:${VARNISH_ADMIN_LISTEN_PORT} \
              -f ${VARNISH_VCL_CONF} \
              -S ${VARNISH_SECRET_FILE} \
              -s ${VARNISH_STORAGE} \
              -u ${VARNISH_USER} \
              -g ${VARNISH_GROUP} \
              ${VARNISH_OPTIONS}"

command_background="true"
pidfile="/run/varnish/varnish.pid"

depend() {
    need net
    after firewall
}

start_pre() {
    checkpath --directory --owner varnish:varnish --mode 0755 /run/varnish
    checkpath --directory --owner varnish:varnish --mode 0755 /var/log/varnish
}
EOF

chmod +x /etc/init.d/varnish

# Create log directory
mkdir -p /var/log/varnish
chown varnish:varnish /var/log/varnish

# Test Varnish configuration
varnishd -C -f /etc/varnish/default.vcl

# Start Varnish service
rc-service varnish start

# Enable Varnish to start at boot
rc-update add varnish default

echo "Varnish service configured and started! 🎯"

What this does: Sets up Varnish as a complete HTTP caching service! 🌟

📊 Quick Cache Server Commands Table

🎮 Practice Time!

Let’s practice what you learned! Try these caching scenarios:

Example 1: WordPress Caching Setup 🟢

What we’re doing: Setting up a complete caching stack for WordPress with Redis object cache and Varnish HTTP cache.

# Create WordPress caching optimization
mkdir -p /opt/wordpress-cache-setup
cd /opt/wordpress-cache-setup

# Install PHP Redis extension for WordPress
apk add php8-redis php8-session

# Create Redis configuration for WordPress
cat > redis-wordpress.conf << 'EOF'
# Redis Configuration for WordPress Object Cache

# Network
bind 127.0.0.1
port 6380
timeout 300

# Memory (dedicated to WordPress)
maxmemory 512mb
maxmemory-policy allkeys-lru

# Persistence (disabled for cache)
save ""
appendonly no

# Security
requirepass wordpress_cache_secret_123

# Database selection (use DB 1 for WordPress)
databases 16

# Logging
loglevel notice
logfile /var/log/redis/wordpress-cache.log
EOF

# Start Redis instance for WordPress
redis-server redis-wordpress.conf --daemonize yes

# Create Varnish VCL for WordPress
cat > wordpress.vcl << 'EOF'
vcl 4.1;

backend wordpress {
    .host = "127.0.0.1";
    .port = "8080";
}

sub vcl_recv {
    set req.backend_hint = wordpress;
    
    # Don't cache WordPress admin, login, or user pages
    if (req.url ~ "^/(wp-admin|wp-login|wp-content/uploads)" ||
        req.url ~ "preview=true" ||
        req.http.Cookie ~ "wordpress_logged_in") {
        return (pass);
    }
    
    # Cache static WordPress assets
    if (req.url ~ "^/wp-content.*\.(css|js|png|gif|jp(e)?g|ico|svg)(\?.*)?$") {
        unset req.http.Cookie;
        return (hash);
    }
    
    # Remove WordPress-specific tracking parameters
    if (req.url ~ "(\?|&)(fbclid|gclid|utm_|ref)=") {
        set req.url = regsuball(req.url, "[\?&](fbclid|gclid|utm_[^&]*|ref)=[^&]*", "");
        set req.url = regsub(req.url, "^([^?]*)\?&", "\1?");
        set req.url = regsub(req.url, "^([^?]*)\?$", "\1");
    }
    
    return (hash);
}

sub vcl_backend_response {
    # Long cache for static assets
    if (bereq.url ~ "^/wp-content.*\.(css|js|png|gif|jp(e)?g|ico|svg)(\?.*)?$") {
        set beresp.ttl = 30d;
        set beresp.http.Cache-Control = "public, max-age=2592000";
    }
    # Short cache for WordPress pages
    elsif (bereq.url ~ "^/$|^/[^/]*/?$") {
        set beresp.ttl = 5m;
        set beresp.http.Cache-Control = "public, max-age=300";
    }
    
    return (deliver);
}
EOF

# Create WordPress cache monitoring script
cat > wordpress-cache-monitor.sh << 'EOF'
#!/bin/sh
echo "🎯 WordPress Cache Performance Monitor"
echo "====================================="

echo "Redis Object Cache Status:"
redis-cli -p 6380 -a wordpress_cache_secret_123 info memory | grep -E "(used_memory_human|maxmemory_human)"
redis-cli -p 6380 -a wordpress_cache_secret_123 info stats | grep -E "(keyspace_hits|keyspace_misses)"

echo -e "\nVarnish HTTP Cache Status:"
varnishstat -1 | grep -E "(cache_hit|cache_miss|n_object)"

echo -e "\nWordPress Cache Recommendations:"
echo "✅ Enable Redis Object Cache plugin in WordPress"
echo "✅ Configure W3 Total Cache or WP Rocket"
echo "✅ Monitor cache hit ratios regularly"
echo "✅ Purge cache when content changes"
EOF

chmod +x wordpress-cache-monitor.sh

# Test WordPress caching setup
./wordpress-cache-monitor.sh

echo "WordPress caching stack configured! 🌟"

What this does: Shows you how to build a complete caching solution for WordPress! 🌟

Example 2: API Response Caching System 🟡

What we’re doing: Creating an intelligent API response caching system using Redis with automatic expiration.

# Create API caching system
mkdir -p /opt/api-cache-system
cd /opt/api-cache-system

# Install curl for API testing
apk add curl jq

# Create API cache management script
cat > api-cache-manager.sh << 'EOF'
#!/bin/sh

REDIS_HOST="127.0.0.1"
REDIS_PORT="6379"
REDIS_PASSWORD="your_secure_redis_password_here"
CACHE_PREFIX="api_cache:"

# Function to generate cache key
generate_cache_key() {
    local endpoint="$1"
    local params="$2"
    echo "${CACHE_PREFIX}$(echo "${endpoint}${params}" | sha256sum | cut -d' ' -f1)"
}

# Function to cache API response
cache_api_response() {
    local endpoint="$1"
    local params="$2"
    local ttl="${3:-300}"  # Default 5 minutes
    local response="$4"
    
    local cache_key=$(generate_cache_key "$endpoint" "$params")
    
    # Store in Redis with expiration
    echo "$response" | redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" -a "$REDIS_PASSWORD" \
        -x setex "$cache_key" "$ttl"
    
    echo "✅ Cached response for $endpoint (TTL: ${ttl}s)"
}

# Function to get cached API response
get_cached_response() {
    local endpoint="$1"
    local params="$2"
    
    local cache_key=$(generate_cache_key "$endpoint" "$params")
    
    redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" -a "$REDIS_PASSWORD" \
        get "$cache_key" 2>/dev/null
}

# Function to make cached API request
cached_api_request() {
    local url="$1"
    local ttl="${2:-300}"
    
    echo "🔍 Checking cache for: $url"
    
    # Try to get from cache first
    cached_response=$(get_cached_response "$url" "")
    
    if [ -n "$cached_response" ] && [ "$cached_response" != "(nil)" ]; then
        echo "✅ Cache HIT - serving from cache"
        echo "$cached_response"
        return 0
    fi
    
    echo "❌ Cache MISS - fetching from API"
    
    # Fetch from API
    api_response=$(curl -s "$url")
    
    if [ $? -eq 0 ] && [ -n "$api_response" ]; then
        # Cache the response
        cache_api_response "$url" "" "$ttl" "$api_response"
        echo "$api_response"
    else
        echo "Error: Failed to fetch from API"
        return 1
    fi
}

# Cache warming function
warm_cache() {
    echo "🔥 Warming API cache..."
    
    # Popular API endpoints to pre-cache
    local endpoints=(
        "https://api.github.com/users/octocat"
        "https://jsonplaceholder.typicode.com/posts/1"
        "https://httpbin.org/json"
    )
    
    for endpoint in "${endpoints[@]}"; do
        echo "Warming: $endpoint"
        cached_api_request "$endpoint" 600 >/dev/null
    done
    
    echo "✅ Cache warming completed"
}

# Cache statistics
show_cache_stats() {
    echo "📊 API Cache Statistics"
    echo "======================"
    
    # Count cached items
    cache_count=$(redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" -a "$REDIS_PASSWORD" \
        eval "return #redis.call('keys', ARGV[1])" 0 "${CACHE_PREFIX}*")
    
    echo "Cached API responses: $cache_count"
    
    # Memory usage
    redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" -a "$REDIS_PASSWORD" \
        info memory | grep -E "(used_memory_human|maxmemory_human)"
    
    # Hit/miss ratio
    redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" -a "$REDIS_PASSWORD" \
        info stats | grep -E "(keyspace_hits|keyspace_misses)"
}

# Main script logic
case "$1" in
    "get")
        if [ -z "$2" ]; then
            echo "Usage: $0 get <url> [ttl]"
            exit 1
        fi
        cached_api_request "$2" "$3"
        ;;
    "warm")
        warm_cache
        ;;
    "stats")
        show_cache_stats
        ;;
    "clear")
        echo "🗑️ Clearing API cache..."
        redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" -a "$REDIS_PASSWORD" \
            eval "local keys = redis.call('keys', ARGV[1]) for i=1,#keys,5000 do redis.call('del', unpack(keys, i, math.min(i+4999, #keys))) end return #keys" 0 "${CACHE_PREFIX}*"
        echo "✅ API cache cleared"
        ;;
    *)
        echo "API Cache Manager"
        echo "Usage: $0 {get|warm|stats|clear}"
        echo ""
        echo "Commands:"
        echo "  get <url> [ttl]  - Get API response (cached or fresh)"
        echo "  warm             - Pre-warm cache with popular endpoints"
        echo "  stats            - Show cache statistics"
        echo "  clear            - Clear all cached API responses"
        ;;
esac
EOF

chmod +x api-cache-manager.sh

# Test API caching system
echo "Testing API caching system..."
./api-cache-manager.sh get "https://httpbin.org/json" 300
./api-cache-manager.sh stats

echo "API response caching system ready! 📚"

What this does: Demonstrates intelligent API response caching with automatic expiration! 📚

🚨 Fix Common Problems

Problem 1: Redis memory usage too high ❌

What happened: Redis consuming more memory than expected. How to fix it: Optimize memory settings and implement proper eviction.

# Check current memory usage
redis-cli info memory

# Set appropriate memory limit
redis-cli config set maxmemory 1gb

# Configure eviction policy
redis-cli config set maxmemory-policy allkeys-lru

# Enable memory optimization
redis-cli config set hash-max-ziplist-entries 512
redis-cli config set hash-max-ziplist-value 64

# Check for memory leaks
redis-cli --bigkeys

Problem 2: Varnish cache hit ratio too low ❌

What happened: Varnish not caching content effectively. How to fix it: Optimize VCL configuration and caching rules.

# Check current hit ratio
varnishstat -1 | grep cache_hit

# Monitor what's not being cached
varnishlog -q "VCL_call eq MISS"

# Common fixes in VCL:
# 1. Remove cookies for static content
# 2. Set proper TTL values
# 3. Handle Vary headers correctly
# 4. Configure grace period

# Restart Varnish with optimized settings
rc-service varnish restart

Don’t worry! Cache configuration is iterative - monitor and adjust based on your specific workload! 💪

💡 Simple Tips

1. Monitor cache hit ratios 📅 - Aim for 80%+ hit ratio for optimal performance
2. Set appropriate TTL values 🌱 - Balance freshness with performance needs
3. Use memory efficiently 🤝 - Configure eviction policies for your use case
4. Regular maintenance 💪 - Monitor memory usage and performance metrics

✅ Check Everything Works

Let’s verify your cache server setup is working perfectly:

# Complete cache server verification
cat > /usr/local/bin/cache-server-check.sh << 'EOF'
#!/bin/sh
echo "=== Cache Server System Check ==="

echo "1. Redis Cache Server:"
if redis-cli ping >/dev/null 2>&1; then
    echo "✅ Redis is running"
    redis-cli info server | grep redis_version
    redis-cli info memory | grep used_memory_human
else
    echo "❌ Redis is not running"
fi

echo -e "\n2. Memcached Server:"
if echo "version" | nc localhost 11211 >/dev/null 2>&1; then
    echo "✅ Memcached is running"
    echo "version" | nc localhost 11211 | head -1
    echo "stats" | nc localhost 11211 | grep bytes | head -1
else
    echo "❌ Memcached is not running"
fi

echo -e "\n3. Varnish HTTP Cache:"
if curl -s -I http://localhost/ >/dev/null 2>&1; then
    echo "✅ Varnish is running"
    varnish_version=$(varnishd -V 2>&1 | head -1)
    echo "$varnish_version"
    varnishstat -1 | grep -E "(cache_hit|cache_miss)" | head -2
else
    echo "❌ Varnish is not accessible"
fi

echo -e "\n4. Performance Test:"
echo "Testing cache performance..."

# Redis performance test
redis_start=$(date +%s.%N)
for i in $(seq 1 1000); do
    redis-cli set test:$i "value$i" >/dev/null
done
redis_end=$(date +%s.%N)
redis_time=$(echo "$redis_end - $redis_start" | bc -l)
echo "Redis: 1000 SET operations in ${redis_time}s"

# Memcached performance test  
memcached_start=$(date +%s.%N)
for i in $(seq 1 100); do
    echo -e "set test$i 0 0 6\r\nvalue$i\r\n" | nc localhost 11211 >/dev/null
done
memcached_end=$(date +%s.%N)
memcached_time=$(echo "$memcached_end - $memcached_start" | bc -l)
echo "Memcached: 100 SET operations in ${memcached_time}s"

echo -e "\n5. Memory Usage:"
echo "System memory:"
free -h | grep ^Mem

echo -e "\n6. Cache Recommendations:"
echo "✅ Monitor cache hit ratios regularly"
echo "✅ Set appropriate memory limits"
echo "✅ Configure proper TTL values"
echo "✅ Implement cache invalidation strategies"

echo -e "\nCache server system operational! ✅"
EOF

chmod +x /usr/local/bin/cache-server-check.sh
/usr/local/bin/cache-server-check.sh

Good output shows:

=== Cache Server System Check ===
1. Redis Cache Server:
✅ Redis is running
redis_version:7.0.5
used_memory_human:2.45M

2. Memcached Server:
✅ Memcached is running
VERSION 1.6.17
STAT bytes 64

3. Varnish HTTP Cache:
✅ Varnish is running
varnishd (varnish-7.2.1 revision 7.2.1)
MAIN.cache_hit             1234
MAIN.cache_miss            567

Cache server system operational! ✅

🏆 What You Learned

Great job! Now you can:

• ✅ Install and configure Redis for high-performance caching
• ✅ Set up Memcached for distributed caching scenarios
• ✅ Configure Varnish HTTP cache for web acceleration
• ✅ Optimize cache servers for production workloads
• ✅ Implement intelligent caching strategies and TTL policies
• ✅ Create monitoring and management scripts for cache systems
• ✅ Build application-specific caching solutions (WordPress, APIs)
• ✅ Troubleshoot common caching performance issues
• ✅ Monitor cache hit ratios and performance metrics

🎯 What’s Next?

Now you can try:

• 📚 Implementing cache clustering and high availability setups
• 🛠️ Setting up cache invalidation and purging strategies
• 🤝 Integrating caching with application frameworks and ORMs
• 🌟 Exploring advanced caching patterns like cache-aside and write-through!

Remember: Effective caching is crucial for high-performance applications! You’re now building lightning-fast systems! 🎉

Keep caching and you’ll master performance optimization on Alpine Linux! 💫