WordCamp Pisa 2026: dal modello a WordPress, la guida completa

Questa è la pagina del mio talk al WordCamp Pisa 2026, Dal modello a WordPress: MLOps con AI locale (sabato 14 novembre, ore 15:15, Track 2). Qui trovi tutto quello che ho fatto sul palco, passo per passo: i comandi, i file completi e i prompt che ho dato all’agente.

L’idea è semplice: un modello AI che gira sul tuo computer, un agente che lo usa per lavorare su una VPS vuota, e alla fine un WordPress online, con dominio, primo articolo, monitoraggio e backup. Alla fine, allo stesso agente chiedi come sta il sito. Non è un’AI che fa magie da sola: a ogni passaggio decidi tu cosa delegare, cosa approvare e come verificare.

Ho provato tutta la guida dall’inizio alla fine a novembre 2026, su una VPS vera e con il modello della demo, e ho controllato ogni comando sulla documentazione ufficiale. Le versioni cambiano in fretta: se qualcosa non torna, ha l’ultima parola la documentazione linkata in fondo.

Cosa ti serve

  • Un computer con una GPU (anche da gaming) oppure un Mac con chip Apple: qui gira il modello. Per quello della demo bastano 8 GB di memoria video e 16 GB di RAM.
  • Una VPS Debian pulita (Debian 12 o 13), con accesso SSH come root: qui finisce il sito.
  • Un dominio gestito su Cloudflare: nella guida uso example.it, sostituiscilo con il tuo.
  • Un’ora di tempo e voglia di leggere quello che l’agente propone prima di dire «vai».

Lo schema è questo: Ollama e Pi girano sul tuo computer; Pi si collega alla VPS via SSH e lì installa Docker, WordPress e il resto. Il modello non lascia mai casa tua.

Le basi, in cinque minuti

Se questi termini li conosci già, salta pure al punto 1. Se no, bastano queste definizioni per seguire tutto il resto.

  • LLM (Large Language Model): un modello che prevede il prossimo pezzo di testo, un token alla volta. Un token è un frammento di parola: in media tre o quattro caratteri.
  • Training: la fase in cui il modello impara dai dati. Servono mesi di calcolo su migliaia di GPU. Non è una cosa che facciamo noi.
  • Inferenza: il modello già addestrato risponde alle domande. Basta una GPU sola: è quello che facciamo in questa guida.
  • Modelli di frontiera: GPT, Claude, Gemini. Li usi via API, a pagamento, e i tuoi dati escono da casa tua.
  • Open weight: Qwen, Gemma, DeepSeek, gpt-oss. Scarichi i pesi (il file del modello) e li fai girare dove vuoi.
  • Open source: pesi, dati e codice di training tutti aperti. Open weight non basta per dirsi open source, e quasi nessun modello lo è davvero.
  • VRAM: la memoria della scheda video. È il limite che decide quale modello puoi far girare.
  • Contesto: quanto testo il modello riesce a tenere a mente in una conversazione (le tue richieste, i file letti, l’output dei comandi). Si misura in token e occupa memoria.

Quantizzazione: perché un modello entra nella tua GPU

La quantizzazione è l’MP3 dei modelli: stessi pesi, salvati con meno bit. Il file pesa meno e gira più veloce, con una piccola perdita di qualità. Un esempio con un modello da 8 miliardi di parametri:

Versione Peso Cosa cambia
Originale, 16 bit 16 GB Piena precisione: serve una GPU da 24 GB
Quantizzato a 8 bit 8,5 GB Metà del peso, qualità quasi identica
Quantizzato a 4 bit 5 GB Entra in una GPU da 8 GB: si parte da qui

La regola da tovagliolo: GB ≈ miliardi di parametri × bit ÷ 8, più la memoria per il contesto. Sotto i 4 bit il modello comincia a sbagliare con grande sicurezza, quindi non scendere oltre. Ollama scarica già la versione quantizzata: non devi fare nulla a mano.

1. Il motore: Ollama

Ollama è il modo più semplice per far girare un modello in locale: un comando per installarlo, uno per scaricare il modello.

Installazione

Su Linux l’installer ha bisogno di due programmi che su una Debian appena installata non ci sono: curl, che scarica i file, e zstd, che li decomprime. Senza, il comando si ferma con un errore. Prima aggiorno l’elenco dei pacchetti e li installo:

sudo apt update
sudo apt install -y curl zstd
curl -fsSL https://ollama.com/install.sh | sh

Se lavori come root, per esempio su una VPS o in un container, il comando sudo spesso non c’è: togli la parola sudo da tutti i comandi di questa guida. Alla fine l’installer può scrivere Unable to detect NVIDIA/AMD GPU: vuol dire solo che manca il programma lspci, la scheda video la cerca comunque Ollama quando parte.

Su macOS (Sonoma 14 o successivo) si scarica l’app da ollama.com/download e si trascina in Applicazioni. Su Windows c’è l’installer nella stessa pagina.

Più contesto per l’agente

Il contesto è quanto testo il modello tiene a mente. Con meno di 24 GB di memoria video Ollama parte con 4.096 token (lo dice la pagina sul contesto): bastano per una chat, non per un agente che legge file e output di comandi. Lo porto a 65.536 e chiedo a Ollama di tenere il modello sempre in memoria, invece di scaricarlo dopo cinque minuti di pausa e ricaricarlo alla domanda successiva:

sudo mkdir -p /etc/systemd/system/ollama.service.d
printf '[Service]\nEnvironment="OLLAMA_CONTEXT_LENGTH=65536"\nEnvironment="OLLAMA_KEEP_ALIVE=-1"\n' | sudo tee /etc/systemd/system/ollama.service.d/override.conf
sudo systemctl daemon-reload
sudo systemctl restart ollama

Su macOS:

launchctl setenv OLLAMA_CONTEXT_LENGTH 65536
launchctl setenv OLLAMA_KEEP_ALIVE -1
# poi chiudi e riapri l'app Ollama

Il contesto occupa memoria: se il modello non ci sta più, scendi a 32.768.

Scegli il modello

Memoria GPU Modello Ollama Peso Note
8 GB gemma4:e4b 6,6 GB Per iniziare; contesto da tenere basso
12–16 GB gemma4:12b 7,7 GB Buon equilibrio, lascia spazio al contesto
16–24 GB gpt-oss:20b 14 GB Bene per testo e strumenti
24 GB e oltre qwen3.8:27b 18 GB Quello che preferisco per lavoro da agente

I pesi sono quelli indicati su ollama.com/library per le versioni quantizzate di default. Su un Mac conta la memoria unificata, non la VRAM.

Il modello della demo: Gemma 4 26B-A4B

Sul palco uso gemma4:26b-a4b-it-qat, su una RTX 3050 da 8 GB, una scheda da gaming di qualche anno fa. Secondo la tabella con 8 GB dovrei fermarmi a gemma4:e4b, ma questo modello fa eccezione, per tre motivi:

  • È un modello a esperti (in inglese mixture of experts). Ha 26 miliardi di parametri, ma per ogni token ne usa solo 4 miliardi, scelti tra tanti piccoli «esperti». Ollama mette in GPU la parte usata sempre e lascia il resto nella RAM del computer: la scheda lavora quasi da sola e il modello va veloce. Sulla 3050 genera circa 30 token al secondo.
  • È in versione QAT, cioè addestrato sapendo che sarebbe stato quantizzato a 4 bit. Perde molto meno qualità di un modello compresso dopo, come nell’esempio dell’MP3.
  • Usa bene gli strumenti. Nelle prove per questo talk ha scritto compose, chiamato API e letto errori senza perdersi, a patto di dargli prompt precisi e una sessione nuova per ogni capitolo.

Cosa serve: 8 GB di memoria video e almeno 16 GB di RAM, perché il file pesa 15 GB e quello che non entra nella scheda sta in memoria.

ollama pull gemma4:26b-a4b-it-qat
ollama run gemma4:26b-a4b-it-qat "Ciao, rispondi in una riga"

Un ultimo ritocco che vale la pena: il batch, cioè quanti token del prompt il modello legge in un colpo solo. Ollama ne legge 512; a 2.048 l’agente, che a ogni passo rilegge file e output dei comandi, risponde molto prima. Nelle mie prove un prompt di 6.700 token è passato da 29 a 18 secondi. Il batch si fissa creando una copia del modello con il parametro già impostato; la copia usa gli stessi file e non occupa altro spazio:

printf 'FROM gemma4:26b-a4b-it-qat\nPARAMETER num_batch 2048\n' > Modelfile
ollama create gemma4-demo -f Modelfile

Da qui in poi il modello si chiama gemma4-demo.

Controlla che stia usando la scheda video:

ollama ps

Nella colonna PROCESSOR deve comparire la GPU, per esempio 6%/94% CPU/GPU. Se leggi 100% CPU, quando Ollama è partito la scheda era occupata da un altro programma, oppure i driver NVIDIA non sono installati. Libera la GPU (con nvidia-smi vedi chi la usa) e riavvia Ollama con sudo systemctl restart ollama: Ollama cerca la scheda solo all’avvio.

Verifica che l’API compatibile con OpenAI risponda, perché è quella che userà l’agente:

curl http://localhost:11434/v1/models

Le alternative a Ollama

Ollama non è l’unico modo per far girare un modello. Lo uso nella guida perché è il più semplice per iniziare.

  • Ollama: un comando e il modello gira. È quello della demo.
  • LM Studio: un’app desktop con interfaccia grafica, se non ami il terminale.
  • llama.cpp: il motore che sta sotto molti altri. Gira anche su CPU e Mac. Va bene per un utente alla volta.
  • vLLM: il server per la produzione, su GPU. Serve decine di richieste in parallelo.

Parlano tutti la stessa API, quella compatibile con OpenAI. Per passare dall’uno all’altro cambi solo l’indirizzo (baseUrl) nella configurazione dell’agente che vedi al punto 2.

2. Le mani: Pi

Pi è un harness per agenti minimale ed estendibile (licenza MIT). Fa poco, apposta: legge file, lancia comandi, usa gli strumenti. Non chiede permessi prima di eseguire: le regole gliele dai tu, ed è il motivo per cui il metodo più sotto è importante.

Installazione

curl -fsSL https://pi.dev/install.sh | sh

L’installer fa qualche domanda: rispondi a tutte con Invio, che vale come sì. Chiede se installare Node.js, se manca (Pi ne ha bisogno), se aggiungere Pi al PATH (l’elenco delle cartelle in cui il terminale cerca i comandi) e se avviarlo subito. Se lo avvii, non c’è ancora nessun modello collegato: esci con Ctrl+C due volte e continua con la guida.

Finita l’installazione chiudi il terminale e aprine uno nuovo: finché non lo fai, il comando pi non viene trovato. Per controllare che sia tutto a posto:

pi --version

In alternativa con npm (serve Node.js 22.19 o successivo):

npm install -g --ignore-scripts @earendil-works/pi-coding-agent

Collegarlo a Ollama

Pi legge i modelli da ~/.pi/agent/models.json. Nessuna chiave a pagamento: la apiKey è letteralmente la parola ollama.

{
  "providers": {
    "ollama": {
      "baseUrl": "http://localhost:11434/v1",
      "api": "openai-completions",
      "apiKey": "ollama",
      "models": [
        { "id": "gemma4-demo", "contextWindow": 65536 }
      ]
    }
  }
}

Se hai scelto un altro modello, cambia l’id con il nome che vedi in ollama list. Avvia Pi nella cartella di lavoro e scegli il modello con /model:

mkdir -p ~/wordcamp-demo && cd ~/wordcamp-demo
pi

Gli altri harness

Un modello da solo scrive testo. L’harness è il programma che gli dà le mani: file, terminale, strumenti. Modello più harness fanno un agente: riceve un obiettivo, sceglie i passi, agisce e controlla il risultato finché ha finito. Pi non è l’unico:

  • Claude Code: il più maturo. Codice chiuso, pensato per i modelli Anthropic.
  • Codex CLI: la CLI è open source, i modelli no. Accetta anche modelli locali.
  • OpenCode: open source, funziona con decine di provider.
  • DeepSeek Harness: open source, a plugin. Ancora in preview.
  • Pi: minimale ed estendibile. È quello della demo.

Il metodo: delega, approva, verifica

Pi legge da solo il file AGENTS.md della cartella in cui lo avvii. Ci metto le regole del gioco, così l’agente propone prima di agire. Questo è il mio, salvato come ~/wordcamp-demo/AGENTS.md; adattalo pure:

# Regole per questo progetto

- Prima di qualsiasi comando che modifica il server (installare, cancellare,
  riavviare, pubblicare) scrivi il piano in punti e aspetta che io risponda "vai".
- Leggere file, controllare stati e log puoi farlo senza chiedere.
- Le credenziali stanno in ~/.config/wordcamp-demo.env (qui) e in
  /opt/wp/.env (sul server). Caricale con
  set -a; . ~/.config/wordcamp-demo.env; set +a e usale per nome,
  senza scriverne i valori a schermo.
- Dopo ogni passaggio dimmi come verificarlo e mostrami l'esito del controllo.
- Se qualcosa fallisce, fermati: spiegami la causa che sospetti prima di riprovare.
- Server di lavoro: "ssh demo-vps" (vedi ~/.ssh/config).
- Per creare o modificare un file sul server, scrivilo prima qui e
  copialo con scp: non passare file lunghi dentro un comando ssh.

Il file delle credenziali sta fuori dalla cartella di lavoro, così l’agente non lo trova quando cerca tra i file. Ogni tanto le password le stampa lo stesso, per «controllare»: il modello è locale e non escono dal tuo computer, ma se stai proiettando lo schermo le vede la sala. Per questo i token che gli dai hanno i permessi minimi.

Chi fa cosa: la tabella da tenere a mente

Passo Chi Cosa Esempio
Delega L’agente Leggere, proporre, scrivere bozze Scrivere il docker compose
Approva Tu Ogni comando che cambia qualcosa Installare Docker sul server
Verifica Tu Prova, non fiducia Aprire il sito e controllare che risponda

Dove si eseguono i comandi

Nella guida ci sono due macchine, e conviene non confonderle:

  • Il tuo computer: qui girano Ollama e Pi, qui stanno le chiavi SSH e la cartella ~/wordcamp-demo. Tutto quello che hai visto ai punti 1 e 2 si esegue qui.
  • La VPS: il server in affitto dove finisce il sito. Ci entri con ssh demo-vps. I comandi docker e i file in /opt/wp stanno lì.

Puoi lanciare ogni comando a mano oppure farlo fare all’agente con i prompt che trovi a ogni passo. Nel secondo caso l’agente ti mostra il piano, tu rispondi «vai», e poi controlli il risultato.

Una sessione nuova per ogni capitolo

Tutto quello che l’agente legge (file, output dei comandi, log di installazione) resta nel suo contesto, e un contesto pieno lo rende più lento e più confuso. Nelle mie prove, dopo aver installato Docker e WordPress nella stessa sessione, l’agente ha cominciato a perdersi in ragionamenti lunghissimi su un compito banale. Chiudi Pi e riaprilo a ogni capitolo di questa guida: riparte da zero, rilegge AGENTS.md e torna svelto. Per lo stesso motivo conviene chiedergli una cosa alla volta.

3. Server e sito

Accesso SSH con chiave

Sul tuo computer, una chiave dedicata e un alias per la VPS (sostituisci l’indirizzo). Il secondo comando, ssh-copy-id, copia la chiave sulla VPS e ti chiede la password di root: è quella che il provider ti ha mandato quando hai creato il server. È l’ultima volta che la usi, da qui in poi si entra con la chiave. Se invece il tuo provider ti ha fatto caricare la chiave pubblica al momento della creazione della VPS, salta quella riga.

Un caso frequente: alcuni provider, Hetzner tra questi, al primo accesso ti obbligano a cambiare la password che ti hanno mandato. Finché non lo fai, ssh-copy-id fallisce con il messaggio «You are required to change your password immediately». In quel caso entra prima una volta a mano con ssh root@203.0.113.10, scegli la nuova password quando te la chiede, esci, e poi lancia i comandi qui sotto usando quella nuova.

Due domande a cui rispondere: ssh-keygen chiede una passphrase, premi Invio due volte e lasciala vuota, perché la chiave la userà l’agente e lui non può digitarla; ssh-copy-id, al primo collegamento, chiede di confermare l’impronta del server: rispondi yes.

ssh-keygen -t ed25519 -f ~/.ssh/demo-vps -C "wordcamp-demo"
ssh-copy-id -i ~/.ssh/demo-vps.pub root@203.0.113.10

cat >> ~/.ssh/config <<'EOF'
Host demo-vps
    HostName 203.0.113.10
    User root
    IdentityFile ~/.ssh/demo-vps
EOF

ssh demo-vps 'uname -a'

Prompt per l’agente: «Collegati a demo-vps, aggiorna i pacchetti di Debian e installa Docker con lo script ufficiale. Prima mostrami il piano.»

Docker con lo script ufficiale

Lo script get.docker.com installa Docker Engine e il plugin Compose. Docker lo indica per ambienti di test e sviluppo: per una macchina di produzione è meglio il repository apt ufficiale.

apt update && apt -y upgrade
curl -fsSL https://get.docker.com | sh
docker --version && docker compose version

WordPress in tre container

Database, WordPress e Caddy, che fa da reverse proxy e prende il certificato HTTPS da solo. Lavoro in /opt/wp. Le password stanno nel file .env:

Prompt per l’agente: «Sul server demo-vps crea in /opt/wp un WordPress con Docker Compose: tre container, database MariaDB, WordPress e Caddy come reverse proxy con HTTPS per il dominio demo.example.it. La password del database generala nel file .env sul server, leggibile solo da root. Prima mostrami il piano e il contenuto dei file, e non creare né avviare niente finché non dico vai.»

Qui sotto trovi i file come li uso io. Puoi incollarli nel prompt, così l’agente parte da quelli invece di scriverli da zero, oppure usarli come riferimento per rileggere la sua proposta. Rileggila sempre: quando ho provato questo passo l’agente aveva messo nel Caddyfile una variabile che Caddy non riceve e due password diverse per database e WordPress. Gliel’ho fatto notare, ha corretto, e solo dopo ho detto «vai».

mkdir -p /opt/wp && cd /opt/wp
cat > .env <<EOF
DB_PASS=$(openssl rand -hex 24)
EOF
chmod 600 .env

Il file docker-compose.yml:

services:
  db:
    image: mariadb:lts
    restart: unless-stopped
    environment:
      MARIADB_DATABASE: wp
      MARIADB_USER: wp
      MARIADB_PASSWORD: ${DB_PASS}
      MARIADB_RANDOM_ROOT_PASSWORD: "1"
    volumes:
      - db:/var/lib/mysql
    healthcheck:
      test: ["CMD", "healthcheck.sh", "--connect", "--innodb_initialized"]
      interval: 10s
      retries: 5

  wordpress:
    image: wordpress:7.1-apache
    restart: unless-stopped
    depends_on:
      db:
        condition: service_healthy
    environment:
      WORDPRESS_DB_HOST: db
      WORDPRESS_DB_USER: wp
      WORDPRESS_DB_PASSWORD: ${DB_PASS}
      WORDPRESS_DB_NAME: wp
    volumes:
      - wp:/var/www/html

  caddy:
    image: caddy:2
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile
      - caddy_data:/data

volumes:
  db: {}
  wp: {}
  caddy_data: {}

Il Caddyfile (per ora solo il sito; gli altri nomi li aggiungo più avanti):

demo.example.it {
    reverse_proxy wordpress:80
}

Avvio e controllo. Caddy otterrà il certificato HTTPS solo quando il DNS punterà alla VPS (passo successivo): fino ad allora nei log vedrai tentativi falliti, è normale. Per uscire dai log premi Ctrl+C.

docker compose up -d
docker compose ps
docker compose logs -f caddy

4. Dominio e contenuti

Il record DNS su Cloudflare

Il token lo creo io, non l’agente: in Cloudflare, My Profile → API Tokens → Create Token, modello Edit zone DNS, limitato alla sola zona del dominio. Lo salvo sul mio computer, in un file fuori dalla cartella di lavoro, insieme allo Zone ID (lo trovi nella pagina Overview del dominio):

mkdir -p ~/.config
cat > ~/.config/wordcamp-demo.env <<'EOF'
CF_API_TOKEN=incolla-qui-il-token
CF_ZONE_ID=incolla-qui-lo-zone-id
VPS_IP=203.0.113.10
EOF
chmod 600 ~/.config/wordcamp-demo.env

Prompt per l’agente: «Crea su Cloudflare tre record A non proxati, demo.example.it, status.example.it ed errors.example.it, verso l’IP della VPS. Usa CF_API_TOKEN, CF_ZONE_ID e VPS_IP. Mostrami prima i comandi e aspetta il mio vai.»

Creo subito anche status ed errors, che serviranno nel capitolo 5. Prima del «vai» leggi i comandi: nella mia prova due su tre puntavano a /zone/ invece di /zones/, con tanto di nota sicura che fosse giusto. L’ho fatto notare, ha corretto, e i record sono stati creati.

Il comando per un record (lo ripeto per status ed errors). Lascio i record DNS only, così Caddy ottiene i certificati senza intermediari:

set -a; . ~/.config/wordcamp-demo.env; set +a
curl -s -X POST "https://api.cloudflare.com/client/v4/zones/$CF_ZONE_ID/dns_records" \
  -H "Authorization: Bearer $CF_API_TOKEN" \
  -H "Content-Type: application/json" \
  --data "{\"type\":\"A\",\"name\":\"demo.example.it\",\"content\":\"$VPS_IP\",\"ttl\":1,\"proxied\":false}"

Verifica dal tuo computer. Il primo comando deve rispondere con l’indirizzo IP della VPS, il secondo con una riga che inizia per HTTP/2. Su Debian e Ubuntu dig va installato prima con sudo apt install -y bind9-dnsutils.

dig +short demo.example.it
curl -I https://demo.example.it

Se il secondo comando dà un errore di certificato, Caddy sta ancora aspettando prima di riprovare. Sulla VPS, in /opt/wp, riavvialo e riprova dopo un minuto:

docker compose restart caddy

Ora WordPress va installato: titolo del sito, utente amministratore, password. Fallo subito, perché finché non lo fai la pagina di installazione è aperta a chiunque arrivi sul dominio. Ci sono due strade.

A mano. Apri https://demo.example.it e completa l’installazione dal browser.

Con uno script. È la strada che uso sul palco: lo script qui sotto installa WordPress, crea l’utente amministratore con una password casuale e crea anche la password per le applicazioni che servirà tra poco per caricare l’articolo. Usa WP-CLI, lo strumento a riga di comando di WordPress, dentro un container usa e getta: sul server non resta installato niente. Le credenziali non compaiono a schermo: finiscono nel file /opt/wp/.wp-credentials, leggibile solo da root. Salvalo sul tuo computer come ~/wordcamp-demo/wp-setup.sh:

#!/usr/bin/env bash
# wp-setup.sh
# Completa l'installazione di WordPress e crea una password per le applicazioni
# (quella che serve alla REST API), usando WP-CLI in un container usa e getta.
#
# Va eseguito sulla VPS, nella cartella del docker-compose.yml (es. /opt/wp):
#   ./wp-setup.sh https://dominio [utente] [email] [titolo]
#
# Le credenziali NON vengono stampate: finiscono nel file .wp-credentials
# (leggibile solo da root) nella stessa cartella.
set -euo pipefail
cd "$(dirname "$0")"

URL="${1:?uso: ./wp-setup.sh https://dominio [utente] [email] [titolo]}"
ADMIN_USER="${2:-admin}"
ADMIN_EMAIL="${3:-admin@example.com}"
TITLE="${4:-Il mio sito}"
APP_NAME="${APP_NAME:-wordcamp-demo}"
WP_LOCALE="${WP_LOCALE:-it_IT}"
OUT=".wp-credentials"

CID="$(docker compose ps -q wordpress)"
[ -n "$CID" ] || { echo "Errore: il container wordpress non è in esecuzione." >&2; exit 1; }

# WP-CLI deve vedere le stesse variabili del database che usa WordPress.
ENVF="$(mktemp)"
trap 'rm -f "$ENVF"' EXIT
docker inspect -f '{{range .Config.Env}}{{println .}}{{end}}' "$CID" | grep '^WORDPRESS_' > "$ENVF"

# Stessi file e stessa rete del container di WordPress; utente 33 = www-data.
wp() {
  docker run --rm --user 33:33 -e HOME=/tmp \
    --volumes-from "$CID" --network "container:$CID" \
    --env-file "$ENVF" wordpress:cli wp "$@"
}

umask 077
ADMIN_PASS=""
if wp core is-installed 2>/dev/null; then
  echo "WordPress è già installato: salto l'installazione."
else
  ADMIN_PASS="$(openssl rand -base64 18 | tr -d '/+=')"
  wp core install --url="$URL" --title="$TITLE" \
    --admin_user="$ADMIN_USER" --admin_email="$ADMIN_EMAIL" \
    --admin_password="$ADMIN_PASS" --skip-email
  if [ -n "$WP_LOCALE" ] && [ "$WP_LOCALE" != "en_US" ]; then
    wp language core install "$WP_LOCALE" --activate || echo "Lingua $WP_LOCALE non installata, resta l'inglese."
  fi
fi

APP_PASS="$(wp user application-password create "$ADMIN_USER" "$APP_NAME" --porcelain)"

{
  echo "WP_URL=$URL"
  echo "WP_USER=$ADMIN_USER"
  [ -n "$ADMIN_PASS" ] && echo "WP_ADMIN_PASSWORD=$ADMIN_PASS"
  echo "WP_APP_PASSWORD=$APP_PASS"
} > "$OUT"
chmod 600 "$OUT"

# Prova: la REST API deve riconoscere l'utente con la nuova password.
CODE="$(curl -s -o /dev/null -w '%{http_code}' -u "$ADMIN_USER:$APP_PASS" "$URL/wp-json/wp/v2/users/me")"
if [ "$CODE" = "200" ]; then
  echo "Fatto. REST API verificata (HTTP 200). Credenziali in $(pwd)/$OUT"
else
  echo "Credenziali salvate in $(pwd)/$OUT, ma la prova REST ha risposto HTTP $CODE." >&2
  exit 1
fi

Prompt per l’agente: «Copia wp-setup.sh su demo-vps in /opt/wp ed eseguilo con indirizzo https://demo.example.it, utente admin, email admin@example.it e titolo “Il mio sito”. Le credenziali finiscono in .wp-credentials sul server: non leggerle. Prima mostrami il piano.»

Poi porto le credenziali sul mio computer, nel file ~/.config/wordcamp-demo.env, dove l’agente le troverà senza che io debba scriverle in un comando. La password per entrare in bacheca è la riga WP_ADMIN_PASSWORD di quel file.

ssh demo-vps 'cat /opt/wp/.wp-credentials' >> ~/.config/wordcamp-demo.env

Il primo articolo, scritto dal modello

Prompt per l’agente: «Scrivi un articolo di 300 parole su come far girare un modello AI in locale, per un pubblico WordPress. Scrivi solo il corpo dell’articolo in HTML semplice, cioè paragrafi, sottotitoli ed elenchi: niente doctype, html, head, body e niente titolo h1, perché il titolo lo mette WordPress. Salvalo nel file articolo.html in questa cartella.»

Rileggo e correggo il testo. Per caricarlo serve una password per le applicazioni, che funziona solo in HTTPS (per questo Caddy serviva prima). Se hai usato lo script ce l’hai già nel file delle credenziali. Se hai installato WordPress a mano, creala in Utenti → Profilo → Password per le applicazioni e aggiungi tu a quel file le righe WP_URL, WP_USER e WP_APP_PASSWORD.

Prompt per l’agente: «Carica articolo.html come bozza su WordPress via REST API, con titolo “Hello WordCamp!”, usando WP_URL, WP_USER e WP_APP_PASSWORD. Il comando va lanciato da questo computer. Mostrami prima il comando e aspetta il mio vai.»

L’articolo viene caricato come bozza. A mano, lo stesso comando è questo:

curl -u "admin:xxxx xxxx xxxx xxxx xxxx xxxx" \
  https://demo.example.it/wp-json/wp/v2/posts \
  -d status=draft \
  --data-urlencode title="Hello WordCamp!" \
  --data-urlencode content@articolo.html

Il tasto Pubblica lo premo io.

5. Monitoraggio e backup

Questo capitolo è lungo e i file sono precisi: un nome di variabile sbagliato e Bugsink non parte. Per questo all’agente non chiedo di scriverli a memoria. Copio il testo di questo capitolo in un file, ~/wordcamp-demo/guida-monitoraggio.md, con i miei domini al posto di example.it, e glielo faccio applicare in due volte, ogni volta in una sessione nuova.

Prompt per l’agente, prima parte: «Applica su demo-vps la prima parte di guida-monitoraggio.md, fino alla sezione Uptime Kuma esclusa: Uptime Kuma e Bugsink nel docker-compose.yml di /opt/wp, le password nuove nel .env del server, i nomi nuovi nel Caddyfile. Adatta la guida ai file che ci sono già, senza toccare i servizi esistenti. Mostrami il piano e le righe esatte che aggiungi, e dopo il mio vai applica e avvia i servizi.»

