Tutoriais de VPS
Moodle na VPS: Docker completo, HTTPS e recuperação
Construa imagem Moodle/PHP com PostgreSQL, Redis e inicialização privada. Configure HTTPS, arquivos, cron, e-mail e backups coerentes, revisando suporte das versões.

Moodle organiza cursos, treinamento, avaliações e acesso a materiais. Hospedar permite controlar arquivos, usuários e plugins; os custos passam para infraestrutura, manutenção e recuperação.
Usamos Ubuntu 24.04/Compose, PostgreSQL, Redis, HTTPS, cron e e-mail. O exemplo Bitnami 4.5 original está incompleto. A alternativa usa Moodle 4.5.16 verificado, PHP 8.3 Apache oficial e PostgreSQL 16.16. Moodle 4.5 encerrou suporte geral de bugs: confira prazo de segurança e planeje migração. Para site novo avalie release com suporte completo e requisitos PHP/banco/document-root; não copie este desenho 4.5 para versões com subdiretório public. Veja requisitos.
| Uso | CPU | RAM | Disco | Nota |
|---|---|---|---|---|
| Teste pessoal | 2 vCPU | 4 GB | 50 GB SSD | Poucos cursos, sem excesso de debug |
| Treinamento pequeno | 4 vCPU | 8 GB | 100 GB NVMe | Backup externo e Redis deliberado |
| Várias turmas | 8 vCPU | 16 GB+ | 200 GB NVMe+ | Avaliar banco/arquivos separados |
São referências. Vídeo costuma exigir armazenamento/plataforma separada. Configure A/AAAA de learn.example.com, publique administração/80/443 necessários e mantenha PostgreSQL/Redis/PHP-FPM privados. Conte moodledata, banco, temporários e recuperação na capacidade.
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
Revise instalador e use Docker suportado. Evite latest; registre commit/digests e docker compose config privado. Confira disponibilidade/suporte Bitnami: imagem arquivada não fornece patches contínuos.
A alternativa inclui moodle, postgres, redis e cron atrás do Nginx. Código vai na imagem; arquivos/banco, em volumes. É instalação nova; dados Bitnami existentes exigem migrar caminhos, permissões e banco.
Variáveis originais de referência:
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
Troque MOODLE_IMAGE por local/moodle:4.5.16, defina senhas diferentes, hostname, nome local do site e e-mail real. Credenciais iniciais são definidas no CLI, não por variáveis de outra imagem. POSTGRES_IMAGE antigo não altera imagens explícitas do YAML novo.
Moodle 4.5 admite PostgreSQL desde 13 e PHP 8.1-8.3 com extensões; 14+ original não era mínimo universal. Usamos PostgreSQL 16 corrigido. Crie Dockerfile em /opt/moodle e fixe digest PHP revisado antes de produção:
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/
Crie /opt/moodle/config.php, deixando moodledata fora do 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');
O Compose original não encaminha variáveis de aplicação/banco e usa caminhos de outra imagem:
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:
Substitua compose/docker-compose.yml pela alternativa completa; não misture desenhos:
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:
Não publica banco/cache. Redis guarda sessões; cursos/tarefas continuam no PostgreSQL. Configure cache da aplicação separadamente no Moodle e meça capacidade real.
Sequência original para imagens 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
Na imagem local, carregue .env explícito, construa aplicação e baixe dependências. Confira docker compose config e extensões:
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
Exclua segredos de build/Git. Revise commit e requisitos antes de inicializar.
O método original abre http://127.0.0.1:8080, escolhe postgres e conserva moodledata; moodledata não deve ser acessível pela web. Aqui use 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
Escolha senha forte sem histórico e confira cada saída. Verificações originais:
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
Na imagem nova, use /var/www/html/admin/cli e www-data para tarefas que escrevem arquivos. Configure categorias, professor/aluno e privacidade antes de importar. Ensine com conta cotidiana, sem administrador; limite auxiliares/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
Uma entrada ocupa 80/443 e app usa 8080 privada. Teste URL HTTPS, headers confiáveis, renovação, login, downloads e upload representativo. Combine upload_max_filesize, post_max_size e limite Moodle com Nginx e overhead multipartes. Arquivo de 240 MB deixa margem em requisição de 256 MB. Veja Caddy.
Cron da alternativa executa aproximadamente por minuto com mesmo código/config/arquivos. Monitore logs e última execução válida; tarefas longas exigem medição. 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
É linha para crontab, não Bash. Escolha um scheduler. Se usar host cron, pare contêiner cron, acrescente env-file/caminho absoluto/usuário correto e preserve erros nos logs.
Configure Redis autenticado para sessões/cache; números de banco não isolam permissões. Confira workers PHP/SQL lento, depois disco/cache. Use CDN/objetos/vídeo compatíveis para mídia pesada, com acesso controlado e custo de saída.
Teste e-mail para reset, cursos, fóruns e tarefas. SPF/DKIM/DMARC atendem remetente; PTR pertence ao servidor de saída real. Confira relógio, TLS e provedor.
- MFA administrativo suportado e contas diárias separadas.
- Professores restritos às turmas; auditoria somente leitura.
- Desative cadastro/convidados/plugins sem uso.
- Integrações com conta/token limitado e rotação.
- Teste controles de login, retenção e avisos de segurança.
Instale plugins confiáveis e compatíveis; teste atualizações e retire dependências abandonadas.
Copie PostgreSQL, código/configuração, moodledata, plugins e Compose. Só banco não recupera envios/anexos/avatares. Esboço 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
Adapte caminho para /var/moodledata, não /bitnami/moodledata. Pare escritas web/cron, use conta/banco reais, pipefail, timestamps únicos, permissões e gzip/hashes. Inclua config.php, Dockerfile, commit/plugins, .env e Compose real. .env não é exportado ao shell; não aceite dump falho com usuário vazio.
Guarde cópia externa criptografada. Restauração mensal isola versões, desativa e-mail/integrações reais e valida login, cursos, arquivos, avaliações e cron.
- Ative manutenção e pare escritas/tarefas.
- Copie banco,
moodledata, configuração, plugins e imagens juntos. - Confira PHP/banco/tema/plugins alvo e teste backup restaurado.
- Construa imagem alvo com tag diferente e execute upgrade em manutenção.
- Teste login/cursos/arquivos/e-mail/cache/tarefas antes de sair da manutenção.
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 pressupõe imagem de registro; alternativa local exige checkout/build anterior. Adapte caminhos/usuário e adie desativar manutenção até validar. Trocar imagem não reverte banco migrado; restaure banco/arquivos/config anteriores.
Confira Nginx/8080 privada, contêiner, PHP/banco, memória e workers. Não aumente concorrência sem medir.
Confira client_max_body_size, upload_max_filesize, post_max_size, limite Moodle, disco e timeout.
Confira SMTP/DNS/saída e admin/cli/cron.php com caminho/usuário corretos. Veja tarefas, cache e recursos; não apague pendências.
Confira moodledata, backups de cursos, temporários, logs, WAL e imagens. Confirme cópia externa antes de apagar.
- Aplicação, banco, Redis e entrada funcionam com versões deliberadas.
- HTTPS, headers e uploads testados.
- Um scheduler executa cron e sessões/cache Redis foram testados.
- SMTP, reset, avisos e uploads reais funcionam.
- MFA e papéis mínimos de cursos/auditoria validados.
- Banco,
moodledata, configuração e plugins têm backup externo. - Recuperação isolada medida e documentada.
Comece com arquivos/banco/e-mail/recuperação; acrescente mídia externa e automação depois de validar.
Leituras: