Le stockage objet s’est impose pour heberger fichiers, sauvegardes, medias ou artefacts applicatifs derriere une API compatible S3. Dans cet article, nous deployons MinIO (stockage objet S3-compatible, leger et performant) sur Debian 13 (Trixie), puis nous placons un reverse proxy Nginx devant, avec un cache de 60 minutes pour soulager le backend sur les objets frequemment lus.

Architecture cible

Le schema ci-dessous illustre le role du cache. Au premier acces (MISS), la requete traverse Nginx jusqu’au stockage objet. Aux acces suivants dans la fenetre de 60 minutes (HIT), Nginx repond directement depuis son cache, sans solliciter MinIO.

Schema client / Nginx / stockage objet avec et sans cache

Prerequis

  • Une machine Debian 13 (Trixie) a jour, avec acces root ou sudo.
  • Un enregistrement DNS pointant vers le serveur (ex. s3.example.com).
  • Quelques Go d’espace disque pour les donnees et le cache.

1. Mise a jour du systeme

apt update && apt upgrade -y
apt install -y curl

2. Installation de MinIO

On telecharge le binaire officiel, on cree un utilisateur systeme dedie et les repertoires de donnees.

# Telecharger le binaire MinIO
curl -O https://dl.min.io/server/minio/release/linux-amd64/minio
chmod +x minio
mv minio /usr/local/bin/

# Creer l'utilisateur systeme et les repertoires de donnees
useradd -r minio-user -s /sbin/nologin || true
mkdir -p /srv/minio/data
chown -R minio-user:minio-user /srv/minio

3. Configuration de MinIO

Creez le fichier d’environnement /etc/default/minio. Le port 9000 sert l’API S3, le port 9001 la console web d’administration.

# /etc/default/minio
MINIO_VOLUMES="/srv/minio/data"
MINIO_OPTS="--address :9000 --console-address :9001"
MINIO_ROOT_USER="admin"
MINIO_ROOT_PASSWORD="RemplaceMoiParUnMotDePasseFort"

Creez ensuite l’unite systemd /etc/systemd/system/minio.service (elle contient des sections entre crochets, on la presente donc telle quelle) :

[Unit]
Description=MinIO Object Storage
Documentation=https://min.io/docs/minio/linux/index.html
Wants=network-online.target
After=network-online.target
AssertFileIsExecutable=/usr/local/bin/minio

[Service]
Type=notify
User=minio-user
Group=minio-user
EnvironmentFile=-/etc/default/minio
ExecStart=/usr/local/bin/minio server $MINIO_OPTS $MINIO_VOLUMES
Restart=always
LimitNOFILE=65536
TimeoutStopSec=infinity
SendSIGKILL=no

[Install]
WantedBy=multi-user.target

4. Demarrage du service

systemctl daemon-reload
systemctl enable --now minio
systemctl status minio --no-pager

La console d’administration est alors accessible sur http://IP_DU_SERVEUR:9001 avec les identifiants definis plus haut.

5. Creer un bucket avec le client mc

Le client mc permet de piloter MinIO en ligne de commande.

# Installer le client MinIO (mc)
curl -O https://dl.min.io/client/mc/release/linux-amd64/mc
chmod +x mc
mv mc /usr/local/bin/

# Declarer un alias vers l'instance locale
mc alias set local http://127.0.0.1:9000 admin RemplaceMoiParUnMotDePasseFort

# Creer un bucket et l'ouvrir en lecture anonyme
mc mb local/public
mc anonymous set download local/public

# Envoyer un objet de test
echo "Hello object storage" > hello.txt
mc cp hello.txt local/public/

6. Reverse proxy Nginx avec cache de 60 minutes

Creez le vhost /etc/nginx/sites-available/objstore.conf. La zone de cache conserve les reponses 200/206 pendant 60 minutes ; l’en-tete X-Cache-Status expose l’etat (HIT / MISS) a chaque reponse.

# Zone de cache : 60 min d'inactivite, 10 Go max
proxy_cache_path /var/cache/nginx/objstore levels=1:2 keys_zone=objcache:50m max_size=10g inactive=60m use_temp_path=off;

server {
    listen 80;
    server_name s3.example.com;

    # Autoriser les gros uploads (objets volumineux)
    client_max_body_size 0;

    location / {
        proxy_pass http://127.0.0.1:9000;

        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;

        # Cache des reponses 200/206 pendant 60 minutes
        proxy_cache objcache;
        proxy_cache_valid 200 206 60m;
        proxy_cache_revalidate on;
        proxy_cache_lock on;
        proxy_cache_use_stale error timeout updating;

        # Ne JAMAIS cacher les requetes authentifiees (signatures S3)
        proxy_cache_bypass $http_authorization;
        proxy_no_cache $http_authorization;

        # Exposer l'etat du cache dans la reponse
        add_header X-Cache-Status $upstream_cache_status;
    }
}

On cree le repertoire de cache, on active le vhost et on recharge Nginx :

# Repertoire de cache
mkdir -p /var/cache/nginx/objstore
chown -R www-data:www-data /var/cache/nginx/objstore

# Activer le vhost et tester la configuration
ln -s /etc/nginx/sites-available/objstore.conf /etc/nginx/sites-enabled/
nginx -t
systemctl reload nginx

7. Verifier le cache

Le premier appel renvoie MISS (Nginx interroge MinIO et met l’objet en cache), les suivants renvoient HIT (servis depuis le cache, sans toucher au backend) pendant 60 minutes.

# 1er appel : MISS
curl -sI http://s3.example.com/public/hello.txt | grep -i x-cache-status

# 2e appel : HIT
curl -sI http://s3.example.com/public/hello.txt | grep -i x-cache-status

Points de vigilance

  • HTTPS : en production, ajoutez un certificat TLS (Let’s Encrypt via certbot) et redirigez le port 80 vers 443.
  • Cache et authentification : ne mettez en cache que les objets publics. Les requetes signees S3 (en-tete Authorization) sont volontairement exclues du cache via proxy_no_cache.
  • Fraicheur : un objet modifie peut etre servi depuis le cache jusqu’a 60 minutes. Pour un contenu qui change souvent, reduisez la duree ou ajoutez un module de purge (ngx_cache_purge).
  • Console privee : n’exposez pas le port 9001 (console d’admin) sur Internet ; reservez-le au LAN ou a un VPN.

Recapitulatif des commandes

# Installation
apt update && apt install -y curl
curl -O https://dl.min.io/server/minio/release/linux-amd64/minio
chmod +x minio && mv minio /usr/local/bin/

# Service MinIO
systemctl daemon-reload && systemctl enable --now minio

# Client + bucket public
mc alias set local http://127.0.0.1:9000 admin MOT_DE_PASSE
mc mb local/public && mc anonymous set download local/public

# Nginx + cache 60 min
nginx -t && systemctl reload nginx

# Verification du cache
curl -sI http://s3.example.com/public/hello.txt | grep -i x-cache-status

Conclusion

Vous disposez d’un stockage objet S3-compatible sous Debian 13, place derriere un reverse proxy Nginx qui met en cache les objets publics pendant 60 minutes. Cette architecture reduit la charge sur MinIO et accelere la distribution des contenus statiques, tout en conservant la compatibilite S3 pour vos applications.

📚 À lire aussi