HomeServer IA sur RPi4 ou N54L

Installer un serveur IA full self-hosted sur Raspberry Pi 4 ou HP MicroServer N54L, sans VPS.

Temps estimé : 60-90 min (selon hardware)

Résultat final : HomeServer local (RPi4 ou N54L) avec OpenClaw, accessible exclusivement via Tailscale, zéro dépendance VPS/cloud.

Objectif

Déployer un HomeServer 100% local en recyclant du hardware existant. Cette option offre :

• Prix : $0 (hardware déjà possédé)
• CPU : RPi4 (4 cores ARM) ou N54L (2 cores x86)
• RAM : 4GB+ (RPi4) ou 8GB (N54L avec upgrade)
• Localisation : Ton salon / bureau — souveraineté totale
• Disponibilité : Immédiate (pas de quota cloud)

⚠️ Note : Alternatives VPS disponibles → TUTO-01a ou TUTO-01b

Prérequis

Hardware

• Option A : Raspberry Pi 4 (4GB+ RAM recommandé, 8GB idéal)
• Option B : HP N54L MicroServer recyclé avec upgrade RAM 8GB
• Alimentation : Adaptateur fiable (RPi4) ou alim d’origine (N54L)
• Stockage : MicroSD 32GB+ (RPi4) ou HDD/SSD 120GB+ (N54L)

Software

• Un ordinateur avec SSH installé (Linux/macOS natif, Windows : Git Bash ou WSL)
• Un compte Tailscale (gratuit, 2 devices pour usage perso)
• Une clé USB pour flasher l’OS (si RPi4)

Étape 1 : Préparer le système d’exploitation

Option A — Raspberry Pi 4 : Flasher Ubuntu Server

1. Télécharge Ubuntu Server 22.04 LTS ARM64 pour Raspberry Pi 4 : https://cdimage.ubuntu.com/ubuntu-server/releases/22.04.5/release/ubuntu-22.04.5-live-server-arm64.iso

2. Utilise Raspberry Pi Imager ou Etcher pour flasher sur microSD

3. Avant d’insérer la microSD, active SSH par défaut :

# Sur la partition boot (accessible depuis ton poste)
touch /media/USER/boot/ssh

4. Insère la microSD dans le RPi4, connecte Ethernet + alimentation

Option B — HP N54L : Installer Ubuntu Server

1. Télécharge Ubuntu Server 22.04 LTS x86_64 : https://releases.ubuntu.com/22.04/ubuntu-22.04.5-live-server-amd64.iso

2. Flash sur USB avec Rufus (Windows) ou Etcher (Linux/macOS)

3. Connecte le USB sur N54L, boot en appuyant sur F9 au démarrage

4. Sélectionne le USB → Install Ubuntu Server

Checklist :

• Ubuntu Server 22.04 LTS installé
• SSH activé (RPi4) ou installé via installateur (N54L)
• IP locale notée (DHCP ou fixe)
• Connexion locale fonctionnelle (moniteur/écran ou SSH depuis réseau local)

Étape 2 : Générer la clé SSH Ed25519

Même méthode que pour un VPS — clé dédiée, passphrase obligatoire.

# Générer la paire de clés Ed25519
ssh-keygen -t ed25519 -C "openclaw-homelab-local" -f ~/.ssh/openclaw_homelab

Le terminal demande une passphrase — NE PAS laisser vide.

# Vérifier les permissions — la clé privée doit être lisible par toi seul
ls -la ~/.ssh/openclaw_homelab
# Doit afficher : -rw------- (600)
# Si ce n'est pas le cas :
chmod 600 ~/.ssh/openclaw_homelab

# Afficher la clé PUBLIQUE à copier sur le HomeServer
cat ~/.ssh/openclaw_homelab.pub
# Format attendu : ssh-ed25519 AAAA... openclaw-homelab-local

Checklist :

• Paire de clés générée dans ~/.ssh/
• Clé privée en chmod 600
• Passphrase définie (non vide)
• Clé publique affichée et prête à copier

Étape 3 : Première connexion SSH locale

Depuis ton poste sur le même réseau local :

# RPi4 : user par défaut = ubuntu
ssh -i ~/.ssh/openclaw_homelab ubuntu@IP_LOCALE_RPI4

# N54L : user créé lors de l'installation (ou root si pas de user créé)
ssh -i ~/.ssh/openclaw_homelab USER_N54L@IP_LOCALE_N54L

Une fois connecté :

# Vérifier l'architecture
uname -m
# RPi4 : aarch64 (ARM 64-bit)
# N54L : x86_64

cat /etc/os-release | grep PRETTY
# Doit afficher : Ubuntu 22.04 LTS

Checklist :

• Connexion SSH réussie
• Architecture confirmée (aarch64 ou x86_64)
• Fingerprint vérifié avant confirmation

Étape 4 : Configurer la clé SSH sur le HomeServer

# Sur le HomeServer (pas en local)
mkdir -p ~/.ssh
chmod 700 ~/.ssh

# Copier la clé PUBLIQUE (celle affichée à l'étape 2)
echo "ssh-ed25519 AAAA... openclaw-homelab-local" >> ~/.ssh/authorized_keys
chmod 600 ~/.ssh/authorized_keys

Déconnecte-toi et reconnecte-toi pour vérifier que la clé fonctionne :

# En local
ssh -i ~/.ssh/openclaw_homelab ubuntu@IP_LOCALE_RPI4
# Ne devrait plus demander de mot de passe, juste la passphrase de la clé

Checklist :

• ~/.ssh/authorized_keys créé avec la clé publique
• Permissions : ~/.ssh = 700, authorized_keys = 600
• Connexion SSH sans mot de passe (passphrase clé uniquement)

Étape 5 : Installer Tailscale

Tailscale sera l’unique point d’entrée distant — pas de port SSH public.

# Sur le HomeServer
curl -fsSL https://tailscale.com/install.sh | sh

# Démarrer Tailscale
sudo tailscale up

Le terminal affiche une URL de login :

https://login.tailscale.com/a/XXXXX

Ouvre cette URL depuis ton navigateur (même device), connecte-toi à ton compte Tailscale, autorise le device.

# Vérifier que Tailscale fonctionne
tailscale ip -4
# Affiche l'IP Tailscale (ex: 100.x.x.x)

# Vérifier la connectivité
ping -c 3 100.x.x.x  # L'IP Tailscale du HomeServer lui-même

Checklist :

• Tailscale installé et démarré
• Device autorisé sur le compte Tailscale
• IP Tailscale récupérée
• Ping Tailscale → OK

Étape 6 : Test d’accès distant via Tailscale

Depuis un autre device (ex: ton smartphone connecté en 4G, pas au même réseau) :

# Sur ton poste portable (avec Tailscale installé et connecté)
ssh -i ~/.ssh/openclaw_homelab ubuntu@IP_TAILSCALE_HOMESERVER

Checklist :

• Connexion SSH via IP Tailscale OK
• Connexion depuis réseau extérieur (4G) OK
• Port 22 non exposé sur Internet

Étape 7 : Sécuriser SSH — Désactiver auth par mot de passe

Après confirmation que l’accès Tailscale fonctionne :

# Sur le HomeServer
sudo nano /etc/ssh/sshd_config

Modifier ces lignes :

# Désactiver auth par mot de passe
PasswordAuthentication no
PubkeyAuthentication yes

# Désactiver root login (si actif)
PermitRootLogin no

# Écouter uniquement sur Tailscale interface (optionnel)
ListenAddress 0.0.0.0  # OK pour usage simple
# Pour strict Tailscale uniquement : ListenAddress 100.0.0.0/8

Redémarrer SSH :

sudo systemctl restart sshd

Test : déconnecte-toi et reconnecte-toi — devrait toujours fonctionner.

Checklist :

• PasswordAuthentication = no
• PubkeyAuthentication = yes
• PermitRootLogin = no (si applicable)
• SSH redémarré
• Connexion clé uniquement fonctionne

Étape 8 : Noter les informations

Crée un fichier local (NON versionné) pour la suite des tutos :

# En local sur ton poste — PAS sur le HomeServer
cat > ~/.openclaw-infra.env << 'EOF'
# Provider : oracle | hetzner | local
VPS_PROVIDER=local

# Type hardware
VPS_HARDWARE=rpi4  # ou n54l

# IP locale (réseau domestique)
VPS_IP_LOCAL=192.168.1.X

# IP Tailscale (accès distant)
VPS_IP_TAILSCALE=100.x.x.x

# Chemin vers la clé SSH
VPS_SSH_KEY=~/.ssh/openclaw_homelab

# User SSH
VPS_SSH_USER=ubuntu  # ou ton user N54L
EOF
chmod 600 ~/.openclaw-infra.env

cat ~/.gitignore | grep openclaw-infra
# Si vide : echo "*.env" >> ~/.gitignore

Checklist :

• Fichier ~/.openclaw-infra.env créé
• VPS_PROVIDER=local
• VPS_HARDWARE= correct
• VPS_IP_TAILSCALE remplacé
• Fichier chmod 600

Sécurité : Checklist finale

Avant de passer aux tutos suivants, vérifie chaque point :

SSH

• ☐ Clé Ed25519 avec passphrase (non vide)
• ☐ Permissions clé privée = 600
• ☐ Auth par mot de passe désactivé
• ☐ Root login désactivé (si applicable)
• ☐ Clé publique SEULE dans authorized_keys

Réseau

• ☐ Port 22 non exposé sur Internet (pas de port-forwarding)
• ☐ Tailscale = unique point d’entrée distant
• ☐ Test connexion depuis réseau extérieur (4G) OK

Hardware

• ☐ Hardware stable (pas de reboot intempestif)
• ☐ Alimentation fiable
• ☐ Stockage avec espace suffisant (20GB+ dispo)

Secrets

• ☐ Aucun secret en dur dans les scripts
• ☐ Variables d’environnement pour tokens/API keys
• ☐ Fichier ~/.openclaw-infra.env chmod 600

Dépannage

SSH “Permission denied (publickey)”

• Vérifications :

  # Permissions côté client
  ls -la ~/.ssh/openclaw_homelab
  # Doit être : -rw------- (600)
  
  # Permissions côté serveur
  ls -la ~/.ssh/authorized_keys
  # Doit être : -rw------- (600)

• Vérifier que la clé PUBLIQUE est dans authorized_keys (pas la privée)

Tailscale “Cannot connect”

• Vérifications :

  # Status Tailscale
  sudo tailscale status
  # Doit afficher "Logged in as XXX@XXX"

• Sur ton poste portable : tailscale status → “Logged in as”
• Sur le compte Tailscale web : Devices → HomeServer actif

RPi4 reboot intempestif

• Cause probable : Alimentation sous-dimensionnée
• Solution : Utiliser alimentateur officiel Raspberry Pi (5V 3A minimum)

N54L lent au démarrage

• Cause probable : Disque HDD ancien (5400 RPM)
• Solution : Upgrade SSD (SATA) si possible

Port 22 exposé sur Internet

• Test : Depuis un device sans Tailscale, telnet VPS_IP_PUBLIC 22
• Si connexion : Vérifie ton routeur → Firewall → Port-forwarding
• Action immédiate : Désactive port-forwarding du port 22

Références

• Ubuntu Server ARM64 (RPi4) : https://cdimage.ubuntu.com/ubuntu-server/releases/22.04.5/release/
• Ubuntu Server x86_64 (N54L) : https://releases.ubuntu.com/22.04/
• Tailscale Install Docs : https://tailscale.com/kb/1027/install-ubuntu-2204
• SSH Hardening : https://stribika.github.io/2015/01/04/secure-secure-shell.html

Comparatif des solutions

Mise à jour README : ajouter Solution 3 dans le tableau comparatif de l’ordre de lecture.

Tuto suivant : TUTO-02