Containerization (Docker)
# Containerization (Docker) for MediaWiki
This article provides a technical overview of using containerization, specifically Docker, for deploying and managing a MediaWiki installation. Containerization offers significant advantages over traditional deployment methods, including consistency, portability, and scalability. This guide is aimed at system administrators and developers new to Docker but familiar with basic server administration concepts.
What is Containerization?
Containerization is a form of operating system virtualization. Unlike virtual machines (VMs) which virtualize hardware, containers virtualize the operating system. This means containers share the host OS kernel, making them lightweight and efficient. Each container packages an application with all its dependencies—libraries, frameworks, configuration files—into a single, executable package. Virtualization is a related but distinct concept.
Docker is the most popular containerization platform. It allows you to create, deploy, and run applications in isolated environments called containers.
Why Use Docker with MediaWiki?
Several benefits make Docker an excellent choice for MediaWiki deployments:
- **Consistency:** Ensures the same environment across development, testing, and production. This eliminates the "works on my machine" problem.
- **Portability:** Containers can run on any system that supports Docker, regardless of the underlying infrastructure. This simplifies migrations and scaling.
- **Isolation:** Containers isolate applications from each other and the host system, improving security and stability.
- **Scalability:** Docker facilitates easy scaling of MediaWiki instances through orchestration tools like Docker Compose or Kubernetes.
- **Simplified Deployment:** Docker simplifies the deployment process, reducing the risk of errors.
- A server with a supported operating system (Linux is recommended).
- Docker installed and running on your server. Refer to the official Docker documentation for installation instructions: [https://docs.docker.com/get-docker/](https://docs.docker.com/get-docker/)
- Docker Compose installed (optional, but highly recommended for multi-container setups).
- Basic familiarity with the command line.
- A basic understanding of PHP and MySQL/MariaDB.
- `docker run`: Starts a new container.
- `-d`: Runs the container in detached mode (in the background).
- `-p 80:80`: Maps port 80 on the host to port 80 in the container (HTTP).
- `-p 443:443`: Maps port 443 on the host to port 443 in the container (HTTPS).
- `-v /path/to/mediawiki/data:/var/www/html/data`: Mounts a volume from the host (`/path/to/mediawiki/data`) to the container (`/var/www/html/data`). This is crucial for persistent storage of MediaWiki data (images, files, etc.). Replace `/path/to/mediawiki/data` with the actual path on your host system.
- `--name mediawiki`: Assigns a name to the container.
- `mediawiki-official/mediawiki:latest`: Specifies the Docker image to use.
- **SSL/TLS:** Secure your MediaWiki instance with SSL/TLS certificates. Let's Encrypt provides free certificates.
- **Backups:** Implement a regular backup strategy for your MediaWiki data and database.
- **Monitoring:** Monitor your containerized MediaWiki instance for performance and health.
- **Updates:** Regularly update your Docker images to benefit from security patches and new features. Consider automating this process.
- Security Best Practices are essential when deploying any web application.
- Telegram: @powervps Servers at a discounted price
Pre-requisites
Before you begin, you will need the following:
Setting up a MediaWiki Container
The most common approach involves utilizing a pre-built Docker image or creating your own. We will focus on using a pre-built image as it's the simplest method for beginners.
Using a Pre-built Image
Several pre-built MediaWiki Docker images are available on Docker Hub. These images typically include the necessary web server (Apache or Nginx), PHP, and database client.
Here's an example using a popular image:
```bash docker run -d -p 80:80 -p 443:443 -v /path/to/mediawiki/data:/var/www/html/data --name mediawiki mediawiki-official/mediawiki:latest ```
Let’s break down the command:
After running this command, your MediaWiki instance should be accessible in your web browser at `http://your_server_ip` (or `https://your_server_ip` if you've configured SSL).
Database Configuration
The above example assumes a database server is already running. You can either connect to an existing database or run a separate database container. Here's a table summarizing typical database connection details:
| Database Type | Host | Port | Username | Password | Database Name |
|---|---|---|---|---|---|
| MySQL | localhost | 3306 | root | your_root_password | wikidb |
| MariaDB | localhost | 3306 | root | your_root_password | wikidb |
You'll need to configure MediaWiki's `LocalSettings.php` file (located within the mounted volume) with these details.
Using Docker Compose
Docker Compose simplifies managing multi-container applications. You can define your MediaWiki setup (web server, database, etc.) in a `docker-compose.yml` file.
Here’s a basic example:
```yaml version: "3.9" services: db: image: mariadb:10.6 restart: always environment: MYSQL_ROOT_PASSWORD: your_root_password MYSQL_DATABASE: wikidb MYSQL_USER: wikiuser MYSQL_PASSWORD: your_wiki_password volumes: - db_data:/var/lib/mysql
mediawiki: image: mediawiki-official/mediawiki:latest restart: always ports: - "80:80" - "443:443" depends_on: - db volumes: - mediawiki_data:/var/www/html/data environment: MW_DB_TYPE: mariadb MW_DB_SERVER: db MW_DB_NAME: wikidb MW_DB_USER: wikiuser MW_DB_PASSWORD: your_wiki_password
volumes: db_data: mediawiki_data: ```
To start the application, run `docker-compose up -d`. This will create and start the database and MediaWiki containers, linking them together.
Technical Specifications Summary
Here's a summary of typical technical specifications for a Dockerized MediaWiki setup:
| Component | Specification | Notes |
|---|---|---|
| Docker Engine Version | 20.10.0 or later | Latest stable version recommended |
| Operating System | Linux (Ubuntu, Debian, CentOS, etc.) | Windows and macOS are also supported, but Linux is preferred for production |
| Web Server | Apache or Nginx | Included in most MediaWiki Docker images |
| PHP Version | 7.4 or 8.1 | Check MediaWiki requirements for compatibility |
| Database | MySQL or MariaDB | MariaDB is often preferred due to its open-source nature |
And a table outlining resource requirements:
| Resource | Minimum | Recommended |
|---|---|---|
| CPU | 1 Core | 2+ Cores |
| RAM | 1 GB | 4+ GB |
| Disk Space | 20 GB | 50+ GB (depending on content) |
Finally, a table showing common ports used:
| Port | Protocol | Description |
|---|---|---|
| 80 | TCP | HTTP (Web Access) |
| 443 | TCP | HTTPS (Secure Web Access) |
| 3306 | TCP | MySQL/MariaDB Database |
Further Considerations
MediaWiki Docker Docker Compose Kubernetes Virtualization PHP MySQL MariaDB Apache Nginx Let's Encrypt LocalSettings.php Docker Hub Security Best Practices Deployment Scaling Troubleshooting
Intel-Based Server Configurations
| Configuration | Specifications | Benchmark |
|---|---|---|
| Core i7-6700K/7700 Server | 64 GB DDR4, NVMe SSD 2 x 512 GB | CPU Benchmark: 8046 |
| Core i7-8700 Server | 64 GB DDR4, NVMe SSD 2x1 TB | CPU Benchmark: 13124 |
| Core i9-9900K Server | 128 GB DDR4, NVMe SSD 2 x 1 TB | CPU Benchmark: 49969 |
| Core i9-13900 Server (64GB) | 64 GB RAM, 2x2 TB NVMe SSD | |
| Core i9-13900 Server (128GB) | 128 GB RAM, 2x2 TB NVMe SSD | |
| Core i5-13500 Server (64GB) | 64 GB RAM, 2x500 GB NVMe SSD | |
| Core i5-13500 Server (128GB) | 128 GB RAM, 2x500 GB NVMe SSD | |
| Core i5-13500 Workstation | 64 GB DDR5 RAM, 2 NVMe SSD, NVIDIA RTX 4000 |
AMD-Based Server Configurations
| Configuration | Specifications | Benchmark |
|---|---|---|
| Ryzen 5 3600 Server | 64 GB RAM, 2x480 GB NVMe | CPU Benchmark: 17849 |
| Ryzen 7 7700 Server | 64 GB DDR5 RAM, 2x1 TB NVMe | CPU Benchmark: 35224 |
| Ryzen 9 5950X Server | 128 GB RAM, 2x4 TB NVMe | CPU Benchmark: 46045 |
| Ryzen 9 7950X Server | 128 GB DDR5 ECC, 2x2 TB NVMe | CPU Benchmark: 63561 |
| EPYC 7502P Server (128GB/1TB) | 128 GB RAM, 1 TB NVMe | CPU Benchmark: 48021 |
| EPYC 7502P Server (128GB/2TB) | 128 GB RAM, 2 TB NVMe | CPU Benchmark: 48021 |
| EPYC 7502P Server (128GB/4TB) | 128 GB RAM, 2x2 TB NVMe | CPU Benchmark: 48021 |
| EPYC 7502P Server (256GB/1TB) | 256 GB RAM, 1 TB NVMe | CPU Benchmark: 48021 |
| EPYC 7502P Server (256GB/4TB) | 256 GB RAM, 2x2 TB NVMe | CPU Benchmark: 48021 |
| EPYC 9454P Server | 256 GB RAM, 2x2 TB NVMe |
Order Your Dedicated Server
Configure and order your ideal server configurationNeed Assistance?
⚠️ *Note: All benchmark scores are approximate and may vary based on configuration. Server availability subject to stock.* ⚠️