---
title: "Cómo instalar MediaWiki en Ubuntu 24.04 con Nginx y MariaDB"
description: "Instala MediaWiki 1.43 LTS en Ubuntu 24.04 con Nginx, PHP-FPM 8.3 y MariaDB, activa HTTPS con Let's Encrypt, añade extensiones y programa copias de seguridad."
category: "Hosting de Aplicaciones Web"
language: es
source: https://cubepath.com/es/docs/hosting-de-aplicaciones-web/instalacion-y-configuracion-de-mediawiki
updated: 2026-09-25
---

# Cómo instalar MediaWiki en Ubuntu 24.04 con Nginx y MariaDB

MediaWiki es el software de wiki que usa Wikipedia: un motor PHP con historial de revisiones, control de permisos y un amplio catálogo de extensiones, muy usado para bases de conocimiento y documentación interna. En este tutorial instalarás la versión de soporte extendido (LTS) de MediaWiki en Ubuntu 24.04 con Nginx, PHP-FPM 8.3 y MariaDB, la publicarás con HTTPS y dejarás configuradas las extensiones, las tareas en segundo plano y las copias de seguridad.

## Requisitos previos

Para seguir esta guía necesitas:

- Un servidor con Ubuntu 24.04 LTS, por ejemplo un VPS de CubePath, con al menos 2 GB de RAM y 20 GB de disco.
- Un usuario no root con privilegios `sudo`.
- Un dominio o subdominio (en esta guía, `wiki.example.com`) con un registro DNS **A** que apunte a la IP del servidor. Sustituye `wiki.example.com` por tu dominio en todos los pasos.
- Los puertos 80 y 443 abiertos.

