RamNode logo
    Sign UpLogin
    Container Orchestration

    Docker Compose, Stack & Engine

    Master professional-grade container orchestration by combining Docker's powerful toolset with RamNode's robust VPS hosting. Learn Docker Engine, Compose, and Stack for reliable, scalable containerized applications.

    Ubuntu 22.04/24.04
    Docker Compose & Stack
    ⏱️ 45-60 minutes

    Prerequisites

    Before starting, ensure you have:

    Server Requirements

    • • RamNode VPS (2GB+ RAM recommended)
    • • Ubuntu 22.04/24.04 or Debian 11
    • • SSD storage for optimal performance
    • • Root access to server
    → View Recommended Standard VPS Plans

    Knowledge Requirements

    • • Docker fundamentals
    • • YAML syntax knowledge
    • • Basic Linux administration
    • • Container networking concepts
    2

    Why Choose RamNode for Docker Deployments?

    RamNode has built a solid reputation in the VPS hosting space, offering several advantages for Docker deployments:

    ⚡ High-Performance SSD Storage

    Significantly improves container startup times and I/O operations, crucial for multi-container applications.

    🔒 Reliable Network Infrastructure

    Excellent uptime records ensure your containerized applications remain accessible to users.

    📈 Flexible Resource Allocation

    Scale resources as your containerized applications grow, perfect for both development and production workloads.

    💰 Competitive Pricing

    Makes professional-grade container orchestration accessible for projects of all sizes.

    3

    Initial VPS Configuration

    Start by selecting an appropriate RamNode VPS plan:

    Minimum 2GB RAM for basic multi-container setups

    4GB+ RAM for production workloads or resource-intensive applications

    SSD storage for optimal container performance

    Once your VPS is provisioned, connect and update your system:

    System Update
    sudo apt update && sudo apt upgrade -y sudo apt install curl wget gnupg lsb-release

    💡 Tip: Choose Ubuntu 22.04 LTS or Debian 11 for the best Docker compatibility and long-term support.

    4

    Installing Docker Engine

    Docker Engine is the core runtime that manages your containers. Install it using Docker's official repository:

    Add Docker's Official GPG Key
    curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
    Set Up Docker Repository
    echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
    Install Docker Engine
    sudo apt update sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
    Add User to Docker Group
    sudo usermod -aG docker $USER

    Log out and back in for the group changes to take effect, then verify your installation:

    Verify Installation
    docker --version docker run hello-world

    ✅ Docker Engine is now installed with the latest Compose plugin for orchestration!

    5

    Docker Compose: Multi-Container Applications

    Docker Compose simplifies the management of multi-container applications by allowing you to define your entire application stack in a single YAML file.

    Basic Compose Setup

    Create a project directory and compose file:

    Create Project Directory
    mkdir my-app && cd my-app nano docker-compose.yml

    Here's a practical example combining a web application with a database:

    docker-compose.yml - Basic Setup
    version: '3.8'

services:
  web:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./html:/usr/share/nginx/html
    depends_on:
      - db
    networks:
      - app-network

  db:
    image: postgres:13
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: appuser
      POSTGRES_PASSWORD: securepassword
    volumes:
      - postgres_data:/var/lib/postgresql/data
    networks:
      - app-network

  redis:
    image: redis:alpine
    networks:
      - app-network

volumes:
  postgres_data:

networks:
  app-network:
    driver: bridge
    6

    Managing Your Application Stack

    Use these essential Docker Compose commands to manage your application stack:

    Essential Compose Commands
    # Start all services
docker compose up -d

# View running services
docker compose ps

# View logs
docker compose logs -f web

# Scale a service
docker compose up -d --scale web=3

# Stop and remove all services
docker compose down

# Update and restart services
docker compose pull && docker compose up -d

    📝 Note: Use docker compose (with space) for the modern plugin version, not the legacy docker-compose command.

    7

    Production-Ready Compose Configuration

    For production deployments on your RamNode VPS, enhance your configuration with health checks, resource limits, and proper logging:

    docker-compose.yml - Production Ready
    version: '3.8'

