Master AEM Dispatcher on RedHat Linux: Docker Container Setup with Apache & mod_ssl

December 1, 2024by abhishekbadar0

Introduction to AEM Dispatcher on RedHat Linux with Docker

In today’s fast-paced digital landscape, delivering high-performance web experiences is crucial for business success. Adobe Experience Manager (AEM) stands as a powerful content management solution, but its true potential is unlocked when paired with the AEM Dispatcher – a caching and load balancing tool that significantly enhances performance and security. When deployed on RedHat Linux within Docker containers, this combination creates a robust, scalable, and manageable infrastructure that can handle enterprise-level traffic demands.

The marriage of RedHat Linux’s enterprise-grade stability, Docker’s containerization benefits, and AEM Dispatcher’s caching capabilities represents a modern approach to web infrastructure. This setup not only improves website performance through intelligent caching but also provides the isolation and reproducibility that Docker containers offer. Whether you’re managing a corporate website, e-commerce platform, or digital experience portal, this configuration ensures optimal performance while maintaining the security standards that RedHat Linux is known for.

Why Choose Docker Containers for AEM Dispatcher on RedHat Linux?

Containerization Benefits for Enterprise Environments

Docker containers bring numerous advantages to AEM Dispatcher deployments on RedHat Linux. First and foremost, containers provide environment consistency – your Dispatcher configuration will behave identically across development, staging, and production environments. This eliminates the common “it works on my machine” problem that plagues many deployment pipelines. Additionally, Docker containers offer superior resource isolation, ensuring that your Dispatcher operations don’t interfere with other services running on the same host.

From an operational perspective, Docker simplifies scaling. When traffic spikes occur, you can quickly spin up additional Dispatcher containers to handle the load. This elasticity is particularly valuable for e-commerce sites during sales events or content portals during product launches. The containerized approach also facilitates easier updates and rollbacks – if a new Dispatcher configuration causes issues, you can instantly revert to the previous container image.

RedHat Linux: The Enterprise Foundation

RedHat Linux provides the rock-solid foundation that enterprise applications demand. With its robust security features, long-term support, and enterprise-grade performance, RedHat Linux ensures your AEM Dispatcher runs on a stable, secure platform. The integration with Red Hat’s ecosystem, including OpenShift for container orchestration, makes this combination particularly powerful for organizations already invested in the RedHat ecosystem.

Prerequisites and Environment Setup

System Requirements

Before diving into the configuration, ensure your environment meets these requirements:

RedHat Enterprise Linux 7 or later (RHEL 8 recommended)
Docker Engine installed and configured
Minimum 4GB RAM (8GB recommended for production)
20GB available disk space
Root or sudo privileges
Basic understanding of Docker concepts and AEM architecture

Installing Docker on RedHat Linux

If Docker isn’t already installed on your RedHat system, begin by adding the Docker repository and installing the necessary packages:

Step 1: Update system packages
sudo yum update -y

Step 2: Add Docker repository
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

Step 3: Install Docker Engine
sudo yum install docker-ce docker-ce-cli containerd.io -y

Step 4: Start and enable Docker service
sudo systemctl start docker sudo systemctl enable docker

Step 5: Verify installation
sudo docker --version

Creating the Docker Container with Apache and mod_ssl

Dockerfile Configuration

The foundation of our AEM Dispatcher setup begins with a properly configured Dockerfile. This file defines the container environment, including the base image, necessary packages, and configuration files.

Create a Dockerfile with the following content:

FROM redhat/ubi8:latest

# Update system and install necessary packages
RUN yum update -y && 
    yum install -y httpd mod_ssl openssl && 
    yum clean all

# Create necessary directories
RUN mkdir -p /etc/httpd/conf.dispatcher.d && 
    mkdir -p /var/www/html && 
    mkdir -p /var/cache/httpd && 
    mkdir -p /var/log/httpd

