Transformer un vieux PC ou laptop en serveur personnel

Besoin d'un serveur de test pour tes projets perso ? Un vieux PC ou un vieux laptop fera l'affaire. Coût : zéro. Temps nécessaire : moins de 30mn. Gain ? Énorme !

Cet article a été mis à jour le 24 août 2025 ; il prend 16 minutes à lire et comporte 3801 mots.

Il y a quelques mois, j’en ai eu assez de payer 6€ par mois pour un VPS de test chez un héber­geur, pour 3 vCPU et 8 Go de RAM. Un lap­top que je n’u­ti­li­sais jamais trai­nait dans mon pla­card : un i3-7020U avec 20 Go de RAM et un SSD de 220 Go. Rien d’ex­tra­or­di­naire, mais lar­ge­ment suf­fi­sant pour mes besoins de déve­lop­pe­ment local.

Alors je me suis ren­sei­gné, j’ai tes­té, et j’ai mon­té mon ser­veur sur cette base. Le résul­tat ? À la hau­teur de mes espé­rances. Voire même au-delà.

Et main­te­nant que mon ser­veur est en place, pour­quoi ne pas te faire pro­fi­ter de l’ex­pé­rience à tra­vers un petit tuto qui t’ac­com­pa­gne­ra dans cette démarche d’au­to­no­mie numérique ? 

Et cerise sur le gâteau, en uti­li­sant exclu­si­ve­ment des outils open source qui sou­vent valent et par­fois sur­passent leurs équi­va­lents commerciaux. 

Que tu sois un déve­lop­peur cher­chant un envi­ron­ne­ment de test gra­tuit ou sim­ple­ment curieux de reprendre le contrôle sur tes don­nées, trans­for­mer un PC ou un lap­top « obso­lète » en ser­veur per­son­nel peut t’in­té­res­ser, et c’est bien plus acces­sible que tu ne le penses. 

On va pro­cé­der par étapes, pour ne pas se perdre encours de route. Et la toute pre­mière étape, c’est de…

Choisir et préparer son matériel

Pas besoin d’une machine de guerre pour notre ser­veur per­so. L’a­van­tage majeur des pro­ces­seurs « ser­veur » (Threa­drip­per, Epyc, Xeon) ? La sta­bi­li­té et la puis­sance néces­saires pour faire tour­ner des appli­ca­tions en 24/7, sur des sys­tèmes for­te­ment sol­li­ci­tés et qui ne doivent sur­tout pas tom­ber en panne.

Mais quand c’est pour toi et toi seul (ou quelques per­sonnes), les contraintes ne sont pas les mêmes. Ton mini ser­veur tien­dra la charge bien plus faci­le­ment qu’en pro­duc­tion. Et une vieille bécane qui ne ser­vait plus à rien ni à per­sonne, jus­te­ment, c’est ce dont on a besoin. 

Inves­tis­se­ment zéro (d’un point de vue finan­cier). ROI expo­nen­tiel. Mais « obso­lète », ça veut tout dire, et en même temps, çà ne veut rien dire de pré­cis, il faut donc en tout pre­mier lieu…

Définir obsolète : jusqu’où remonter dans le temps ?

Tous les vieux PC ne sont pas adap­tés à un usage ser­veur moderne. Pour faire tour­ner Ubun­tu Ser­ver et Docker, il faut un mini­mum de compatibilité :

Maté­riel com­pa­tible (à par­tir de 2007–2009) :

• Pro­ces­seurs Intel : Core 2 Duo et géné­ra­tions sui­vantes, Xeon série 5400 (Har­per­town) ou Neha­lem (W‑3520, séries 35xx)
• Pro­ces­seurs AMD : Ath­lon 64, Opte­ron 2ième géné­ra­tion, Phe­nom et géné­ra­tions suivantes
• Archi­tec­ture : 64 bits obli­ga­toire avec sup­port SSE2

