## Introduction

Les problèmes de performance de Docker Hub peuvent ralentir les pipelines CI/CD, frustrer les développeurs et retarder les déploiements. Les symptômes se manifestent souvent par des téléchargements d'images lents, des délais d'attente lors des envois (push) ou une latence élevée lors des interactions avec le registre. L'optimisation des performances de Docker Hub ne relève pas du hasard ; elle nécessite une observation systématique, des changements ciblés et une vérification.

Ce guide s'adresse aux développeurs, aux ingénieurs DevOps et aux responsables techniques qui ont besoin de mesures concrètes pour diagnostiquer et améliorer les performances de Docker Hub. Nous couvrirons l'évaluation de l'environnement, les modifications de configuration sûres, les techniques de vérification, la récupération après échec et une liste de contrôle de maintenance. Chaque recommandation inclut des commandes concrètes, les résultats attendus et des considérations de retour en arrière.

L'accent est mis sur le registre Docker Hub lui-même, le client Docker et les couches réseau. Nous ne traiterons pas des performances plus larges de l'orchestration de conteneurs ni de l'optimisation au niveau applicatif. À la fin, vous serez en mesure d'identifier la cause profonde des interactions lentes avec Docker Hub et d'appliquer des correctifs éprouvés.

## Inventaire de la version et de l'environnement

Avant de modifier quoi que ce soit, documentez votre environnement Docker. Connaître les versions exactes et la configuration permet d'éviter d'appliquer des correctifs incompatibles ou inutiles. Commencez par collecter les éléments suivants :

- Version du moteur Docker : `docker version --format '{{.Server.Version}}'`
- Version de Docker Compose (si utilisé) : `docker compose version`
- Système d'exploitation et noyau : `uname -a`
- Configuration réseau : `docker network ls`
- Pilote de stockage : `docker info --format '{{.Driver}}'`

Pour un serveur Ubuntu 22.04 typique exécutant Docker 24.0.5, la sortie de `docker version` inclut à la fois les détails du client et du serveur. Exemple :

```
Client: Docker Engine - Community
 Version:           24.0.5
 API version:       1.43
 Go version:        go1.20.4
 Git commit:        ced0996
 Built:             Fri Jul 21 15:20:41 2023
 OS/Arch:           linux/amd64
 Context:           default

Server: Docker Engine - Community
 Engine:
  Version:          24.0.5
  API version:      1.43 (minimum version 1.12)
  Go version:       go1.20.4
  Git commit:       a61e2b4
  Built:            Fri Jul 21 15:20:41 2023
  OS/Arch:          linux/amd64
  Experimental:     false
```

Enregistrez ces informations dans un fichier texte ou un système de gestion de configuration. Si vous utilisez Docker Desktop sur macOS ou Windows, notez la version et l'allocation des ressources (CPU, mémoire) car elles affectent les performances.

Vérifiez la configuration actuelle du démon Docker, en particulier si vous avez configuré des miroirs de registre ou des registres non sécurisés. Exécutez `docker info` et recherchez la section `Registry Mirrors`. Exemple sur un système avec un miroir local :

```
 Registry Mirrors:
  http://mirror.local:5000/
```

Si aucun miroir n'est configuré, cette section peut être absente ou afficher `[]`.

Avant d'apporter des modifications, vérifiez que Docker Hub lui-même est accessible et mesurez la latence de base. Utilisez `curl` pour chronométrer une requête vers le point de terminaison d'authentification de Docker Hub :

```bash
time curl -sI https://auth.docker.io/token?service=registry.docker.io > /dev/null
```

Exemple de sortie :

```
real    0m0.512s
user    0m0.015s
sys     0m0.009s
```

Une latence inférieure à 1 seconde est normale dans la plupart des régions. Des temps plus élevés peuvent indiquer des problèmes réseau.

Documentez le temps de téléchargement de base pour une image connue. Par exemple, téléchargez une petite image comme `alpine:3.18` et mesurez le temps :

```bash
time docker pull alpine:3.18
```

Sortie typique :

```
3.18: Pulling from library/alpine
7264a8db6415: Pull complete 
Digest: sha256:48d9183eb12a05c99bcc0bf44a003607b8e941e1d4b6f8f8f9d5c2edc2b4b6b4
Status: Downloaded newer image for alpine:3.18
docker.io/library/alpine:3.18

real    0m1.234s
user    0m0.017s
sys     0m0.010s
```

Enregistrez le temps total et le temps passé sur chaque couche. Cette base de référence vous aidera à évaluer l'impact de tout changement.

## Chemin de configuration sûr

Après avoir évalué l'environnement, vous pouvez modifier en toute sécurité la configuration de Docker pour améliorer les performances. Les changements les plus efficaces concernent la mise en cache, la concurrence et le réglage réseau.

### Miroirs de registre

Un miroir de registre met en cache les images de Docker Hub, réduisant ainsi la latence de téléchargement des images fréquemment utilisées. Si vous disposez d'un miroir local ou organisationnel, configurez Docker pour l'utiliser. Modifiez `/etc/docker/daemon.json` (créez-le s'il est absent) et ajoutez :

```json
{
  "registry-mirrors": ["https://mirror.example.com"]
}
```

Remplacez `https://mirror.example.com` par l'URL de votre miroir. Si vous utilisez Docker Desktop, accédez à Paramètres > Docker Engine et ajoutez le même JSON. Après modification, redémarrez Docker :

```bash
sudo systemctl restart docker   # systèmes systemd
# ou
sudo service docker restart     # systèmes SysVinit
```

Vérifiez que le miroir est actif :

```bash
docker info --format '{{json .RegistryConfig.Mirrors}}'
```

La sortie attendue inclut l'URL de votre miroir, par exemple `["https://mirror.example.com"]`.

Testez à nouveau les performances de téléchargement avec la même image `alpine:3.18`. Si l'image a déjà été téléchargée, supprimez-la d'abord pour forcer un nouveau téléchargement :

```bash
docker rmi alpine:3.18
time docker pull alpine:3.18
```

Comparez le nouveau temps de téléchargement avec la base de référence. Dans de nombreux cas, vous constaterez une réduction, surtout si le miroir est situé plus près de votre infrastructure.

### Téléchargements et envois simultanés maximaux

Docker utilise par défaut 3 téléchargements simultanés et 3 envois simultanés. Pour les connexions à large bande passante, augmenter ces valeurs peut accélérer les téléchargements et les envois. Modifiez la configuration du démon :

```json
{
  "max-concurrent-downloads": 10,
  "max-concurrent-uploads": 5
}
```

Après avoir redémarré Docker, vérifiez avec `docker info | grep -i concurrent`.

### DNS et MTU

Les conteneurs Docker héritent souvent des paramètres DNS de l'hôte, mais des erreurs de configuration peuvent entraîner des téléchargements d'images lents en raison d'échecs de résolution. Assurez-vous que le démon Docker utilise des serveurs DNS fiables. Dans `daemon.json`, définissez :

```json
{
  "dns": ["8.8.8.8", "1.1.1.1"]
}
```

Des inadéquations de MTU peuvent provoquer une fragmentation des paquets, entraînant des transferts lents. Si vous êtes sur un VPN ou un réseau personnalisé, vérifiez le MTU de votre interface et définissez le MTU de Docker en conséquence. Dans `daemon.json` :

```json
{
  "mtu": 1400
}
```

Ajustez la valeur au MTU de votre réseau moins les frais généraux (généralement 1500 - 100 = 1400 pour certains VPN). Redémarrez Docker et testez la connectivité avec `docker run --rm alpine ping -c 4 docker.com`.

### Pilote de stockage

Le pilote de stockage de Docker affecte la vitesse d'extraction des couches d'image. Overlay2 est le pilote recommandé pour la plupart des distributions Linux. Vérifiez votre pilote actuel :

```bash
docker info --format '{{.Driver}}'
```

S'il ne s'agit pas de `overlay2`, envisagez de changer. C'est un changement plus invasif car il nécessite de recréer les conteneurs et les images. Arrêtez Docker, sauvegardez `/var/lib/docker`, modifiez le pilote de stockage dans `/etc/docker/daemon.json` et redémarrez. Exemple de configuration :

```json
{
  "storage-driver": "overlay2"
}
```

Après redémarrage, vérifiez avec `docker info`. Notez que cela peut ne pas être nécessaire si votre distribution utilise déjà overlay2 par défaut.

## Vérification et diagnostics

Après avoir appliqué les modifications de configuration, vous devez vérifier que les performances se sont améliorées et qu'aucune régression n'est survenue. Utilisez une combinaison de commandes Docker et d'outils tiers.

### Chronométrage des opérations d'image

Mesurez les temps de téléchargement et d'envoi avec `time`. Avant et après chaque modification, exécutez :

```bash
time docker pull nginx:1.25
time docker push yourregistry/yourimage:tag
```

Enregistrez les temps dans un tableur ou un journal.

### Limites de débit de Docker Hub

Docker Hub applique des limites de débit pour les utilisateurs anonymes et authentifiés. Si vous atteignez les limites, les téléchargements échouent ou ralentissent considérablement. Vérifiez l'état de votre limite de débit en inspectant les en-têtes de réponse de Docker Hub. Utilisez `curl` :

```bash
curl -I https://registry-1.docker.io/v2/
```

Recherchez les en-têtes `RateLimit-Limit` et `RateLimit-Remaining`. Pour les requêtes authentifiées, obtenez un jeton et effectuez une requête autorisée :

```bash
TOKEN=$(curl -s "https://auth.docker.io/token?service=registry.docker.io&scope=repository:library/alpine:pull" | jq -r .token)
curl -I -H "Authorization: Bearer $TOKEN" https://registry-1.docker.io/v2/library/alpine/manifests/3.18
```

Cela nécessite l'installation de `jq`. Si vous êtes proche des limites, envisagez de vous connecter avec `docker login` pour augmenter votre quota.

### Diagnostics réseau

Utilisez `docker run --rm appropriate/curl` pour tester la connectivité depuis l'intérieur d'un conteneur :

```bash
docker run --rm appropriate/curl -sI https://registry-1.docker.io/v2/
```

Si vous suspectez des problèmes DNS, exécutez :

```bash
docker run --rm alpine nslookup registry-1.docker.io
```

Vérifiez la perte de paquets ou la latence élevée à l'aide de `mtr` :

```bash
docker run --rm --net=host travelping/nettools mtr -r -c 10 registry-1.docker.io
```

### Analyse des couches d'image

Les images volumineuses prennent plus de temps à télécharger et à envoyer. Utilisez `docker history` pour inspecter la taille des couches :

```bash
docker history nginx:1.25
```

La sortie montre la taille de chaque couche. Si une couche est excessivement grande (par exemple, 500 Mo), envisagez d'optimiser le Dockerfile pour réduire cette couche. Les coupables courants incluent l'installation de paquets inutiles ou la copie de fichiers volumineux.

Utilisez des outils comme `dive` pour analyser le contenu de l'image :

```bash
docker run --rm -v /var/run/docker.sock:/var/run/docker.sock wagoodman/dive:latest nginx:1.25
```

Cet outil interactif montre l'espace gaspillé et la duplication de fichiers.

## Modes de défaillance et récupération

Même avec un réglage minutieux, les choses peuvent mal tourner. Soyez prêt à diagnostiquer et à annuler les modifications.

### Défaillances courantes

1. **Le démon Docker ne démarre pas après un changement de configuration.**
   - Cause : JSON invalide dans `daemon.json` ou paramètre non pris en charge.
   - Détection : Vérifiez les journaux du démon avec `journalctl -u docker.service` ou `/var/log/docker.log`.
   - Récupération : Validez le JSON avec `jq . /etc/docker/daemon.json`. Revenez au dernier fichier connu et redémarrez Docker.

2. **Le téléchargement d'image est plus lent après l'ajout d'un miroir.**
   - Cause : Le miroir est éloigné ou surchargé.
   - Détection : Comparez les temps de téléchargement avec et sans le miroir. Vérifiez la latence du miroir avec `curl`.
   - Récupération : Supprimez le miroir de `daemon.json`, redémarrez Docker et mesurez à nouveau. Si le miroir n'apporte aucun avantage, laissez-le de côté.

3. **L'augmentation des téléchargements simultanés provoque une congestion du réseau.**
   - Cause : Trop de connexions simultanées saturent la bande passante.
   - Détection : Observez l'utilisation du réseau pendant les téléchargements avec `iftop` ou `nload`. Si le débit chute considérablement, la concurrence est peut-être trop élevée.
   - Récupération : Réduisez `max-concurrent-downloads` à une valeur inférieure (par exemple, 5) et redémarrez Docker.

4. **Le changement de MTU interrompt la connectivité vers Docker Hub.**
   - Cause : Une valeur MTU incorrecte provoque une perte de paquets.
   - Détection : `docker run --rm alpine ping -c 4 registry-1.docker.io` échoue ou affiche une perte de paquets élevée.
   - Récupération : Revenez au MTU par défaut (généralement 1500) ou supprimez la clé `mtu` de `daemon.json`, redémarrez Docker et testez à nouveau.

### Procédure de retour en arrière

Conservez toujours une sauvegarde de `/etc/docker/daemon.json` avant de le modifier. Par exemple :

```bash
sudo cp /etc/docker/daemon.json /etc/docker/daemon.json.bak
```

Après un changement échoué, restaurez la sauvegarde :

```bash
sudo cp /etc/docker/daemon.json.bak /etc/docker/daemon.json
sudo systemctl restart docker
```

Vérifiez que Docker fonctionne et que `docker pull alpine:3.18` réussit.

## Pièges courants et comment les éviter

De nombreux problèmes de performance proviennent de malentendus ou de détails négligés. Voici les erreurs fréquentes :

### Ignorer les limites de débit

Le téléchargement anonyme d'images depuis Docker Hub est limité à 100 téléchargements par 6 heures par adresse IP. Les utilisateurs authentifiés bénéficient de 200 téléchargements par 6 heures. Si vous dépassez cette limite, vous recevez des erreurs `429 Too Many Requests`. Pour éviter cela, connectez-vous toujours avec `docker login` à un compte Docker Hub, ou utilisez un miroir de registre qui met en cache les images. Surveillez régulièrement l'état de votre limite de débit.

### Ne pas épingler les versions d'image

L'utilisation de l'étiquette `latest` peut amener Docker à télécharger une nouvelle version de manière inattendue, entraînant des téléchargements accrus et une incompatibilité potentielle. Épinglez des versions spécifiques dans vos Dockerfiles et vos manifestes de déploiement, par exemple `FROM node:18.17.1-alpine` au lieu de `FROM node:latest`.

### Négliger la taille des images

Les images volumineuses consomment de la bande passante et du stockage. Optimisez les Dockerfiles en utilisant des constructions multi-étapes, en minimisant les couches et en nettoyant les caches de paquets. Par exemple, dans une application Node.js :

```dockerfile
FROM node:18-alpine AS build
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM node:18-alpine
WORKDIR /app
COPY --from=build /app/dist ./dist
COPY package*.json ./
RUN npm ci --omit=dev
CMD ["node", "dist/index.js"]
```

Cela réduit l'image finale de potentiellement 500 Mo à moins de 100 Mo.

### Mal configurer les paramètres de proxy

Si votre environnement utilise un proxy, Docker doit être configuré pour l'utiliser lors du téléchargement d'images. Définissez `HTTP_PROXY` et `HTTPS_PROXY` dans l'environnement du démon Docker. Sur systemd, créez `/etc/systemd/system/docker.service.d/http-proxy.conf` :

```ini
[Service]
Environment="HTTP_PROXY=http://proxy.example.com:8080"
Environment="HTTPS_PROXY=http://proxy.example.com:8080"
Environment="NO_PROXY=localhost,127.0.0.1"
```

Puis rechargez et redémarrez Docker :

```bash
sudo systemctl daemon-reload
sudo systemctl restart docker
```

### Oublier de tester après les modifications

Mesurez toujours avant et après les modifications. Sans données de base, vous ne pouvez pas savoir si un changement a aidé. Tenez un journal des temps de téléchargement à l'aide d'un script simple :

```bash
echo "$(date) $( (time docker pull alpine:3.18) 2>&1 | grep real )" >> pull_times.log
```

Examinez ce journal chaque semaine pour repérer les régressions.

## Liste de contrôle des opérations

Utilisez la liste de contrôle suivante pour maintenir les performances de Docker Hub au fil du temps. Attribuez un responsable à chaque élément et examinez-la mensuellement.

| # | Élément | Responsable | Fréquence | Vérification |
|---|---------|-------------|-----------|--------------|
| 1 | Vérifier la configuration du démon Docker (`daemon.json`) pour détecter des modifications non intentionnelles | Ingénieur DevOps | Hebdomadaire | La sortie de `docker info` correspond aux valeurs attendues |
| 2 | Surveiller les temps de téléchargement d'une image de référence (`alpine:3.18`) | Ingénieur DevOps | Hebdomadaire | Temps de téléchargement dans les 20 % de la base de référence |
| 3 | Examiner l'état de la limite de débit de Docker Hub | Ingénieur DevOps | Quotidien | `RateLimit-Remaining` au-dessus du seuil (par exemple, 50) |
| 4 | Vérifier la santé et la latence du miroir de registre | Administrateur réseau | Hebdomadaire | Le miroir répond en moins de 200 ms |
| 5 | Auditer les tailles d'image et élaguer les images inutilisées | Ingénieur DevOps | Mensuel | `docker system df` montre de l'espace récupérable |
| 6 | Tester la connectivité des conteneurs vers Docker Hub | Ingénieur DevOps | Mensuel | `docker run --rm alpine ping -c 1 registry-1.docker.io` réussit |
| 7 | Examiner les règles de proxy et de pare-feu affectant le trafic Docker | Ingénieur sécurité | Trimestriel | Aucun blocage non intentionnel |
| 8 | Mettre à jour Docker Engine et CLI vers la dernière version stable | Ingénieur DevOps | Trimestriel | `docker version` affiche des versions prises en charge |

Pour chaque élément, documentez la personne responsable et définissez un rappel de calendrier récurrent. Utilisez un système de surveillance comme Prometheus avec Node Exporter pour collecter des métriques sur les performances du démon Docker, les E/S réseau et l'utilisation du disque.

## Conclusion

L'optimisation des performances de Docker Hub est un processus itératif de mesure, d'ajustement et de vérification. Commencez par un inventaire complet de l'environnement pour comprendre votre point de départ. Appliquez ensuite des modifications de configuration sûres telles que des miroirs de registre, des ajustements de concurrence et des optimisations réseau. Vérifiez toujours l'impact avec des commandes de chronométrage concrètes et diagnostiquez les problèmes à l'aide des outils intégrés de Docker et d'utilitaires tiers.

Soyez conscient des pièges courants comme les limites de débit, les étiquettes non épinglées et les images surdimensionnées. Maintenez une liste de contrôle des opérations régulière avec une propriété claire et une cadence de révision pour prévenir la dégradation des performances.

En suivant ces pratiques, vous pouvez réduire considérablement les temps de téléchargement, éviter les goulots d'étranglement et maintenir vos pipelines CI/CD en bon état de fonctionnement. Commencez par un changement à faible risque, mesurez le résultat et construisez à partir de là.