# Copy AEM Dispatcher configuration files
COPY dispatcher.any /etc/httpd/conf.dispatcher.d/
COPY farm.any /etc/httpd/conf.dispatcher.d/
COPY ssl.conf /etc/httpd/conf.d/

# Copy SSL certificates (replace with your actual certificates)
COPY ssl.crt /etc/pki/tls/certs/
COPY ssl.key /etc/pki/tls/private/

# Set proper permissions
RUN chown -R apache:apache /var/cache/httpd && 
    chmod -R 755 /var/cache/httpd

# Expose HTTP and HTTPS ports
EXPOSE 80 443

# Start Apache with Dispatcher module
CMD ["httpd", "-D", "FOREGROUND"]

Building the Container Image

With the Dockerfile in place, build your container image:

docker build -t aem-dispatcher-redhat .

This command creates a Docker image named “aem-dispatcher-redhat” that includes Apache HTTP Server with mod_ssl and is ready for AEM Dispatcher configuration.

Configuring AEM Dispatcher in the Docker Container

Dispatcher Configuration Files

The AEM Dispatcher requires several configuration files to function properly. Create a dispatcher.any file with the following structure:

/dispatcher {
    /filters {
        /0000 { /type "allow" /url "/content/*" }
        /0001 { /type "allow" /url "/etc/*" }
        /0002 { /type "allow" /url "/libs/*" }
        /0003 { /type "deny" /url "*" /selectors "(feed|rss|pages|languages|blueprint|infinity|tidy|sysview|docview|query|jcr:content|_jcr_content|api)" /extension "(json)" }
    }
    
    /cache {
        /docroot "/var/cache/httpd"
        /rules {
            /0000 { /type "deny" /url ".*" }
            /0001 { /type "allow" /url "/content/*.html" }
        }
        /invalidate {
            /0000 { /type "allow" /url "/content/*" }
            /0001 { /type "deny" /url "*" }
        }
    }
    
    /sessionmanagement {
        /directory "/tmp/dispatcher"
    }
}

Farm Configuration

Create a farm.any file to define your AEM publish instances:

/farm {
    /website {
        /clientheaders {
            "*"
        }
        
        /virtualhosts {
            "*"
        }
        
        /renders {
            /publish {
                /hostname "aem-publish-instance"
                /port "4503"
                /timeout "0"
            }
        }
        
        /filter {
            /0000 { /type "allow" /url "*" }
        }
        
        /cache {
            /docroot "/var/cache/httpd"
            /rules {
                /0000 { /type "deny" /url ".*" }
                /0001 { /type "allow" /url "/content/*.html" }
            }
            /invalidate {
                /0000 { /type "allow" /url "/content/*" }
            }
            /allowedClients {
                /0000 { /type "allow" /url "*" }
            }
        }
        
        /sessionmanagement {
            /directory "/tmp/dispatcher"
        }
    }
}

SSL Configuration with mod_ssl

SSL Certificate Setup

Security is paramount in enterprise environments. Configure mod_ssl to enable HTTPS connections. Create an ssl.conf file:

Listen 443 https


    ServerName your-domain.com
    DocumentRoot /var/www/html
    
    SSLEngine on
    SSLCertificateFile /etc/pki/tls/certs/ssl.crt
    SSLCertificateKeyFile /etc/pki/tls/private/ssl.key
    
    # Security headers
    Header always set Strict-Transport-Security "max-age=63072000; includeSubDomains; preload"
    Header always set X-Content-Type-Options nosniff
    Header always set X-Frame-Options DENY
    
    # Dispatcher module configuration
    
        SetHandler dispatcher-handler
        ModMimeUsePathInfo On
    
    
    ErrorLog /var/log/httpd/ssl_error_log
    TransferLog /var/log/httpd/ssl_access_log

Generating SSL Certificates

For development purposes, you can generate self-signed certificates:

openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout ssl.key -out ssl.crt -subj "/C=US/ST=State/L=City/O=Organization/CN=your-domain.com"

For production environments, always use certificates from a trusted Certificate Authority (CA).