Maté­riel trop ancien : Les machines 32 bits ou très anciennes (486, Pen­tium III) ne peuvent pas faire tour­ner les dis­tri­bu­tions Linux actuelles. Mais elles gardent leur charme pour la nos­tal­gie (jeux DOS, sys­tèmes légers comme Free­DOS) ou des pro­jets spécialisés.

Spécifications recommandées

Mini­mum viable (comme mon i3-7020U) :

• un pro­ces­seur 64 bits dual-core (même un i3 fait l’affaire)
• 4 Go de RAM mini­mum (16 ou 20 Go comme dans mon cas, c’est le luxe)
• un disque dur ou SSD (le SSD change vrai­ment la donne en réactivité)
• une carte réseau Ether­net ou Wi-Fi (Ether­net est plus stable pour un serveur)

Confi­gu­ra­tion idéale :

• un pro­ces­seur quad-core ou dual-core avec hyperthreading
• 8 Go de RAM ou plus
• SSD pour le sys­tème et les appli­ca­tions critiques
• une connexion Ether­net stable

Préparation du matériel

Quelques recom­man­da­tions avant de com­men­cer l’installation :

1. Net­toyage phy­sique : dépous­siére les com­po­sants internes pour évi­ter la surchauffe
2. Véri­fi­ca­tion du disque : uti­lise smartctl pour véri­fier l’é­tat du disque dur
3. Sau­ve­garde : récu­père toutes les don­nées impor­tantes avant la réinstallation
4. Test de sta­bi­li­té : laisse tour­ner la machine quelques heures pour détec­ter d’é­ven­tuels pro­blèmes matériels

Installer un système d’exploitation adapté

Pourquoi choisir Ubuntu Server ?

Tout sim­ple­ment parce qu’U­bun­tu Ser­ver est le choix idéal pour débuter :

• Il offre une ins­tal­la­tion simple et guidée
• Il béné­fi­cie d’une docu­men­ta­tion abondante
• Il pro­fite d’un large sup­port communautaire
• Ses ver­sions LTS (Long Term Sup­port) sont stables et uti­li­sables sur des années
• Il ne pro­pose pas d’in­ter­face gra­phique inutile

Tu peux ins­tal­ler une autre dis­tri­bu­tion : Debian, Alma­Li­nux, Rocky Linux sont tout aus­si indi­quées, mais les ins­truc­tions dans ce tuto­rial sont pour Debian / Ubuntu.

Tu as fait ton choix ? Alors pas­sons à…

L’installation étape par étape

1. Tout d’a­bord, pré­pare le sup­port d’ins­tal­la­tion :
   • Télé­charge l’i­mage ISO d’U­bun­tu Ser­ver LTS depuis le site officiel
   • Crée une clé USB boo­table avec Rufus (Win­dows) ou dd (Linux/macOS)
2. Ensuite, ins­talle le sys­tème :
   • Démarre sur la clé USB
   • Suis l’as­sis­tant d’installation
   • Choi­sis un par­ti­tion­ne­ment simple (par défaut, sauf besoins spécifiques)
   • Impor­tant : n’ins­talle pas d’en­vi­ron­ne­ment gra­phique – inutile et « gour­mand » en ressources
3. Enfin, occupe toi de la confi­gu­ra­tion réseau
   • une IP sta­tique est recom­man­dée pour un serveur
   • Ou tu fais une réser­va­tion DHCP côté rou­teur pour simplifier

Tu peux main­te­nant faire tes pre­mier pas d’ad­mi­nis­tra­teur système :

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

# Installation d'outils de base
sudo apt install curl wget git htop

Ça y est, tu as un ser­veur, en confi­gu­ra­tion mini­male certes, mais prêt à l’emploi.

Pour autant, tu n’es pas ren­du. Dans l’é­tat, tu ne feras pas grand chose de ton ser­veur, alors je te conseille de conti­nuer par…

L’installation et la configuration de Docker

Docker ? Ok. Mais pourquoi Docker ?