services:
  web:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./html:/usr/share/nginx/html
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
      - ./ssl:/etc/ssl/certs
    restart: unless-stopped
    deploy:
      resources:
        limits:
          memory: 512M
        reservations:
          memory: 256M
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost"]
      interval: 30s
      timeout: 10s
      retries: 3

  app:
    build: .
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgresql://appuser:securepassword@db:5432/myapp
    restart: unless-stopped
    depends_on:
      db:
        condition: service_healthy
    deploy:
      replicas: 2
      resources:
        limits:
          memory: 1G
          cpus: '0.5'

  db:
    image: postgres:13
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: appuser
      POSTGRES_PASSWORD_FILE: /run/secrets/db_password
    volumes:
      - postgres_data:/var/lib/postgresql/data
    restart: unless-stopped
    secrets:
      - db_password
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U appuser -d myapp"]
      interval: 30s
      timeout: 5s
      retries: 3

secrets:
  db_password:
    file: ./secrets/db_password.txt

volumes:
  postgres_data:
    8

    Docker Stack: Swarm Mode for High Availability

    Docker Stack provides orchestration capabilities for multi-node deployments, perfect for scaling beyond a single VPS.

    What is Docker Stack?

    Docker Stack is a higher-level abstraction that runs on Docker Swarm mode, providing features like rolling updates, service discovery, load balancing, and declarative service management across multiple nodes.

    9

    Initialize Docker Swarm

    Transform your RamNode VPS into a swarm manager:

    Initialize Swarm Mode
    # Initialize swarm mode
docker swarm init --advertise-addr YOUR_VPS_IP

# View swarm status
docker node ls

    💡 Tip: Replace YOUR_VPS_IP with your actual RamNode VPS IP address. This command will output a token to join worker nodes if you plan to add more VPS instances later.

    10

    Deploying with Docker Stack

    Convert your Compose file to work with Docker Stack by adding deploy configurations:

    docker-compose.yml - Stack Configuration
    version: '3.8'

services:
  web:
    image: nginx:alpine
    ports:
      - target: 80
        published: 80
        mode: ingress
    volumes:
      - ./html:/usr/share/nginx/html
    deploy:
      replicas: 3
      restart_policy:
        condition: on-failure
        delay: 5s
        max_attempts: 3
      update_config:
        parallelism: 1
        delay: 10s
        failure_action: rollback
      placement:
        constraints:
          - node.role == worker

  app:
    image: myapp:latest
    deploy:
      replicas: 5
      restart_policy:
        condition: on-failure
      resources:
        limits:
          memory: 512M
        reservations:
          memory: 256M
      update_config:
        parallelism: 2
        delay: 10s

networks:
  default:
    driver: overlay
    attachable: true

    Deploy and manage your stack:

    Stack Management Commands
    # Deploy the stack
docker stack deploy -c docker-compose.yml myapp

# List running stacks
docker stack ls

# View stack services
docker stack services myapp

# Remove the stack
docker stack rm myapp
    11

    Best Practices & Monitoring

    Monitor your containerized applications to ensure optimal performance on your VPS:

    Resource Monitoring

    System Monitoring Commands
    # Monitor container resource usage
docker stats

# View system resource usage
htop
df -h
free -m

# Clean up unused resources
docker system prune -a
docker volume prune

    Performance Tuning

    Optimize Docker performance on your RamNode VPS:

    Docker Daemon Configuration
    sudo nano /etc/docker/daemon.json
    /etc/docker/daemon.json
    {
  "storage-driver": "overlay2",
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3"
  },
  "live-restore": true,
  "userland-proxy": false,
  "experimental": false
}
    12

    Security Best Practices

    Implement security best practices for your Docker deployment:

    User Security

    Create Dedicated Docker User
    # Create a dedicated docker user
sudo useradd -r -s /bin/false dockeruser

# Run containers with non-root users
# In your Dockerfile:
USER dockeruser

    Firewall Configuration

    Configure UFW Firewall
    sudo ufw enable
sudo ufw allow ssh
sudo ufw allow 80
sudo ufw allow 443
sudo ufw deny 2376  # Secure Docker daemon socket

    Backup Strategy

    Backup Commands
    # Backup volumes
docker run --rm -v myapp_postgres_data:/data -v $(pwd):/backup alpine tar czf /backup/postgres_backup.tar.gz -C /data .

# Backup entire compose project
tar czf myapp_backup.tar.gz docker-compose.yml .env secrets/ volumes/
    13

    Troubleshooting Common Issues

    Debug and resolve common Docker deployment issues:

    🎉 Congratulations!

    You've mastered Docker Engine, Compose, and Stack on RamNode! Your containerized applications now have professional-grade orchestration, monitoring, and high availability capabilities.

    View RamNode Pricing