Optimiser les images JPG, PNG, WebP et AVIF sur un serveur Linux

Optimiser les images d’un site web reste l’un des leviers les plus efficaces pour réduire le poids des pages, accélérer le chargement et économiser de la bande passante. Sur un serveur Linux, on peut le faire proprement en ligne de commande, sans dépendre uniquement d’un plugin WordPress ou d’un service externe.

Historiquement, deux outils faisaient très bien le travail : jpegoptim pour les JPEG et optipng pour les PNG. Ils restent utiles aujourd’hui. Cependant, l’optimisation moderne ne s’arrête plus aux fichiers JPG et PNG : il faut aussi penser WebP, AVIF, sauvegardes, traitement incrémental, logs et intégration WordPress.

Voici une méthode propre pour optimiser des images sur un serveur Linux, sans transformer votre médiathèque en terrain d’expérimentation sauvage.

Pourquoi optimiser les images côté serveur ?

Les images représentent souvent une grande partie du poids d’une page web. Une photo trop lourde, un PNG non compressé ou une miniature générée sans optimisation peut ralentir tout un site, surtout sur mobile.

Optimiser les images permet de :

• réduire le poids des pages ;
• améliorer les temps de chargement ;
• réduire la bande passante consommée ;
• améliorer l’expérience mobile ;
• limiter l’espace disque utilisé ;
• mieux préparer les images pour un CDN ;
• éviter de dépendre totalement d’un plugin ou d’une API payante.

Le gain exact dépend du type d’image, de sa qualité initiale, de sa résolution et de son format. Mais sur un vieux site WordPress, une galerie photo ou une médiathèque jamais nettoyée, les économies peuvent être très visibles. Les images oubliées depuis 2011 ont souvent une belle marge de progression. Comme nous tous, finalement.

Lossless ou lossy : quelle différence ?

Avant de lancer une commande sur tout un serveur, il faut comprendre la différence entre compression sans perte et compression avec perte.

Type	Principe	Avantage	Risque
Lossless	Optimise le fichier sans changer visiblement l’image.	Très sûr pour les originaux.	Gain parfois limité.
Lossy	Réduit aussi la qualité visuelle pour diminuer le poids.	Gain souvent beaucoup plus important.	Dégradation possible si le réglage est trop agressif.

Pour une première passe sur un serveur en production, commencez par du lossless. Vous réduisez le poids sans prendre de risque visuel important.

Pour les images très lourdes, notamment les photos, une compression lossy raisonnable peut ensuite donner de meilleurs résultats. Il faut toutefois tester sur un échantillon avant de traiter toute la médiathèque.

Quels outils utiliser ?

Voici une base solide pour un serveur Linux moderne :

Format	Outil	Usage
JPEG / JPG	jpegoptim	Optimisation lossless ou compression avec qualité maximale définie.
PNG	optipng	Optimisation PNG sans perte.
PNG	pngquant	Compression PNG lossy, souvent très efficace pour réduire le poids.
WebP	cwebp	Conversion JPEG/PNG vers WebP.
AVIF	avifenc	Conversion vers AVIF avec compression moderne.
SVG	svgo	Nettoyage et optimisation des SVG.

Dans cet article, on se concentre sur les images raster les plus courantes : JPEG, PNG, WebP et AVIF. Pour les SVG, le sujet mérite souvent un traitement séparé, car il faut éviter de casser des attributs, animations ou IDs utilisés par le CSS et JavaScript.

Installer les outils sur Debian ou Ubuntu

Sur Debian, Ubuntu ou une distribution dérivée, installez les outils de base :

sudo apt update
sudo apt install jpegoptim optipng pngquant webp libavif-bin findutils

Vérifiez ensuite les versions installées :

jpegoptim --version
optipng -v
pngquant --version
cwebp -version
avifenc --version

Selon votre distribution, certains paquets peuvent porter un nom légèrement différent ou être moins récents. Pour un serveur de production, privilégiez les paquets de la distribution sauf besoin précis. Les binaires compilés à la main, c’est bien. Les binaires oubliés dans /usr/local/bin trois ans plus tard, beaucoup moins.

Installer les outils sur Fedora

Sur Fedora, utilisez dnf :

sudo dnf install jpegoptim optipng pngquant libwebp-tools libavif-tools findutils

Installer les outils sur Arch Linux

