Skip to main content

Installation de PeerTube avec Docker : Alternative éthique à YouTube pour associations et collectifs

Table des matières

  1. [Introduction à PeerTube]PeerTube
  2. [Prérequis matériels]matériels
  3. [Installation initiale avec Docker]Docker
  4. [Comprendre le transcodage vidéo]vidéo
  5. [Configuration optimale du transcodage]transcodage
  6. [Organisation du stockage]stockage
  7. [Système de backup automatique]automatique
  8. [Commandes utiles]utiles
  9. [Surveillance et maintenance]maintenance

Introduction à PeerTube

Qu'est-ce que PeerTube ?

PeerTube est une plateforme vidéo gratuite et open source, alternative à YouTube. Elle utilise le WebRTC (Web Real-Time Communication) pour permettre le partage de vidéos en peer-to-peer directement dans le navigateur, sans plugin ni application externe.

Avantages principaux :

  • Pas de publicité
  • Hébergement autonome
  • Partage de bande passante entre spectateurs (P2P)
  • Contrôle total de vos données

À qui s'adresse ce guide ?

Ce tutoriel est conçu pour mettre en place une instance de test de PeerTube sur un serveur domestique. Il convient parfaitement pour :

  • Tester PeerTube avant de l'utiliser en production
  • Héberger des vidéos pour une petite communauté
  • Apprendre à gérer une plateforme vidéo auto-hébergée

Prérequis matériels

Configuration minimale recommandée

  • Processeur : 4 cœurs minimum (8 threads recommandé pour le transcodage)
  • RAM : 4 GB minimum, 8 GB recommandé
  • Stockage :
    • Un SSD/NVMe rapide pour les données actives (200 GB minimum)
    • Un HDD pour les backups (optionnel mais recommandé)

Configuration de ce tutoriel

Pour ce guide, nous utiliserons un serveur avec :

  • CPU : AMD Ryzen 5 (8 threads)
  • Stockage principal : NVMe 454 GB
  • Stockage secondaire : HDD 916 GB (pour les backups)
  • Système : Debian 12 (Bookworm)

Installation initiale avec Docker

Étape 1 : Préparer les fichiers

Suivez la documentation officielle pour télécharger les fichiers de base.

Étape 2 : Modifications pour un environnement de test local

Fichier docker-compose.yml

Pour une installation locale (sans nom de domaine), commentez les services non nécessaires :

# Commentez ces lignes pour une installation locale :
# webserver:    # Nginx (pas besoin en local)
# certbot:      # SSL (pas besoin en local)
# volumes:
#   - ./docker-volume/assets # Pas nécessaire

# Décommentez cette ligne pour accéder à PeerTube :
ports:
  - "9000:9000"  # Accès direct à PeerTube

Fichier .env

Configurez les variables pour l'accès local :

# Accès local
PEERTUBE_WEBSERVER_HOSTNAME=localhost
PEERTUBE_WEBSERVER_PORT=9000
PEERTUBE_WEBSERVER_HTTPS=false

# Base de données
POSTGRES_USER=peertube
POSTGRES_PASSWORD=peertube_password

# Administration
PEERTUBE_ADMIN_EMAIL=admin@localhost

⚠️ Important : Générer un secret sécurisé

Ne laissez jamais le secret par défaut. Générez-en un nouveau :

openssl rand -hex 32

Copiez le résultat et remplacez la valeur de PEERTUBE_SECRET dans le fichier .env.

Étape 3 : Démarrer PeerTube

cd /chemin/vers/votre/dossier
docker compose up -d

Accédez à votre instance sur : http://localhost:9000

Comprendre le transcodage vidéo

Qu'est-ce que le transcodage ?

Le transcodage est le processus qui transforme votre vidéo originale en plusieurs versions optimisées :

Vidéo originale (fichier.mkv, 4 GB)
         ↓
    TRANSCODAGE
         ↓
├── Version 1080p (500 MB)
├── Version 720p (300 MB)
├── Version 480p (150 MB)
└── Version 360p (80 MB)

Pourquoi c'est essentiel ?

1. Compatibilité universelle

  • Tous les navigateurs ne lisent pas tous les formats
  • Le transcodage garantit une lecture partout (Chrome, Firefox, Safari, etc.)

2. Adaptation à la connexion Internet

  • Connexion lente → qualité 360p ou 480p
  • Fibre optique → qualité 1080p ou supérieure
  • Streaming fluide pour tous

3. Sans transcodage

  • Les utilisateurs avec mauvaise connexion ne peuvent pas regarder
  • Risque de formats vidéo incompatibles

Les contraintes du transcodage

Ressources nécessaires :

  • CPU : Très gourmand en processeur (peut prendre 100% d'un cœur)
  • Temps : 2-3x la durée de la vidéo (une vidéo de 1h = 2-3h de transcodage)
  • Espace disque : 1 vidéo devient 3-5 versions différentes

Exemple concret :

  • Vidéo de 30 minutes uploadée
  • Transcodage avec 3 qualités (480p, 720p, 1080p)
  • Temps estimé : 1h30 à 2h
  • Espace utilisé : ~3x la taille originale

Configuration optimale du transcodage

Choix du format de streaming : HLS

Nous recommandons HLS (HTTP Live Streaming) plutôt que Web Videos :

Avantages du HLS :

  • Lecture adaptative automatique selon la connexion
  • Support natif du peer-to-peer (WebRTC)
  • Meilleur streaming pour les longues vidéos

Configuration dans docker-volume/config/local-production.json :

"web_videos": {
  "enabled": false
},
"hls": {
  "enabled": true,
  "split_audio_and_video": false
}

Choix des résolutions

Pour un serveur de test avec audience limitée :

Résolution Activer ? Usage
2160p (4K) ❌ Trop lourd pour un serveur de test
1440p ❌ Pas nécessaire
1080p ✅ Qualité maximale recommandée
720p ✅ Bon compromis qualité/poids
480p ✅ Pour connexions moyennes
360p ❌ Pas nécessaire pour un serveur local
240p ❌ Qualité trop faible

Configuration :

"resolutions": {
  "240p": false,
  "360p": false,
  "480p": true,
  "720p": true,
  "1080p": true,
  "1440p": false,
  "2160p": false
}

Optimisation des performances CPU

Pour un processeur 8 threads (comme un Ryzen 5) :

"transcoding": {
  "enabled": true,
  "threads": 3,
  "concurrency": 2,
  "profile": "default",
  "allow_audio_files": true,
  "always_transcode_original_resolution": false
}

Explication des paramètres :

threads: 3

  • Nombre de threads CPU par vidéo en transcodage
  • Trop élevé → le système rame
  • Trop bas → transcodage très lent
  • 3 = bon équilibre pour 8 threads totaux

concurrency: 2

  • Nombre de vidéos transcodées en parallèle
  • threads: 3 × concurrency: 2 = 6 threads utilisés
  • Reste 2 threads libres pour le système

Calcul simple :

CPU total : 8 threads
Transcodage : 6 threads (3 × 2)
Système : 2 threads libres

Options de stockage

"keep_original_file": false

⚠️ Attention : Mettre false supprime le fichier original après transcodage. C'est acceptable pour un serveur de test, mais conservez l'original en production (true).

Modifier la configuration

Méthode 1 : Interface web (recommandé)

  1. Ouvrez http://localhost:9000
  2. Connectez-vous en tant qu'admin
  3. Allez dans Administration → Configuration → VOD
  4. Modifiez les valeurs
  5. Sauvegardez

Méthode 2 : Ligne de commande

cd /chemin/vers/votre/dossier
nano docker-volume/config/local-production.json

# Cherchez la section "transcoding" (ligne ~119)
# Modifiez les valeurs

# Redémarrez PeerTube
docker compose restart peertube

Organisation du stockage

Architecture recommandée

Stockage NVMe (rapide) - 454 GB
└── /home/user/Serveur/
    ├── docker-compose.yml
    ├── .env
    └── docker-volume/
        ├── config/          # Configuration PeerTube
        ├── data/            # Vidéos et médias
        ├── db/              # Base PostgreSQL
        └── redis/           # Cache Redis

Stockage HDD (lent mais grand) - 916 GB
└── /mnt/backup-disk/
    └── peertube_backup/     # Sauvegardes automatiques

Pourquoi cette organisation ?

NVMe / SSD rapide :

  • Transcodage vidéo (lecture/écriture intensive)
  • Base de données (accès rapide)
  • Fichiers temporaires

HDD lent :

  • Sauvegardes (vitesse moins importante)
  • Archive des anciennes vidéos
  • Coût au GB plus faible

Configuration du disque de backup

Étape 1 : Identifier votre disque

lsblk

Vous verrez quelque chose comme :

NAME        SIZE TYPE
sda       931.5G disk
└─sda1    931.5G part    ← C'est notre HDD de backup
nvme0n1   454.5G disk
└─nvme0n1p2 454G part    ← C'est notre disque système

Étape 2 : Obtenir l'UUID du disque

L'UUID est un identifiant unique qui ne change jamais (contrairement à /dev/sda1 qui peut changer).

sudo blkid /dev/sda1

Résultat :

/dev/sda1: UUID="abcd1234-5678-90ef-ghij-klmnopqrstuv" TYPE="ext4"

Notez l'UUID (vous en aurez besoin).

Étape 3 : Créer le point de montage

sudo mkdir -p /mnt/backup-disk

Étape 4 : Test de montage manuel

sudo mount /dev/sda1 /mnt/backup-disk
df -h | grep backup-disk

Si ça fonctionne, vous verrez votre disque monté.

Étape 5 : Montage automatique au démarrage

Éditez le fichier système /etc/fstab :

sudo nano /etc/fstab

Ajoutez cette ligne à la fin (remplacez l'UUID par le vôtre) :

UUID=abcd1234-5678-90ef-ghij-klmnopqrstuv  /mnt/backup-disk  ext4  defaults,nofail  0  2

Explication :

  • defaults : Options standard (lecture/écriture, etc.)
  • nofail : Le système démarre même si ce disque est déconnecté
  • 0 2 : Vérification du disque au démarrage

Testez :

sudo umount /mnt/backup-disk   # Démonter
sudo mount -a                   # Remonter tout
df -h | grep backup-disk        # Vérifier

Système de backup automatique {#backup}

Principe du backup

┌───────────────────────┐
│   PeerTube (NVMe)     │
│   Données actives     │
│   Accès rapide        │
└───────────┬───────────┘
            │
            │ Copie quotidienne (2h du matin)
            │ rsync --delete
            ↓
┌───────────────────────┐
│   HDD Backup          │
│   Copie de sécurité   │
│   Grande capacité     │
└───────────────────────┘

Créer le script de backup

Étape 1 : Créer le fichier script

sudo nano /usr/local/bin/backup-peertube.sh

Copiez ce contenu :

#!/bin/bash
# Script de backup automatique PeerTube
# Copie les données vers le disque de backup

DATE=$(date +%Y-%m-%d_%H:%M:%S)
LOG="/var/log/peertube-backup.log"

# Source : données PeerTube
SOURCE="/home/user/Serveur/docker-volume/"

# Destination : disque de backup
DEST="/mnt/backup-disk/peertube_backup/"

echo "[$DATE] Début du backup PeerTube" >> $LOG

# Copie avec rsync
rsync -av --delete "$SOURCE" "$DEST" >> $LOG 2>&1

# Vérification du résultat
if [ $? -eq 0 ]; then
    echo "[$DATE] ✓ Backup terminé avec succès" >> $LOG
else
    echo "[$DATE] ✗ ERREUR lors du backup" >> $LOG
fi

Explication du script :

  • DATE=$(date ...) : Récupère la date/heure actuelle
  • LOG="/var/log/..." : Fichier où tout est enregistré
  • rsync -av --delete :
    • -a : Mode archive (préserve tout)
    • -v : Verbose (montre ce qui est copié)
    • --delete : Supprime les fichiers disparus de la source
  • >> $LOG 2>&1 : Enregistre tout dans le fichier log
  • if [ $? -eq 0 ] : Vérifie si rsync a réussi

Étape 2 : Rendre le script exécutable

sudo chmod +x /usr/local/bin/backup-peertube.sh

Étape 3 : Créer le dossier de destination

sudo mkdir -p /mnt/backup-disk/peertube_backup
sudo chown $USER:$USER /mnt/backup-disk/peertube_backup

Étape 4 : Test manuel

sudo /usr/local/bin/backup-peertube.sh

Vérifiez que ça fonctionne :

# Voir les logs
tail -20 /var/log/peertube-backup.log

# Vérifier que les fichiers sont copiés
ls -lh /mnt/backup-disk/peertube_backup/

Automatiser avec Cron

Cron permet d'exécuter des scripts automatiquement à des heures précises.

Ajouter une tâche quotidienne

echo "0 2 * * * root /usr/local/bin/backup-peertube.sh" | sudo tee -a /etc/crontab

Comprendre la syntaxe Cron :

0 2 * * * root /usr/local/bin/backup-peertube.sh
│ │ │ │ │  │    └─ Commande à exécuter
│ │ │ │ │  └────── Utilisateur (root)
│ │ │ │ └────────── Jour de la semaine (* = tous)
│ │ │ └──────────── Mois (* = tous)
│ │ └────────────── Jour du mois (* = tous)
│ └──────────────── Heure (2h du matin)
└────────────────── Minute (0 = pile)

Exemples d'horaires Cron :

Syntaxe Signification
0 2 * * * Tous les jours à 2h00
0 */6 * * * Toutes les 6 heures
30 3 * * 0 Tous les dimanches à 3h30
0 0 1 * * Le 1er de chaque mois à minuit

Vérifier l'installation

sudo grep "backup-peertube" /etc/crontab

Commandes utiles

Gestion de PeerTube

# Se placer dans le dossier
cd /chemin/vers/votre/dossier

# Démarrer PeerTube
docker compose up -d

# Arrêter PeerTube
docker compose down

# Redémarrer PeerTube
docker compose restart peertube

# Voir les logs en temps réel
docker compose logs -f peertube

# Voir l'état des conteneurs
docker compose ps

Gestion des backups

# Lancer un backup manuel
sudo /usr/local/bin/backup-peertube.sh

# Voir les derniers logs de backup
tail -50 /var/log/peertube-backup.log

# Chercher les erreurs dans les logs
grep "ERREUR" /var/log/peertube-backup.log

# Vérifier l'espace disque
df -h | grep -E "backup-disk|nvme"

# Taille du dossier de backup
du -sh /mnt/backup-disk/peertube_backup/

Monitoring du transcodage

# Voir les vidéos en cours de transcodage
docker exec -it <nom-conteneur-peertube> ls -lh /data/transcoding-jobs/

# Surveiller l'utilisation CPU en temps réel
htop

# Surveiller l'espace disque toutes les 5 secondes
watch -n 5 'df -h | grep nvme'

Vérification des ressources Docker

# Nombre de CPUs disponibles
nproc

# Vérifier que Docker voit tous les CPUs
docker info | grep "CPUs:"

# Résultat attendu : même nombre que nproc

Limiter les ressources Docker (optionnel)

Si le transcodage ralentit trop votre PC, ajoutez ceci dans docker-compose.yml :

services:
  peertube:
    image: chocobozzz/peertube:production-bookworm
    # ... autres configs ...
    
    # Nouvelles lignes à ajouter :
    deploy:
      resources:
        limits:
          cpus: '6'        # Maximum 6 cœurs
          memory: 4G       # Maximum 4 GB de RAM
        reservations:
          cpus: '2'        # Minimum 2 cœurs garantis
          memory: 1G       # Minimum 1 GB de RAM

Quand utiliser ces limites ?

  • Vous utilisez le PC pendant le transcodage
  • D'autres services Docker tournent en parallèle
  • Le système devient trop lent

Surveillance et maintenance

Surveillance régulière

1. Espace disque (hebdomadaire)

df -h /

Si l'espace disque dépasse 80%, libérez de l'espace :

  • Supprimez d'anciennes vidéos
  • Nettoyez les logs Docker : docker system prune -a

2. Logs de backup (mensuel)

grep "ERREUR" /var/log/peertube-backup.log

Si des erreurs apparaissent, vérifiez :

  • Le disque de backup est monté : df -h | grep backup
  • Les permissions : ls -ld /mnt/backup-disk/peertube_backup

3. Performance du transcodage

Observez le temps de transcodage. Si c'est trop lent :

Augmenter la concurrence :

"concurrency": 3   // Au lieu de 2

Attention : Plus de concurrence = plus de CPU utilisé.

Évolutions possibles

1. Activer le streaming en direct

Modifiez docker-volume/config/local-production.json :

"live": {
  "enabled": true,
  "max_duration": 3600,        // 1 heure max
  "max_instance_lives": 20,    // 20 lives simultanés max
  "allow_replay": true
}

Redémarrez :

docker compose restart peertube

2. Ajouter des résolutions supérieures

Si vous voulez proposer du 1440p ou 4K :

"resolutions": {
  "1440p": true,
  "2160p": true
}

⚠️ Attention : Le transcodage sera beaucoup plus long et utilisera beaucoup plus d'espace disque.

3. Remote runners (transcodage distant)

Si votre serveur est trop lent, vous pouvez déléguer le transcodage à d'autres machines. Voir la documentation officielle.

4. Rotation des backups

Pour garder plusieurs versions des backups (quotidien, hebdomadaire, mensuel), utilisez des outils comme :

  • rsnapshot
  • borg
  • restic

Résumé de la configuration

✅ Ce que nous avons mis en place

Aspect Configuration Résultat
Format streaming HLS activé Lecture adaptative fluide
Résolutions 480p, 720p, 1080p Compromis qualité/poids
Threads CPU 3 threads/vidéo Bon équilibre
Concurrence 2 vidéos en parallèle Maximum 6 threads utilisés
Stockage NVMe Données actives Accès rapide
Stockage HDD Backups quotidiens Grande capacité
Backup automatique Tous les jours à 2h Sécurité des données

📊 Ressources du serveur

Processeur : 8 threads
├── Transcodage : 6 threads (3 × 2)
└── Système : 2 threads libres

Stockage :
├── NVMe 454 GB : Données PeerTube
└── HDD 916 GB : Backups quotidiens

Réseau :
├── Port 9000 : Accès web (HTTP)
└── Port 1935 : Streaming live (RTMP)

Prochaines étapes

  1. Tester le transcodage

    • Uploadez 2-3 vidéos de test
    • Observez le temps de transcodage
    • Vérifiez la qualité des différentes résolutions

  2. Surveiller les backups

    • Attendez 1 semaine
    • Vérifiez les logs : tail /var/log/peertube-backup.log
    • Testez une restauration

  3. Ajuster les performances

    • Si trop lent : augmentez concurrency
    • Si le PC rame : diminuez threads
    • Si manque d'espace : désactivez la 1080p

Ressources utiles

Back to top