Running and Managing the Docker Container

Starting the Container

Launch your AEM Dispatcher container with the following command:

docker run -d --name aem-dispatcher -p 80:80 -p 443:443 -v /path/to/local/cache:/var/cache/httpd -v /path/to/local/logs:/var/log/httpd aem-dispatcher-redhat

This command:

Runs the container in detached mode (-d)
Names the container “aem-dispatcher”
Maps host ports 80 and 443 to container ports
Mounts local directories for cache and logs persistence

Container Management Commands

Essential Docker commands for managing your AEM Dispatcher container:

View running containers:
docker ps

View container logs:
docker logs aem-dispatcher

Stop container:
docker stop aem-dispatcher

Restart container:
docker restart aem-dispatcher

Remove container:
docker rm aem-dispatcher

Performance Optimization and Best Practices

Caching Strategies

Optimize your AEM Dispatcher caching for maximum performance:

Leverage TTL-based caching: Configure appropriate time-to-live values for different content types
Implement cache warming: Pre-load frequently accessed content into cache
Use grace period: Configure grace period to serve stale content when origin is unavailable
Optimize cache file structure: Organize cache directories for optimal filesystem performance

Security Hardening

Enhance security for your AEM Dispatcher deployment:

Regular updates: Keep RedHat Linux, Apache, and Docker updated with security patches
Network segmentation: Isolate Dispatcher containers from other services
SSL/TLS configuration: Use strong ciphers and protocols
Access controls: Implement proper firewall rules and access restrictions

Monitoring and Logging

Implement comprehensive monitoring for your AEM Dispatcher:

Log aggregation: Use centralized logging solutions
Performance metrics: Monitor cache hit rates, response times, and resource usage
Health checks: Implement container health checks and auto-recovery
Alerting: Set up alerts for critical events and performance degradation

Troubleshooting Common Issues

Container Startup Problems

If your container fails to start, check these common issues:

Verify Docker service is running: systemctl status docker
Check container logs: docker logs aem-dispatcher
Ensure port 80 and 443 are not occupied by other services
Validate configuration file syntax

SSL Certificate Issues

Common SSL-related problems and solutions:

Certificate path incorrect – verify file locations in ssl.conf
Certificate permissions – ensure private key is readable only by root
Certificate expiration – monitor and renew certificates before expiry
Mixed content issues – ensure all resources are served via HTTPS

Dispatcher Cache Problems

Address caching issues effectively:

Clear cache manually when needed: Remove files from /var/cache/httpd
Verify cache rules in dispatcher.any
Check cache directory permissions
Monitor cache disk space usage

Conclusion: Enterprise-Ready AEM Dispatcher Deployment

Deploying AEM Dispatcher on RedHat Linux using Docker containers represents a modern, scalable approach to enterprise web infrastructure. This configuration combines the stability of RedHat Linux with the flexibility of Docker containerization, creating a robust platform for delivering high-performance web experiences. The integration of Apache with mod_ssl ensures secure communications while the AEM Dispatcher provides intelligent caching that significantly improves website performance.

The containerized approach offers numerous benefits for enterprise environments, including consistent deployments across environments, easy scaling during traffic spikes, simplified updates and rollbacks, and improved resource isolation. By following the configuration steps outlined in this guide, you can establish a production-ready AEM Dispatcher setup that meets enterprise security and performance requirements.

Remember that successful AEM Dispatcher deployment goes beyond initial configuration. Continuous monitoring, regular security updates, and performance optimization are essential for maintaining optimal operation. As your traffic patterns and business requirements evolve, the containerized approach provides the flexibility to adapt and scale your infrastructure accordingly.

This Docker-based AEM Dispatcher setup on RedHat Linux positions your organization to deliver exceptional digital experiences while maintaining the reliability and security that enterprise applications demand. Whether you’re serving corporate content, e-commerce platforms, or customer portals, this architecture provides a solid foundation for success in the digital age.