> Nota: esta guía usa MediaWiki 1.43.9, la rama LTS en el momento de escribirla. Consulta la versión actual en la [página de descargas de MediaWiki](https://www.mediawiki.org/wiki/Download) y ajusta los números si hay una publicación más reciente de la misma rama.

## Paso 1: Instalar Nginx, PHP y MariaDB

Actualiza el índice de paquetes e instala el servidor web, PHP-FPM con las extensiones que MediaWiki necesita y el servidor de base de datos:

```bash
sudo apt update
sudo apt install -y nginx mariadb-server php8.3-fpm php8.3-mysql php8.3-xml php8.3-mbstring php8.3-intl php8.3-gd php8.3-curl php-apcu imagemagick
```

- `php8.3-intl`, `php8.3-mbstring` y `php8.3-xml` son obligatorias para MediaWiki.
- `php-apcu` proporciona la caché de objetos local que el instalador detecta y usa automáticamente.
- `imagemagick` genera las miniaturas de las imágenes subidas.

Comprueba que los tres servicios están activos:

```bash
systemctl is-active nginx php8.3-fpm mariadb
```

```output
active
active
active
```

Si usas UFW, abre HTTP y HTTPS:

```bash
sudo ufw allow 'Nginx Full'
```

## Paso 2: Crear la base de datos

Ejecuta el script de seguridad de MariaDB para eliminar usuarios anónimos y la base de datos de pruebas. Puedes mantener la autenticación por socket de root, que es la opción por defecto en Ubuntu:

```bash
sudo mariadb-secure-installation
```

Abre la consola de MariaDB como root:

```bash
sudo mariadb
```

Crea la base de datos y un usuario exclusivo para la wiki. Sustituye `your_strong_password` por una contraseña robusta:

```sql
CREATE DATABASE mediawiki CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
CREATE USER 'mediawiki'@'localhost' IDENTIFIED BY 'your_strong_password';
GRANT ALL PRIVILEGES ON mediawiki.* TO 'mediawiki'@'localhost';
FLUSH PRIVILEGES;
EXIT;
```

Comprueba que el usuario puede conectarse:

```bash
mariadb -u mediawiki -p -e "SHOW DATABASES;"
```

```output
+--------------------+
| Database           |
+--------------------+
| information_schema |
| mediawiki          |
+--------------------+
```

## Paso 3: Descargar MediaWiki

Descarga el paquete oficial en tu directorio personal y extráelo en `/var/www/mediawiki`:

```bash
cd ~
wget https://releases.wikimedia.org/mediawiki/1.43/mediawiki-1.43.9.tar.gz
sudo mkdir -p /var/www/mediawiki
sudo tar -xzf mediawiki-1.43.9.tar.gz -C /var/www/mediawiki --strip-components=1
```

El código debe pertenecer a root para que el proceso de PHP no pueda modificarlo. Solo el directorio `images`, donde se guardan los archivos subidos y las miniaturas, necesita permisos de escritura para `www-data`:

```bash
sudo chown -R root:root /var/www/mediawiki
sudo chown -R www-data:www-data /var/www/mediawiki/images
```

Verifica la versión extraída:

```bash
grep "MW_VERSION'" /var/www/mediawiki/includes/Defines.php
```

```output
define( 'MW_VERSION', '1.43.9' );
```

## Paso 4: Configurar Nginx

Crea el bloque de servidor de la wiki:

```bash
sudo nano /etc/nginx/sites-available/mediawiki
```

Pega esta configuración:

```nginx
server {
    listen 80;
    listen [::]:80;
    server_name wiki.example.com;

    root /var/www/mediawiki;
    index index.php;

    client_max_body_size 50M;

    location / {
        try_files $uri $uri/ /index.php?$query_string;
    }

    # Directorios internos que nunca deben servirse
    location ~ ^/(cache|includes|languages|maintenance|serialized|tests|vendor|images/deleted)/ {
        deny all;
    }

    # Los archivos subidos se sirven como estáticos, nunca se ejecutan
    location ^~ /images/ {
        add_header X-Content-Type-Options nosniff;
        try_files $uri =404;
    }

    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/run/php/php8.3-fpm.sock;
    }

    location ~ /\.ht {
        deny all;
    }
}
```

Las ubicaciones con expresión regular se evalúan en orden, por eso el bloqueo de directorios internos va antes que el de PHP. El prefijo `^~` en `/images/` impide que un archivo `.php` subido llegue a PHP-FPM.

Activa el sitio, desactiva el sitio por defecto y comprueba la sintaxis:

```bash
sudo ln -s /etc/nginx/sites-available/mediawiki /etc/nginx/sites-enabled/
sudo rm /etc/nginx/sites-enabled/default
sudo nginx -t
```

```output
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
```

Recarga Nginx:

```bash
sudo systemctl reload nginx
```

Para permitir subidas de hasta 50 MB también en PHP, edita la configuración de PHP-FPM:

```bash
sudo nano /etc/php/8.3/fpm/php.ini
```

Busca y ajusta estas directivas:

```ini
upload_max_filesize = 50M
post_max_size = 50M
memory_limit = 256M
```

Reinicia PHP-FPM para aplicar los cambios:

```bash
sudo systemctl restart php8.3-fpm
```

## Paso 5: Activar HTTPS con Let's Encrypt

Instala Certbot con el plugin de Nginx y solicita el certificado. Certbot modifica el bloque de servidor para escuchar en el puerto 443 y redirigir HTTP a HTTPS:

```bash
sudo apt install -y certbot python3-certbot-nginx
sudo certbot --nginx -d wiki.example.com
```

Cuando termine, comprueba que la renovación automática funciona:

```bash
sudo certbot renew --dry-run
```

```output
Congratulations, all simulated renewals succeeded:
  /etc/letsencrypt/live/wiki.example.com/fullchain.pem (success)
```

## Paso 6: Ejecutar el instalador web

Abre `https://wiki.example.com/mw-config/index.php` en el navegador. El instalador comprueba el entorno y te guía en varias pantallas:

1. **Idioma**: elige el idioma de la interfaz y el del contenido de la wiki.
2. **Entorno**: debe indicar que el entorno es correcto y que APCu está disponible. Si falta alguna extensión de PHP, instálala, reinicia `php8.3-fpm` y recarga la página.
3. **Base de datos**: tipo MariaDB/MySQL, servidor `localhost`, nombre `mediawiki`, usuario `mediawiki` y la contraseña del paso 2. En la pantalla siguiente marca la opción de usar la misma cuenta que para la instalación.
4. **Nombre**: el nombre de la wiki y la cuenta de administrador (usuario, contraseña y correo).
5. **Opciones**: perfil de permisos (wiki abierta, solo usuarios registrados pueden editar, privada, etc.), subida de archivos, licencia y **extensiones**. Marca las que vayas a usar; el paquete incluye, entre otras, VisualEditor, ParserFunctions, Cite, CategoryTree y SyntaxHighlight.

Al finalizar, el instalador crea las tablas y te ofrece descargar `LocalSettings.php`, el archivo de configuración de la wiki. Descárgalo en tu equipo y súbelo al servidor desde tu máquina local:

```bash
scp LocalSettings.php your_user@your_server_ip:/tmp/
```

En el servidor, muévelo a la raíz de la wiki. Contiene la contraseña de la base de datos, así que solo root y el grupo `www-data` deben poder leerlo:

```bash
sudo mv /tmp/LocalSettings.php /var/www/mediawiki/LocalSettings.php
sudo chown root:www-data /var/www/mediawiki/LocalSettings.php
sudo chmod 640 /var/www/mediawiki/LocalSettings.php
```

Recarga `https://wiki.example.com`: verás la página principal de tu wiki. Inicia sesión con la cuenta de administrador y abre `Especial:Versión` (`https://wiki.example.com/index.php?title=Special:Version`) para confirmar la versión de MediaWiki, PHP y MariaDB, y las extensiones cargadas.

## Paso 7: Ajustar LocalSettings.php

Casi toda la configuración posterior se hace en `LocalSettings.php`. Ábrelo:

```bash
sudo nano /var/www/mediawiki/LocalSettings.php
```

Comprueba que `$wgServer` usa HTTPS y tu dominio:

```php
$wgServer = "https://wiki.example.com";
```

Las extensiones que marcaste en el instalador aparecen al final como llamadas a `wfLoadExtension()`. Para activar después otra extensión incluida en el paquete, añade su línea al final del archivo:

```php
wfLoadExtension( 'SyntaxHighlight_GeSHi' );
```

Para extensiones que no vienen en el paquete, descarga la rama que coincide con tu versión (en este caso `REL1_43`) en `/var/www/mediawiki/extensions/` y añade su `wfLoadExtension()`. Algunas extensiones necesitan además actualizar la base de datos:

```bash
cd /var/www/mediawiki
sudo -u www-data php maintenance/run.php update --quick
```

Comprueba de nuevo `Especial:Versión` para ver la extensión en la lista.

## Paso 8: Procesar la cola de trabajos con cron

MediaWiki deja en una cola tareas como actualizar enlaces o regenerar categorías, y por defecto las ejecuta durante las peticiones web. En una wiki con tráfico es mejor procesarlas en segundo plano. Desactiva la ejecución en peticiones añadiendo esta línea a `LocalSettings.php`:

```php
$wgJobRunRate = 0;
```

Crea un trabajo de cron del sistema que procese la cola cada cinco minutos como `www-data`:

```bash
sudo nano /etc/cron.d/mediawiki
```

```text
*/5 * * * * www-data /usr/bin/php /var/www/mediawiki/maintenance/run.php runJobs --maxtime=240 > /dev/null 2>&1
```

Comprueba que el comando funciona ejecutándolo a mano:

```bash
sudo -u www-data php /var/www/mediawiki/maintenance/run.php runJobs --maxtime=60
```

Si no hay trabajos pendientes, termina sin mostrar nada o con un resumen de las tareas procesadas.

## Paso 9: Programar copias de seguridad

Una copia útil de MediaWiki incluye la base de datos, el directorio `images` y `LocalSettings.php`. Crea un script para ello:

```bash
sudo nano /usr/local/sbin/mediawiki-backup
```

```bash
#!/usr/bin/env bash
set -euo pipefail

backup_dir="/var/backups/mediawiki"
wiki_dir="/var/www/mediawiki"
stamp="$(date +%Y%m%d-%H%M%S)"

mkdir -p "$backup_dir"

# Base de datos: root se autentica por socket, sin contraseña en el script
mariadb-dump --single-transaction --default-character-set=utf8mb4 mediawiki \
  | gzip > "$backup_dir/mediawiki-db-$stamp.sql.gz"

# Archivos subidos y configuración
tar -czf "$backup_dir/mediawiki-files-$stamp.tar.gz" \
  -C "$wiki_dir" images LocalSettings.php

# Conservar 14 días
find "$backup_dir" -type f -name 'mediawiki-*' -mtime +14 -delete
```

Hazlo ejecutable y pruébalo:

```bash
sudo chmod 750 /usr/local/sbin/mediawiki-backup
sudo /usr/local/sbin/mediawiki-backup
sudo ls -lh /var/backups/mediawiki
```

```output
-rw-r--r-- 1 root root 1.2M Sep 25 03:00 mediawiki-db-20260925-030000.sql.gz
-rw-r--r-- 1 root root  18M Sep 25 03:00 mediawiki-files-20260925-030000.tar.gz
```

Prográmalo cada noche a las 3:00:

```bash
echo '0 3 * * * root /usr/local/sbin/mediawiki-backup' | sudo tee /etc/cron.d/mediawiki-backup
```

Copia periódicamente `/var/backups/mediawiki` a otro servidor o a un almacenamiento externo: una copia en el mismo disco no te protege si pierdes el servidor.

## Solución de problemas

**Error 502 Bad Gateway.** Nginx no encuentra el socket de PHP-FPM. Comprueba que el servicio está activo con `systemctl status php8.3-fpm` y que la ruta del socket en la configuración es `/run/php/php8.3-fpm.sock`.

**No se pueden subir archivos.** Verifica que `$wgEnableUploads = true;` está en `LocalSettings.php`, que `images` pertenece a `www-data` y que los límites de `php.ini` y `client_max_body_size` son suficientes para el tamaño del archivo.

**Errores tras actualizar MediaWiki o una extensión.** Ejecuta el actualizador de esquema y revisa el registro de Nginx:

```bash
cd /var/www/mediawiki
sudo -u www-data php maintenance/run.php update --quick
sudo tail -n 50 /var/log/nginx/error.log
```

## Conclusión

Tienes MediaWiki funcionando en Ubuntu 24.04 con Nginx, PHP-FPM y MariaDB, servido por HTTPS, con la cola de trabajos en segundo plano y copias de seguridad diarias. Como siguientes pasos, configura URL cortas (por ejemplo `/wiki/Página`) con `$wgArticlePath`, ajusta los permisos de grupos con `$wgGroupPermissions` según quién deba poder editar, y configura el envío de correo con `$wgSMTP` para las notificaciones y la recuperación de contraseñas.