Docker a révo­lu­tion­né la ges­tion des ser­vices en les iso­lant dans des conte­neurs légers. Sur mon petit ser­veur, je fais tour­ner simul­ta­né­ment Next­cloud, Gra­fa­na, Pro­me­theus, n8n, et plu­sieurs pro­jets de test sans aucun conflit. Chaque appli­ca­tion vit dans son propre uni­vers, avec ses dépen­dances, tout en par­ta­geant les res­sources sys­tème de façon optimale.

L’autre avan­tage énorme : la por­ta­bi­li­té. Si demain je change de ser­veur, je copie mes fichiers de confi­gu­ra­tion docker et tout redé­marre à l’i­den­tique. Fini les ins­tal­la­tions manuelles inter­mi­nables et les « ça mar­chait sur mon ancienne machine ».

Docker est qua­si-agnos­tique : tant que tu ne pars pas sur des confi­gu­ra­tions ARM (Pi 5 par exemple), tout ce qui est docke­ri­sable est docke­ri­sé et uti­li­sable sans confi­gu­ra­tion com­pli­quée – tu ver­ras dans la suite du tuto.

Mais avant de pro­fi­ter de ton ser­veur, on passe à…

L’installation de Docker

# Suppression des anciennes versions
sudo apt remove docker docker-engine docker.io containerd runc

# Installation des dépendances
sudo apt install apt-transport-https ca-certificates curl gnupg lsb-release

# Ajout de la clé GPG officielle de Docker
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# Ajout du dépôt
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Installation
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-compose-plugin

# Ajout de l'utilisateur au groupe docker
sudo usermod -aG docker $USER

Vérification de l’installation

# Test Docker
docker --version
docker run hello-world

# Test Docker Compose (nouvelle syntaxe sans tiret)
docker compose version

Tu vois, ins­tal­ler Docker n’est pas vrai­ment dou­lou­reux, il suf­fit de suivre les étapes une à une. Et la pro­chaine, c’est le…

Déploiement d’une stack de services de base

Objectif de la stack

Nous allons déployer une infra­struc­ture com­plète uni­que­ment avec des outils open source :

• Trae­fik, le reverse proxy automatique
• Por­tai­ner, l’in­ter­face gra­phique de Docker
• Pro­me­theus pour la col­lecte de métriques
• Gra­fa­na pour la visua­li­sa­tion des don­nées récu­pé­rées par Prometheus

Cette stack tourne par­fai­te­ment sur mon vieux laptop.

Je te pro­pose tout d’a­bord de créer la struc­ture des fichiers. Tu ne mets pas tout en vrac dans le réper­toire prin­ci­pal, tu orga­nises pro­pre­ment pour mieux t’y retrou­ver ensuite. Donc un dos­sier certs où tu met­tras plus tard les cer­ti­fi­cats SSL.

~/stack-docker/
├── docker-compose.yml
├── traefik.yml
├── prometheus.yml
└── certs/
    ├── cert.pem
    └── cert.key

Main­te­nant, tu sais où on va, et la pro­chaine étape, c’est la…

Configuration de Docker

Le pre­mier fichier que tu vas créer, c’est docker-compose.yml. La com­mande ? Toute simple :

vim docker-compose.yml

C’est tout. Un petit i (pour insert) et tu peux col­ler le conte­nu sui­vant dans ton fichier. Tu enre­gistres uti­li­sant la touche Échap puis en entrant la séquence sui­vante au cla­vier : :x, tu valides, et c’est terminé.

services:
  traefik:
    image: traefik:latest
    container_name: traefik
    command:
      - "--configFile=/traefik.yml"
    ports:
      - "80:80"
      - "443:443"
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.traefik.rule=Host(`traefik.localhost`)"
      - "traefik.http.routers.traefik.entrypoints=websecure"
      - "traefik.http.routers.traefik.tls=true"
      - "traefik.http.routers.traefik.service=api@internal"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - ./traefik.yml:/traefik.yml:ro
      - ./certs:/certs:ro
    networks:
      - web
    restart: unless-stopped

  portainer:
    image: portainer/portainer-ce:latest
    container_name: portainer
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.portainer.rule=Host(`portainer.localhost`)"
      - "traefik.http.routers.portainer.entrypoints=websecure"
      - "traefik.http.routers.portainer.tls=true"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - portainer_data:/data
    networks:
      - web
    restart: unless-stopped

  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.prometheus.rule=Host(`prometheus.localhost`)"
      - "traefik.http.routers.prometheus.entrypoints=websecure"
      - "traefik.http.routers.prometheus.tls=true"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml:ro
      - prometheus_data:/prometheus
    networks:
      - web
    restart: unless-stopped

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    environment:
      - GF_SECURITY_ADMIN_USER=admin
      - GF_SECURITY_ADMIN_PASSWORD=changeme123
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.grafana.rule=Host(`grafana.localhost`)"
      - "traefik.http.routers.grafana.entrypoints=websecure"
      - "traefik.http.routers.grafana.tls=true"
    volumes:
      - grafana_data:/var/lib/grafana
    networks:
      - web
    restart: unless-stopped

volumes:
  portainer_data:
  prometheus_data:
  grafana_data:

networks:
  web:
    external: false

Tu remarques que dans ce fichier, il y a toute une sec­tion dédiée à Trae­fik, et qu’en­suite, on le retrouve pour expo­ser tous les ser­vices aux­queks on accède via un navi­ga­teur. Mais il faut avant pas­ser par…

La configuration de Traefik

Avant de pas­ser à la confi­gu­ra­tion, un mot sur ce qu’est un reverse proxy : c’est tout sim­ple­ment un aiguilleur intel­li­gent qui dirige les visi­teurs vers le bon ser­vice en fonc­tion de l’a­dresse demandée.

Crée le fichier ~/stack-docker/traefik.yml :

entryPoints:
  web:
    address: ":80"
    http:
      redirections:
        entryPoint:
          to: websecure
          scheme: https
  websecure:
    address: ":443"
    http:
      tls:
        certificates:
          - certFile: "/certs/cert.pem"
            keyFile: "/certs/cert.key"

providers:
  docker:
    exposedByDefault: false
    network: stack-docker_web

api:
  dashboard: true
  # Pas de insecure: true car on passe par Traefik lui-même

Les fichiers docker-compose.yml et traefik.yml sont les fichiers essen­tiels de ta confi­gu­ra­tion. Pour autant, les outils sui­vants ne sont pas inutiles. Pro­me­theus te par­met de connaître en temps réel l’é­tat de san­té de ton ser­veur. Un must-have pour ne pas subir un crash que tu aurais pu anti­ci­per. Pour l’ins­tal­ler, tu n’as rien de plus à faire, c’est dans le fichier docker-compose.yml que tu l’as deman­dé. Mais il faut pour lui aus­si par une phase essen­tielle, la…

Configuration de Prometheus

Crée le fichier ~/stack-docker/prometheus.yml :

global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['prometheus:9090']
  
  - job_name: 'node-exporter'
    static_configs:
      - targets: ['node-exporter:9100']

Voi­là, tu en as fini avec les fichiers de confi­gu­ra­tion. Mais ce n’est pas fini, il reste encore quelques étapes essen­tielles avant que tu ne pro­fites de ton ser­veur. Un ser­veur, même s’il n’hé­ber­geait que les pho­tos de grand-maman à la plage, néces­site un mini­mum de sécu­ri­sa­tion. Retrou­ver ses pho­tos sur les sites de hackers russes ne lui ferait peut-être pas plai­sir… et ce qui ne fais pas plai­sir à grand-maman ne te fais pas plus plai­sir à toi… CQFD.

Sécuriser avec des certificats SSL

HTTPS local avec mkcert

Pour sécu­ri­ser tes ser­vices locaux, mkcert est la solu­tion idéale. Sur mon setup, j’ai long­temps galé­ré avec les cer­ti­fi­cats auto-signés et les erreurs de navi­ga­teur. Mkcert résout tout ça élégamment :

