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

Table des matières

1. Introduction à PeerTube
2. Prérequis matériels
3. Installation initiale avec DockerArchitecture
4. Comprendre le transcodage vidéoPréparation
5. Configuration optimale du transcodageInstallation
6. Organisation du stockageTraefik
7. SystèmeConfiguration de backup automatiquePeerTube
8. Commandes utilesSécurité
9. SurveillanceRéseau
et
10. Transcodage
maintenance
11. Utilisateurs
12. Stockage
13. Maintenance
14. Troubleshooting

1. Introduction à PeerTube

Qu'Qu’est-ce que PeerTube ?

PeerTube est une plateforme vidéo gratuiteopen source, décentralisée et open source, alternative à YouTube. Elle utilise le protocole 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.peer.

Avantages principaux :

• Pas de publicité
• Hébergement autonome
• Partage de bande passante entre spectateurs (P2P)P2P
• Contrôle total de vosdes données
• Fédération via ActivityPub
• Streaming HLS adaptatif

À qui s's’adresse ce guide ?

Ce tutoriel estpermet conçude pour mettre en placedéployer 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 :

• Nom de domaine personnalisé
• HTTPS automatique (Let’s Encrypt)
• Sécurité renforcée (firewall, fail2ban)
• Inscriptions avec validation email
• Architecture scalable

2. Prérequis

Matériel recommandé

Logiciels requis

• Stockage principal : NVMe 454 GB
• Stockage secondaire : HDD 916 GB (pour les backups)
• SystèmeOS : 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 remplacezDocker 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 formatsCompose
• LeAccès transcodage garantit une lecture partoutDNS (Chrome,OVH, Firefox,Cloudflare, Safari,etc.)
• IP publique fixe ou dynamique
• Compte email SMTP (Gmail, SendGrid, etc.)

2.

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

3. SansArchitecture

Schéma

d’architecture
• Les utilisateurs avec mauvaise connexion ne peuvent pas regarder
• Risqueet de formats vidéo incompatibles

Les contraintes du transcodage

Ressources nécessaires :fonctionnement

• 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é│                                   │   │
│   │  Visiteur   │───▶│   Traefik   │───▶│         PeerTube                  │   │
│   │             │    │             │    │                                   │   │
│   └─────────────┘    └─────────────┘    └───────────────────────────────────┘   │
│          ▲                                      │                           │
│          │                                      ▼                           │
│   ┌──────┴──────┐                        ┌─────────────────────┐               │
│   │   Internet  │                        │   PostgreSQL/Redis   │               │
│   └────────────┘                        └─────────────────────┘               │
│                                                                               │
└───────────────────────────────────────────────────────────────────────────────┘

Créer

Flux de données :

1. Le visiteur accède à peertube.mondomaine.fr (HTTPS).
2. Traefik gère le scriptcertificat SSL et redirige vers PeerTube.
3. PeerTube lit/écrit dans PostgreSQL et Redis.
4. Les vidéos sont stockées en HLS pour le streaming adaptatif.

---

4. Préparation du serveur

Structure des dossiers

mkdir -p ~/peertube/{traefik/{dynamic,acme},config}
cd ~/peertube

Permissions critiques :

touch traefik/acme/acme.json
chmod 600 traefik/acme/acme.json

---

5. Installation avec Docker Compose

Fichier docker-compose.yml

services:
  traefik:
    image: traefik:v3.3
    container_name: traefik
    restart: always
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - ./traefik/traefik.yml:/etc/traefik/traefik.yml:ro
      - ./traefik/dynamic:/etc/traefik/dynamic:ro
      - ./traefik/acme:/acme
    networks:
      - traefik-proxy

  peertube:
    image: chocobozzz/peertube:v8.0.0-trixie
    container_name: peertube
    restart: always
    volumes:
      - data:/data
      - ./config:/config
    depends_on:
      - postgres
      - redis
      - traefik
    networks:
      - traefik-proxy
      - peertube
    environment:
      - PEERTUBE_WEBSERVER_HOSTNAME=peertube.mondomaine.fr
      - PEERTUBE_WEBSERVER_HTTPS=true
      - PEERTUBE_WEBSERVER_PORT=443
      - PEERTUBE_DB_HOSTNAME=postgres
      - PEERTUBE_DB_USERNAME=peertube
      - PEERTUBE_DB_PASSWORD=peertube
      - PEERTUBE_REDIS_HOSTNAME=redis
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.peertube.entrypoints=http"
      - "traefik.http.routers.peertube.rule=Host(`peertube.mondomaine.fr`)"
      - "traefik.http.routers.peertube-secure.entrypoints=https"
      - "traefik.http.routers.peertube-secure.rule=Host(`peertube.mondomaine.fr`)"
      - "traefik.http.routers.peertube-secure.tls=true"
      - "traefik.http.routers.peertube-secure.tls.certresolver=letsencrypt"
      - "traefik.http.services.peertube.loadbalancer.server.port=9000"
      - "traefik.docker.network=traefik-proxy"

  postgres:
    image: postgres:16-alpine
    container_name: peertube-postgres
    restart: always
    environment:
      POSTGRES_USER: peertube
      POSTGRES_PASSWORD: peertube
      POSTGRES_DB: peertube
    volumes:
      - db:/var/lib/postgresql/data
    networks:
      - peertube

  redis:
    image: redis:7-alpine
    container_name: peertube-redis
    restart: always
    volumes:
      - redis:/data
    networks:
      - peertube

