Installation avancée

Déployez Erugo sur un serveur de production avec Docker, certificats SSL et un proxy inverse. Ce guide couvre l'installation complète, de la création du serveur à l'accès HTTPS sécurisé.

Aperçu

Ce guide vous accompagne dans le déploiement d'Erugo sur un VPS avec Docker, Nginx Proxy Manager pour le proxy inverse et SSL, et un stockage persistant pour les fichiers téléchargés.

À la fin, vous aurez une instance Erugo prête pour la production, accessible via HTTPS avec renouvellement automatique des certificats SSL.

Configuration matérielle requise

Erugo n'a pas de configuration matérielle officiellement publiée, mais selon sa pile technologique (PHP, Laravel, Vue.js) et les scénarios d'utilisation typiques, voici les spécifications minimales recommandées :

Créer votre serveur

Vous aurez besoin d'un VPS (Virtual Private Server) d'un fournisseur cloud. Les options populaires incluent Hetzner, DigitalOcean, Linode ou Vultr. Ce guide utilise Ubuntu 24.04 comme système d'exploitation.

Configuration du serveur

• Emplacement : Choisissez une région proche de vos utilisateurs
• Image : Ubuntu 24.04
• Type : vCPU partagé (x86 Intel/AMD)
• Taille : 2 vCPU, 4 Go RAM, 40 Go SSD (ou plus)
• Réseau : IPv4 et IPv6 publiques

Sponsor Erugo

Le site web et l'instance de démonstration d'Erugo sont hébergés sur des serveurs VPS Box To Play. Ils fournissent un hébergement fiable depuis plus d'un an, avec des options VPS à prix raisonnable que nous recommanderions indépendamment de leur parrainage.

Configuration des clés SSH

Pour la sécurité, utilisez une clé SSH Ed25519 qui offre une meilleure sécurité et efficacité par rapport à RSA et ECDSA.

Générer une clé SSH

Sur votre machine locale, générez une nouvelle clé SSH :

ssh-keygen -t ed25519 -f ~/.ssh/id_ed25519_erugo

Ajoutez le contenu de ~/.ssh/id_ed25519_erugo.pub (la clé publique) aux paramètres de clé SSH de votre fournisseur cloud lors de la création du serveur.

Se connecter à votre serveur

Une fois votre serveur créé, notez l'adresse IP et connectez-vous via SSH :

ssh -i ~/.ssh/id_ed25519_erugo root@VOTRE_IP_SERVEUR

Remplacez VOTRE_IP_SERVEUR par l'adresse IP réelle de votre serveur.

Créer un utilisateur non-root

Pour les meilleures pratiques de sécurité, créez un utilisateur non-root dédié pour exécuter Docker au lieu d'utiliser le compte root. Cela limite les privilèges et réduit les vecteurs d'attaque potentiels.

Créer l'utilisateur

Exécutez ces commandes en tant que root pour créer un utilisateur nommé erugo :

# Créer l'utilisateur erugo
adduser --disabled-password --gecos "" erugo

# Ajouter l'utilisateur erugo au groupe sudo
usermod -aG sudo erugo

# Configurer l'authentification par clé SSH
mkdir -p /home/erugo/.ssh
cp /root/.ssh/authorized_keys /home/erugo/.ssh/authorized_keys
chown -R erugo:erugo /home/erugo/.ssh
chmod 700 /home/erugo/.ssh
chmod 600 /home/erugo/.ssh/authorized_keys

# Configurer sudo sans mot de passe pour l'utilisateur erugo
echo "erugo ALL=(ALL) NOPASSWD:ALL" > /etc/sudoers.d/erugo
chmod 440 /etc/sudoers.d/erugo

Basculer vers le nouvel utilisateur

Déconnectez-vous et reconnectez-vous en tant que nouvel utilisateur :

ssh -i ~/.ssh/id_ed25519_erugo erugo@VOTRE_IP_SERVEUR

Installer Docker

Installez Docker en utilisant le script de commodité officiel :

bash <(wget -qO- https://get.docker.com)

Ajouter l'utilisateur au groupe Docker

Pour éviter d'utiliser sudo pour chaque commande Docker :

sudo usermod -aG docker $USER

Vérifier l'installation

Après vous être reconnecté, vérifiez que Docker fonctionne :

docker run hello-world

Vous devriez voir un message de succès confirmant que Docker est installé correctement.

Configuration DNS

Configurez les enregistrements DNS pour accéder à votre instance Erugo via un domaine personnalisé. Vous aurez besoin d'accéder aux paramètres DNS de votre domaine (par exemple via Cloudflare, votre registrar, etc.).

Créer un enregistrement A

• Naviguez vers vos paramètres DNS
• Ajoutez un nouvel enregistrement A
• Définissez le Nom sur votre sous-domaine souhaité (ex : erugo ou fichiers)
• Définissez le Contenu sur l'adresse IP de votre serveur
• Définissez le TTL sur Auto ou une valeur basse pendant la configuration

Par exemple, si votre domaine est exemple.com et que vous utilisez le sous-domaine fichiers, vous accéderez à Erugo à fichiers.exemple.com.

Nginx Proxy Manager

Nginx Proxy Manager fournit un moyen facile de gérer les hôtes de proxy inverse avec génération automatique de certificats SSL via Let's Encrypt.

Créer le répertoire

mkdir nginx-proxy-manager
cd nginx-proxy-manager

Configuration Docker Compose

Créez un fichier docker-compose.yml :

services:
  app:
    image: 'jc21/nginx-proxy-manager:latest'
    restart: unless-stopped
    ports:
      - '80:80'
      - '443:443'
      - '81:81'
    volumes:
      - ./data:/data
      - ./letsencrypt:/etc/letsencrypt
    networks:
      - nginx_internal_network

networks:
  nginx_internal_network:
    name: nginx_internal_network
    driver: bridge

Démarrer Nginx Proxy Manager

docker compose up -d && docker compose logs -f

Appuyez sur Ctrl+C pour arrêter de suivre les logs une fois que le conteneur est en cours d'exécution.

Accéder à l'interface d'administration

Ouvrez votre navigateur et naviguez vers :

Identifiants de connexion par défaut :

• E-mail : [email protected]
• Mot de passe : changeme

Configuration Docker Compose

Créez un répertoire dédié pour Erugo :

cd ~
mkdir erugo
cd erugo

Créez le fichier docker-compose.yml :

services:
  app:
    image: wardy784/erugo:latest
    restart: always
    container_name: erugo
    volumes:
      - /home/erugo/Erugo-Storage:/var/www/html/storage
    deploy:
      resources:
        limits:
          memory: 2G
        reservations:
          memory: 1G
    networks:
      - nginx_internal_network

networks:
  nginx_internal_network:
    external: true

Configuration du stockage persistant

Le montage de volume garantit que les fichiers téléchargés sont stockés sur votre système hôte, pas seulement à l'intérieur du conteneur. Cela signifie :

• Les fichiers ne seront pas perdus si le conteneur est recréé
• Vous pouvez facilement sauvegarder ou inspecter les fichiers téléchargés depuis le serveur

Créer le répertoire de stockage

mkdir -p /home/erugo/Erugo-Storage
chown -R $(id -u):$(id -g) /home/erugo/Erugo-Storage

Démarrer Erugo

docker compose up -d && docker compose logs -f

Appuyez sur Ctrl+C pour arrêter de suivre les logs une fois que le conteneur est en cours d'exécution.

Configurer l'hôte proxy

Maintenant, configurez Nginx Proxy Manager pour router le trafic vers votre conteneur Erugo.

Ajouter un nouvel hôte proxy

1. Accédez à Nginx Proxy Manager à http://VOTRE_IP_SERVEUR:81
2. Cliquez sur Hosts → Proxy Hosts
3. Cliquez sur Add Proxy Host

Paramètres de l'onglet Details

Configuration du certificat SSL

Configurez SSL pour sécuriser votre instance Erugo avec HTTPS.

Paramètres de l'onglet SSL

1. Cliquez sur l'onglet SSL dans les paramètres de l'hôte proxy
2. Sélectionnez Request a new SSL Certificate
3. Activez Force SSL
4. Activez HTTP/2 Support
5. Entrez votre adresse e-mail pour les notifications Let's Encrypt
6. Acceptez les conditions d'utilisation de Let's Encrypt
7. Cliquez sur Save

Attendez quelques secondes que le certificat SSL soit émis. Une fois terminé, vous pouvez accéder à Erugo en toute sécurité à https://fichiers.exemple.com (en utilisant votre domaine réel).

Comprendre le réseau Docker

Dans cette configuration, Nginx Proxy Manager et Erugo sont tous deux connectés au même réseau bridge défini par l'utilisateur nommé nginx_internal_network.

Pourquoi ça fonctionne

Les réseaux bridge définis par l'utilisateur de Docker incluent la découverte automatique de services basée sur DNS :

• Chaque conteneur peut atteindre les autres en utilisant le nom du conteneur comme nom d'hôte
• Lorsque NPM route le trafic vers Erugo, il transfère à http://erugo:80
• Pas besoin d'exposer le port 80 sur l'hôte ou de rechercher les IP internes des conteneurs

Tout est géré de manière transparente à l'intérieur du réseau Docker, offrant à la fois sécurité et commodité.

Remerciements

Ce guide est basé sur l'excellent tutoriel de Pierluigi Montinaro, qui écrit sur l'auto-hébergement et le DevOps sur son blog DevOps Chronicles.