# Installation de mkcert
curl -JLO "https://dl.filippo.io/mkcert/latest?for=linux/amd64"
chmod +x mkcert-v*-linux-amd64
sudo mv mkcert-v*-linux-amd64 /usr/local/bin/mkcert

# Installation du CA racine
mkcert -install

# Génération des certificats
mkdir -p ~/stack-docker/certs
cd ~/stack-docker/certs
mkcert localhost portainer.localhost prometheus.localhost grafana.localhost traefik.localhost
mv localhost+4.pem cert.pem
mv localhost+4-key.pem cert.key

Note d’ex­pé­rience : Même avec mkcert, Fire­fox peut par­fois faire du zèle. Sur Chrome, ça marche impec­ca­ble­ment. C’est un petit prix à payer pour avoir du HTTPS local sans confi­gu­ra­tion complexe.

Configuration des noms locaux

Pour accé­der à tes ser­vices via des noms plu­tôt que des IP :

1. Édite le fichier hosts sur chaque machine cliente : 
   • Linux/Mac : /etc/hosts
   • Win­dows : C:\Windows\System32\drivers\etc\hosts
2. Ajoute les entrées :

192.168.1.100 traefik.localhost
192.168.1.100 portainer.localhost
192.168.1.100 prometheus.localhost
192.168.1.100 grafana.localhost

(Rem­place 192.168.1.100 par l’IP de votre serveur)

Astuce pra­tique : Sur mon setup, j’ai confi­gu­ré une réser­va­tion DHCP pour que mon ser­veur ait tou­jours la même IP (192.168.1.50). Plus simple que de gérer une IP sta­tique et ça évite les conflits.

Lancement et configuration de la stack

Démarrage des services

cd ~/stack-docker
docker compose up -d

Vérification du déploiement

# Vérifier que tous les conteneurs tournent
docker ps

# Consulter les logs en cas de problème
docker compose logs traefik
docker compose logs portainer

Accès aux interfaces

Depuis ta machine de déve­lop­pe­ment, tu peux accé­der à :

• Trae­fik Dash­board : https://traefik.localhost
• Por­tai­ner : https://portainer.localhost
• Pro­me­theus : https://prometheus.localhost
• Gra­fa­na : https://grafana.localhost

⚠️ Sécu­ri­té : Change immé­dia­te­ment les mots de passe par défaut !

Configuration de Grafana

1. Connecte-toi avec admin/changeme123
2. Change le mot de passe
3. Ajoute Pro­me­theus comme source de données : 
   • URL : http://prometheus:9090
   • Clique sur « Save & Test »
4. Importe un dash­board préconfiguré : 
   • ID 1860 (Node Expor­ter Full)
   • ID 179 (Docker monitoring)

Sécuriser le serveur

Configuration SSH sécurisée

Édite le fichier /etc/ssh/sshd_config :

sudo vim /etc/ssh/sshd_config

Modi­fie ou ajoute ces lignes :

PermitRootLogin no
PasswordAuthentication no  # Après avoir configuré les clés
Port 2222  # Port non standard (optionnel)

Redé­marre le ser­vice SSH :

sudo systemctl restart ssh

Assure-toi que la connexion par clé SSH fonc­tionne par­fai­te­ment, afin d’é­vi­ter de te retrou­ver blo­qué hors de ton propre serveur.

Tu as oublié de véri­fier que ta clé SSH fonc­tionne ? Pas de panique ! Quelques mani­pu­la­tions simples et tout va ren­trer dans l’ordre :

• Branche un écran à ton ser­veur (si c’est une tour, sur un lap­top tu l’as déjà).
• Édite le fichier de confi­gu­ra­tion sshd_config et remets PasswordAuthentication yes avant de sau­ve­gar­der et de relan­cer le ser­vice. Et ne tourne pas en boucle, teste bien cette fois-ci !

Configuration des clés SSH

# Sur votre machine locale
ssh-keygen -t rsa -b 4096 -C "votre@email.com"

# Copie de la clé vers le serveur
ssh-copy-id utilisateur@IP_SERVEUR