networks:
  traefik-proxy:
    name: traefik-proxy
    driver: bridge
  peertube:
    name: peertube
    driver: bridge

volumes:
  data:
  db:
  redis:

⚠️ Remplacez peertube.mondomaine.fr et les mots de backuppasse par vos valeurs.

---

6. Configuration Traefik

Fichier traefik/traefik.yml

Étape

api:
  1dashboard: true
  insecure: false

entryPoints:
  http:
    address: ":80"
    http:
      redirections:
        entryPoint:
          to: https
          scheme: https
          permanent: true
  https:
    address: ":443"
    http:
      tls:
        certResolver: letsencrypt

providers:
  docker:
    endpoint: "unix:///var/run/docker.sock"
    exposedByDefault: false
    network: traefik-proxy
  file:
    directory: /etc/traefik/dynamic
    watch: true

certificatesResolvers:
  letsencrypt:
    acme:
      email: admin@mondomaine.fr
      storage: /acme/acme.json
      httpChallenge:
        entryPoint: http

---

7. Configuration PeerTube

Fichier config/production.yaml

listen:
  hostname: '0.0.0.0'
  port: 9000

webserver:
  https: true
  hostname: 'peertube.mondomaine.fr'
  port: 443

database:
  hostname: 'postgres'
  port: 5432
  suffix: ''
  username: 'peertube'
  password: 'peertube'
  pool:
    max: 5

redis:
  hostname: 'redis'
  port: 6379
  auth: null
  db: 0

smtp:
  hostname: smtp.gmail.com
  port: 465
  username: votre-email@gmail.com
  password: "votre-mot-de-passe-app"
  tls: true
  disable_starttls: false
  ca_file: null
  from_address: votre-email@gmail.com

signup:
  enabled: true
  limit: 10
  requires_email_verification: true

video_transcoding:
  enabled: true
  web_videos:
    enabled: false
  hls:
    enabled: true

secrets:
  peertube: "REMPLACER_PAR_VOTRE_SECRET"

⚠️ Générez un secret sécurisé :

Créer

openssl lerand fichier-hex script

sudo apt install -y ufw
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow 22/tcp comment 'SSH'
sudo ufw allow 80/tcp comment 'HTTP'
sudo ufw allow 443/tcp comment 'HTTPS'
sudo ufw --force enable

sudo apt install -y fail2ban
sudo nano /usr/local/bin/backup-etc/fail2ban/jail.local

[DEFAULT]
bantime = 3600
findtime = 600
maxretry = 5
banaction = ufw
backend = systemd

[sshd]
enabled = true
port = 22
maxretry = 3
bantime = 7200

peertube.shmondomaine.fr → VOTRE_IP_PUBLIQUE

video_transcoding:
  enabled: true
  web_videos:
    enabled: false
  hls:
    enabled: true

signup:
  enabled: true
  requires_email_verification: true

#!/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/peertube/"

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

echo "[$DATE] Début du backup PeerTube" >> $LOG
#docker Copiecompose avecstop rsyncpeertube postgres redis
rsync -av --delete "$SOURCE" "$DEST" >> $LOG 2>&1
#docker Vérificationcompose dustart résultatpeertube ifpostgres [ $? -eq 0 ]; then
    echo "[$DATE] ✓ Backup terminé avec succès" >> $LOG
else
    echo "[$DATE] ✗ ERREUR lors du backup" >> $LOG
firedis

sudodocker chmodcompose +xlogs /usr/local/bin/backup-peertube.sh-f peertube
docker compose restart peertube
docker system prune -a

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

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

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

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

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)

sudo grep "backup-peertube" /etc/crontab

# 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

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

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

# 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

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

df -h /

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

"concurrency": 3   // Au lieu de 2

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

docker compose restart peertube

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

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)