Sur Arch Linux ou une distribution dérivée :

sudo pacman -S jpegoptim optipng pngquant libwebp libavif findutils

Sauvegarder avant d’optimiser

Avant toute optimisation massive, faites une sauvegarde. C’est non négociable.

Beaucoup d’outils modifient les fichiers sur place. C’est pratique, mais cela signifie aussi qu’une mauvaise commande peut toucher des milliers d’images en quelques secondes. Linux est très obéissant. Trop, parfois.

Exemple avec rsync :

rsync -a --info=progress2 /var/www/site/public_html/wp-content/uploads/ \
  /var/backups/uploads-before-image-optim/Code language: JavaScript (javascript)

Si votre site est critique, créez aussi un snapshot côté hébergeur ou stockage. Et si vous optimisez une médiathèque WordPress, testez d’abord sur une copie ou sur un petit dossier d’échantillon.

Mesurer le poids avant optimisation

Avant de traiter les images, mesurez le poids du dossier. Cela permet de vérifier ensuite le gain réel.

du -sh /var/www/site/public_html/wp-content/uploadsCode language: JavaScript (javascript)

Pour connaître le nombre de fichiers JPEG et PNG :

find /var/www/site/public_html/wp-content/uploads -type f \
  \( -iname "*.jpg" -o -iname "*.jpeg" -o -iname "*.png" \) | wc -lCode language: JavaScript (javascript)

Pour trouver les plus grosses images :

find /var/www/site/public_html/wp-content/uploads -type f \
  \( -iname "*.jpg" -o -iname "*.jpeg" -o -iname "*.png" \) \
  -printf "%s %p\n" | sort -nr | head -50Code language: JavaScript (javascript)

Cette commande fonctionne avec GNU find, donc surtout sous Linux. Elle permet de cibler les fichiers les plus lourds avant de lancer un traitement global.

Optimiser les JPEG avec jpegoptim

jpegoptim optimise les JPEG. Par défaut, il peut réduire le poids sans changer la qualité visuelle, notamment en optimisant les tables Huffman et en supprimant certains marqueurs inutiles.

Testez d’abord sur une seule image :

jpegoptim --strip-all image.jpgCode language: CSS (css)

L’option --strip-all supprime les métadonnées, dont EXIF, IPTC et commentaires. C’est très utile pour le web, mais évitez-la si vous devez conserver les informations de prise de vue, géolocalisation, copyright ou workflow photo.

Pour optimiser récursivement tous les JPEG d’un dossier :

find /var/www/site/public_html/wp-content/uploads -type f \
  \( -iname "*.jpg" -o -iname "*.jpeg" \) \
  -print0 | xargs -0 jpegoptim --strip-allCode language: JavaScript (javascript)

Cette commande modifie les fichiers sur place. D’où la sauvegarde avant. Oui, encore elle. Elle est pénible, mais elle a toujours raison.

Compression JPEG avec qualité maximale

Pour réduire davantage les JPEG, vous pouvez fixer une qualité maximale. Par exemple, --max=85 demande à jpegoptim de recompresser les images au-dessus de ce seuil.

find /var/www/site/public_html/wp-content/uploads -type f \
  \( -iname "*.jpg" -o -iname "*.jpeg" \) \
  -print0 | xargs -0 jpegoptim --strip-all --max=85Code language: JavaScript (javascript)

Pour le web, une qualité entre 82 et 88 donne souvent un bon compromis. Mais ne lancez pas cela à l’aveugle sur toute une médiathèque. Testez d’abord :

mkdir -p /tmp/image-test
cp /var/www/site/public_html/wp-content/uploads/2025/01/exemple.jpg /tmp/image-test/
jpegoptim --strip-all --max=85 /tmp/image-test/exemple.jpgCode language: JavaScript (javascript)

Comparez ensuite le fichier original et le fichier optimisé. Si le rendu convient, vous pourrez généraliser.

Optimiser les PNG avec OptiPNG

optipng optimise les PNG sans perte. Il teste plusieurs paramètres de compression et conserve le résultat le plus léger.

Test sur une image :

optipng -o2 image.pngCode language: CSS (css)

L’option -o2 offre un bon compromis entre temps de traitement et gain. Les niveaux plus élevés peuvent être plus longs pour un gain parfois marginal.

Optimisation récursive des PNG :