Prompt per l’agente, seconda parte: «Dallo stesso file applica su demo-vps la sezione Backup con restic e Backrest, adattandola ai nomi che ci sono già nel docker-compose.yml e nel .env del server. Mostrami il piano e le righe esatte, e dopo il mio vai avvia Backrest e lancia una volta il dump.»

«Adatta a quello che c’è già» non è una formula di cortesia: se il compose l’ha scritto l’agente, i nomi dei volumi e delle variabili possono essere diversi da quelli che vedi qui sotto. Nella mia prova il volume di WordPress si chiamava wp_data invece di wp e le variabili del database cominciavano per MYSQL_: l’agente li ha letti e ha corretto da solo. Qui sotto trovi i file di riferimento, da usare anche se preferisci fare tutto a mano.

Aggiungo due servizi al compose: Uptime Kuma per sapere se il sito è online, Bugsink per sapere cosa si è rotto. In /opt/wp/.env aggiungo le password che servono:

cd /opt/wp
cat >> .env <<EOF
BUGSINK_DB_PASS=$(openssl rand -hex 24)
BUGSINK_SECRET_KEY=$(openssl rand -base64 50 | tr -d '\n')
BUGSINK_ADMIN=admin@example.it:$(openssl rand -hex 12)
EOF
grep BUGSINK_ADMIN .env   # la password dell'utente admin di Bugsink

I servizi da aggiungere sotto services: nel docker-compose.yml (e i nuovi volumi in fondo):

  uptime-kuma:
    image: louislam/uptime-kuma:2
    restart: unless-stopped
    volumes:
      - kuma:/app/data

  bugsink-db:
    image: postgres:17-alpine
    restart: unless-stopped
    environment:
      POSTGRES_USER: bugsink
      POSTGRES_PASSWORD: ${BUGSINK_DB_PASS}
      POSTGRES_DB: bugsink
    volumes:
      - bugsink-db:/var/lib/postgresql/data
    healthcheck:
      test: pg_isready -h bugsink-db
      interval: 5s
      retries: 5

  bugsink:
    image: bugsink/bugsink:2
    restart: unless-stopped
    depends_on:
      bugsink-db:
        condition: service_healthy
    environment:
      SECRET_KEY: ${BUGSINK_SECRET_KEY}
      CREATE_SUPERUSER: ${BUGSINK_ADMIN}
      PORT: 8000
      DATABASE_URL: postgresql://bugsink:${BUGSINK_DB_PASS}@bugsink-db:5432/bugsink
      BEHIND_HTTPS_PROXY: "true"
      BASE_URL: https://errors.example.it

In fondo al file, nella sezione volumes: che esiste già, aggiungi queste due righe sotto caddy_data: {} (attenzione: non vanno sotto services:):

  kuma: {}
  bugsink-db: {}

E nel Caddyfile:

status.example.it {
    reverse_proxy uptime-kuma:3001
}

errors.example.it {
    reverse_proxy bugsink:8000 {
        header_up X-Real-IP {remote_host}
    }
}

La riga header_up passa a Bugsink l’indirizzo di chi fa la richiesta: è la configurazione indicata nella documentazione di Bugsink per Caddy.

I due nomi nuovi, status.example.it e errors.example.it, hanno bisogno ciascuno del proprio record DNS verso l’indirizzo IP della VPS, creato come quello del sito nel capitolo 4. Creali prima di andare avanti: senza record Caddy non riesce a ottenere il certificato.

docker compose up -d
docker compose restart caddy

Se i record li hai creati dopo aver avviato Caddy, il certificato non arriva subito: Caddy ha già provato, ha fallito e aspetta sempre più a lungo tra un tentativo e l’altro. Ripeti docker compose restart caddy e in meno di un minuto i due indirizzi rispondono in HTTPS.

Uptime Kuma

Apri https://status.example.it, al primo avvio scegli SQLite come database (per un solo sito basta), poi crea l’utente. Aggiungi un monitor HTTP(s) su https://demo.example.it e imposta l’intervallo a 20 secondi (di default è 60). Fanne un secondo su https://errors.example.it: se Bugsink si ferma, gli errori del sito spariscono in silenzio. Le notifiche (Telegram, email e altri 90 canali) si configurano in Settings → Notifications, oppure dalla pagina del monitor con il pulsante Configura le notifiche.

