Installare MediaWiki con Nginx su CentOS 7: guida passo-passo

Questa guida mostra come installare MediaWiki su CentOS 7 usando Nginx, PHP-FPM e MariaDB (LEMP). Copre l’installazione dei pacchetti, la configurazione di PHP-FPM (socket), la creazione del database, l’ottenimento di certificati SSL gratis con Let’s Encrypt, la configurazione del virtual host Nginx e l’installazione web di MediaWiki. Include inoltre checklist, risoluzione dei problemi, hardening e suggerimenti per la produzione.

• Cosa faremo
• Prerequisiti
• Passo 1 — Installare Nginx su CentOS 7
• Passo 2 — Installare e configurare PHP-FPM
• Passo 3 — Installare e configurare MariaDB
• Passo 4 — Scaricare e preparare MediaWiki
• Passo 5 — Ottenere certificati SSL con Let’s Encrypt
• Passo 6 — Configurare il virtual host Nginx per MediaWiki
• Passo 7 — Installazione web di MediaWiki
• Passo 8 — Installare e attivare il tema predefinito (Vector)
• Controlli post-installazione e permessi
• Hardening, rinnovo automatico SSL e backup
• Risoluzione dei problemi comuni
• Checklist per ruolo (Amministratore di sistema, Sviluppatore, Operazioni)
• Quando scegliere alternative (Apache, SQLite)
• Esempi di test d’accettazione
• Domande frequenti
• Riepilogo

Cosa faremo

1. Installare Nginx su CentOS 7
2. Installare e configurare PHP-FPM (PHP 7.0 nel tutorial)
3. Installare e configurare MariaDB
4. Scaricare e configurare MediaWiki
5. Ottenere certificati SSL gratuiti con Let’s Encrypt
6. Configurare il virtual host Nginx per MediaWiki
7. Completare l’installazione via interfaccia web
8. Installare e attivare il tema Vector

Prerequisiti

• Un server CentOS 7 aggiornato
• Accesso root o utente con sudo
• Un nome di dominio puntato verso l’IP del server
• Porte 80 e 443 aperte (firewalld o equivalente)

Important: in questa guida i percorsi e gli utenti usati sono quelli tipici. Adatta i comandi al tuo ambiente (es. user/group: nginx o www-data a seconda della configurazione). Se usi SELinux, vedi la sezione SELinux più avanti.

Passo 1 — Installare Nginx su CentOS 7

Nginx non è incluso nei repository base di CentOS 7. Usiamo EPEL (Extra Packages for Enterprise Linux).

Aggiorna i pacchetti e installa EPEL:

yum -y update
yum -y install epel-release

Installa Nginx:

yum -y install nginx

Avvia e abilita Nginx all’avvio:

systemctl start nginx
systemctl enable nginx

Verifica le porte in ascolto:

netstat -plntu

Nota: su alcuni sistemi potresti usare ss invece di netstat.

Passo 2 — Installare e configurare PHP-FPM

Useremo PHP 7.0 come nell’esempio originale. Le versioni possono cambiare: prediligi versioni supportate e sicure (PHP 7.4, 8.x) in produzione.

Aggiungi il repository webtatic per PHP 7.0:

rpm -Uvh https://mirror.webtatic.com/yum/el7/webtatic-release.rpm

Installa PHP-FPM e le estensioni richieste:

yum -y install ImageMagick php70w-fpm php70w-intl php70w-xml php70w-curl php70w-gd php70w-mbstring php70w-mysql php70w-cli php70w-pear php70w-pecl-apcu

Configuriamo PHP-FPM per usare un socket UNIX, indicato per prestazioni locali con Nginx.

Modifica /etc/php.ini e imposta:

vim /etc/php.ini
# trovare e modificare:
cgi.fix_pathinfo=0

Poi modifica la pool www di PHP-FPM:

vim /etc/php-fpm.d/www.conf

Sostituisci user e group con nginx (o con l’utente usato dal tuo Nginx):

user = nginx
group = nginx

Imposta il listen su socket:

listen = /run/php-fpm/php-fpm.sock

Imposta proprietari e permessi del socket:

listen.owner = nginx
listen.group = nginx
listen.mode = 0660

Aggiungi variabili d’ambiente utili (decommenta):

env[HOSTNAME] = $HOSTNAME
env[PATH] = /usr/local/bin:/usr/bin:/bin
env[TMP] = /tmp
env[TMPDIR] = /tmp
env[TEMP] = /tmp

Crea la directory per le sessioni e assegna i permessi:

mkdir -p /var/lib/php/session/
chown -R nginx:nginx /var/lib/php/session/

Avvia e abilita PHP-FPM:

systemctl start php-fpm
systemctl enable php-fpm

Verifica il socket:

netstat -pl | grep php

Note rapide:

• Se preferisci, PHP-FPM può ascoltare su TCP (127.0.0.1:9000). Usa il socket per meno overhead locale.
• Se usi SELinux, applica i context corretti per /run/php-fpm e /var/lib/php/session (vedi sezione SELinux).

Passo 3 — Installare e configurare MariaDB

MediaWiki supporta MySQL/MariaDB e SQLite. Per una installazione multiutente e produzione, MariaDB/MySQL è preferibile.

Installa MariaDB:

yum -y install mariadb mariadb-server

Avvia e abilita il servizio:

systemctl start mariadb
systemctl enable mariadb

Esegui la configurazione sicura:

mysql_secure_installation

Rispondi alle richieste (consigliato accettare le opzioni predefinite di sicurezza).

Crea il database e l’utente per MediaWiki (esempio):

mysql -u root -p
# inserisci la password root
create database mediawikidb;
grant all privileges on mediawikidb.* to mediawiki@'localhost' identified by 'mypassword';
flush privileges;
exit;

Sostituisci mediawikidb, mediawiki e mypassword con valori più sicuri. Non usare password deboli in produzione.

Nota di sicurezza: limitare l’accesso remoto al DB e usare password complesse. Valuta l’uso di utenti con privilegi ridotti per operazioni normali.

Passo 4 — Scaricare e preparare MediaWiki

Installa git, zip, unzip e composer:

yum -y install git zip unzip composer

Crea la cartella di destinazione e clona il codice sorgente:

mkdir -p /var/www/mediawiki
git clone https://gerrit.wikimedia.org/r/p/mediawiki/core.git /var/www/mediawiki

Installa le dipendenze PHP con composer (senza dev):

cd /var/www/mediawiki
composer install --no-dev

Imposta i permessi (esempio con nginx):

chown -R nginx:nginx /var/www/mediawiki

Note su permessi: MediaWiki richiede che alcune cartelle siano scrivibili (es. images, cache, localisations). In questa guida usiamo nginx:nginx come user di processo di PHP-FPM e Nginx. Alcuni tutorial usano www-data; assicurati che l’utente del processo web corrisponda ai permessi del filesystem.

Passo 5 — Ottenere certificati SSL con Let’s Encrypt

MediaWiki dovrebbe essere servito via HTTPS. Usiamo Let’s Encrypt per certificati gratuiti.

Installa il client Let’s Encrypt (certbot o letsencrypt):

yum -y install letsencrypt

Prima di emettere il certificato, arresta Nginx (il client può usare un server temporaneo) e assicurati che le porte 80/443 siano permesse:

systemctl stop nginx
firewall-cmd --add-service=http --permanent
firewall-cmd --add-service=https --permanent
firewall-cmd --reload

Genera il certificato:

letsencrypt certonly

Segui la procedura: scegli l’opzione per il server temporaneo (spin temporary web server), inserisci email, accetta i termini e indica il tuo dominio (es. wiki.tuodominio.example).

Dopo il successo, troverai i certificati in /etc/letsencrypt/live/tuodominio.example/

Rinnovo automatico: Let’s Encrypt scade ogni 90 giorni. Il client certbot/letsencrypt offre meccanismi di rinnovo. Vedi la sezione Rinnovo automatico più avanti.

Passo 6 — Configurare il virtual host Nginx per MediaWiki

Crea un file di configurazione Nginx in /etc/nginx/conf.d/mediawiki.conf e incolla la configurazione riportata. Adatta server_name e path dei certificati al tuo dominio.

# HTTP Request will be Redirected to the HTTPS
server {
    listen 80;
    listen [::]:80;
    server_name wiki.hakase-labs.co;
    return 301 https://$host$request_uri;
}

# HTTPS Configuration
server {

    listen 443 ssl;
    listen [::]:443;
    
    server_name wiki.hakase-labs.co;
    root /var/www/mediawiki;

    index index.php;
    autoindex off;

    # SSL Certificate Configuration
    ssl_certificate /etc/letsencrypt/live/wiki.hakase-labs.co/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/wiki.hakase-labs.co/privkey.pem;

    client_max_body_size 5m;
    client_body_timeout 60;

    location / {
        try_files $uri $uri/ @rewrite;
    }

    location @rewrite {
        rewrite ^/(.*)$ /index.php?title=$1&$args;
    }

    location ^~ /maintenance/ {
        return 403;
    }

    # PHP-FPM Configuration Nginx
    location ~ \.php$ {
        try_files $uri =404;
        fastcgi_split_path_info ^(.+\.php)(/.+)$;
        fastcgi_pass unix:/run/php-fpm/php-fpm.sock;
        fastcgi_index index.php;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        include fastcgi_params;
    }

    location ~* \.(js|css|png|jpg|jpeg|gif|ico)$ {
        try_files $uri /index.php;
        expires max;
        log_not_found off;
    }

    location = /_.gif {
        expires max;
        empty_gif;
    }

    location ^~ ^/(cache|includes|maintenance|languages|serialized|tests|images/deleted)/ {
        deny all;
    }

    location ^~ ^/(bin|docs|extensions|includes|maintenance|mw-config|resources|serialized|tests)/ {
        internal;
    }

    # Security for 'image' directory
    location ~* ^/images/.*.(html|htm|shtml|php)$ {
        types { }
        default_type text/plain;
    }

    # Security for 'image' directory
    location ^~ /images/ {
        try_files $uri /index.php;
    }

}

Note importanti:

• Sostituisci wiki.hakase-labs.co con il tuo dominio.
• Aggiorna i percorsi dei certificati se diversi.

Testa la configurazione e riavvia Nginx:

nginx -t
systemctl restart nginx

Passo 7 — Installazione web di MediaWiki

Apri il browser e vai a:

http://wiki.hakase-labs.co/

Verrai reindirizzato a HTTPS. Clicca “Set up the wiki” e segui i passi.

Scelte comuni durante l’installazione web

• Lingua: scegli la lingua principale del tuo wiki
• Controlli ambiente: assicurati che tutti i requisiti siano soddisfatti
• Database: usa i dati creati (mediawikidb, mediawiki, mypassword)
• Configurazioni predefinite: in genere vanno bene per una prima installazione
• Utente amministratore: crea un account amministratore

Esempi di schermate (solo riferimento visivo):

Al termine, scarica il file LocalSettings.php e posizionalo nella directory /var/www/mediawiki.

Esempio di copia dal client locale verso il server (SCP):

scp LocalSettings.php [email protected]:/var/www/mediawiki/

Attenzione: nel testo originale si suggerisce di impostare ownership su www-data. Se sul tuo server stai usando nginx:nginx, cambia la proprietà coerentemente:

# Se usi nginx come user web
chown -R nginx:nginx /var/www/mediawiki

Ricarica la pagina del wiki e clicca “enter your wiki”.

Passo 8 — Installare e attivare il tema predefinito (Vector)

Clona il tema Vector nella cartella skins:

cd /var/www/mediawiki/skins/
sudo git clone https://gerrit.wikimedia.org/r/mediawiki/skins/Vector

Assegna i permessi:

chown -R nginx:nginx /var/www/mediawiki/skins/

Aggiungi la riga di caricamento del tema in LocalSettings.php:

vim /var/www/mediawiki/LocalSettings.php
# alla fine del file aggiungi:
wfLoadSkin( 'Vector' );

Ricarica la pagina del wiki per verificare il tema attivo.

Controlli post-installazione e permessi

• Assicurati che le directory images e cache siano scrivibili dall’utente web
• Controlla error_log di Nginx e php-fpm se qualcosa non funziona
• Testa upload di immagini e creazione di pagine

Comandi utili per permessi:

chown -R nginx:nginx /var/www/mediawiki
chmod -R 750 /var/www/mediawiki
chmod -R 770 /var/www/mediawiki/images

Nota: evita permessi 777 in produzione.

Hardening e suggerimenti di produzione

• Forza HTTPS con redirect 301 (già presente nella configurazione Nginx)
• Aggiungi header di sicurezza (esempio):

add_header X-Frame-Options "SAMEORIGIN";
add_header X-Content-Type-Options "nosniff";
add_header Referrer-Policy "no-referrer-when-downgrade";
add_header Strict-Transport-Security "max-age=31536000; includeSubDomains; preload";

• Disabilita o limita l’accesso SSH con chiavi public-key
• Mantieni aggiornati OS, PHP, Nginx e MediaWiki
• Esegui backup regolari del database e della cartella /var/www/mediawiki
• Considera di usare un sistema di caching (Redis, memcached) per migliorare le prestazioni

SELinux