find /var/www/site/public_html/wp-content/uploads -type f -iname "*.png" \
  -print0 | xargs -0 optipng -o2Code language: JavaScript (javascript)

Pour un serveur avec beaucoup de PNG, commencez par -o2. Monter à -o5 ou -o7 peut consommer beaucoup plus de CPU pour quelques pourcents de mieux. Votre serveur a probablement d’autres choses à faire que méditer pendant 14 heures sur un logo de 12 Ko.

Compresser fortement les PNG avec pngquant

pngquant compresse les PNG avec perte, souvent avec d’excellents gains. Il réduit notamment la palette de couleurs. C’est très efficace pour des captures d’écran, illustrations, interfaces ou images avec aplats.

Testez sur une copie :

pngquant --quality=70-90 --speed 1 --ext .png --force image.png

Cette commande remplace l’image si le résultat respecte la qualité demandée. Pour ne pas remplacer l’original, utilisez une extension différente :

pngquant --quality=70-90 --speed 1 --ext -compressed.png image.png

Pour une médiathèque WordPress, utilisez pngquant avec prudence. Il est très performant, mais ce n’est plus du lossless. Pour les logos, captures et images importantes, vérifiez visuellement un échantillon.

Générer des WebP avec cwebp

Optimiser les JPEG et PNG originaux est utile, mais les formats modernes apportent souvent de meilleurs gains pour le web. WebP est largement supporté par les navigateurs modernes et se prête bien aux photos comme aux images graphiques.

Convertir un JPEG en WebP :

cwebp -q 82 image.jpg -o image.jpg.webpCode language: CSS (css)

Convertir un PNG en WebP lossless :

cwebp -lossless image.png -o image.png.webpCode language: CSS (css)

Conversion récursive des JPEG vers WebP, sans écraser les fichiers existants :

find /var/www/site/public_html/wp-content/uploads -type f \
  \( -iname "*.jpg" -o -iname "*.jpeg" \) \
  ! -name "*.webp" -print0 |
while IFS= read -r -d '' file; do
  output="${file}.webp"

  if [ -f "$output" ]; then
    continue
  fi

  cwebp -quiet -q 82 "$file" -o "$output"
doneCode language: JavaScript (javascript)

Cette méthode génère des fichiers .webp à côté des originaux. Ensuite, il faut que le serveur ou WordPress les serve correctement via <picture>, réécriture Nginx/Apache ou plugin adapté.

Générer des AVIF avec avifenc

AVIF peut produire des fichiers encore plus petits que WebP, surtout sur certaines photos. En revanche, l’encodage est généralement plus lent. Il faut donc éviter de lancer une conversion AVIF agressive en pleine journée sur un serveur déjà chargé.

Convertir une image en AVIF :

avifenc --min 28 --max 36 image.jpg image.jpg.avifCode language: CSS (css)

Conversion récursive prudente :

find /var/www/site/public_html/wp-content/uploads -type f \
  \( -iname "*.jpg" -o -iname "*.jpeg" -o -iname "*.png" \) \
  ! -name "*.avif" -print0 |
while IFS= read -r -d '' file; do
  output="${file}.avif"

  if [ -f "$output" ]; then
    continue
  fi

  nice -n 10 avifenc --min 28 --max 36 "$file" "$output"
doneCode language: JavaScript (javascript)

nice -n 10 baisse la priorité du processus. C’est préférable sur un serveur qui héberge déjà des sites. Les visiteurs n’ont pas demandé à servir de benchmark AVIF.

Faut-il optimiser les originaux ou seulement générer WebP/AVIF ?

Les deux approches répondent à des besoins différents.

Action	Avantage	Limite
Optimiser les JPG/PNG originaux	Réduit le poids des fichiers existants et des fallbacks.	Gain limité en lossless.
Générer WebP	Très bon support navigateur et bon gain.	Nécessite une logique de service côté site.
Générer AVIF	Excellente compression dans beaucoup de cas.	Encodage plus lent et workflow plus strict.

Pour un site WordPress moderne, je recommande souvent :

• optimiser les originaux JPEG/PNG sans perte ou avec une compression raisonnable ;
• générer WebP pour une compatibilité large ;
• générer AVIF si le serveur, le thème, le CDN et le workflow le gèrent bien ;
• conserver les originaux comme fallback ;
• éviter de retraiter sans cesse les mêmes fichiers.

