Runtipi: Installare un'app docker non è mai stato così semplice

Runtipi è un orchestratore self-hosted: un'unica interfaccia web per installare, gestire e aggiornare decine di app Docker (Nextcloud, Jellyfin, Pi-hole, Navidrome, ecc.) con un click.

Non serve sapere cosa sia un docker-compose.yml. Non serve configurare reverse proxy, database o reti. Apri il browser, scegli l'app, premi Install.

Requisiti minimi

⚠️ Runtipi non gira nativamente su Windows o macOS. La soluzione è una VM Linux (vedi sotto).

Opzione A — Hai già un server Linux

Una riga e sei a posto:

curl -L https://setup.runtipi.io | bash

L'installer gestisce tutto: Docker, reti, Traefik, database. Dopo 2-5 minuti apri http://<IP_server> nel browser.

Opzione B — Sei su Windows o macOS

Passo 1 — Crea la VM

Configurazione VM:

• 4 vCPU, 4 GB RAM, 30 GB disco
• Rete: NAT (semplice) o Bridge (se vuoi accedere dalla LAN)
• Guest: Ubuntu Server 24.04 (senza GUI, ~600 MB)

Passo 2 — Installa Runtipi nella VM

SSH dentro la VM e:

curl -L https://setup.runtipi.io | bash

Passo 3 — Accedi

Dal browser del tuo PC: http://<IP_VM>:8377

💡 Suggerimento: se usi VirtualBox con rete NAT, fai un port forwarding dalla porta 8377 del host alla porta 80 della VM. Così accedi da http://localhost:8377.

Opzione C — Installazione manuale con Docker Compose

Se vuoi il controllo totale (o se l'installer non è compatibile con il tuo setup), ecco il compose "a prova di non addetto":

docker-compose.yml

  services:
  runtipi-reverse-proxy:
    container_name: runtipi-reverse-proxy
    image: traefik:v3.6.14
    restart: unless-stopped
    depends_on:
      runtipi:
        condition: service_healthy
    ports:
      - "8377:80"
    command: --providers.docker
    volumes:
      - ./traefik:/etc/traefik
      - ./traefik/shared:/shared
      - /var/run/docker.sock:/var/run/docker.sock:ro
    networks:
      - tipi_main_network

  runtipi-db:
    container_name: runtipi-db
    image: postgres:14
    restart: unless-stopped
    stop_grace_period: 1m
    volumes:
      - ./data/postgres:/var/lib/postgresql/data
    environment:
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_USER: tipi
      POSTGRES_DB: tipi
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -d tipi -U tipi"]
      interval: 5s
      timeout: 10s
      retries: 20
      start_period: 5s
    networks:
      - tipi_main_network

  runtipi-queue:
    container_name: runtipi-queue
    image: rabbitmq:4-alpine
    restart: unless-stopped
    environment:
      RABBITMQ_DEFAULT_USER: tipi
      RABBITMQ_DEFAULT_PASS: ${RABBITMQ_PASSWORD}
    networks:
      - tipi_main_network

  runtipi:
    container_name: runtipi
    image: ghcr.io/runtipi/runtipi:${TIPI_IMAGE_TAG}
    restart: unless-stopped
    privileged: true
    healthcheck:
      start_period: 10s
      test: ["CMD", "curl", "-f", "http://localhost:3000/api/health"]
      interval: 10s
      timeout: 10s
      retries: 20
    depends_on:
      runtipi-db:
        condition: service_healthy
      runtipi-queue:
        condition: service_started
    env_file:
      - .env
    volumes:
      - ./media:/data/media
      - ./state:/data/state
      - ./repos:/data/repos
      - ./apps:/data/apps
      - ./logs:/data/logs
      - ./traefik:/data/traefik
      - ./user-config:/data/user-config
      - ./app-data:/app-data
      - ./backups:/data/backups
      - ./.env:/data/.env
      - ./cache:/cache
      - ./docker-compose.yml:/data/docker-compose.yml
      - /var/run/docker.sock:/var/run/docker.sock
      - /proc:/host/proc
      - /etc/localtime:/etc/localtime:ro
      - /etc/timezone:/etc/timezone:ro
    environment:
      NODE_ENV: production
      ROOT_FOLDER_HOST: /home/mac/runtipi
      RABBITMQ_HOST: runtipi-queue
      RABBITMQ_USERNAME: tipi
    networks:
      - tipi_main_network
    labels:
      traefik.enable: "true"
      traefik.http.services.dashboard.loadbalancer.server.port: "3000"
      traefik.http.routers.dashboard.rule: PathPrefix("/")
      traefik.http.routers.dashboard.service: dashboard
      traefik.http.routers.dashboard.entrypoints: web

networks:
  tipi_main_network:
    driver: bridge
    name: runtipi_tipi_main_network   

.env

TIPI_VERSION=4.11.0
TIPI_IMAGE_TAG=v4.11
POSTGRES_PASSWORD=runtipi
RABBITMQ_PASSWORD=runtipi

Script di installazione "a prova di non addetto"

#!/bin/bash
# install-runtipi.sh — copia questo file sul server ed eseguilo

set -e

DIR="$HOME/runtipi"

echo "📁 Creazione cartelle..."
mkdir -p "$DIR"/{media,state,repos,apps,logs,traefik/shared,user-config,app-data,backups,cache,data/postgres}
cd "$DIR"

echo "📝 Scrittura file..."
cat > .env << 'EOF'
TIPI_VERSION=4.11.0
TIPI_IMAGE_TAG=v4.11
POSTGRES_PASSWORD=runtipi
RABBITMQ_PASSWORD=runtipi
EOF

# (qui incollare il docker-compose.yml)

echo "🚀 Avvio..."
docker compose up -d

echo ""
echo "✅ Fatto! Apri http://$(hostname -I | awk '{print $1}'):8377 nel browser"

chmod +x install-runtipi.sh
./install-runtipi.sh

Primo accesso

1. Apri http://<IP>:8377
2. Crea l'account admin (email + password)
3. Vai in Apps → scegli → Install

Note pratiche

TL;DR

In nessun caso serve capire Docker. Runtipi lo fa al posto tuo.