Pare-feu avec UFW

# Installation et activation
sudo apt install ufw
sudo ufw default deny incoming
sudo ufw default allow outgoing

# Autoriser SSH (adapte le port si modifié)
sudo ufw allow 22/tcp

# Autoriser les services web
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw allow 8080/tcp

# Activation
sudo ufw enable

Monitoring et surveillance

Ajout de Node Exporter pour les métriques système

Ajoute cette sec­tion dans ton fichier ~/stack-docker/docker-compose.yml :

  node-exporter:
    image: prom/node-exporter:latest
    container_name: node-exporter
    command:
      - '--path.rootfs=/host'
    volumes:
      - '/:/host:ro,rslave'
    networks:
      - web
    restart: unless-stopped

Dashboards Grafana recommandés

• Node Expor­ter Full (1860) : moni­to­ring sys­tème complet
• Docker moni­to­ring (179) : sur­veillance des conteneurs
• Trae­fik 2.0 (4475) : métriques du reverse proxy

Surveillance des ressources en ligne de commande

# Installation d'outils de monitoring
sudo apt install htop iotop iftop ncdu

# Surveillance temps réel
htop          # Processus et mémoire
iotop         # E/S disque
iftop         # Trafic réseau
df -h         # Espace disque

Maintenance et sauvegarde

Mises à jour automatiques

# Configuration des mises à jour automatiques
sudo apt install unattended-upgrades
sudo dpkg-reconfigure unattended-upgrades

Script de sauvegarde

Crée le fichier ~/backup-docker.sh :

#!/bin/bash
# Script de sauvegarde automatique

BACKUP_DIR="/backup"
DATE=$(date +%Y%m%d_%H%M%S)

# Création du dossier de sauvegarde
mkdir -p $BACKUP_DIR

# Sauvegarde des volumes Docker
docker run --rm -v portainer_data:/data -v $BACKUP_DIR:/backup alpine tar czf /backup/portainer_$DATE.tar.gz -C /data .
docker run --rm -v grafana_data:/data -v $BACKUP_DIR:/backup alpine tar czf /backup/grafana_$DATE.tar.gz -C /data .
docker run --rm -v prometheus_data:/data -v $BACKUP_DIR:/backup alpine tar czf /backup/prometheus_$DATE.tar.gz -C /data .

# Sauvegarde de la configuration
tar czf $BACKUP_DIR/config_$DATE.tar.gz ~/stack-docker/

# Nettoyage des sauvegardes anciennes (> 30 jours)
find $BACKUP_DIR -name "*.tar.gz" -mtime +30 -delete

echo "Sauvegarde terminée : $DATE"

Rend le script exécutable :

chmod +x ~/backup-docker.sh

Même si tu as une sau­ve­garde locale, n’ou­blie pas l’im­por­tance d’une stra­té­gie de sau­ve­garde externe (vers un NAS ou un ser­vice cloud, sur ton poste de tra­vail ou sur un SSD externe) pour te pré­mu­nir contre une panne maté­rielle du ser­veur lui-même.

Tâches cron pour l’automatisation

# Édition de la crontab
crontab -e

# Exemples de tâches
# Sauvegarde quotidienne à 2h du matin
0 2 * * * /home/user/backup-docker.sh

# Mise à jour des conteneurs le dimanche à 3h
0 3 * * 0 cd /home/user/stack-docker && docker compose pull && docker compose up -d

# Nettoyage Docker hebdomadaire
0 4 * * 0 docker system prune -f

Extensions et évolutions possibles

Services populaires à ajouter

Cloud per­son­nel :

• Next­cloud : sto­ckage et syn­chro­ni­sa­tion de fichiers
• Sync­thing : syn­chro­ni­sa­tion P2P

Media et divertissement :

• Plex/Jellyfin : ser­veur multimédia
• Trans­mis­sion : client BitTorrent

Pro­duc­ti­vi­té :

• n8n : auto­ma­ti­sa­tion de tâches (alter­na­tive à Zapier)
• Ghost : pla­te­forme de blog
• Word­Press : site web complet