Script Bash complet pour optimiser JPG et PNG

Voici un script Bash simple qui optimise les JPEG avec jpegoptim et les PNG avec optipng. Il journalise les actions et évite les noms de fichiers cassés grâce à -print0.

Créez le fichier :

sudo nano /usr/local/bin/optimize-images-lossless.sh

Ajoutez :

#!/usr/bin/env bash
set -euo pipefail

TARGET_DIR="${1:-}"
LOG_FILE="${2:-/var/log/optimize-images.log}"

if [[ -z "$TARGET_DIR" || ! -d "$TARGET_DIR" ]]; then
  echo "Usage: $0 /chemin/du/dossier [/chemin/log]"
  exit 1
fi

if ! command -v jpegoptim >/dev/null 2>&1; then
  echo "jpegoptim est introuvable."
  exit 1
fi

if ! command -v optipng >/dev/null 2>&1; then
  echo "optipng est introuvable."
  exit 1
fi

{
  echo "=== $(date '+%F %T') - optimisation de $TARGET_DIR ==="

  find "$TARGET_DIR" -type f \( -iname "*.jpg" -o -iname "*.jpeg" \) -print0 |
    while IFS= read -r -d '' file; do
      jpegoptim --strip-all "$file" || echo "Erreur JPEG: $file"
    done

  find "$TARGET_DIR" -type f -iname "*.png" -print0 |
    while IFS= read -r -d '' file; do
      optipng -o2 "$file" || echo "Erreur PNG: $file"
    done

  echo "=== $(date '+%F %T') - terminé ==="
} >> "$LOG_FILE" 2>&1Code language: PHP (php)

Rendez le script exécutable :

sudo chmod +x /usr/local/bin/optimize-images-lossless.sh

Lancez-le sur un dossier :

sudo /usr/local/bin/optimize-images-lossless.sh \
  /var/www/site/public_html/wp-content/uploadsCode language: JavaScript (javascript)

Consultez le log :

tail -f /var/log/optimize-images.logCode language: JavaScript (javascript)

Script Bash pour générer WebP sans retraiter les fichiers existants

Voici un script dédié à WebP. Il crée un fichier .webp à côté de chaque JPEG ou PNG, mais il ignore les fichiers déjà convertis.

sudo nano /usr/local/bin/generate-webp.sh

#!/usr/bin/env bash
set -euo pipefail

TARGET_DIR="${1:-}"
QUALITY="${2:-82}"
LOG_FILE="${3:-/var/log/generate-webp.log}"

if [[ -z "$TARGET_DIR" || ! -d "$TARGET_DIR" ]]; then
  echo "Usage: $0 /chemin/du/dossier [qualite] [/chemin/log]"
  exit 1
fi

if ! command -v cwebp >/dev/null 2>&1; then
  echo "cwebp est introuvable."
  exit 1
fi

{
  echo "=== $(date '+%F %T') - génération WebP dans $TARGET_DIR ==="

  find "$TARGET_DIR" -type f \( -iname "*.jpg" -o -iname "*.jpeg" -o -iname "*.png" \) -print0 |
    while IFS= read -r -d '' file; do
      output="${file}.webp"

      if [[ -f "$output" ]]; then
        continue
      fi

      cwebp -quiet -q "$QUALITY" "$file" -o "$output" || echo "Erreur WebP: $file"
    done

  echo "=== $(date '+%F %T') - terminé ==="
} >> "$LOG_FILE" 2>&1Code language: PHP (php)

Rendez-le exécutable :

sudo chmod +x /usr/local/bin/generate-webp.sh

Lancez-le :

sudo /usr/local/bin/generate-webp.sh \
  /var/www/site/public_html/wp-content/uploads 82Code language: JavaScript (javascript)

Ce script ne suffit pas à servir les WebP aux visiteurs. Il génère seulement les fichiers. Il faut ensuite adapter WordPress, le thème, le serveur web ou le CDN pour utiliser ces versions modernes.

Limiter le traitement aux fichiers récents

Après une première optimisation complète, évitez de retraiter toute la médiathèque chaque nuit. C’est inutile et coûteux.

Pour traiter uniquement les images modifiées dans les dernières 24 heures :

