Come deployare un agente AI su un Droplet DigitalOcean

Perché tutti finiscono su DigitalOcean per gli agenti AI

Quando decidi di self-hostare un agente AI, prima o poi arrivi allo stesso trio: Hetzner, AWS EC2 o DigitalOcean. Ognuno attira un pubblico diverso. Hetzner attira chi ottimizza i costi in Europa. AWS attira la squadra "in azienda lo usiamo già". DigitalOcean attira l'indie SaaS che vuole una macchina Ubuntu pulita, un pannello di controllo curato, un'immagine 1-Click Docker ufficiale e una documentazione che non presume di che team fai parte.

C'è un altro motivo per cui DigitalOcean compare così spesso in questa nicchia: la DigitalOcean Community ha un catalogo crescente di tutorial sugli agenti AI e di immagini 1-Click nel Marketplace (Docker Agent, Ollama, basi pensate per gli agenti) che accorciano la prima ora di installazione. Se il tuo runtime esce già come container, metà della battaglia "portare l'agente online" è di fatto vinta.

Questa guida è per chi ha scelto DigitalOcean e vuole tirare su un agente self-hosted (Hermes Agent, un workflow n8n con nodo LLM, un proxy di OpenAI Assistants, tutto ciò che chiama un'API di modello da un server sempre acceso) senza saltare i pezzi che contano alle 3 di notte. Sizing, hardening, Docker Compose, un test su Telegram e la lista onesta di ciò che si romperà.

Se stai ancora scegliendo il provider, la nostra guida a Hetzner e il confronto tra VPS economici coprono il resto. Questo post dà per scontato DigitalOcean.

Passo 1: scegli il Droplet giusto

La linea di CPU condivise di DigitalOcean nel 2026 si divide in tre gruppi che vedi nel pannello di creazione:

• Regular Intel - le classiche vCPU condivise, più vecchie e lente per dollaro
• Premium Intel / Premium AMD - chip più nuovi, single-thread più veloce
• Basic AMD (fatturazione al secondo) - il punto ideale attuale per servizi piccoli

Per un agente guidato dalle API (che chiama OpenAI, Anthropic, OpenRouter o il tuo Ollama e orchestra i tool call in locale), l'inferenza gira sui server del provider. Il Droplet deve solo far girare il processo dell'agente, un gateway Telegram e il daemon Docker: non serve molta CPU. Il vincolo è la RAM.

DigitalOcean è passata alla fatturazione al secondo (minimo 60 secondi) il 1º gennaio 2026, quindi un Droplet che accendi per provare e distruggi lo stesso pomeriggio ti costa centesimi, non un mese. Ogni Droplet include una quota di traffico (1 TB sul piano da 6 $, 4 TB sul piano da 24-28 $), più che sufficiente per un agente che soprattutto rilancia messaggi di chat.

Consiglio: parti con s-2vcpu-4gb-amd. Due vCPU e 4 GB di RAM lasciano margine per l'agente, un piccolo polling IMAP, una skill con browser headless e un reverse proxy, senza sorprese OOM la prima volta che il backend di memoria scrive un batch su disco. Se l'unico carico è un agente di chat contro un modello cloud, il piano da 6 $ (s-1vcpu-1gb) basta davvero.

Salta il piano da 4 $ se ti serve Docker più un volume di memoria più un gateway Telegram. Supererà la soglia OOM entro una settimana.

Passo 2: blinda il Droplet prima di entrare in SSH

Questo è il passo che si salta e che fa male dopo. DigitalOcean ha una Cloud Firewall che gira a livello di hypervisor, prima che i pacchetti arrivino alla VM. Configurala prima che il Droplet parta, così la macchina non accetta mai un pacchetto su una porta che non volevi aprire.

Nella console DigitalOcean vai in Networking > Firewalls > Create Firewall. Regole in ingresso:

• SSH (TCP 22) solo da My IP (o da un piccolo CIDR se hai un IP fisso di ufficio)
• HTTP (TCP 80) da All IPv4, All IPv6 (solo se metti su un reverse proxy)
• HTTPS (TCP 443) da All IPv4, All IPv6 (solo per webhook HTTPS o una UI web)
• ICMP da All IPv4, All IPv6 (perché i ping di monitoring funzionino)

In uscita: lascia i default - l'agente deve poter raggiungere l'API del modello. Aggancia questa firewall al Droplet in fase di creazione. Non creare prima il Droplet per poi collegare la firewall dopo.

Per un setup più forte, chiudi del tutto la porta 22 verso internet e raggiungi la macchina via Tailscale. DigitalOcean ha una 1-Click Tailscale e la documentazione di Tailscale copre il flusso "chiudi la porta 22 per sempre". La Cloud Firewall scarta i tentativi SSH al bordo, quindi non toccano neanche fail2ban o i tuoi log.

Quando crei il Droplet, scegli Ubuntu 24.04 LTS, incolla la tua chiave pubblica SSH, aggancia la firewall e clicca Create. Appena il Droplet è su, entra in SSH come root e fai subito quattro cose:

# 1. Aggiorna
apt update && apt upgrade -y && apt install -y ufw fail2ban unattended-upgrades

# 2. Crea un utente non-root
adduser --disabled-password --gecos "" agent
usermod -aG sudo agent
mkdir -p /home/agent/.ssh && cp ~/.ssh/authorized_keys /home/agent/.ssh/
chown -R agent:agent /home/agent/.ssh && chmod 600 /home/agent/.ssh/authorized_keys

# 3. Blinda SSH
sed -i 's/^#*PermitRootLogin.*/PermitRootLogin no/' /etc/ssh/sshd_config
sed -i 's/^#*PasswordAuthentication.*/PasswordAuthentication no/' /etc/ssh/sshd_config
systemctl restart ssh

# 4. Firewall dell'host (UFW), ridondante rispetto alla Cloud Firewall ma un'utile rete di sicurezza
ufw default deny incoming && ufw default allow outgoing
ufw allow OpenSSH && ufw allow 80/tcp && ufw allow 443/tcp
ufw --force enable

Poi attiva gli aggiornamenti di sicurezza non presidiati e fail2ban:

dpkg-reconfigure -plow unattended-upgrades   # rispondi Yes
systemctl enable --now fail2ban

Esci da root, rientra come agent e vai avanti da lì.

Passo 3: installa Docker (o usa l'immagine 1-Click)

Hai due strade.

Strada A: installa Docker su Ubuntu pulito. Standard, una riga, funziona ovunque:

curl -fsSL https://get.docker.com | sudo sh
sudo usermod -aG docker agent
newgrp docker
docker run --rm hello-world

Strada B: usa l'immagine Docker del Marketplace DigitalOcean. Nella pagina di creazione del Droplet scegli Marketplace > Docker (Ubuntu 24.04 con Docker preinstallato). Salti l'installazione e parti da un setup già pronto. Stesso risultato, un comando in meno.

Se il tuo runtime pubblica un'immagine 1-Click ufficiale su DigitalOcean (Docker Agent, Ollama e una lista che cresce lo fanno), puoi andare oltre e usare direttamente quell'immagine, poi comporre solo il tuo file env e i volumi.

Passo 4: metti su l'agente con Docker Compose

Crea ~/agent/docker-compose.yml. L'esempio è generico; cambia la reference dell'immagine con il runtime che usi.

services:
  agent:
    image: ghcr.io/your-runtime/agent:latest
    container_name: agent
    restart: unless-stopped
    env_file: .env
    volumes:
      - ./data:/data
      - ./skills:/skills
      - ./memory:/memory
    ports:
      - "127.0.0.1:8080:8080"   # UI web esposta solo su localhost

Poi ~/agent/.env:

# Provider modello (BYOK - porta la tua chiave)
OPENAI_API_KEY=sk-...
# o ANTHROPIC_API_KEY / OPENROUTER_API_KEY

# Gateway di messaggistica
TELEGRAM_BOT_TOKEN=...
TELEGRAM_ALLOWED_USERS=12345678

# Persistenza
DATA_DIR=/data
MEMORY_DIR=/memory

chmod 600 .env perché gli altri utenti della macchina non possano leggere le chiavi, e via:

docker compose up -d
docker compose logs -f agent

restart: unless-stopped è ciò che tiene vivo l'agente attraverso i riavvii del Droplet (DigitalOcean ne fa ogni tanto per manutenzione).

Aggancia un Volume persistente

Il disco di root del Droplet basta per il container, ma lo stato dell'agente (file di memoria, skill, storico conversazioni) va su un Volume DigitalOcean a parte. Sopravvive alla distruzione del Droplet, ha snapshot indipendenti e può essere riagganciato a un nuovo Droplet se cambi taglia.

Dalla console: Volumes > Create > 10 GB > attach to your Droplet. Poi sulla macchina:

sudo mkdir -p /mnt/agent-state
sudo mount -o discard,defaults,noatime /dev/sda /mnt/agent-state
echo '/dev/sda /mnt/agent-state ext4 defaults,nofail,discard 0 0' | sudo tee -a /etc/fstab
sudo chown agent:agent /mnt/agent-state

Fai puntare i volumi ./data, ./skills, ./memory di docker-compose.yml a sottodirectory di /mnt/agent-state. Un Volume da 10 GB costa circa 1 $/mese.

Passo 5: collega Telegram e prova

Se Telegram è il tuo canale (la maggior parte di chi self-hosta ci arriva perché la Bot API è gratuita e istantanea), il loop di test è corto:

1. Parla con @BotFather, esegui /newbot, salva il token in .env.
2. Parla con @userinfobot per ottenere il tuo ID utente numerico di Telegram e mettilo in TELEGRAM_ALLOWED_USERS.
3. docker compose restart agent.
4. Apri il tuo nuovo bot e manda "ciao".

Dovresti avere risposta entro pochi secondi. Se no, docker compose logs -f agent di solito punta al problema: token mancante, ID utente permesso sbagliato o provider che restituisce 401.

Per un approfondimento sulla parte Telegram (gruppi, topic, modalità voce, troubleshooting), leggi come costruire un agente AI su Telegram.

Passo 6: backup e monitoring

Due abitudini economiche che si ripagano alla prima rottura:

• DigitalOcean Backups o Snapshots. I Backups sono settimanali e automatici con quattro settimane di retention, al 20% del prezzo del Droplet. Gli Snapshots sono manuali, al GB al mese (circa 0,05 $/GB/mese). Come minimo, taggane uno "before-update" prima di ogni docker compose pull.
• Un ping di uptime. BetterStack, UptimeRobot o l'Uptime di DigitalOcean stesso. Fagli colpire https://tuo-dominio/health (o un check TCP) ogni 5 minuti. La prima volta che il long-polling di Telegram cade alle 3 di notte lo scopri prima di pranzo, non a pranzo.

Per lo stato dell'agente sul Volume basta un cron di una riga che impacchetta /mnt/agent-state in /var/backups/agent-$(date +%F).tar.gz, più un rsync verso DigitalOcean Spaces (compatibile S3, piano d'ingresso 5 $/mese). Spaces conserva i tarball a prezzo di object storage, molto sotto al "attacco un secondo Droplet".

Passo 7: aggiornamenti

Una volta a settimana, snapshot fresco alla mano:

cd ~/agent
docker compose pull
docker compose up -d
docker image prune -f

Di solito meno di un minuto. Se la nuova immagine rompe qualcosa, ripristini lo snapshot dalla console. L'unico stato che perdi è quello scritto tra lo snapshot e adesso, che vive nel Volume di memoria.

Cosa si rompe prima o poi

Lista onesta, indipendente dal provider e provata dal tempo:

• Il long-polling di Telegram cade ai piccoli buchi di rete. La maggior parte dei runtime si riconnette; se il tuo non lo fa, lo prende il ping di uptime.
• docker compose pull :latest porta un cambio di config incompatibile. Fissa i tag delle immagini a versioni specifiche in produzione.
• Il provider del modello ti rate-limita e l'agente ammutolisce senza errore chiaro. Logga lo stato HTTP dal client del provider.
• Il disco di root si riempie perché una skill scrive in /tmp senza rotazione. du -sh /* e docker system df devono stare nella memoria muscolare. È proprio per questo che lo stato persistente vive su un Volume.
• Ti dimentichi la regola di firewall quando aggiungi un servizio. Sia Cloud Firewall che UFW vogliono la nuova porta, altrimenti perdi 20 minuti a debuggare "connection refused" dal lato sbagliato.

Niente di tutto questo è specifico di DigitalOcean. È la tassa per gestire tutto da soli.

Il conto reale

Numeri di massima al mese per una piccola produzione su DigitalOcean, metà 2026:

• Droplet (s-2vcpu-4gb-amd): 28 $
• Volume da 10 GB: 1 $
• Weekly Backups: circa 5,60 $
• Spaces (backup off-site, 250 GB / 1 TB di transfer): 5 $
• Ping di uptime: 0 $ (piano gratuito)

Totale: circa 40 $/mese per un host di agente AI ben salvato, monitorato e isolato su DigitalOcean. Su Hetzner la stessa forma sta intorno a 8-10 $/mese (regioni UE, CPU comparabile, 20 TB di transfer inclusi), su AWS EC2 lo stesso set finisce a 60-80 $/mese una volta aggiunti EBS e uscita dati. DigitalOcean sta esattamente in mezzo, al prezzo della cura, dei docs, delle 1-Click e del non dover pensare ai tier di fatturazione.

Quando i conti del VPS non tornano più

Se i passi qui sopra ti convincono, quello è esattamente il flusso per cui è pensata DigitalOcean. Pannello pulito, immagini a un clic, un ecosistema pieno di tutorial "come far girare X".

Se ti sembrano una tassa sul weekend, il paragone cambia. L'hosting gestito scambia una piccola cifra al mese e un pomeriggio di domenica con un setup che include già gateway Telegram, BYOK verso il tuo provider di modello, memoria persistente, snapshot e "resta su mentre dormi". La nostra guida hosting vs self-hosting fa i conti per bene, incluso quanto vale il tuo tempo.

Parti con Hermify se preferisci la strada gestita: un Hermes Agent su infrastruttura di produzione in circa un minuto, senza Cloud Firewall da configurare né Volumi da attaccare. Se preferisci farlo da te su DigitalOcean, questa guida dovrebbe portarti fino in fondo.

Fonti

• How To Build a Multi-Agent AI System with Docker Agent - DigitalOcean
• Docker Agent 1-Click - DigitalOcean Marketplace
• AI Agents category - DigitalOcean Marketplace
• Droplet Pricing 2026 - DigitalOcean
• DigitalOcean vs Hetzner Cloud 2026 - Better Stack
• SSH Access Through Tailscale Behind a Cloud Firewall - KBeezie
• Using DigitalOcean Droplets as Ephemeral Sandboxes for AI Agents - dev.to