Se SELinux è abilitato, potresti dover applicare i context corretti:

# esempio per permettere a nginx/php-fpm di scrivere in /var/www/mediawiki
semanage fcontext -a -t httpd_sys_rw_content_t "/var/www/mediawiki(/.*)?"
restorecon -Rv /var/www/mediawiki

Aggiungi anche i boolean necessari per permettere a Nginx di connettersi al socket/unix

setsebool -P httpd_can_network_connect on
setsebool -P httpd_execmem on

Verifica gli avvisi di SELinux tramite audit2why o journalctl.

Rinnovo automatico dei certificati Let’s Encrypt

Un metodo comune è aggiungere un cron job che esegue il rinnovo e riavvia Nginx se necessario.

Esempio crontab su root (controlla la strada del tuo client):

0 3 * * * /usr/bin/letsencrypt renew --quiet --renew-hook "systemctl reload nginx"

Oppure con certbot:

0 3 * * * /usr/bin/certbot renew --quiet --deploy-hook "systemctl reload nginx"

Testa il rinnovo con –dry-run prima di affidarti al cron.

Backup consigliati

• Backup del database (mysqldump o strumenti di replica):

mysqldump -u root -p mediawikidb > /root/backups/mediawikidb-$(date +%F).sql

• Backup dei file di configurazione e della cartella images:

tar -czf /root/backups/mediawiki-files-$(date +%F).tar.gz /var/www/mediawiki

Automatizza backup e verifica recovery periodica.

Risoluzione dei problemi comuni

• Pagina bianca o 500: controlla /var/log/nginx/error.log e /var/log/php-fpm/www-error.log
• 502 Bad Gateway: verifica che PHP-FPM sia in esecuzione e che il percorso del socket corrisponda
• Errori di permessi su upload: verifica owner/group delle cartelle images e cache
• Certificato scaduto: controlla certbot renew –dry-run e i log del cron

Checklist per ruolo

Amministratore di sistema:

• Aggiorna e patcha OS
• Configura firewall e SELinux
• Monitora servizi e log

Sviluppatore/Estensioni:

• Installa estensioni in una sandbox
• Verifica compatibilità con la versione di MediaWiki

Operazioni/DevOps:

• Implementa backup e restore testati
• Configura alert su errori critici (DB down, spazio su disco)

Quando scegliere alternative

• Apache + PHP-FPM: se hai bisogno di mod_php o di configurazioni legacy
• SQLite: adatto per wiki piccoli o test, non consigliato per produzione con molti utenti

Decisione rapida (diagramma):

flowchart TD
  A[Hai molti utenti concorrenti?] -->|Sì| B[Usa MariaDB/MySQL]
  A -->|No| C[SQLite è accettabile]
  B --> D[Usa Nginx + PHP-FPM con socket]
  C --> D
  D --> E{Hai esigenze di caching?}
  E -->|Sì| F[Aggiungi Redis/Memcached]
  E -->|No| G[Passive caching sufficiente]

Esempi di test d’accettazione

• Creazione di un account amministratore e login riuscito
• Creazione di pagina, modifica, e cronologia che registra modifiche
• Caricamento di immagine e visualizzazione corretta
• Controllo HTTPS valido con certificato non scaduto

FAQ

È necessario usare PHP 7.0 esattamente?

No. Questo tutorial usa PHP 7.0 per coerenza con l’originale. Preferisci versioni più recenti e supportate per sicurezza e prestazioni.

Posso usare MySQL invece di MariaDB?

Sì. MediaWiki è compatibile sia con MySQL che con MariaDB.

Devo usare socket UNIX per PHP-FPM?

Il socket UNIX è consigliato per comunicazioni locali con meno overhead. TCP è utile se PHP-FPM è su un host separato.

Come rinnovare automaticamente i certificati Let’s Encrypt?

Imposta un cron job che esegua certbot renew –deploy-hook “systemctl reload nginx” e verifica con –dry-run.

Riepilogo

• Hai installato Nginx, PHP-FPM e MariaDB.
• Hai scaricato e attivato MediaWiki e il tema Vector.
• Hai ottenuto certificati SSL da Let’s Encrypt e configurato Nginx per HTTPS.
• Sono incluse sezioni su hardening, rinnovo automatico, backup e risoluzione dei problemi.

Note finali:

• Adatta utenti e permessi in base alla tua distribuzione e alle tue policy di sicurezza.
• Testa restore e rinnovi prima della messa in produzione.

Riferimenti

• https://www.mediawiki.org/wiki/