find /var/www/site/public_html/wp-content/uploads -type f -mtime -1 \
  \( -iname "*.jpg" -o -iname "*.jpeg" -o -iname "*.png" \) \
  -print0Code language: JavaScript (javascript)

Vous pouvez intégrer -mtime -1 dans vos scripts si vous planifiez une tâche quotidienne.

Pour traiter les fichiers modifiés dans les 60 dernières minutes, utilisez -mmin :

find /var/www/site/public_html/wp-content/uploads -type f -mmin -60 \
  \( -iname "*.jpg" -o -iname "*.jpeg" -o -iname "*.png" \) \
  -print0Code language: JavaScript (javascript)

Planifier l’optimisation avec cron

Pour lancer l’optimisation régulièrement, utilisez cron. Évitez les heures de fort trafic.

sudo crontab -e

Exemple : optimisation quotidienne à 3h15 :

15 3 * * * /usr/local/bin/optimize-images-lossless.sh /var/www/site/public_html/wp-content/uploadsCode language: JavaScript (javascript)

Exemple : génération WebP quotidienne à 3h45 :

45 3 * * * /usr/local/bin/generate-webp.sh /var/www/site/public_html/wp-content/uploads 82Code language: JavaScript (javascript)

Sur un serveur chargé, préférez systemd timers, car ils offrent de meilleurs logs et une gestion plus propre des échecs. Mais pour une tâche simple, cron reste parfaitement acceptable.

Planifier avec systemd timer

Créez un service systemd :

sudo nano /etc/systemd/system/optimize-images.service

[Unit]
Description=Optimize website images

[Service]
Type=oneshot
Nice=10
IOSchedulingClass=best-effort
IOSchedulingPriority=7
ExecStart=/usr/local/bin/optimize-images-lossless.sh /var/www/site/public_html/wp-content/uploadsCode language: JavaScript (javascript)

Créez ensuite le timer :

sudo nano /etc/systemd/system/optimize-images.timer

[Unit]
Description=Run image optimization daily

[Timer]
OnCalendar=*-*-* 03:15:00
Persistent=true

[Install]
WantedBy=timers.targetCode language: JavaScript (javascript)

Activez le timer :

sudo systemctl daemon-reload
sudo systemctl enable --now optimize-images.timerCode language: CSS (css)

Vérifiez :

systemctl list-timers | grep optimize-images
journalctl -u optimize-images.service -n 100 --no-pagerCode language: PHP (php)

Cas WordPress : attention aux miniatures

WordPress ne stocke pas seulement l’image originale. Il génère aussi plusieurs tailles intermédiaires : miniatures, tailles medium, large, formats personnalisés du thème, tailles WooCommerce, images ajoutées par certains plugins, etc.

Optimiser uniquement les images originales ne suffit donc pas toujours. Il faut traiter tout le dossier wp-content/uploads, ou utiliser un outil intégré à WordPress qui optimise chaque taille générée.

Le chemin classique est :

/var/www/site/public_html/wp-content/uploadsCode language: JavaScript (javascript)

Sur un WordPress multisite, les chemins peuvent ressembler à :

/var/www/site/public_html/wp-content/uploads/sites/2
/var/www/site/public_html/wp-content/uploads/sites/3Code language: JavaScript (javascript)

Avant traitement, vérifiez donc l’arborescence exacte. Ne partez pas du principe que tout est dans le dossier de l’année courante.

WordPress : plugin ou optimisation serveur ?

Les deux approches peuvent cohabiter, mais il faut éviter les doublons.

Approche	Avantage	Limite
Plugin WordPress	Optimise à l’upload, connaît les tailles WordPress.	Peut coûter cher ou consommer des ressources PHP.
Script serveur	Rapide, contrôlable, automatisable.	Ne met pas toujours à jour les métadonnées WordPress.
CDN d’images	Conversion et redimensionnement à la volée.	Dépendance à un fournisseur externe.

Si vous utilisez déjà ShortPixel, Imagify, EWWW, Optimole ou un CDN d’images, évitez de recompresser agressivement les mêmes fichiers côté serveur. Vous risquez de perdre en qualité pour peu de gain.

En revanche, un script serveur est très utile pour :

• nettoyer une ancienne médiathèque ;
• optimiser un site statique ;
• traiter des exports avant migration ;
• préparer un dossier avant mise en ligne ;
• automatiser un pipeline de build ;
• gérer des images hors WordPress.

