> ## Content Index
> Fetch the complete content index at: https://opensourcesociety.net/llms.txt
> Use this file to discover other available public pages before exploring further.

# Runtipi: Installare un'app docker non è mai stato così semplice
- URL: https://opensourcesociety.net/runtipi-installare-unapp-docker-non-e-mai-stato-cosi-semplice/
- Published: 2026-10-23T12:22:50.000Z
- Updated: 2026-10-23T12:22:50.000Z
- Author: Marco Scurria

**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

|       | Minimo        | Consigliato             |
| ----- | ------------- | ----------------------- |
| CPU   | 2 core x86-64 | 4 core (x86-64 o ARM64) |
| RAM   | 4 GB          | 8 GB                    |
| Disco | 10 GB liberi  | 40 GB+ SSD              |
| OS    | Linux 64-bit  | Ubuntu 22.04+           |

> ⚠️ 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

| Piattaforma | Strumento                     | Note                                                       |
| ----------- | ----------------------------- | ---------------------------------------------------------- |
| **Windows** | VirtualBox (gratis) o Hyper-V | VirtualBox è più semplice per iniziare                     |
| **macOS**   | UTM (gratis) o Parallels      | UTM usa Apple Virtualization API, molto veloce su M1/M2/M3 |

**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

| Tema                  | Dettaglio                                                                                     |
| --------------------- | --------------------------------------------------------------------------------------------- |
| **Porta**             | 8377 (cambiabile nel compose). Se 80 è occupata dal router, non c'è conflitto                 |
| **Pi-hole / Unbound** | Se hai già un DNS custom su rete macvlan, non interferisce: Runtipi usa la sua bridge interna |
| **Backup**            | Runtipi ha backup integrato (da UI). Fai anche un rsync della cartella \~/runtipi/            |
| **Update**            | Da UI: **Settings → Update**. Fa backup automatico prima                                      |
| **Raspberry Pi**      | Funziona (ARM64), ma alcune app non hanno immagine ARM                                        |

---

## TL;DR

| Sei su...                    | Fai questo                               |
| ---------------------------- | ---------------------------------------- |
| **Linux** (server, VPS, RPi) | curl -L https://setup.runtipi.io \| bash |
| **Windows**                  | VirtualBox → Ubuntu 24.04 → stessa riga  |
| **macOS**                    | UTM → Ubuntu 24.04 → stessa riga         |
| **Vuoi controllo totale**    | docker compose up -d con il file sopra   |

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