Sécu­ri­té et réseau :

• Pi-hole : blo­queur de publi­ci­tés DNS
• Wire­Guard : VPN personnel

Exemple d’ajout de service : Nextcloud

Pour ajou­ter Next­cloud à votre stack, ajoute cette sec­tion dans ~/stack-docker/docker-compose.yml :

  nextcloud:
    image: nextcloud:latest
    container_name: nextcloud
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.nextcloud.rule=Host(`nextcloud.localhost`)"
      - "traefik.http.routers.nextcloud.entrypoints=websecure"
      - "traefik.http.routers.nextcloud.tls=true"
    volumes:
      - nextcloud_data:/var/www/html
    environment:
      - MYSQL_ROOT_PASSWORD=rootpass
      - MYSQL_PASSWORD=ncpass
      - MYSQL_DATABASE=nextcloud
      - MYSQL_USER=nextcloud
    networks:
      - web
    restart: unless-stopped

Et ajoute le volume cor­res­pon­dant dans la sec­tion volumes :

volumes:
  portainer_data:
  prometheus_data:
  grafana_data:
  nextcloud_data:  # Nouvelle ligne

Conclusion

Cette expé­rience m’a ouvert les yeux : pour­quoi dépendre de ser­vices payants quand on peut créer sa propre infra­struc­ture avec du maté­riel exis­tant ou avec du maté­riel d’oc­ca­sion à bas prix ? Une tour ou un por­table avec un i3 et 16Go de RAM se trouve à moins de 50 € sur lebon­coin.

Aujourd’­hui, mon petit ser­veur fait tour­ner une dizaine de ser­vices en conti­nu, sur­veille mes appli­ca­tions, héberge mes pro­jets en phase de test, et tout cela sans débour­ser un cen­time sup­plé­men­taire. Et il tient la charge, avec une stack cor­recte (Trae­fik, Por­tai­ner, AlloyDB Omni, n8n, Pro­me­theus, Gra­fa­na, node importer…) :

Et même par ces temps cani­cu­laires (cap­ture en date du 11 août 2025, avec des pics de tem­pé­ra­ture à 42°C et 29/30°C à l’in­té­rieur – je n’ai pas de clim…), il ne sur­chauffe pas :

Avec le tableau de bord deTrea­fik, j’ai un œil sur mon réseau :

Et grâce à Por­tai­ner, je peux avoir un accès direct à mes images Docker, je peux en ins­tal­ler, j’ai un accès direct aux logs sans pas­ser par la ligne de commande…

Pour les per­for­mances, par rap­port au VPS Conta­bo que j’ai déjà tes­té, ce ser­veur sur lap­top est une pépite : pro­ces­seur, RAM, SSD sont plus per­for­mants (ce n’est pas peu dire) et l’ex­ploi­ta­tion en mode local m’af­fran­chit de la latence du réseau.

Un i3-7020U de 2017 qui bat un ser­veur payant… ça donne à réflé­chir sur la qua­li­té de cer­taines offres « low cost ».

La preuve par 9 dans un com­pa­ra­tif rapide…

Laptop vs VPS Contabo : Pourquoi payer quand on a mieux à la maison ?

Configurations comparées

Résultats des tests de performance

CPU (sysbench cpu –threads=1)

sysbench cpu --threads=1 --time=10 run

Mémoire (sysbench memory)

sysbench memory --memory-total-size=1G run

Stockage (dd tests)

dd if=/dev/zero of=testfile bs=1M count=1024 conv=fdatasync
dd if=testfile of=/dev/null bs=1M count=1024

Le verdict

En uti­li­sant mon lap­top au lieu du VPS Conta­bo, j’é­co­no­mise 5€36 par mois soit 64€32 par an pour des per­for­mances supé­rieures. En dédui­sant la consom­ma­tion élec­trique (envi­ron 50KWh sur un an, soit ~8/10€ TTC) on est tou­jours dans le vert avec une éco­no­mie réelle d’au moins 55€ sur l’an­née.