Servir WebP ou AVIF avec WordPress

Générer des fichiers WebP ou AVIF ne suffit pas. Le navigateur doit les recevoir à la place des JPEG ou PNG lorsque c’est possible.

Il existe plusieurs méthodes :

• utiliser un plugin WordPress compatible WebP/AVIF ;
• modifier le HTML pour utiliser des balises <picture> ;
• servir automatiquement les variantes via Nginx ou Apache ;
• laisser un CDN d’images convertir et servir les formats modernes ;
• utiliser le plugin Modern Image Formats de l’équipe Performance WordPress.

Pour WordPress, la solution la plus maintenable est souvent un plugin dédié ou une logique intégrée au thème. Une réécriture serveur peut être très performante, mais elle doit être testée avec le cache, le CDN, les images responsive et les fichiers déjà générés.

Exemple Nginx pour servir WebP si disponible

Si vous générez des fichiers .webp à côté des originaux, Nginx peut servir WebP aux navigateurs compatibles. Exemple simplifié :

map $http_accept $webp_suffix {
    default "";
    "~*webp" ".webp";
}

server {
    location ~* \.(png|jpe?g)$ {
        add_header Vary Accept;
        try_files $uri$webp_suffix $uri =404;
        expires 30d;
        access_log off;
    }
}Code language: PHP (php)

Attention : cette configuration est volontairement minimale. Sur un vrai serveur, il faut l’adapter à votre structure Nginx, à votre cache, à votre CDN et aux autres règles d’images. Testez toujours avec :

sudo nginx -t
curl -I -H "Accept: image/webp" https://example.com/wp-content/uploads/image.jpgCode language: JavaScript (javascript)

Vérifiez aussi le header Content-Type. Servir un fichier WebP avec un mauvais type MIME, c’est le genre de détail qui donne envie de parler sévèrement à son serveur.

Ne pas optimiser certains dossiers

Vous ne devez pas forcément traiter tout le serveur. Excluez les dossiers de cache, sauvegardes, sources, dépôts Git, fichiers temporaires ou images déjà générées par un autre outil.

Exemple avec exclusions :

find /var/www/site/public_html -type f \
  \( -path "*/cache/*" -o -path "*/backup/*" -o -path "*/backups/*" -o -path "*/.git/*" \) -prune -o \
  \( -iname "*.jpg" -o -iname "*.jpeg" -o -iname "*.png" \) \
  -printCode language: PHP (php)

Avant d’ajouter une action destructive, lancez toujours la commande en mode affichage. Regardez ce qu’elle trouve. Ensuite seulement, ajoutez jpegoptim, optipng ou une conversion.

Gérer les noms de fichiers avec espaces

Les noms de fichiers peuvent contenir des espaces, apostrophes, parenthèses, accents et autres petites surprises. Utilisez toujours -print0 avec find et xargs -0, ou une boucle Bash qui lit les fichiers avec le séparateur nul.

Bonne pratique :

find /chemin -type f -iname "*.jpg" -print0 |
  xargs -0 jpegoptim --strip-allCode language: JavaScript (javascript)

À éviter :

for file in $(find /chemin -name "*.jpg"); do
  jpegoptim "$file"
doneCode language: JavaScript (javascript)

La seconde version casse dès qu’un nom contient un espace. Et les utilisateurs adorent mettre des espaces dans les noms de fichiers. C’est même leur sport officiel.

Limiter l’impact CPU et I/O

L’optimisation d’images peut consommer du CPU et de l’I/O disque. Sur un serveur en production, lancez ces tâches pendant les heures creuses et baissez leur priorité.

Exemple avec nice et ionice :

nice -n 10 ionice -c2 -n7 /usr/local/bin/optimize-images-lossless.sh \
  /var/www/site/public_html/wp-content/uploadsCode language: JavaScript (javascript)

Pour une conversion AVIF massive, soyez encore plus prudent. L’encodage peut être lent. Lancez-le par lots, surveillez le load average et vérifiez les logs.

Créer un rapport avant/après

Pour mesurer le gain, notez la taille avant et après :

du -sh /var/www/site/public_html/wp-content/uploadsCode language: JavaScript (javascript)

Vous pouvez aussi créer un rapport des 100 plus gros fichiers restants :

find /var/www/site/public_html/wp-content/uploads -type f \
  \( -iname "*.jpg" -o -iname "*.jpeg" -o -iname "*.png" -o -iname "*.webp" -o -iname "*.avif" \) \
  -printf "%s %p\n" | sort -nr | head -100 > /tmp/largest-images.txtCode language: JavaScript (javascript)

Consultez ensuite :

less /tmp/largest-images.txt

Très souvent, quelques fichiers énormes expliquent une bonne partie du poids total. Il vaut mieux corriger 50 images absurdes que recompresser nerveusement 40 000 miniatures déjà correctes.

Redimensionner avant de compresser

La compression ne remplace pas le redimensionnement. Une photo de 6000 pixels de large affichée en 900 pixels restera trop lourde, même optimisée.

Pour redimensionner côté serveur, utilisez plutôt ImageMagick ou libvips. Exemple avec ImageMagick :

magick input.jpg -resize '1920x1920>' output.jpgCode language: JavaScript (javascript)

Le symbole > évite d’agrandir les petites images. Dans un bloc de code HTML, il doit être échappé, d’où > si vous l’écrivez directement dans Gutenberg.

Pour de très gros traitements, libvips est souvent plus rapide et plus économe en mémoire qu’ImageMagick. C’est un excellent choix pour des pipelines d’images sérieux.

Faut-il supprimer les métadonnées EXIF ?

Pour le web, supprimer les métadonnées est souvent une bonne idée. Cela réduit le poids et évite d’exposer des informations inutiles, comme le modèle d’appareil, la date ou parfois la géolocalisation.

Avec jpegoptim, utilisez :

jpegoptim --strip-all image.jpgCode language: CSS (css)

Mais attention : sur un site de photographie, d’archives, de portfolio ou de presse, certaines métadonnées peuvent être utiles. Dans ce cas, ne supprimez pas tout sans réflexion. Une optimisation bien faite respecte le contexte éditorial.

Dépannage

jpegoptim ou optipng modifie trop de fichiers

Commencez toujours par afficher la liste des fichiers avant traitement :

find /chemin -type f \( -iname "*.jpg" -o -iname "*.jpeg" \) -printCode language: PHP (php)

Ajoutez ensuite la commande d’optimisation uniquement lorsque la liste est correcte.

Les fichiers WebP sont générés mais jamais servis

La conversion seule ne suffit pas. Vérifiez votre thème, votre plugin d’images, vos règles Nginx/Apache ou votre CDN. Le HTML ou le serveur doit envoyer WebP aux navigateurs compatibles.

La qualité JPEG est devenue trop faible

Vous avez probablement utilisé une valeur --max trop agressive. Restaurez depuis sauvegarde, puis testez une qualité plus élevée, par exemple --max=88 ou uniquement du lossless avec --strip-all.

La conversion AVIF est très lente

C’est normal. AVIF peut être coûteux à encoder. Réduisez le volume traité, utilisez nice, lancez la tâche de nuit, ou commencez avec WebP si vous cherchez un compromis plus simple.

Les permissions WordPress sont cassées après optimisation

Si vous lancez les scripts avec root, vérifiez ensuite le propriétaire et les permissions des fichiers. Sur un serveur classique, les fichiers doivent souvent appartenir à l’utilisateur du site ou au groupe web approprié.

sudo chown -R www-data:www-data /var/www/site/public_html/wp-content/uploads
find /var/www/site/public_html/wp-content/uploads -type d -exec chmod 755 {} \;
find /var/www/site/public_html/wp-content/uploads -type f -exec chmod 644 {} \;Code language: JavaScript (javascript)

Adaptez www-data à votre hébergement. Sur certains serveurs, chaque site possède son propre utilisateur système.

Méthode recommandée pour un site WordPress existant

Pour un WordPress déjà en production, je recommande cette séquence :

1. Sauvegarder wp-content/uploads.
2. Mesurer le poids actuel avec du -sh.
3. Trouver les plus grosses images.
4. Tester jpegoptim et optipng sur un échantillon.
5. Lancer une optimisation lossless globale.
6. Générer WebP ou AVIF si le site sait les servir.
7. Vérifier l’affichage front-office.
8. Vérifier les permissions.
9. Mesurer le gain après traitement.
10. Automatiser uniquement les nouveaux fichiers ou fichiers récents.

Ne commencez pas par une compression lossy massive. Commencez propre, mesurez, puis ajustez. Le but est d’améliorer la performance, pas de transformer toutes les photos du site en aquarelles tristes.

Besoin d’optimiser les images d’un site WordPress ou WooCommerce ?

Je peux vous aider à auditer et optimiser les images d’un site WordPress ou WooCommerce : poids de la médiathèque, formats modernes, WebP, AVIF, configuration serveur, CDN, cache, images responsive et performance réelle côté Core Web Vitals.

L’objectif n’est pas seulement de “compresser les images”. Il faut servir la bonne image, au bon format, à la bonne taille, sans casser la qualité ni le référencement des médias.

• Audit du poids des images et des tailles WordPress.
• Optimisation serveur avec scripts sûrs et sauvegardes.
• Configuration WebP/AVIF avec fallback.
• Réglages Nginx, Apache, CDN et cache.
• Optimisation WooCommerce pour catalogues volumineux.
• Diagnostic performance mobile et Core Web Vitals.

Si votre site sert encore des images beaucoup trop lourdes, contactez-moi. On peut souvent gagner beaucoup sans refaire tout le site.

Checklist rapide

• Sauvegarder les images avant traitement.
• Mesurer le poids avant optimisation.
• Optimiser les JPEG avec jpegoptim.
• Optimiser les PNG avec optipng.
• Utiliser pngquant seulement si une compression lossy est acceptable.
• Générer WebP avec cwebp si le site sait les servir.
• Générer AVIF avec prudence, hors heures de pointe.
• Utiliser -print0 et xargs -0 pour les noms de fichiers complexes.
• Exclure caches, backups et dossiers inutiles.
• Automatiser uniquement après avoir testé.

À retenir

jpegoptim et optipng restent deux excellents outils pour optimiser les images JPG et PNG sur un serveur Linux. Ils sont simples, rapides et efficaces pour une première passe lossless.

Cependant, l’optimisation moderne va plus loin. Pour un site web actuel, il faut aussi penser aux formats WebP et AVIF, aux tailles WordPress, aux fallbacks, au CDN, aux règles serveur et à l’automatisation incrémentale.

La bonne méthode : sauvegarder, tester, optimiser, mesurer, puis automatiser. Dans cet ordre. Tout autre ordre finit généralement par une restauration de backup et une tasse de café beaucoup trop forte.

FAQ : optimiser les images sur un serveur Linux

jpegoptim modifie-t-il les fichiers originaux ?

Oui, par défaut, jpegoptim modifie les fichiers optimisés sur place. Faites une sauvegarde avant un traitement massif, ou testez sur une copie.

OptiPNG compresse-t-il sans perte ?

Oui, optipng optimise les PNG sans perte. Il peut réduire le poids sans modifier visiblement l’image.

Faut-il utiliser pngquant sur un site WordPress ?

Oui, mais avec prudence. pngquant peut réduire fortement le poids des PNG, mais il s’agit d’une compression avec perte. Testez d’abord sur un échantillon.

WebP remplace-t-il JPEG et PNG ?

Pas totalement. WebP est excellent pour le web moderne, mais il faut garder les originaux ou fallbacks selon votre configuration, votre thème, votre CDN et les navigateurs ciblés.

AVIF est-il meilleur que WebP ?

AVIF peut produire des fichiers plus petits, mais l’encodage est souvent plus lent. WebP reste plus simple à intégrer dans beaucoup de workflows.

Puis-je optimiser directement wp-content/uploads ?

Oui, mais seulement après sauvegarde et test sur un échantillon. Vérifiez aussi les permissions après traitement, surtout si vous lancez les scripts avec root.

Articles liés

• Trimage Image Compressor optimise JPG, PNG
• Serveur dédié : optimiser les GIF avec gifsicle
• CSS : superposer du texte lisible sur une image de fond
• WordPress : vérifier la compatibilité PHP 8
• Serveur dédié : analyser les performances CPU, RAM, disque et réseau sous Linux

Sources

• Arch Linux Manual — jpegoptim
• Ubuntu Manpages — jpegoptim
• jpegoptim — dépôt GitHub officiel
• OptiPNG — site officiel
• pngquant — site officiel
• Google Developers — cwebp
• web.dev — utiliser AVIF pour compresser les images
• WordPress.org — Modern Image Formats
• libvips — site officiel

Report a typo