A complete containerized deployment of AzerothCore WoW 3.3.5a (Wrath of the Lich King) private server with Playerbot functionality, Eluna scripting, and automated management features.

Implementation Credits

This project is a Docker/Podman implementation based on:

AzerothCore - The open-source MMORPG server application for World of Warcraft
AzerothCore with Playerbots Docker Setup - Docker configuration inspiration and Playerbot integration approach

Key Improvements in This Implementation

Logger Issue Resolution: Fixed worldserver startup issues with proper logger configuration
Dynamic URL Generation: Web interfaces automatically detect external URLs for deployment flexibility
Port Collision Prevention: All external ports optimized to avoid common development tool conflicts
Enhanced Security: Comprehensive security settings for all web interfaces (Grafana, InfluxDB, PHPMyAdmin)
Full Environment Variable Configuration: No hardcoded values, everything configurable via .env
External Domain Support: Configurable base URLs for custom domain deployment
Multi-Runtime Support: Works with both Docker and Podman
Automated Database Initialization: Complete schema import and setup automation
Comprehensive Health Checks: Built-in service monitoring and restart policies
Automated Backup System: Scheduled backups with configurable retention
Production-Ready Security: Advanced security configurations and best practices

Overview
Features
Requirements
Project Structure
Container Architecture
Initial Setup
Configuration
Volume Management
Maintenance
Backup System
Deployment Scripts
Troubleshooting
Security Considerations

Overview

This project provides a production-ready AzerothCore deployment using Docker/Podman containers, building upon the foundational work of the AzerothCore project and incorporating containerization patterns from coc0nut's Docker setup.

What This Implementation Provides

Enhanced Configuration: All settings externalized to environment variables
Container Runtime Flexibility: Works with both Docker and Podman
Production Features: Health checks, automated backups, log management
Improved Security: No hardcoded passwords, configurable network isolation
Operational Tools: Comprehensive maintenance scripts and troubleshooting guides
Full Documentation: Complete setup, configuration, and maintenance procedures

Core Components

Automated database initialization and imports
Playerbot support for solo play (using liyunfan1223's mod-playerbots)
Eluna Lua scripting engine
Automated backups
Full configuration through environment variables
Support for both Docker and Podman runtimes
Portainer compatibility

Version Information

AzerothCore: 3.3.5a (master branch) from azerothcore/azerothcore-wotlk
Playerbot Module: liyunfan1223/mod-playerbots
MySQL: 8.0
Game Client: World of Warcraft 3.3.5a (Build 12340)
Base Images: Official AzerothCore Docker images

Features

✅ Fully Containerized: All components run in isolated containers
✅ Automated Setup: Database creation, schema import, and configuration handled automatically
✅ Playerbot Integration: AI-controlled bots for solo/small group play
✅ Eluna Support: Lua scripting for custom content
✅ Automated Backups: Scheduled database backups with retention policies
✅ Environment-Based Config: All settings configurable via .env file
✅ Health Monitoring: Built-in health checks for all services
✅ Network Isolation: Custom bridge network for container communication
✅ Persistent Storage: Named volumes for data persistence

Requirements

System Requirements

OS: Linux (Ubuntu 20.04+, Debian 11+, RHEL 8+, or similar)
RAM: Minimum 4GB, Recommended 8GB+
Storage: 20GB minimum (50GB+ recommended with client data)
CPU: 2+ cores recommended
Network: Static IP recommended for external access

Software Requirements

Container Runtime: Docker 20.10+ OR Podman 3.0+
Compose Tool: docker-compose 1.29+ OR podman-compose 1.0+
MySQL Client: For manual database operations (optional)
Git: For cloning repositories (optional)

Game Client Requirements

WoW Client: Version 3.3.5a (Build 12340)
Client Data: Extracted maps, vmaps, mmaps, and DBC files

Project Structure

acore-compose/
├── docker-compose-azerothcore-database.yml     # Database layer
├── docker-compose-azerothcore-services.yml     # Game services layer
├── docker-compose-azerothcore-tools.yml        # Management tools layer
├── docker-compose-azerothcore-database.env     # Database configuration
├── docker-compose-azerothcore-services.env     # Services configuration
├── docker-compose-azerothcore-tools.env        # Tools configuration
├── docker-compose-azerothcore-optional.env     # Optional services config
├── scripts/                                     # Deployment, cleanup, and backup automation
├── local-data/                                 # Local storage (when not using NFS)
└── readme.md                                   # This documentation

Container Architecture

Service Containers

Container	Image	Purpose	Exposed Ports
`ac-mysql`	mysql:8.0	MySQL database server	64306:3306
`ac-authserver`	acore/ac-wotlk-authserver:14.0.0-dev	Authentication server	3784:3724
`ac-worldserver`	acore/ac-wotlk-worldserver:14.0.0-dev	Game world server	8215:8085, 7778:7878
`ac-eluna`	acore/eluna-ts:master	Lua scripting engine	-
`ac-phpmyadmin`	phpmyadmin/phpmyadmin:latest	Database management web UI	8081:80
`ac-grafana`	grafana/grafana:latest	Monitoring dashboard	3001:3000
`ac-influxdb`	influxdb:2.7-alpine	Metrics database	8087:8086
`ac-keira3`	uprightbass360/keira3:latest	Production database editor with API	4201:8080
`ac-backup`	mysql:8.0	Automated backup service	-
`ac-modules`	alpine/git:latest	Module management	-

Container Relationships

graph TD
    A[ac-mysql] -->|depends_on| B[ac-db-init]
    B -->|depends_on| C[ac-db-import]
    C -->|depends_on| D[ac-authserver]
    C -->|depends_on| E[ac-worldserver]
    E -->|depends_on| F[ac-eluna]
    A -->|backup| G[ac-backup]

Network Architecture

Network Name: azerothcore
Type: Bridge network
Subnet: 172.28.0.0/16 (configurable)
Internal DNS: Container names resolve to IPs

Initial Setup

Step 1: Clone and Configure

# Clone the repository
git clone https://github.com/uprightbass360/acore-compose.git
cd acore-compose

# Environment files are pre-configured with defaults
# Modify the relevant .env files for your deployment:
# - docker-compose-azerothcore-database.env: Database settings
# - docker-compose-azerothcore-services.env: Game server settings
# - docker-compose-azerothcore-tools.env: Management tools settings

Step 2: Deploy the Stack

Deploy services in the correct order:

# Step 1: Deploy database layer
docker compose --env-file docker-compose-azerothcore-database.env -f docker-compose-azerothcore-database.yml up -d
#The database import happens automatically via the `ac-db-import` container. Monitor progress:
docker logs ac-db-init -f      # Watch database initialization
# Check import status
docker logs ac-db-import -f
# Verify databases were created
docker exec ac-mysql mysql -uroot -p${MYSQL_ROOT_PASSWORD} -e "SHOW DATABASES;"

# Step 2: Wait for database initialization, then deploy services
docker compose --env-file docker-compose-azerothcore-services.env -f docker-compose-azerothcore-services.yml up -d
docker logs ac-client-data -f  # Watch data download/extraction

The server automatically downloads and extracts game data on first run. The ac-client-data service will:

Download the latest client data from wowgaming/client-data releases (~15GB)
Extract maps, vmaps, mmaps, and DBC files
Cache the download for future deployments
Verify data integrity
This can take around 20 minutes to complete depending on your storage

No manual data extraction is required, but ensure you have sufficient disk space and bandwidth.

# Step 3: Deploy management tools (optional)
docker compose --env-file docker-compose-azerothcore-tools.env -f docker-compose-azerothcore-tools.yml up -d

Step 3: Create Admin Account

Once the worldserver is running:

# Attach to worldserver console
docker attach ac-worldserver

# In the worldserver console, create admin account:
account create admin yourpassword
account set gmlevel admin 3 -1
server info

# Detach from console without stopping: Ctrl+P, Ctrl+Q

Step 4: Configure Game Client

Edit your WoW 3.3.5a client's realmlist.wtf:

set realmlist YOUR_SERVER_IP

Configuration

Environment Variables

Configuration is managed through separate .env files for each layer:

Database Layer (`docker-compose-azerothcore-database.env`)

MYSQL_ROOT_PASSWORD: Database root password (default: azerothcore123)
MYSQL_EXTERNAL_PORT: External MySQL port (default: 64306)
STORAGE_PATH: Data storage path (default: /nfs/containers/azerothcore)
NETWORK_SUBNET: Docker network subnet
BACKUP_RETENTION_DAYS: Backup retention period

Services Layer (`docker-compose-azerothcore-services.env`)

AUTH_EXTERNAL_PORT: Auth server external port (3784)
WORLD_EXTERNAL_PORT: World server external port (8215)
SOAP_EXTERNAL_PORT: SOAP API port (7778)
PLAYERBOT_ENABLED: Enable/disable playerbots (1/0)
PLAYERBOT_MAX_BOTS: Maximum number of bots (default: 40)

Tools Layer (`docker-compose-azerothcore-tools.env`)

PMA_EXTERNAL_PORT: PHPMyAdmin port (8081)
KEIRA3_EXTERNAL_PORT: Database editor port (4201)
GF_EXTERNAL_PORT: Grafana monitoring port (3001)
INFLUXDB_EXTERNAL_PORT: InfluxDB metrics port (8087)
STORAGE_PATH_TOOLS: Tools storage path (default: ./volumes-tools)

Realm Configuration

Update realm settings in the database:

# Update realm IP address
docker exec ac-mysql mysql -uroot -p${MYSQL_ROOT_PASSWORD} -e "
USE acore_auth;
UPDATE realmlist SET address='NEW_IP' WHERE id=1;"

# View current realm configuration
docker exec ac-mysql mysql -uroot -p${MYSQL_ROOT_PASSWORD} -e "
USE acore_auth;
SELECT * FROM realmlist;"

Volume Management

Named Volumes

Volume Name	Container Mount	Purpose	Can Be Bind Mounted
`ac_mysql_data`	`/var/lib/mysql`	MySQL database files	✅ Yes - For backup/migration
`ac_data`	`/azerothcore/data`	Game data (maps, vmaps, etc.)	✅ Yes - Required for data files
`ac_config`	`/azerothcore/env/dist/etc`	Configuration files	✅ Yes - For custom configs
`ac_logs`	`/azerothcore/logs`	Application logs	✅ Yes - For log analysis
`ac_backup`	`/backups`	Database backups	✅ Yes - For external backup storage

Bind Mount Examples

To use bind mounts instead of named volumes, modify the compose file:

volumes:
  # Replace named volume with bind mount
  - /srv/azerothcore/mysql:/var/lib/mysql
  - /srv/azerothcore/data:/azerothcore/data
  - /srv/azerothcore/config:/azerothcore/env/dist/etc
  - /srv/azerothcore/logs:/azerothcore/logs
  - /srv/azerothcore/backups:/backups

Volume Backup Procedures

Backup MySQL Data:

# Create backup of MySQL volume
docker run --rm \
  -v ac_mysql_data:/data \
  -v $(pwd):/backup \
  alpine tar czf /backup/mysql-backup-$(date +%Y%m%d).tar.gz -C /data .

Backup Game Data:

# Create backup of game data volume
docker run --rm \
  -v ac_data:/data \
  -v $(pwd):/backup \
  alpine tar czf /backup/gamedata-backup-$(date +%Y%m%d).tar.gz -C /data .

Maintenance

Daily Operations

Check Service Status:

# View all AzerothCore containers
docker ps | grep ac-

# Check resource usage
docker stats $(docker ps --format "{{.Names}}" | grep ac-)

# View recent logs
docker logs ac-worldserver --tail 100
docker logs ac-authserver --tail 100

Server Commands:

# Attach to worldserver console
docker attach ac-worldserver

# Common console commands:
server info                    # Show server status
account create USER PASS       # Create new account
account set gmlevel USER 3 -1 # Set GM level
server shutdown 60             # Shutdown in 60 seconds
saveall                       # Save all characters

Database Maintenance

Manual Backup:

# Full database backup
docker exec ac-mysql mysqldump \
  -uroot -p${MYSQL_ROOT_PASSWORD} \
  --all-databases \
  --single-transaction \
  --routines \
  --triggers \
  > backup-$(date +%Y%m%d-%H%M%S).sql

Restore Backup:

# Restore from backup
docker exec -i ac-mysql mysql \
  -uroot -p${MYSQL_ROOT_PASSWORD} \
  < backup-file.sql

Database Optimization:

# Optimize all tables
docker exec ac-mysql mysqlcheck \
  -uroot -p${MYSQL_ROOT_PASSWORD} \
  --all-databases \
  --optimize

Container Updates

Update Containers:

# Pull latest images for database layer
docker-compose -f docker-compose-azerothcore-database.yml pull

# Pull latest images for services layer
docker-compose -f docker-compose-azerothcore-services.yml pull

# Pull latest images for tools layer
docker-compose -f docker-compose-azerothcore-tools.yml pull

# Recreate containers with new images
docker-compose -f docker-compose-azerothcore-database.yml up -d --force-recreate
docker-compose -f docker-compose-azerothcore-services.yml up -d --force-recreate
docker-compose -f docker-compose-azerothcore-tools.yml up -d --force-recreate

# Remove old unused images
docker image prune -a

Update AzerothCore:

# Stop services layer
docker-compose -f docker-compose-azerothcore-services.yml stop

# Update database
docker-compose -f docker-compose-azerothcore-database.yml up ac-db-import

# Restart services layer
docker-compose -f docker-compose-azerothcore-services.yml up -d

Log Management

View Logs:

# Follow worldserver logs
docker logs -f ac-worldserver

# Export logs to file
docker logs ac-worldserver > worldserver.log 2>&1

# Clear old logs (if using bind mount)
find /srv/azerothcore/logs -name "*.log" -mtime +30 -delete

Log Rotation (using bind mount):

# Create logrotate config
cat > /etc/logrotate.d/azerothcore <<EOF
/srv/azerothcore/logs/*.log {
    daily
    rotate 7
    compress
    delaycompress
    missingok
    notifempty
}
EOF

Backup System

The deployment includes a comprehensive automated backup system with individual database backups, compression, and retention management.

Backup Configuration

Configure via environment variables in docker-compose-azerothcore-database.env:

BACKUP_CRON_SCHEDULE: Cron expression (default: "0 3 * * *" - 3 AM daily)
BACKUP_RETENTION_DAYS: Days to keep backups (default: 7)
HOST_BACKUP_PATH: Local backup storage path (default: ./backups)
HOST_BACKUP_SCRIPTS_PATH: Backup scripts path (default: ./scripts)

Backup Features

✅ Individual Database Backups: Separate compressed files for each database ✅ Backup Manifests: JSON metadata with timestamps and backup information ✅ Automated Compression: Gzip compression for space efficiency ✅ Retention Management: Automatic cleanup of old backups ✅ External Scripts: Uses external backup/restore scripts for flexibility

Backup Operations

Automatic Backups

The ac-backup container runs continuously and performs scheduled backups:

Schedule: Daily at 3:00 AM by default (configurable via BACKUP_CRON_SCHEDULE)
Databases: All AzerothCore databases (auth, world, characters)
Format: Individual compressed SQL files per database
Retention: Automatic cleanup after configured days

Manual Backups

# Execute backup immediately using container
docker exec ac-backup /scripts/backup.sh

# Or run backup script directly (if scripts are accessible)
cd scripts
./backup.sh

# Check backup status and logs
docker logs ac-backup --tail 20

# List available backups
ls -la backups/

Backup Structure

backups/
├── 20250930_181843/                    # Timestamp-based backup directory
│   ├── acore_auth.sql.gz              # Compressed auth database (8KB)
│   ├── acore_world.sql.gz             # Compressed world database (77MB)
│   ├── acore_characters.sql.gz        # Compressed characters database (16KB)
│   └── manifest.json                  # Backup metadata
├── 20250930_120000/                    # Previous backup
└── ...                                 # Additional backups (retention managed)

Backup Metadata

Each backup includes a manifest.json file with backup information:

{
    "timestamp": "20250930_181843",
    "databases": ["acore_auth acore_world acore_characters"],
    "backup_size": "77M",
    "retention_days": 7,
    "mysql_version": "8.0.43"
}

Backup Restoration

Using Restore Script

cd scripts
./restore.sh /path/to/backup/directory/20250930_181843

Manual Restoration

# Restore individual database from compressed backup
gunzip -c backups/20250930_181843/acore_world.sql.gz | \
  docker exec -i ac-mysql mysql -uroot -p${MYSQL_ROOT_PASSWORD} acore_world

# Restore all databases from a backup directory
for db in auth world characters; do
  gunzip -c backups/20250930_181843/acore_${db}.sql.gz | \
    docker exec -i ac-mysql mysql -uroot -p${MYSQL_ROOT_PASSWORD} acore_${db}
done

Backup Monitoring

# Monitor backup service logs
docker logs ac-backup -f

# Check backup service status
docker ps | grep ac-backup

# Verify recent backups
find backups/ -name "*.sql.gz" -mtime -1 -ls

# Check backup sizes
du -sh backups/*/

Deployment Scripts

The scripts/ directory contains automation tools for deployment, health checking, and cleanup operations.

Available Scripts

Script	Purpose	Usage
`deploy-and-check.sh`	Automated deployment and health verification	`./deploy-and-check.sh [--skip-deploy] [--quick-check]`
`cleanup.sh`	Multi-level resource cleanup	`./cleanup.sh [--soft\|--hard\|--nuclear] [--dry-run]`
`backup.sh`	Manual database backup	`./backup.sh`
`restore.sh`	Database restoration	`./restore.sh <backup_directory>`

Deployment and Health Check Script

The deploy-and-check.sh script provides automated deployment and comprehensive health verification.

Features

✅ Layered Deployment: Deploys database → services → tools in correct order ✅ Container Health Validation: Checks all 8 core containers ✅ Port Connectivity Tests: Validates all external ports ✅ Web Service Verification: HTTP response and content validation ✅ Database Validation: Schema and realm configuration checks ✅ Comprehensive Reporting: Color-coded status with detailed results

Usage Examples

cd scripts

# Full deployment with health checks
./deploy-and-check.sh

# Health check only (skip deployment)
./deploy-and-check.sh --skip-deploy

# Quick health check (basic tests only)
./deploy-and-check.sh --skip-deploy --quick-check

Cleanup Script

The cleanup.sh script provides safe and comprehensive cleanup options with multiple levels of cleanup intensity.

Cleanup Levels

🟢 Soft (--soft): Stop containers only (preserves data)
🟡 Hard (--hard): Remove containers + networks (preserves volumes/data)
🔴 Nuclear (--nuclear): Complete removal (DESTROYS ALL DATA)

Usage Examples

cd scripts

# Safe cleanup - stop containers only
./cleanup.sh --soft

# Moderate cleanup - remove containers and networks (preserves data)
./cleanup.sh --hard

# Complete cleanup - remove everything (DESTROYS ALL DATA)
./cleanup.sh --nuclear

# See what would happen without doing it
./cleanup.sh --hard --dry-run

# Force cleanup without prompts (for automation)
./cleanup.sh --hard --force

Script Documentation

For complete documentation on each script:

Deployment: See scripts/DEPLOYMENT.md
Cleanup: See scripts/CLEANUP.md
Scripts Overview: See scripts/README.md

Troubleshooting

Common Issues

1. Worldserver Won't Start

Error: "Failed to find map files for starting areas"

Solution: Ensure game data files are properly extracted and placed in the data volume:

# Check if data files exist
docker run --rm -v ac_data:/data alpine ls -la /data/

# Should see: dbc/, maps/, vmaps/, mmaps/ directories

2. Cannot Connect to Realm

Error: Realm list shows but cannot enter world

Solution: Update realm IP address:

docker exec ac-mysql mysql -uroot -p${MYSQL_ROOT_PASSWORD} -e "
USE acore_auth;
UPDATE realmlist SET address='YOUR_PUBLIC_IP' WHERE id=1;"

3. Database Connection Failed

Error: "Can't connect to MySQL server"

Solution: Check MySQL container and credentials:

# Verify MySQL is running
docker ps | grep ac-mysql

# Test connection
docker exec ac-authserver ping ac-mysql

# Check MySQL logs
docker logs ac-mysql --tail 50

4. Permission Denied Errors

Error: Various permission denied messages

Solution: Containers are configured to run as root to handle NFS permissions. Check volume mount permissions and ensure storage paths are accessible.

Debug Commands

# Check container health
docker inspect ac-mysql | grep -A 10 "Health"

# View network configuration
docker network inspect azerothcore

# Check volume mounts
docker inspect ac-worldserver | grep -A 10 "Mounts"

# Test database connectivity
docker exec ac-mysql mysql -uroot -p${MYSQL_ROOT_PASSWORD} -e "STATUS;"

# View process list in container
docker top ac-worldserver

# Execute commands in container
docker exec ac-worldserver ls -la /azerothcore/data/

Reset Procedures

Complete Reset:

# Stop all layers
docker-compose -f docker-compose-azerothcore-tools.yml down
docker-compose -f docker-compose-azerothcore-services.yml down
docker-compose -f docker-compose-azerothcore-database.yml down

# Remove all volumes (WARNING: Deletes all data)
docker volume prune -f

# Remove all containers and images
docker system prune -a

# Start fresh (in order)
docker-compose -f docker-compose-azerothcore-database.yml up -d
docker-compose -f docker-compose-azerothcore-services.yml up -d
docker-compose -f docker-compose-azerothcore-tools.yml up -d

Reset Specific Service:

# Reset worldserver only
docker-compose -f docker-compose-azerothcore-services.yml stop ac-worldserver
docker-compose -f docker-compose-azerothcore-services.yml rm -f ac-worldserver
docker-compose -f docker-compose-azerothcore-services.yml up -d ac-worldserver

Security Considerations

Best Practices

Strong Passwords
- Use complex passwords for MySQL root
- Avoid default passwords for game accounts
- Regularly rotate admin credentials
Network Security
- Use firewall rules to restrict access
- Consider VPN for admin access
- Disable SOAP if not needed
File Permissions
- Restrict access to .env files: chmod 600 *.env
- Secure backup directories
- Containers run as root to handle NFS permissions
Regular Updates
- Keep containers updated
- Apply security patches promptly
- Monitor security advisories

Firewall Configuration

# Allow only necessary ports
ufw allow 3784/tcp  # Auth server
ufw allow 8215/tcp  # World server
ufw allow 22/tcp    # SSH (restrict source IP)
ufw enable

Monitoring

# Monitor connection attempts
docker logs ac-authserver | grep -i "failed"

# Check for unusual database queries
docker exec ac-mysql mysql -uroot -p${MYSQL_ROOT_PASSWORD} -e "
SHOW PROCESSLIST;"

# Monitor resource usage
docker stats --no-stream

Support and Resources

Official Documentation

AzerothCore Wiki - Official documentation
AzerothCore GitHub - Source code and issues
AzerothCore Docker - Official Docker images
Playerbot Documentation - Playerbot module wiki
Docker Documentation - Docker reference
Podman Documentation - Podman reference

Community Resources

AzerothCore Discord - Community support
AzerothCore Forums - Discussions
ChromieCraft - AzerothCore-based progressive server

Available Services

Service	Endpoint	Port	Purpose
Game Server	`localhost:8215`	8215	World server (game connection)
Auth Server	`localhost:3784`	3784	Authentication server
SOAP API	`localhost:7778`	7778	Server administration API
PHPMyAdmin	`http://localhost:8081`	8081	Database management interface
Keira3	`http://localhost:4201`	4201	Database editor web UI with API backend
Grafana	`http://localhost:3001`	3001	Monitoring dashboard
InfluxDB	`localhost:8087`	8087	Metrics database
MySQL	`localhost:64306`	64306	Direct database access

Database Credentials

Host: localhost:64306
User: root
Password: azerothcore123 (configurable in environment files)
Databases: acore_auth, acore_world, acore_characters

Original Docker Setup - Base Docker configuration this project extends
AzerothCore Modules - Additional modules catalog

Useful Commands Reference

# Quick status check
docker ps | grep ac-

# Restart database layer
docker-compose -f docker-compose-azerothcore-database.yml restart

# Restart services layer
docker-compose -f docker-compose-azerothcore-services.yml restart

# Restart tools layer
docker-compose -f docker-compose-azerothcore-tools.yml restart

# View database logs
docker-compose -f docker-compose-azerothcore-database.yml logs

# View services logs
docker-compose -f docker-compose-azerothcore-services.yml logs

# View tools logs
docker-compose -f docker-compose-azerothcore-tools.yml logs

# Stop everything (in reverse order)
docker-compose -f docker-compose-azerothcore-tools.yml down
docker-compose -f docker-compose-azerothcore-services.yml down
docker-compose -f docker-compose-azerothcore-database.yml down

# Start everything (in order)
docker-compose -f docker-compose-azerothcore-database.yml up -d
docker-compose -f docker-compose-azerothcore-services.yml up -d
docker-compose -f docker-compose-azerothcore-tools.yml up -d

# Update and restart all layers
docker-compose -f docker-compose-azerothcore-database.yml pull && docker-compose -f docker-compose-azerothcore-database.yml up -d
docker-compose -f docker-compose-azerothcore-services.yml pull && docker-compose -f docker-compose-azerothcore-services.yml up -d
docker-compose -f docker-compose-azerothcore-tools.yml pull && docker-compose -f docker-compose-azerothcore-tools.yml up -d

# Backup database
docker exec ac-mysql mysqldump -uroot -p${MYSQL_ROOT_PASSWORD} --all-databases > backup.sql

# Connect to worldserver console
docker attach ac-worldserver

License and Attribution

Project Licenses

AzerothCore: Licensed under AGPL-3.0
This Docker Configuration: Provided under MIT License for the configuration files
Playerbot Module: Check mod-playerbots for specific licensing

Credits

AzerothCore Team: For the core server application
coc0nut: For the initial Docker setup approach with Playerbots
liyunfan1223: For the Playerbot module
Community Contributors: For various modules and improvements

Legal Notice

World of Warcraft® and Blizzard Entertainment® are registered trademarks of Blizzard Entertainment, Inc. This project is not affiliated with Blizzard Entertainment.

Contributing

Contributions are welcome! Please:

Fork the repository
Create a feature branch
Commit your changes
Push to the branch
Create a Pull Request

Note: This is an unofficial community deployment. Always backup your data before updates or changes.

readme.md

AzerothCore Docker/Podman Stack

Implementation Credits

Key Improvements in This Implementation

Table of Contents

Overview

What This Implementation Provides

Core Components

Version Information

Features

Requirements

System Requirements

Software Requirements

Game Client Requirements

Project Structure

Container Architecture

Service Containers

Container Relationships

Network Architecture

Initial Setup

Step 1: Clone and Configure

Step 2: Deploy the Stack

Step 3: Create Admin Account

Step 4: Configure Game Client

Configuration

Environment Variables

Database Layer (docker-compose-azerothcore-database.env)

Services Layer (docker-compose-azerothcore-services.env)

Tools Layer (docker-compose-azerothcore-tools.env)

Realm Configuration

Volume Management

Named Volumes

Bind Mount Examples

Volume Backup Procedures

Backup MySQL Data:

Backup Game Data:

Maintenance

Daily Operations

Check Service Status:

Server Commands:

Database Maintenance

Manual Backup:

Restore Backup:

Database Optimization:

Container Updates

Update Containers:

Update AzerothCore:

Log Management

View Logs:

Log Rotation (using bind mount):

Backup System

Backup Configuration

Backup Features

Backup Operations

Automatic Backups

Manual Backups

Backup Structure

Backup Metadata

Backup Restoration

Using Restore Script

Manual Restoration

Backup Monitoring

Deployment Scripts

Available Scripts

Deployment and Health Check Script

Features

Usage Examples

Cleanup Script

Cleanup Levels

Usage Examples

Script Documentation

Troubleshooting

Common Issues

1. Worldserver Won't Start

2. Cannot Connect to Realm

3. Database Connection Failed

4. Permission Denied Errors

Debug Commands

Reset Procedures

Complete Reset:

Database Layer (`docker-compose-azerothcore-database.env`)

Services Layer (`docker-compose-azerothcore-services.env`)

Tools Layer (`docker-compose-azerothcore-tools.env`)