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

Guide complet : Installer et optimiser PeerTube avec Docker

Tutoriel complet - Décembre 2025
Niveau : Intermédiaire
Système : Debian 12 (Bookworm) avec Docker Compose v2

Table des matières

Introduction à PeerTube

Prérequis matériels

Installation initiale avec Docker

Comprendre le transcodage vidéo

Configuration optimale du transcodage

Organisation du stockage

Système de backup automatique

Commandes utiles

Surveillance et maintenance

Introduction à PeerTube {#introduction}

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 ~~projet~~serveur ~~gratuit et open source fournissant aux navigateurs Web et aux applications mobiles une communication en temps réel (RTC) via des interfaces de programmation d'applications (API).~~domestique. Il ~~permet~~convient àparfaitement la communication audio et vidéo et au streaming de fonctionner à l'intérieur des pages Web en permettant une communication directe entre pairs, éliminant ainsi le besoin d'installer des plugins ou de télécharger des applications natives

~~https://docs.joinpeertube.org/install/docker~~

~~Modifications du docker-compose.yml~~pour :

✓Tester ~~Commenté~~PeerTube leavant ~~service~~de ~~webserver~~l'utiliser ~~(nginx)~~en production
✓Héberger ~~Commenté~~des levidéos ~~service~~pour ~~certbot~~une ~~(SSL)~~petite communauté
~~✓ Décommenté le port 9000:9000 pour accéder directement~~Apprendre à ~~PeerTube~~

gérer

✓une ~~Commenté~~plateforme levidéo ~~volume assets~~auto-hébergée

Prérequis matériels {#prérequis}

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

~~Modifications~~Pour duce ~~.env~~guide, nous utiliserons un serveur avec :

✓CPU ~~PEERTUBE_WEBSERVER_HOSTNAME~~: =AMD ~~localhost~~Ryzen 5 (8 threads)
✓Stockage ~~PEERTUBE_WEBSERVER_PORT~~principal =: ~~9000~~NVMe 454 GB
✓Stockage ~~PEERTUBE_WEBSERVER_HTTPS~~secondaire =: ~~false~~HDD 916 GB (pour les backups)
✓Système ~~POSTGRES_USER~~: =Debian ~~peertube~~

~~✓ POSTGRES_PASSWORD = peertube_password~~

~~✓ PEERTUBE_ADMIN_EMAIL = admin@localhost~~

~~✓ Autres domaines configurés en localhost~~(Bookworm)

Installation initiale avec Docker {#installation}

É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 : N'oubliez pas de générerGénérer un vraisecret sécurisé

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

openssl rand -hex 32

Copiez le résultat et ~~remplacer~~remplacez la valeur de PEERTUBE_SECRET dans le fichier .env.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 {#transcodage}

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 {#config-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é)

Ouvrez http://localhost:9000

Connectez-vous en tant qu'admin

Allez dans Administration → Configuration → VOD

Modifiez les valeurs

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 {#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 {#commandes}

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 {#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

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

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

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

Ouvrir au public (optionnel)
- Obtenez un nom de domaine
- Configurez un reverse proxy (Nginx/Caddy)
- Activez SSL avec Let's Encrypt

Ressources utiles

Documentation officielle : https://docs.joinpeertube.org/

Docker Compose : https://docs.docker.com/compose/

Rsync manuel : https://linux.die.net/man/1/rsync

Crontab generator : https://crontab.guru/

Forum PeerTube : https://framacolibri.org/c/peertube/

Dépannage fréquent

Problème : PeerTube ne démarre pas

# Voir les logs d'erreur
docker compose logs peertube

# Vérifier que les ports sont libres
sudo ss -tlnp | grep -E '9000|1935'

# Redémarrer proprement
docker compose down
docker compose up -d

Problème : Le transcodage ne fonctionne pas

Vérifiez la configuration :

cat docker-volume/config/local-production.json | grep -A 10 "transcoding"

Vérifiez que le transcodage est activé dans l'interface web

Regardez les logs :

docker compose logs -f peertube | grep transcode

Problème : Backup échoue

# Vérifier que le disque est monté
df -h | grep backup

# Vérifier les permissions
ls -ld /mnt/backup-disk/peertube_backup

# Tester manuellement
sudo /usr/local/bin/backup-peertube.sh
tail -20 /var/log/peertube-backup.log

Problème : Manque d'espace disque

# Voir l'utilisation détaillée
du -sh docker-volume/*

# Les gros dossiers sont généralement :
# - docker-volume/data (vidéos)
# - docker-volume/db (base de données)

# Nettoyer Docker
docker system prune -a --volumes

Bon courage avec votre instance PeerTube ! 🎥