Tutoriales de VPS
Moodle en un VPS: Docker completo, HTTPS y recuperación
Construye imagen Moodle/PHP con PostgreSQL, Redis e inicialización privada. Configura HTTPS, archivos, cron, correo y copias coherentes, revisando soporte de versiones.

Moodle organiza cursos, formación, evaluaciones y acceso a materiales. Alojarlo permite controlar archivos, usuarios y plugins; los costes pasan a infraestructura, mantenimiento y recuperación.
Usamos Ubuntu 24.04/Compose, PostgreSQL, Redis, HTTPS, cron y correo. El fragmento Bitnami 4.5 original es incompleto. La alternativa usa Moodle 4.5.16 verificado, PHP 8.3 Apache oficial y PostgreSQL 16.16. Moodle 4.5 terminó soporte general de errores: revisa plazo de seguridad y planifica migración. Para sitio nuevo evalúa release con soporte completo y requisitos PHP/base/document-root; no copies este diseño 4.5 a versiones con subdirectorio public. Consulta requisitos.
| Uso | CPU | RAM | Disco | Nota |
|---|---|---|---|---|
| Prueba personal | 2 vCPU | 4 GB | 50 GB SSD | Pocos cursos, sin exceso de debug |
| Formación pequeña | 4 vCPU | 8 GB | 100 GB NVMe | Copia externa y Redis deliberado |
| Varias clases | 8 vCPU | 16 GB+ | 200 GB NVMe+ | Evaluar base/archivos separados |
Son referencias. Vídeo suele requerir almacenamiento/plataforma aparte. Configura A/AAAA de learn.example.com, publica administración/80/443 necesarios y deja PostgreSQL/Redis/PHP-FPM privados. Cuenta moodledata, base, temporales y recuperación en capacidad.
sudo apt update
sudo apt install -y ca-certificates curl git openssl
curl -fsSL https://get.docker.com | sudo sh
sudo usermod -aG docker "$USER"
newgrp docker
sudo mkdir -p /opt/moodle
sudo chown -R "$USER":"$USER" /opt/moodle
cd /opt/moodle
mkdir -p compose moodledata backups
touch compose/docker-compose.yml .env
chmod 600 .env
Revisa instalador y usa Docker soportado. Evita latest; registra commit/digests y docker compose config privado. Verifica disponibilidad/soporte Bitnami: imagen archivada no aporta parches continuos.
La alternativa incluye moodle, postgres, redis y cron detrás de Nginx. Código va en imagen; archivos/base, en volúmenes. Es para instalación nueva; datos Bitnami existentes requieren migrar rutas, permisos y base.
Variables originales de referencia:
MOODLE_IMAGE=bitnami/moodle:4.5
POSTGRES_IMAGE=postgres:16
POSTGRES_DB=moodle
POSTGRES_USER=moodle
POSTGRES_PASSWORD=change-a-long-database-password
REDIS_PASSWORD=change-a-long-redis-password
MOODLE_HOST=learn.example.com
MOODLE_SITE_NAME=企业学习平台
MOODLE_ADMIN_USER=admin
MOODLE_ADMIN_PASSWORD=change-a-long-admin-password
[email protected]
openssl rand -base64 48
openssl rand -hex 32
Cambia MOODLE_IMAGE a local/moodle:4.5.16, define contraseñas diferentes, hostname, nombre local del sitio y correo real. Credenciales iniciales se fijan por CLI, no por variables específicas de otra imagen. POSTGRES_IMAGE antiguo no modifica las imágenes explícitas del YAML nuevo.
Moodle 4.5 admite PostgreSQL desde 13 y PHP 8.1-8.3 con extensiones; 14+ original no era mínimo universal. Usamos PostgreSQL 16 parcheado. Crea Dockerfile en /opt/moodle y fija digest PHP revisado antes de producción:
FROM php:8.3-apache-bookworm
RUN apt-get update && apt-get install -y --no-install-recommends \
libpq-dev libicu-dev libzip-dev libpng-dev libjpeg62-turbo-dev \
libfreetype6-dev libonig-dev libxml2-dev \
&& docker-php-ext-configure gd --with-freetype --with-jpeg \
&& docker-php-ext-install -j2 pgsql intl zip gd soap mbstring opcache exif \
&& pecl install redis-6.3.0 \
&& docker-php-ext-enable redis \
&& rm -rf /var/lib/apt/lists/*
RUN printf '%s\n' 'max_input_vars=5000' 'upload_max_filesize=240M' \
'post_max_size=256M' 'memory_limit=256M' 'opcache.enable=1' \
> /usr/local/etc/php/conf.d/moodle.ini \
&& mkdir -p /var/moodledata \
&& chown www-data:www-data /var/moodledata \
&& chmod 770 /var/moodledata
COPY moodle-code/ /var/www/html/
Crea /opt/moodle/config.php, dejando moodledata fuera del document-root:
<?php
unset($CFG);
global $CFG;
$CFG = new stdClass();
$CFG->dbtype = 'pgsql';
$CFG->dblibrary = 'native';
$CFG->dbhost = 'postgres';
$CFG->dbname = getenv('POSTGRES_DB');
$CFG->dbuser = getenv('POSTGRES_USER');
$CFG->dbpass = getenv('POSTGRES_PASSWORD');
$CFG->prefix = 'mdl_';
$CFG->dboptions = ['dbpersist' => false, 'dbport' => 5432, 'dbsocket' => ''];
$CFG->wwwroot = 'https://' . getenv('MOODLE_HOST');
$CFG->dataroot = '/var/moodledata';
$CFG->admin = 'admin';
$CFG->directorypermissions = 02770;
$CFG->sslproxy = true;
$CFG->session_handler_class = '\core\session\redis';
$CFG->session_redis_host = 'redis';
$CFG->session_redis_port = 6379;
$CFG->session_redis_database = 0;
$CFG->session_redis_auth = getenv('REDIS_PASSWORD');
$CFG->session_redis_prefix = 'moodle45_session:';
require_once(__DIR__ . '/lib/setup.php');
El Compose original carece de variables de aplicación/base y usa rutas de otra imagen:
services:
postgres:
image: postgres:16
restart: unless-stopped
environment:
POSTGRES_DB: ${POSTGRES_DB}
POSTGRES_USER: ${POSTGRES_USER}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
volumes:
- postgres_data:/var/lib/postgresql/data
redis:
image: redis:7-alpine
command: ["redis-server", "--requirepass", "${REDIS_PASSWORD}"]
restart: unless-stopped
volumes:
- redis_data:/data
moodle:
image: ${MOODLE_IMAGE}
restart: unless-stopped
depends_on:
- postgres
- redis
ports:
- "127.0.0.1:8080:8080"
volumes:
- moodle_data:/bitnami/moodle
- moodle_files:/bitnami/moodledata
volumes:
postgres_data:
redis_data:
moodle_data:
moodle_files:
Reemplaza compose/docker-compose.yml por la alternativa completa; no mezcles diseños:
name: moodle45
x-moodle: &moodle
image: ${MOODLE_IMAGE:?Set a versioned local image}
build:
context: ..
env_file: ../.env
restart: unless-stopped
volumes:
- ../config.php:/var/www/html/config.php:ro
- moodle_files:/var/moodledata
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_started
services:
postgres:
image: postgres:16.16
restart: unless-stopped
environment:
POSTGRES_DB: ${POSTGRES_DB:?Define database}
POSTGRES_USER: ${POSTGRES_USER:?Define user}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Define password}
volumes:
- postgres_data:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U $$POSTGRES_USER -d $$POSTGRES_DB"]
interval: 10s
timeout: 5s
retries: 10
redis:
image: redis:8.6.8
command: ["redis-server", "--requirepass", "${REDIS_PASSWORD:?Define password}", "--maxmemory", "256mb", "--maxmemory-policy", "noeviction"]
restart: unless-stopped
volumes:
- redis_data:/data
moodle:
<<: *moodle
ports:
- "127.0.0.1:8080:80"
cron:
<<: *moodle
user: www-data
command: ["sh", "-c", "while :; do php /var/www/html/admin/cli/cron.php; sleep 60; done"]
volumes:
postgres_data:
redis_data:
moodle_files:
No publica base/caché. Redis guarda sesiones; cursos/tareas siguen en PostgreSQL. Configura caché de aplicación aparte en Moodle y mide capacidad real.
Secuencia original para imágenes de registro:
docker compose -f compose/docker-compose.yml config
docker compose -f compose/docker-compose.yml pull
docker compose -f compose/docker-compose.yml up -d
docker compose -f compose/docker-compose.yml ps
En esta imagen local, carga .env explícito, construye aplicación y descarga dependencias. Comprueba docker compose config y extensiones:
cd /opt/moodle
git clone --depth 1 --branch v4.5.16 https://github.com/moodle/moodle.git moodle-code
git -C moodle-code rev-parse HEAD
printf '%s\n' '.env' 'backups' 'moodledata' 'moodle-code/.git' > .dockerignore
chmod 600 .env
chmod 644 config.php
docker compose --env-file .env -f compose/docker-compose.yml config --quiet
docker compose --env-file .env -f compose/docker-compose.yml build --pull moodle
docker compose --env-file .env -f compose/docker-compose.yml pull postgres redis
docker compose --env-file .env -f compose/docker-compose.yml up -d postgres redis moodle
docker compose --env-file .env -f compose/docker-compose.yml exec --user www-data moodle php -m
Excluye secretos de build/Git. Revisa commit y requisitos antes de inicializar.
El método original abre http://127.0.0.1:8080, elige postgres y conserva moodledata; moodledata no debe ser accesible por web. Aquí usa CLI privado antes de abrir Nginx:
read -rsp 'Moodle administrator password: ' MOODLE_FIRST_ADMIN_PASSWORD
printf '\n'
export MOODLE_FIRST_ADMIN_PASSWORD
docker compose --env-file .env -f compose/docker-compose.yml exec -T \
--user www-data -e MOODLE_FIRST_ADMIN_PASSWORD moodle sh -c \
'php /var/www/html/admin/cli/install_database.php --agree-license \
--adminuser=admin --adminpass="$MOODLE_FIRST_ADMIN_PASSWORD" \
--adminemail="$MOODLE_ADMIN_EMAIL" --fullname="$MOODLE_SITE_NAME" --shortname=Training'
unset MOODLE_FIRST_ADMIN_PASSWORD
docker compose --env-file .env -f compose/docker-compose.yml exec --user www-data moodle \
php /var/www/html/admin/cli/cfg.php --name=wwwroot
docker compose --env-file .env -f compose/docker-compose.yml exec --user www-data moodle \
php /var/www/html/admin/cli/cron.php
docker compose --env-file .env -f compose/docker-compose.yml up -d cron
Elige contraseña fuerte sin historial y verifica cada salida. Comprobaciones originales:
docker compose -f compose/docker-compose.yml exec moodle php admin/cli/cfg.php --name=wwwroot
docker compose -f compose/docker-compose.yml exec moodle php admin/cli/cron.php
En imagen nueva usa /var/www/html/admin/cli y www-data para tareas que escriben archivos. Configura categorías, profesor/alumno y privacidad antes de importar. Enseña con cuenta cotidiana, no administrador; limita asistentes/auditores.
sudo apt install -y nginx certbot python3-certbot-nginx
sudo nano /etc/nginx/sites-available/moodle
server {
listen 80;
server_name learn.example.com;
client_max_body_size 256m;
location / {
proxy_pass http://127.0.0.1:8080;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
}
sudo ln -s /etc/nginx/sites-available/moodle /etc/nginx/sites-enabled/moodle
sudo nginx -t
sudo systemctl reload nginx
sudo certbot --nginx -d learn.example.com
Una entrada ocupa 80/443 y app usa 8080 privado. Prueba URL HTTPS, headers confiables, renovación, login, descargas y subida representativa. Coordina upload_max_filesize, post_max_size y límite Moodle con Nginx y overhead multipartes. 240 MB por archivo deja margen bajo 256 MB por solicitud. Consulta Caddy.
Cron de la alternativa ejecuta aproximadamente cada minuto con mismo código/config/archivos. Vigila logs y última ejecución válida; tareas largas requieren medir. Alternativa original de crontab:
* * * * * cd /opt/moodle && docker compose -f compose/docker-compose.yml exec -T moodle php admin/cli/cron.php >/dev/null 2>&1
Es una línea para crontab, no Bash. Elige un solo scheduler. Si usas host cron, detén contenedor cron, añade env-file/ruta absoluta/usuario correcto y conserva errores en logs.
Configura Redis autenticado para sesiones y caché; números de base no aíslan permisos. Revisa workers PHP/SQL lento, después disco/caché. Usa CDN/objetos/vídeo compatibles para medios pesados, con control de acceso y coste de salida.
Prueba correo para reset, cursos, foros y tareas. SPF/DKIM/DMARC corresponden al remitente; PTR al servidor de salida real. Verifica reloj, TLS y proveedor.
- MFA administrativo soportado y cuentas diarias separadas.
- Profesores limitados a cursos asignados; auditoría solo lectura.
- Desactiva registro/invitados/plugins sin uso.
- Integraciones con cuenta/token limitado y rotación.
- Prueba controles de login, retención y avisos de seguridad.
Instala plugins confiables y compatibles; prueba actualizaciones y retira dependencias abandonadas.
Copia PostgreSQL, código/configuración, moodledata, plugins y Compose. Solo base no recupera entregas/adjuntos/avatares. Esquema original:
mkdir -p /opt/moodle/backups
docker compose -f compose/docker-compose.yml exec -T postgres pg_dump -U "$POSTGRES_USER" "$POSTGRES_DB" | gzip > /opt/moodle/backups/moodle-$(date +%F).sql.gz
docker compose -f compose/docker-compose.yml cp moodle:/bitnami/moodledata /opt/moodle/backups/moodledata-$(date +%F)
cp .env compose/docker-compose.yml /opt/moodle/backups/
docker compose -f compose/docker-compose.yml config > /opt/moodle/backups/compose-$(date +%F).yaml
Adapta ruta a /var/moodledata, no /bitnami/moodledata. Detén escrituras web/cron, usa cuenta/base reales, pipefail, timestamps únicos, permisos y gzip/hashes. Incluye config.php, Dockerfile, commit/plugins, .env y Compose real. .env no se exporta al shell; no aceptes dump fallido con usuario vacío.
Guarda copia externa cifrada. Restauración mensual aísla versiones, desactiva correo/integraciones reales y verifica login, cursos, archivos, evaluaciones y cron.
- Activa mantenimiento y detén escrituras/tareas.
- Copia base,
moodledata, configuración, plugins e imágenes juntos. - Verifica PHP/base/tema/plugins objetivo y prueba copia restaurada.
- Construye imagen objetivo con tag distinto y ejecuta upgrade durante mantenimiento.
- Prueba login/cursos/archivos/correo/caché/tareas antes de salir del mantenimiento.
docker compose -f compose/docker-compose.yml exec moodle php admin/cli/maintenance.php --enable
docker compose -f compose/docker-compose.yml pull
docker compose -f compose/docker-compose.yml up -d
docker compose -f compose/docker-compose.yml exec moodle php admin/cli/upgrade.php --non-interactive
docker compose -f compose/docker-compose.yml exec moodle php admin/cli/maintenance.php --disable
Pull original presupone imagen de registro; alternativa local requiere checkout/build previo. Adapta rutas/usuario y pospone desactivar mantenimiento hasta verificar. Cambiar imagen no revierte una base migrada; restaura base/archivos/config previos.
Revisa Nginx/8080 privado, contenedor, PHP/base, memoria y workers. No aumentes concurrencia sin medir.
Comprueba client_max_body_size, upload_max_filesize, post_max_size, límite Moodle, disco y timeout.
Revisa SMTP/DNS/salida y admin/cli/cron.php con ruta/usuario correctos. Mira tareas, caché y recursos; no borres pendientes.
Comprueba moodledata, copias de cursos, temporales, logs, WAL e imágenes. Confirma copia externa antes de borrar.
- Aplicación, base, Redis y entrada funcionan con versiones deliberadas.
- HTTPS, headers y uploads probados.
- Un scheduler ejecuta cron y sesiones/caché Redis se han probado.
- SMTP, reset, avisos y uploads reales funcionan.
- MFA y roles mínimos de cursos/auditoría verificados.
- Base,
moodledata, configuración y plugins tienen copia externa. - Recuperación aislada medida y documentada.
Empieza con archivos/base/correo/recuperación; añade medios externos y automatización después de verificar.
Lecturas: