Micro-SD ou SSD pour stockage Raspberry Pi ?

Micro-SD pour OS de démarrage. SSD USB pour data si volume important. Pi 4 supporte boot depuis USB. Évite la corruption SD due aux écritures fréquentes comme logs ou base de données. Compter SSD 256 à 500 Go pour usage Nextcloud confortable avec marge sur 2-3 ans d'usage.

Faut-il un boîtier passif ou ventilé pour Pi serveur ?

Climat tropical : ventilé recommandé. Boîtiers Argon ONE ou similaires avec heatsink plus ventilateur silencieux plus bouton power. Le Pi tourne mieux à 50°C qu'à 75°C, surtout pour un usage 24/7. La longévité du SoC et de la SD card y gagne significativement.

Comment exposer mes services Pi en HTTPS ?

Reverse proxy avec Caddy ou Nginx plus Let's Encrypt automatique. Plus simple : utiliser Tailscale Funnel ou Cloudflare Tunnel pour exposer sans IP publique ni port-forwarding routeur. Voir doc Tailscale Funnel ou Cloudflare Tunnel pour setup zero-trust en quelques commandes.

Mon Pi rame avec tous ces services, quelles optimisations ?

Vérifier RAM utilisée avec htop, I/O disk avec iotop, processus zombie avec ps aux. Réduire scrape interval Prometheus, désactiver swap si SSD, limiter Docker logs avec max-size 10m. Si vraiment limité : passer Pi 5 ou Mini PC x86 pour le serveur principal et garder Pi pour edge computing.

Raspberry Pi serveur domestique : tutoriel complet 2026

Lecture : 14 minutes · Niveau : intermédiaire · Mise à jour : avril 2026

Tutoriel pas-à-pas pour transformer un Raspberry Pi 4B (ou 5) en serveur multi-usage : OS sécurisé, Pi-hole (ad-blocker DNS), Home Assistant (domotique IoT), Nextcloud (cloud privé), broker MQTT Mosquitto, monitoring Prometheus/Grafana, accès distant Tailscale. Tout est testable sur un Pi à environ 80 USD + micro-SD 64 Go + alim 5V/3A.

Pourquoi un Raspberry Pi plutôt qu’un VPS cloud ou un mini PC ? Pour une PME ouest-africaine, plusieurs critères font pencher la balance : (1) coût d’acquisition unique modéré sans abonnement mensuel, (2) consommation électrique très faible (~5-10W) — important quand l’électricité est instable et coûteuse, (3) données restent en local, ce qui simplifie la conformité cdp.sn et évite la dépendance à un cloud étranger, (4) réversibilité totale — si l’expérience ne convient pas, le matériel est revendu sans engagement. Le VPS cloud reste pertinent pour des charges importantes ou des accès très distants ; le mini PC x86 quand on dépasse les capacités d’un Pi. Mais pour démarrer ou pour la majorité des usages PME standards, le Pi est imbattable.

Vision d’ensemble du serveur ainsi construit. Au final, un seul Raspberry Pi rend les services suivants : ad-blocking pour tout le réseau, plateforme de domotique et IoT centralisée, cloud privé pour les fichiers de l’entreprise, broker pour les capteurs, dashboard de monitoring, accès distant sécurisé sans exposition Internet, sauvegardes automatiques chiffrées vers le cloud. L’équivalent en services SaaS commerciaux représenterait plusieurs centaines d’euros par an. Le Pi rend ces services pour un coût matériel unique modeste plus quelques heures de configuration initiale.

Voir aussi → IoT pratique et sécurité pour PME, ESP32 + MQTT tutoriel, Sécurité IoT MQTT firmware.

1. Setup OS : Raspberry Pi OS Lite

Recommandé : Raspberry Pi OS Lite 64-bit (sans bureau, plus léger pour serveur).

# Sur PC : télécharger Raspberry Pi Imager
# https://www.raspberrypi.com/software/
sudo snap install rpi-imager

# Flash micro-SD :
# - OS : "Raspberry Pi OS Lite (64-bit)"
# - Settings (icône engrenage) :
#   * Hostname : pi-server
#   * Username : adminpi
#   * Password : (fort, unique)
#   * Activer SSH avec clé publique (coller votre ~/.ssh/id_ed25519.pub)
#   * Wi-Fi (si pas Ethernet)
#   * Locale FR_FR

Insérer la SD, brancher Ethernet (préféré au Wi-Fi pour serveur), alimenter.

Première connexion SSH :

ssh adminpi@pi-server.local
# Ou IP : ssh adminpi@192.168.1.20

# Mise à jour système
sudo apt update && sudo apt upgrade -y
sudo apt install -y vim htop git curl ufw fail2ban

2. Hardening initial (SSH, ufw, fail2ban)

Désactiver login root + password SSH :

sudo nano /etc/ssh/sshd_config

PermitRootLogin no
PasswordAuthentication no
PubkeyAuthentication yes

sudo systemctl restart ssh

Pare-feu UFW :

sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow ssh
# Port adicionalement ouverts plus tard selon services
sudo ufw enable
sudo ufw status

fail2ban : déjà installé, configuration par défaut suffit pour SSH. Vérifier :

sudo fail2ban-client status sshd

Mises à jour automatiques :

sudo apt install -y unattended-upgrades
sudo dpkg-reconfigure unattended-upgrades   # → Yes

3. Pi-hole : DNS ad-blocker

Pi-hole bloque les pubs et trackers au niveau DNS pour tout le réseau.

curl -sSL https://install.pi-hole.net | bash

L’installer demande :
– Interface (eth0)
– Upstream DNS (Cloudflare ou Quad9 recommandé)
– Listes de blocage (par défaut OK)
– Web UI : Yes
– Web UI password : noter

Configurer le routeur du LAN :
– DNS primaire : IP du Pi (ex. 192.168.1.20)
– DNS secondaire : 1.1.1.1 (fallback)

→ Tous les appareils du réseau utilisent Pi-hole automatiquement.

Interface admin : http://pi-server.local/admin ou http://IP/admin.

Statistiques typiques : 20-40% des requêtes DNS bloquées (pubs, trackers, malware C2).

4. Home Assistant via Docker

# Installer Docker
curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker adminpi
newgrp docker

# Docker compose
sudo apt install -y docker-compose-plugin

docker-compose.yml dans ~/homeassistant :

services:
  ha:
    image: ghcr.io/home-assistant/home-assistant:stable
    container_name: homeassistant
    restart: unless-stopped
    network_mode: host
    privileged: true
    volumes:
      - ./config:/config
      - /etc/localtime:/etc/localtime:ro

mkdir -p ~/homeassistant/config
cd ~/homeassistant
docker compose up -d
docker logs -f homeassistant

Ouvrir http://pi-server.local:8123 → wizard initial (créer compte admin local).

Intégrations utiles :
– MQTT (pour les ESP32)
– Météo (OpenWeatherMap)
– Devices LAN (Sonoff, Shelly, Tuya, Yeelight)
– Automatisations (allumer lumière à 18h, alerte porte)

UFW : ouvrir port 8123 si accès depuis LAN :

sudo ufw allow from 192.168.1.0/24 to any port 8123

5. Mosquitto broker MQTT local

sudo apt install -y mosquitto mosquitto-clients
sudo systemctl enable --now mosquitto

# Config avec auth (voir tutoriel ESP32 + MQTT)
sudo mosquitto_passwd -c /etc/mosquitto/passwd capteur1

/etc/mosquitto/conf.d/local.conf :

listener 1883 0.0.0.0
listener 8883 0.0.0.0
allow_anonymous false
password_file /etc/mosquitto/passwd

# TLS
cafile   /etc/mosquitto/certs/ca.crt
certfile /etc/mosquitto/certs/server.crt
keyfile  /etc/mosquitto/certs/server.key

# Générer certificats auto-signés (lab)
sudo openssl req -new -x509 -days 365 -extensions v3_ca \
  -keyout /etc/mosquitto/certs/ca.key -out /etc/mosquitto/certs/ca.crt
# ... voir doc Mosquitto pour génération complète

sudo systemctl restart mosquitto

UFW :

sudo ufw allow from 192.168.1.0/24 to any port 1883
sudo ufw allow from 192.168.1.0/24 to any port 8883

Voir ESP32 + MQTT : tutoriel pratique pour intégration des capteurs.

6. Nextcloud cloud privé

Nextcloud = alternative privée à Google Drive / Dropbox, hébergée chez vous.

# ~/nextcloud/docker-compose.yml
services:
  db:
    image: mariadb:10.11
    restart: unless-stopped
    command: --transaction-isolation=READ-COMMITTED --binlog-format=ROW
    volumes:
      - ./db:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: ChangeMe123!
      MYSQL_DATABASE: nextcloud
      MYSQL_USER: nextcloud
      MYSQL_PASSWORD: AlsoChangeMe456!

  app:
    image: nextcloud:stable
    restart: unless-stopped
    ports:
      - "8080:80"
    volumes:
      - ./html:/var/www/html
      - ./data:/var/www/html/data
    environment:
      MYSQL_HOST: db
      MYSQL_DATABASE: nextcloud
      MYSQL_USER: nextcloud
      MYSQL_PASSWORD: AlsoChangeMe456!
    depends_on:
      - db

mkdir -p ~/nextcloud
cd ~/nextcloud
nano docker-compose.yml   # coller config
docker compose up -d

Ouvrir http://pi-server.local:8080 → wizard installation.

Stockage USB externe pour data volumineuse :

sudo mkdir -p /mnt/external
# Brancher disque USB, identifier avec lsblk
sudo mount /dev/sda1 /mnt/external
# Modifier docker-compose : volume data → /mnt/external/nextcloud-data

Apps Nextcloud utiles : Files, Calendar, Contacts, Notes, Tasks, Talk (vidéo), Mail, OnlyOffice (édition collaborative).

7. Tailscale : accès distant zero-trust

Tailscale crée un VPN mesh entre vos appareils sans port-forwarding ni IP publique.

curl -fsSL https://tailscale.com/install.sh | sh
sudo tailscale up
# Suivre l'URL pour authentifier (compte Google/Microsoft/GitHub)

Sur votre laptop / smartphone : installer client Tailscale, login même compte. Tous vos appareils ont une IP 100.x.y.z accessible mutuellement.

Avantages :
– Pas de port forwarding routeur
– Chiffré bout en bout (WireGuard)
– Accès Pi depuis n’importe où dans le monde
– Plan gratuit jusqu’à 100 appareils

Test :

# Sur le laptop, depuis n'importe où :
ssh adminpi@100.x.y.z
# Ou sur l'ip Tailscale du Pi

8. Monitoring : Prometheus + Grafana

docker-compose dans ~/monitoring :

services:
  prometheus:
    image: prom/prometheus
    restart: unless-stopped
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prom-data:/prometheus

  grafana:
    image: grafana/grafana
    restart: unless-stopped
    ports:
      - "3000:3000"
    volumes:
      - grafana-data:/var/lib/grafana
    environment:
      GF_SECURITY_ADMIN_PASSWORD: ChangeMe!

  node-exporter:
    image: prom/node-exporter
    restart: unless-stopped
    ports:
      - "9100:9100"
    network_mode: host
    pid: host
    volumes:
      - /:/host:ro,rslave

volumes:
  prom-data:
  grafana-data:

prometheus.yml :

global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'node'
    static_configs:
      - targets: ['localhost:9100']

docker compose up -d

Grafana : http://pi-server.local:3000 → admin/ChangeMe! → Add data source Prometheus → URL http://prometheus:9090. Importer dashboard ID 1860 (Node Exporter Full) → 30+ graphs CPU/RAM/disk/réseau prêts.

9. Backup chiffré (Restic + B2)

Voir Sauvegarde 3-2-1 connexion limitée pour le détail Restic.

Setup rapide pour Pi :

sudo apt install -y restic
mkdir -p ~/.config/restic
echo "MotDePasseFort" > ~/.config/restic/password
chmod 600 ~/.config/restic/password

# Init repo Backblaze B2
export B2_ACCOUNT_ID="..."
export B2_ACCOUNT_KEY="..."
restic -r b2:mon-bucket-pi:/backup init

# Backup quotidien (cron)
sudo nano /etc/cron.daily/restic-backup

#!/bin/bash
export RESTIC_PASSWORD_FILE=/home/adminpi/.config/restic/password
export RESTIC_REPOSITORY=b2:mon-bucket-pi:/backup
export B2_ACCOUNT_ID="..."
export B2_ACCOUNT_KEY="..."

# Sauvegarder les volumes Docker importants
restic backup ~/homeassistant ~/nextcloud /etc \
  --exclude='*.log' --exclude='cache' \
  --tag daily

restic forget --keep-daily 7 --keep-weekly 4 --keep-monthly 12 --prune

sudo chmod +x /etc/cron.daily/restic-backup

10. Auto-shutdown sur coupure courant (UPS)

Le Pi corrompt facilement la SD si coupure brutale. UPS basique recommandé.

Options matérielles :
– PiSugar : batterie + RTC pour Pi
– GeeekPi UPS HAT : carte avec batterie 18650
– Onduleur USB-C classique avec sortie monitoring

Script auto-shutdown si batterie faible (avec UPS supportant I2C) :

# /usr/local/bin/ups_monitor.py
import smbus
import os
import time

bus = smbus.SMBus(1)
UPS_ADDR = 0x36  # selon UPS

def read_voltage():
    raw = bus.read_word_data(UPS_ADDR, 0x02)
    return ((raw << 8) | (raw >> 8)) * 1.25 / 1000 / 16

while True:
    v = read_voltage()
    if v < 3.4:
        os.system("shutdown -h now 'Battery low'")
    time.sleep(60)

# Service systemd
sudo nano /etc/systemd/system/ups-monitor.service

[Unit]
Description=UPS Monitor

[Service]
ExecStart=/usr/bin/python3 /usr/local/bin/ups_monitor.py
Restart=always

[Install]
WantedBy=multi-user.target

sudo systemctl enable --now ups-monitor

FAQ

Pi 4 ou Pi 5 pour serveur ?

Pi 5 plus puissant (CPU +30%, RAM jusqu’à 8 Go, NVMe via HAT) mais consomme plus et chauffe. Pi 4 reste excellent pour la plupart des usages PME serveur. Pour Home Assistant + Nextcloud + monitoring : Pi 4 4 Go suffit largement.

Micro-SD ou SSD pour stockage ?

Micro-SD pour OS de démarrage. SSD USB pour data si volume important — Pi 4 supporte boot depuis USB. Évite la corruption SD due aux écritures fréquentes (logs, base données). Compter SSD 256-500 Go pour usage Nextcloud confortable.

Faut-il un boîtier passif ou ventilé ?

Climat tropical : ventilé recommandé. Boîtiers Argon ONE ou similaires avec heatsink + ventilateur silencieux + bouton power. Le Pi tourne mieux à 50°C qu’à 75°C, surtout pour un usage 24/7.

Comment exposer mes services en HTTPS ?

Reverse proxy avec Caddy ou Nginx + Let’s Encrypt automatique. Plus simple : utiliser Tailscale Funnel ou Cloudflare Tunnel pour exposer sans IP publique. Voir doc Tailscale Funnel ou Cloudflare Tunnel pour setup.

Mon Pi rame avec tous ces services. Optimisations ?

Vérifier : RAM utilisée (htop), I/O disk (iotop), processus zombie (ps aux). Réduire scrape interval Prometheus, désactiver swap si SSD, limiter Docker logs (max-size: "10m"). Si vraiment limité : passer Pi 5 ou Mini PC x86.

Comment migrer si le Pi meurt ?

Restic restore depuis B2 sur nouveau Pi. Les volumes Docker stockent les données importantes — recréer les conteneurs et restaurer les volumes. Documenter docker-compose dans Git privé. Pi remplaçable en 1-2h après hardware reçu.

Tailscale collecte-t-il mes données ?

Tailscale ne voit pas le contenu (chiffré WireGuard end-to-end) mais voit la métadonnée (qui se connecte à quoi). Pour 100% privé : auto-héberger Headscale (open-source compatible). Pour PME : Tailscale géré suffit, leur politique privacy est claire.

Combien de capteurs ESP32 un Pi 4 peut-il gérer ?

Mosquitto + Home Assistant + InfluxDB sur Pi 4 4 Go : facilement 100-200 capteurs publishant toutes les 10-60 sec. Au-delà : Pi 5 8 Go ou Mini PC x86. Le bottleneck est généralement la base de données et Grafana, pas Mosquitto qui est très léger.

Articles liés (cluster IoT)

Voir aussi : Sauvegarde 3-2-1 connexion limitée, Linux administration avancée pour PME.

Article mis à jour le 25 avril 2026. Pour signaler une erreur ou suggérer une amélioration, écrivez-nous.