Aperçu du Homelab

Vous gérez votre homelab à l'aide de Proxmox avec des VMs pour Ubuntu, Kali, et pfSense. Vos principaux objectifs incluent l'hébergement de vos propres services, l'automatisation des flux de travail et la connexion sécurisée de l'ensemble avec Twingate.

Composants de l'infrastructure

Proxmox VE (Hyperviseur)

  • Objectif: Plateforme de virtualisation pour tous les services
  • Matériel: Serveur dédié ou station de travail puissante
  • VMs hébergées:
    • Ubuntu Server (services principaux)
    • Kali Linux (tests d'intrusion)
    • pfSense (pare-feu et routage)

VM Ubuntu (Hôte de services)

  • Rôle: Serveur d'applications principal
  • Services:
    • Synchronisation Obsidian (CouchDB)
    • Plateforme d'automatisation n8n
    • Conteneurs Docker
    • Serveurs de bases de données

VM pfSense (Sécurité réseau)

  • Rôle: Pare-feu et passerelle réseau
  • Fonctionnalités:
    • Gestion des VLANs
    • Serveur VPN
    • Résolveur DNS
    • Surveillance du trafic

Twingate (Accès distant sécurisé)

  • Objectif: Accès réseau Zero-Trust
  • Avantages: Accès distant sécurisé sans exposition des ports

Configuration d'Obsidian

Solution de synchronisation auto-hébergée

  • Obsidian est auto-hébergé à l'aide de CouchDB
  • Exécuté sur la VM Ubuntu
  • Connecté à l'aide du plugin Obsidian LiveSync
  • Accès distant sécurisé géré via Twingate

Pourquoi auto-héberger la synchronisation Obsidian ?

  1. Souveraineté des données: Contrôle total sur vos notes
  2. Confidentialité: Aucun accès tiers aux informations sensibles
  3. Coût: Alternative gratuite à l'abonnement Obsidian Sync
  4. Apprentissage: Expérience pratique de la gestion de bases de données

Plan de configuration étape par étape

Phase 1 : Préparation du serveur

1. Mettre à jour et sécuriser la VM Ubuntu

# Mises à jour système
sudo apt update && sudo apt upgrade -y

# Installer les outils essentiels
sudo apt install -y curl wget git vim ufw

# Configurer le pare-feu
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow ssh
sudo ufw enable

2. Installer Docker et Docker Compose

# Installer Docker
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

# Installer Docker Compose
sudo apt install docker-compose -y

# Ajouter l'utilisateur au groupe docker
sudo usermod -aG docker $USER
newgrp docker

# Vérifier l'installation
docker --version
docker-compose --version

3. Créer les répertoires de services

# Créer une structure de répertoires organisée
mkdir -p ~/services/{obsidian-sync,n8n,backups}
cd ~/services

Phase 2 : Déploiement de CouchDB pour la synchronisation Obsidian

1. Créer la configuration Docker Compose

cd ~/services/obsidian-sync
nano docker-compose.yml
version: '3.8'
services:
  couchdb:
    image: couchdb:latest
    container_name: couchdb-for-obsidian
    environment:
      - COUCHDB_USER=admin
      - COUCHDB_PASSWORD=your_secure_password_here
    volumes:
      - ./data:/opt/couchdb/data
      - ./config:/opt/couchdb/etc/local.d
    ports:
      - 5984:5984
    restart: unless-stopped
    networks:
      - homelab
networks:
  homelab:
    driver: bridge

2. Lancer CouchDB

# Démarrer CouchDB
docker-compose up -d

# Vérifier son exécution
docker ps | grep couchdb

# Vérifier les logs
docker logs -f couchdb-for-obsidian

3. Configurer CouchDB

  1. Ouvrir le tableau de bord CouchDB : http://<ubuntu-vm-ip>:5984/_utils
  2. Se connecter avec les identifiants de docker-compose.yml
  3. Créer une base de données nommée obsidian
  4. Activer CORS si l'accès provient d'origines différentes

4. Connecter le client de bureau Obsidian

  1. Installer le plugin Self-Hosted LiveSync dans Obsidian
  2. Configurer les paramètres du plugin :
    • URL de la base de données distante: http://<ubuntu-vm-ip>:5984/obsidian
    • Nom d'utilisateur: admin
    • Mot de passe: Votre mot de passe CouchDB
  3. Initialiser la synchronisation et tester

Phase 3 : Installer et configurer n8n

1. Créer le répertoire et la configuration n8n

cd ~/services/n8n
nano docker-compose.yml
version: '3'
services:
  n8n:
    image: n8nio/n8n:latest
    container_name: n8n-automation
    restart: unless-stopped
    environment:
      - GENERIC_TIMEZONE=Europe/Paris
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=admin
      - N8N_BASIC_AUTH_PASSWORD=secure_password
      - N8N_HOST=n8n.lab
      - N8N_PORT=5678
      - N8N_PROTOCOL=https
      - WEBHOOK_URL=https://n8n.lab/
    ports:
      - 5678:5678
    volumes:
      - ./data:/home/node/.n8n
      - ./local-files:/files
    networks:
      - homelab
networks:
  homelab:
    external: true

2. Lancer n8n

# Démarrer n8n
docker-compose up -d

# Vérifier l'état
docker logs -f n8n-automation

3. Accéder à l'interface n8n

  • Naviguer vers : http://<ubuntu-vm-ip>:5678
  • Se connecter avec les identifiants de docker-compose.yml
  • Compléter l'assistant de configuration initial

Phase 4 : Automatiser les sauvegardes avec n8n

Stratégie de sauvegarde

  1. Sauvegardes quotidiennes: Coffre Obsidian et données CouchDB
  2. Sauvegardes hebdomadaires: Configuration complète du système
  3. Archives mensuelles: Stockage à long terme

Créer un flux de travail de sauvegarde dans n8n

Composants du flux de travail :
  1. Déclencheur planifié (Nœud Cron)

    • Planification: Tous les dimanches à 2h00
    • Expression: 0 2 * * 0
  2. Créer une sauvegarde (Nœud d'exécution de commande)

    #!/bin/bash
    BACKUP_DIR="/backups/obsidian"
    DATE=$(date +%Y-%m-%d_%H-%M-%S)
    
    # Créer le répertoire de sauvegarde
    mkdir -p $BACKUP_DIR
    
    # Sauvegarder le coffre Obsidian
    tar czf $BACKUP_DIR/obsidian-vault_$DATE.tar.gz /path/to/obsidian-vault
    
    # Sauvegarder les données CouchDB
    tar czf $BACKUP_DIR/couchdb-data_$DATE.tar.gz ~/services/obsidian-sync/data
    
    # Conserver uniquement les sauvegardes des 4 dernières semaines
    find $BACKUP_DIR -name "*.tar.gz" -mtime +28 -delete
    
    echo "Sauvegarde terminée : $DATE"
  3. Vérifier la sauvegarde (Nœud d'exécution de commande)

    # Vérifier si le fichier de sauvegarde existe et a une taille raisonnable
    LATEST_BACKUP=$(ls -t /backups/obsidian/*.tar.gz | head -1)
    SIZE=$(stat -f%z "$LATEST_BACKUP" 2>/dev/null || stat -c%s "$LATEST_BACKUP")
    
    if [ $SIZE -gt 1024 ]; then
      echo "Sauvegarde réussie : $LATEST_BACKUP ($SIZE bytes)"
      exit 0
    else
      echo "Sauvegarde échouée ou trop petite !"
      exit 1
    fi
  4. Envoyer une notification (Nœud Requête HTTP ou Telegram)

    • Sur succès : “✅ Sauvegarde terminée avec succès”
    • Sur échec : “❌ Sauvegarde échouée ! Veuillez vérifier les logs”

Phase 5 : Accès distant et sécurité

Installer Twingate

  1. Créer un compte Twingate
  2. Déployer le connecteur Twingate
# Télécharger et installer le connecteur Twingate
curl -s https://binaries.twingate.com/connector/setup.sh | sudo bash

# Configurer le connecteur
sudo twingate-connector setup
  1. Configurer les ressources
    • Ajouter les services de la VM Ubuntu
    • Ajouter l'interface web Proxmox
    • Ajouter la plateforme d'automatisation n8n

Alternative : Tunnel Cloudflare

Pour un accès HTTPS sans redirection de port :

# Installer cloudflared
wget https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64.deb
sudo dpkg -i cloudflared-linux-amd64.deb

# Authentification
cloudflared tunnel login

# Créer un tunnel
cloudflared tunnel create homelab

# Configurer le tunnel
nano ~/.cloudflared/config.yml
tunnel: <tunnel-id>
credentials-file: /root/.cloudflared/<tunnel-id>.json

ingress:
  - hostname: n8n.yourdomain.com
    service: http://localhost:5678
  - hostname: couchdb.yourdomain.com
    service: http://localhost:5984
  - service: http_status:404

Plan d'action pour le week-end

Programme du samedi

Matin (2-3 heures)

Après-midi (2-3 heures)

Soirée (1-2 heures)

Programme du dimanche

Matin (2-3 heures)

Après-midi (2-3 heures)

Soirée (1-2 heures)

Objectif final : Environnement auto-hébergé complet

D'ici lundi, vous aurez :

✅ Infrastructure

  • Hyperviseur Proxmox avec VMs organisées
  • Réseau sécurisé avec pare-feu pfSense
  • Architecture de services basée sur Docker

✅ Services de base

  • Synchronisation Obsidian auto-hébergée (CouchDB)
  • Plateforme d'automatisation n8n
  • Système de sauvegarde automatisé

✅ Sécurité

  • Accès distant sécurisé (Twingate)
  • Connexions chiffrées (HTTPS/SSL)
  • Sauvegardes automatisées régulières

✅ Automatisation

  • Automatisation hebdomadaire des sauvegardes
  • Système de notification pour la surveillance
  • Base de flux de travail pour les projets futurs

Prochaines étapes et améliorations futures

Court terme (1-2 semaines)

  • Ajouter un reverse proxy (Nginx Proxy Manager)
  • Configurer des noms de domaine personnalisés
  • Configurer la surveillance (Uptime Kuma)

Moyen terme (1-2 mois)

  • Ajouter plus de flux de travail d'automatisation
  • Implémenter l'agrégation de logs (Loki + Grafana)
  • Créer un plan de reprise après sinistre

Long terme (3-6 mois)

  • Étendre le homelab avec des services supplémentaires
  • Implémenter GitOps pour l'infrastructure en tant que code
  • Créer une documentation complète

Conclusion

Cette feuille de route offre un chemin clair, de la configuration initiale à un fully fonctionnel, self-hosted homelab environment. En suivant cette approche par phases, vous construirez une base solide pour l'automatisation, la sécurité et l'apprentissage continu.

La clé du succès est un progrès constant et incrémental. Commencez par les bases, assurez-vous que chaque composant fonctionne correctement et ajoutez progressivement de la complexité. Documentez tout dans Obsidian, et n'hésitez pas à expérimenter et à apprendre des échecs.

Votre parcours homelab est un marathon, pas un sprint. Profitez du processus !