Haproxy with docker09.04.25

Are you looking to deploy a web application that can handle high traffic volumes and ensure high availability? Traditionally this required provisioning multiple servers and configuring a dedicated hardware or software load balancer, which could be complex and costly.

Nowadays, you can leverage HAProxy and Docker to streamline the deployment of scalable, resilient web services. In this post, we‘ll walk through how to use Docker Compose to deploy an HAProxy load balancer and web app. By the end, you‘ll have a fully functional setup that can be extended for production use. Let‘s dive in!
Introduction to HAProxy

HAProxy (High Availability Proxy) is a widely used open source TCP/HTTP load balancer and proxying solution. Some of the key features and benefits include:

Layer 4 (TCP) and Layer 7 (HTTP/HTTPS) load balancing
    URL-based routing and content switching
    Session persistence
    SSL termination
    Health checking and failover of backends
    Detailed logging and statistics
    Battle-tested and high performance (~10,000 requests per second on mid-range hardware)

At a high level, HAProxy sits between clients and servers (backends) and distributes incoming traffic using configurable load balancing algorithms (e.g. round robin, least connections). This allows horizontally scaling the capacity of a web service by adding more backends.

HAProxy is often deployed on dedicated servers in between the client-facing web/app servers and the backend servers. However, this traditional approach requires more infrastructure overhead to provision and maintain physical or virtual machines for HAProxy.
Intro to Docker & Docker Compose

Docker is a platform for developing, shipping, and running applications using containers. Containers provide a lightweight form of virtualization by packaging an application and its dependencies in an isolated filesystem. Some key benefits of using containers include:

Portability between environments (dev, staging, prod)
    Efficiency and lower overhead than VMs
    Loose coupling of services
    Easy horizontal scaling

Docker Compose is a tool for defining and running multi-container applications. It uses a declarative YAML configuration file to specify the containers, networks, and volumes that make up an application. Compose makes it easy to create and manage the lifecycle of all the containers as a single unit.

For this post, we‘ll use Docker and Docker Compose to deploy HAProxy and a sample web app without needing to provision any servers. This is a great way to quickly test load balancing and try out different configuration options.
Configuring HAProxy with Docker Compose

Let‘s walk through the process of creating a Docker Compose file to deploy HAProxy and a web app. We‘ll use a simple Flask web app as the backend, but you could swap this out for your language/framework of choice.
Project Structure

Here‘s the basic project structure:

.
├── docker-compose.yml
├── haproxy.cfg
└── webapp
    ├── Dockerfile
    ├── app.py
    └── requirements.txt

docker-compose.yml defines the HAProxy and web services
    haproxy.cfg contains the HAProxy configuration
    webapp/ contains a simple Flask web app

Defining Services

Open up docker-compose.yml and add the following:

version: ‘3‘

services:

haproxy:
    image: haproxy:2.7
    ports:
      - "80:80"
    volumes:
      - "./haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg"

webapp1:
    build: ./webapp
    environment:
      APP_ID: 1

webapp2:
    build: ./webapp 
    environment:
      APP_ID: 2

webapp3:
    build: ./webapp
    environment:
      APP_ID: 3

This defines four services:

haproxy uses the official HAProxy 2.7 image from Docker Hub. It maps port 80 from the host to the container and mounts the local haproxy.cfg file as the HAProxy config in the container.

webapp1, webapp2, and webapp3 are three instances of the web app container. They are built from the webapp/Dockerfile and each set an APP_ID environment variable to differentiate the instances.

By default, Compose sets up a single network for the application where each service can reach the others via their service name.
HAProxy Configuration

Next, add the following to haproxy.cfg:

defaults
    mode    http
    timeout connect 5s
    timeout client 5s
    timeout server 5s

frontend www
    bind *:80
    default_backend app

backend app
    balance roundrobin
    server webapp1 webapp1:5000 check
    server webapp2 webapp2:5000 check
    server webapp3 webapp3:5000 check

This is a basic HAProxy configuration for load balancing HTTP traffic. It sets some default timeouts, defines a frontend to listen on port 80, and specifies a backend named app containing the three webapp instances.

The balance roundrobin line sets the load balancing algorithm to round robin, which distributes requests to each backend server in turn. The check option after each server enables active health checking.
Web Application

Finally, create a directory named webapp and add the following files:

Dockerfile:

FROM python:3.9-alpine
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["gunicorn", "-b", "0.0.0.0:5000", "app:app"]

This multi-stage Dockerfile uses a Python base image, installs dependencies, copies the application code, and runs it using Gunicorn.

requirements.txt:

Flask==2.3.2
gunicorn==20.1.0

app.py:

from flask import Flask, request

app = Flask(__name__)

@app.route(‘/‘)
def hello():
    app_id = request.environ.get(‘APP_ID‘)
    return f‘Hello from webapp {app_id}!\n‘

This defines a simple Flask app with a single route that returns a greeting identifying the app instance.
Deploying the Application

With all the configuration in place, we can now deploy the application using Docker Compose:

docker compose up -d

This builds the web app image and starts all the containers in detached mode. You should see output similar to:

[+] Running 5/5
 ⠿ Network loadbalancing_default   Created
 ⠿ Container loadbalancing-webapp1-1  Started
 ⠿ Container loadbalancing-webapp2-1  Started
 ⠿ Container loadbalancing-webapp3-1  Started
 ⠿ Container loadbalancing-haproxy-1  Started

You can verify the containers are running with:

docker compose ps

Which should show:

NAME                               COMMAND                  SERVICE             STATUS              PORTS
loadbalancing-haproxy-1   "/docker-entrypoint.…"   haproxy             running             0.0.0.0:80->80/tcp
loadbalancing-webapp1-1   "/bin/sh -c ‘gunico…"    webapp1             running             5000/tcp
loadbalancing-webapp2-1   "/bin/sh -c ‘gunico…"    webapp2             running             5000/tcp
loadbalancing-webapp3-1   "/bin/sh -c ‘gunico…"    webapp3             running             5000/tcp

Testing the Load Balancer

Open up a new terminal and use curl to make some requests to the load balancer:

curl http://localhost
curl http://localhost
curl http://localhost

You should see responses from each of the web app instances in round-robin order:

Hello from webapp 1!
Hello from webapp 2! 
Hello from webapp 3!

Congratulations! You now have a basic HAProxy load balancer up and running with Docker Compose. You can test the load balancing and failover by stopping one or more of the web containers:

docker compose stop webapp1

Subsequent requests will only be served by the remaining backends.
Advanced Configuration

This example demonstrates the basics of deploying HAProxy with Docker Compose, but HAProxy supports many more advanced features and configuration options. Some things to consider for a production deployment include:

Session Persistence: HAProxy can use cookies or other methods to ensure a client gets sent to the same backend server across requests. This is important for stateful applications.

SSL Termination: HAProxy can handle decrypting incoming HTTPS traffic and forwarding it to backends as HTTP, centralizing certificate management.

Access Control Lists (ACLs): HAProxy‘s configuration language supports defining ACLs to route requests based on IP, host, path, headers, etc.

Logging: HAProxy can log detailed information about traffic and errors to syslog or a file for monitoring and debugging.

Monitoring: HAProxy provides a web-based stats page and a Prometheus exporter for monitoring load balancing metrics.

See the official HAProxy documentation for details on all the available configuration options.
Production Considerations

To run HAProxy in Docker for a production deployment, consider the following:

High Availability: Run multiple HAProxy containers and use DNS load balancing or an external load balancer to distribute traffic between them.

Resource Allocation: Use Docker Compose‘s resource limits to cap memory and CPU usage and ensure containers have sufficient resources.

Updates and Restarts: Use Compose‘s update and restart policies to control how containers are replaced and recover from failures.

Centralized Logging: Use Docker‘s logging drivers to ship logs to a centralized location for aggregation and analysis.

Secrets Management: Don‘t store sensitive information like SSL certificates in the Compose file. Use Docker Secrets or a secrets management tool.

Security: Follow Docker security best practices like running containers as a non-root user, regularly scanning for vulnerabilities, and enabling AppArmor/SELinux profiles.

Additionally, while Docker Compose is great for small to medium deployments, you may want to consider a container orchestration platform like Kubernetes for very large-scale and complex deployments that require features like service discovery, auto scaling, and rollouts.
Conclusion

https://www.bomberbot.com/proxy/load-balancing-a-web-app-with-haproxy-and-docker-compose/

Anonymous

Haproxy with docker09.04.25

Information Epoch 1745180297