D’au­tant que mon lap­top d’en­trée de gamme sur­passe le VPS payant dans tous les domaines :

• CPU 23% plus per­for­mant par cœur, avec un cœur supplémentaire
• RAM 55% plus rapide (par Go, et j’en ai 2,5 x plus)
• Sto­ckage 2 à 7 fois plus rapide
• Latence 9 fois plus stable

Le mot de la fin

Avant de sor­tir la carte bleue pour un VPS de test ou déve­lop­pe­ment, véri­fie si votre vieux lap­top ne fait pas déjà mieux que ce que tu vas payer !

Trans­for­mer un vieux PC en ser­veur per­son­nel, c’est bien plus qu’un simple recy­clage. Mon petit i3-7020U avec ses 20 Go de RAM fait aujourd’­hui tour­ner une infra­struc­ture qui coû­te­rait faci­le­ment 80 à 100 € par mois en ser­veur et en ser­vices cloud. En quelques mois, j’é­co­no­mise bien plus que le prix d’a­chat ini­tial du laptop.

Mais au-delà de l’as­pect éco­no­mique, c’est une véri­table leçon d’au­to­no­mie numé­rique. Avec Ubun­tu Ser­ver, Docker et cette stack d’ou­tils open source, tu dis­poses d’une infra­struc­ture moderne qui n’a rien à envier aux solu­tions com­mer­ciales. Gra­fa­na riva­lise avec Tableau, Pro­me­theus rem­place New Relic, Trae­fik fait mieux que beau­coup de reverse proxy payants.

Ce pro­jet, simple à démar­rer, gran­dit avec tes besoins. Mon ser­veur héberge main­te­nant mes pro­jets de déve­lop­pe­ment, mes sau­ve­gardes auto­ma­tiques, mon cloud per­son­nel avec Next­cloud, et des outils d’au­to­ma­ti­sa­tion comme n8n. Tout ça tourne 24h/24 sans bron­cher, sur une machine que je n’u­til­sais plus. Et je ne regrette pas les heures pas­sées à cher­cher des solu­tions, à ins­tal­ler, à tes­ter avant d’a­voir mon mini serveur.

Ce que toi tu gagnes

• Tu fais des éco­no­mies : fini les 6€/mois pour un ser­veur de test basique, et les dizaines d’eu­ros sup­plé­men­taires pour les ser­vices que tu héberges
• Tu montes en com­pé­tences : en admi­nis­tra­tion sys­tème, Docker, monitoring
• Tu gagnes en auto­no­mie : Tes don­nées t’ap­par­tiennent, tes ser­vices aussi
• Et en évo­lu­ti­vi­té : ton infra­struc­ture prête pour tous tes futurs projets
• Tu as la satis­fac­tion et le plai­sir de faire du neuf avec de l’ancien

Aller plus loin

Ton ser­veur per­son­nel est main­te­nant prêt à t’ac­com­pa­gner dans tes pro­jets. N’hé­site pas à expé­ri­men­ter, ajou­ter des ser­vices, opti­mi­ser les per­for­mances. C’est ton ter­rain de jeu, sans limite de temps ni res­tric­tion de quota.

L’in­ves­tis­se­ment ini­tial (quelques heures de confi­gu­ra­tion) te fera éco­no­mi­ser plu­sieurs cen­taines d’eu­ros par an, tout en te don­nant une maî­trise com­plète de ton infra­struc­ture numérique.

Pas­cal CESCATO

Je ne me contente pas de refor­mu­ler des com­mu­ni­qués ou de dérou­ler des specs. Je teste, je creuse, je démonte quand il faut – parce qu’un sujet mal com­pris est un sujet mal écrit. J’écris avec les mains dans le cam­bouis, sans sim­pli­fier à outrance ni recra­cher du mar­ke­ting. Mon truc, c’est de rendre clair sans tra­hir, lisible sans lis­ser. Et non, je ne “fais pas du conte­nu”. Pas pour faire du conte­nu, en tout cas.