Io uso Telegram, perché l’avviso arriva sul telefono in un paio di secondi. Servono due cose: un bot, cioè un account automatico che manda i messaggi, e l’ID della chat in cui deve scrivere.

  1. Crea il bot. In Telegram cerca @BotFather, scrivi /newbot e segui le domande: un nome, poi un nome utente che finisca per bot. BotFather risponde con il token, una stringa lunga con i due punti in mezzo. È una password: non incollarla in chat né in un prompt.
  2. Scrivi al bot. Cerca il bot appena creato e premi Avvia. Un bot non può scrivere per primo a nessuno: finché non lo fai, non esiste una chat a cui mandare gli avvisi.
  3. Ricava l’ID della chat. Da terminale, con il tuo token al posto di IL_TUO_TOKEN (la parola bot davanti resta):
    curl -s "https://api.telegram.org/botIL_TUO_TOKEN/getUpdates"

    Nella risposta cerca "chat":{"id":123456789: quel numero è l’ID. Se la risposta è "result":[], il bot non ha ancora ricevuto messaggi: torna al passo 2.

  4. Configura Uptime Kuma. Tipo di notifica Telegram, incolla token e ID della chat, premi Fai una prova (deve arrivarti un messaggio) e poi Salva.
  5. Collega la notifica al monitor. Nella pagina di modifica del monitor attiva l’interruttore accanto al nome della notifica e salva. Senza questo passo Kuma diventa rosso ma non ti avvisa.

Finita la demo, se il token è passato da qualche parte dove non doveva, lo rigeneri da BotFather con /revoke.

Un limite da conoscere: se Kuma gira sulla stessa VPS, non può accorgersi che è caduta la VPS intera. Per la demo va bene; in produzione mettilo altrove.

Bugsink e il plugin per WordPress

Apri https://errors.example.it, entra con l’utente creato sopra. Bugsink organizza i progetti in gruppi di lavoro, i team, e senza un team il progetto non si può creare. Quindi prima Teams → New Team (basta un nome, per esempio «Demo»), poi Projects → New Project: scegli il team, dai un nome al progetto e salva. La pagina che si apre mostra il DSN, l’indirizzo con dentro una chiave a cui WordPress manderà gli errori: copialo. Bugsink è compatibile con gli SDK di Sentry, quindi su WordPress uso il plugin Sentry for WordPress. Il DSN lo passo a WordPress dal compose, nel servizio wordpress:

    environment:
      # ...le variabili del database restano come prima
      WORDPRESS_CONFIG_EXTRA: |
        define( 'WP_SENTRY_PHP_DSN', 'https://chiave@errors.example.it/1' );

Installo il plugin dalla bacheca (Plugin → Aggiungi nuovo, cerca «Sentry for WordPress»), lo attivo e ricreo il container:

docker compose up -d wordpress

Il plugin ha un evento di prova in Strumenti → Sentry.

Houston, abbiamo un problema

Il momento della demo. Primo test, il sito va giù:

docker compose stop wordpress
# entro il prossimo controllo (20 secondi) Kuma diventa rosso e arriva la notifica
docker compose start wordpress

Secondo test, un errore PHP vero. Un mu-plugin che lancia un’eccezione solo quando visito /?boom=1:

docker compose exec -T wordpress sh -c 'mkdir -p wp-content/mu-plugins && cat > wp-content/mu-plugins/boom.php' <<'PHP'
<?php
// Errore di prova per Bugsink: visita https://demo.example.it/?boom=1
add_action( 'init', function () {
    if ( isset( $_GET['boom'] ) ) {
        throw new RuntimeException( 'Errore di prova WordCamp Pisa' );
    }
} );
PHP

Perché l’agente possa leggere l’errore gli serve un accesso a Bugsink. Lo creo io: in Bugsink, menu Tokens → Add Token. Il modulo chiede quali permessi dare al token: all’agente basta leggere, quindi spunto solo read alle voci issues, events e projects e lascio vuoto tutto il resto. Così, anche se il token finisse nelle mani sbagliate, non si potrebbe cancellare né modificare niente. Creato il token, lo copio con Copy e lo aggiungo al file delle credenziali sul mio computer, insieme all’indirizzo:

cat >> ~/.config/wordcamp-demo.env <<'EOF'
BUGSINK_URL=https://errors.example.it
BUGSINK_TOKEN=incolla-qui-il-token
EOF

Con il token l’agente interroga l’API di Bugsink. Questo è il comando che elenca gli errori del progetto 1:

set -a; . ~/.config/wordcamp-demo.env; set +a
curl -s -H "Authorization: Bearer $BUGSINK_TOKEN" "$BUGSINK_URL/api/canonical/0/issues/?project=1"

Prompt per l’agente: «Leggi l’ultimo errore su Bugsink usando BUGSINK_URL e BUGSINK_TOKEN, spiegami la causa e proponi una correzione. Non applicarla finché non dico vai.»

Se un token finisce a schermo, revocalo dal menu Tokens e creane uno nuovo.

Finita la prova, il file si cancella: docker compose exec wordpress rm wp-content/mu-plugins/boom.php.

Backup con restic e Backrest

restic fa snapshot cifrati e deduplicati; Backrest gli aggiunge un’interfaccia web e la pianificazione. Salvo due cose: il dump del database e i file di WordPress.

Il dump lo fa il server ogni notte, prima del backup:

mkdir -p /srv/backup
cat > /etc/cron.d/wp-dump <<'EOF'
15 2 * * * root cd /opt/wp && docker compose exec -T db sh -c 'mariadb-dump -u "$MARIADB_USER" -p"$MARIADB_PASSWORD" --single-transaction "$MARIADB_DATABASE"' > /srv/backup/wp.sql.tmp && mv /srv/backup/wp.sql.tmp /srv/backup/wp.sql
EOF

Il dump viene scritto prima in un file temporaneo: se qualcosa va storto, quello della notte prima resta intatto. Non aspettare la notte per scoprire se funziona: lancia una volta a mano il comando che c’è nel file e controlla che /srv/backup/wp.sql esista. Nella mia prova l’agente aveva scritto il cron con le variabili vuote e diceva che era tutto a posto. Peggio ancora, riscrivendo il docker-compose.yml con un comando ssh aveva svuotato tutte le variabili: Bugsink si è fermato e me ne sono accorto due ore dopo. Chiedendogli la causa, ha dato la colpa alla chiave «poco sicura». Da qui la regola di AGENTS.md sui file copiati con scp e il secondo monitor su Kuma.

Backrest nel compose, con i dati montati in sola lettura e l’interfaccia raggiungibile solo dal server:

  backrest:
    image: ghcr.io/garethgeorge/backrest:latest
    restart: unless-stopped
    environment:
      BACKREST_DATA: /data
      BACKREST_CONFIG: /config/config.json
      XDG_CACHE_HOME: /cache
      TZ: Europe/Rome
    volumes:
      - ./backrest/data:/data
      - ./backrest/config:/config
      - ./backrest/cache:/cache
      - ./backrest/repos:/repos
      - /srv/backup:/userdata/db:ro
      - wp:/userdata/wp:ro
    ports:
      - "127.0.0.1:9898:9898"

Ci arrivo con un tunnel SSH e configuro il repository e il piano di backup su /userdata. Il repository è il posto dove finiscono i backup: può essere S3, Backblaze B2 o una cartella. Se scegli una cartella usa /repos, che è montata sul disco della VPS: qualsiasi altro percorso sparisce quando il container viene ricreato.

ssh -L 9898:localhost:9898 demo-vps
# poi apri http://localhost:9898

Nell’interfaccia i passi sono quattro:

  1. Primo avvio. Backrest chiede un Instance ID, cioè un nome per questa installazione (per esempio demo-vps), e se vuoi un utente con password. L’interfaccia risponde solo dal server e ci arrivi dal tunnel SSH, quindi per la demo puoi disattivare l’autenticazione.
  2. Add Repo. In Repo Name un nome a scelta (per esempio locale), in Repository URI il percorso /repos/wp, in Password una password lunga: il pulsante Generate ne crea una. Questa password cifra i backup e senza non si ripristina nulla: salvala in un gestore di password prima di premere Submit.
  3. Add Plan. In Plan Name un nome (per esempio wordpress), in Repository il repository appena creato, in Paths premi Add e scrivi /userdata. In Cron Expression metti 30 2 * * *: ogni notte alle 2:30, un quarto d’ora dopo il dump del database.
  4. Primo backup. Apri il piano e premi Backup Now, senza aspettare la notte. Alla fine compare uno snapshot con il numero di file salvati.

Poi la cosa più importante: provare il restore, dall’interfaccia di Backrest (apri uno snapshot e scegli Restore). Chi usa restic da riga di comando fa la stessa cosa con restic -r percorso-del-repository restore latest --target /tmp/restore. Un backup mai ripristinato è solo una speranza.

6. Chiedi all’agente

Finito il capitolo 5, il sito ha tutto quello che serve: errori, uptime, contenuti e backup. Invece di aprire quattro interfacce, lo chiedo all’agente, in italiano. Mancano due cose: un accesso a Kuma e una mappa che dica all’agente dove guardare.

La chiave di Kuma la creo io: Impostazioni → Chiavi API → Aggiungi chiave API, un nome, spunta su Non scade e Genera. La chiave apre solo le metriche, in lettura, e compare una volta sola: la copio subito nel file delle credenziali.

cat >> ~/.config/wordcamp-demo.env <<'EOF'
KUMA_URL=https://status.example.it
KUMA_API_KEY=incolla-qui-la-chiave
EOF

Poi aggiungo in fondo ad AGENTS.md la mappa:

## Dove trovare le informazioni sul sito

- Errori: API di Bugsink, con BUGSINK_URL e BUGSINK_TOKEN
  (percorsi /api/canonical/0/).
- Uptime e tempi di risposta: KUMA_URL/metrics, utente vuoto
  e KUMA_API_KEY come password.
- Contenuti: REST API di WordPress con WP_URL, WP_USER e WP_APP_PASSWORD,
  corpo in JSON con l'header Content-Type: application/json.
  Pubblicare, modificare o cancellare conta come modifica:
  prima il piano e il mio vai.
- Backup: API di Backrest, raggiungibile solo dal server: da demo-vps fai una POST
  JSON a localhost:9898/v1.Backrest/ListSnapshots con {"repoId":"locale"}.

Da qui in poi apro una sessione nuova e chiedo. Queste sono le domande che ho fatto nella prova, e ogni risposta è arrivata in uno-tre minuti:

  • «Il sito è su? Dimmi uptime e tempi di risposta di oggi.»
  • «Ci sono errori su Bugsink? Dimmi gli ultimi.»
  • «Quando è stato fatto l’ultimo backup e cosa contiene?»
  • «Quali bozze ci sono sul sito?»
  • «Pubblica la bozza Hello WordCamp!»

Per leggere non chiede il permesso. Per pubblicare, modificare o cancellare vale la regola di sempre: prima il piano, poi il «vai». Anche qui la revisione serve: al primo tentativo di pubblicazione l’agente aveva dimenticato l’header JSON, WordPress aveva ignorato la richiesta e lui si è fermato a chiedere. Gliel’ho fatto notare e l’articolo è uscito. Da quella prova viene la mezza riga sul JSON nella mappa.

Prima di andare in produzione

La demo è volutamente semplice. Su un sito vero aggiungerei almeno:

  • SSH solo dalla VPN, con Tailscale (curl -fsSL https://tailscale.com/install.sh | sh e sudo tailscale set --ssh), oppure Headscale se vuoi il control plane in casa; poi chiudi la porta 22 su Internet.
  • Un utente non root per l’agente, con i soli permessi che servono.
  • Docker dal repository apt ufficiale invece dello script, e aggiornamenti automatici di sicurezza.
  • Uptime Kuma su una macchina diversa da quella che controlla.
  • Backup anche fuori dal server, con il restore provato a calendario.

Da dove vengono i docker compose

Nessun compose di questa guida è inventato: ognuno parte dall’esempio ufficiale del progetto. Qui trovi l’originale e cosa ho cambiato, così puoi confrontarli.

Servizio Esempio ufficiale Cosa ho cambiato
WordPress e database compose.yaml dell’immagine ufficiale, lo stesso mostrato su Docker Hub Versione fissata a wordpress:7.1-apache; MariaDB al posto di MySQL; nessuna porta esposta perché davanti c’è Caddy; WordPress parte solo quando il database è pronto
Controllo di salute di MariaDB Using healthcheck.sh Stesso comando di test, con 5 tentativi invece di 3
Caddy Docker Compose example dell’immagine ufficiale e la direttiva reverse_proxy Solo le porte 80 e 443 e il volume dei certificati; il Caddyfile è montato come file singolo, più semplice per una demo: dopo ogni modifica serve docker compose restart caddy
Uptime Kuma compose.yaml del repository Nessuna porta esposta (ci si arriva da Caddy); dati in un volume Docker invece che in una cartella
Bugsink docker-compose-sample.yaml e la guida Docker Compose install Nessuna porta esposta; BEHIND_HTTPS_PROXY attivo e BASE_URL pubblico perché sta dietro Caddy; password generate nel file .env
Backrest Sezione Docker Compose del README Interfaccia raggiungibile solo dal server (127.0.0.1); dati di WordPress e dump montati in sola lettura

Fonti e documentazione

Le slide del talk e il video (appena WordPress.tv lo pubblica) arrivano su questa pagina. Qui sotto ci sono le pagine ufficiali che ho usato per ogni passaggio, nell’ordine della guida.

Modello e agente

Server e sito

Dominio e contenuti

Monitoraggio e backup

Se rifai l’esperimento e qualcosa non torna, scrivimi: la guida la aggiorno con quello che impariamo insieme.