Docker et Rust : conteneurisation d'applications de niveau avancé

Docker et Rust : conteneurisation d'applications de niveau avancé

La conteneurisation d'applications Rust avec Docker n'est pas simplement un empaquetage de code dans une image. À un niveau avancé, c'est l'art de créer des conteneurs minimaux, rapides et sécurisés, parfaitement adaptés à un environnement de production. Rust, en tant que langage de programmation système, se compile en code natif, ce qui offre des opportunités uniques pour optimiser les images Docker. Dans cet article, nous explorerons des techniques qui vont au-delà du simple docker build et montrerons comment créer des conteneurs efficaces pour les applications Rust.

1. Construction multi-étapes (Multi-stage build) pour Rust

La construction multi-étapes est la pierre angulaire de la conteneurisation avancée de Rust. Elle permet de séparer l'environnement de construction (avec le compilateur, les dépendances et les outils) de l'image finale, qui ne contient que le fichier binaire compilé et les dépendances d'exécution nécessaires.

Considérons un exemple de Dockerfile pour un serveur web utilisant actix-web :

# Étape 1 : ConstructionFROM rust:1.75-slim-bullseye AS builder

WORKDIR /app

# Copier uniquement les fichiers de dépendances pour la mise en cache des couchesCOPY Cargo.toml Cargo.lock ./

# Créer un main.rs vide pour compiler les dépendancesRUN mkdir src && echo "fn main() {}" > src/main.rsRUN cargo build --release 2>/dev/null || true

# Copier maintenant le code source réelCOPY src ./src

# Recompiler uniquement les fichiers modifiés (le cache des dépendances est préservé)RUN cargo build --release

# Étape 2 : Image finaleFROM debian:bullseye-slim

RUN apt-get update && apt-get install -y --no-install-recommends \    ca-certificates \    libssl1.1 \    && rm -rf /var/lib/apt/lists/*

COPY --from=builder /app/target/release/my_app /usr/local/bin/my_app

USER nobodyEXPOSE 8080

CMD ["/usr/local/bin/my_app"]

Optimisations clés :

• Mise en cache des dépendances : Seuls Cargo.toml et Cargo.lock sont copiés en premier, puis les dépendances sont compilées. Cela permet à Docker d'utiliser le cache des couches si les fichiers de manifeste n'ont pas changé.
• Image finale minimale : Utilisation de debian:bullseye-slim au lieu de l'image Rust complète. Cela réduit la taille d'environ 1,5 Go à environ 150 Mo.
• Sécurité : L'application est exécutée en tant qu'utilisateur nobody, et non en tant que root.

2. Minimisation de la taille de l'image : d'Alpine à scratch

Les applications Rust ne nécessitent pas d'environnement d'exécution comme une machine virtuelle Java ou un interpréteur Python. Cela permet d'utiliser des images de base minimales.

Option avec Alpine Linux :

FROM alpine:3.19 AS builderRUN apk add --no-cache musl-dev# ... construction ...

FROM alpine:3.19RUN apk add --no-cache ca-certificatesCOPY --from=builder /app/target/release/my_app /my_appCMD ["/my_app"]

Option avec scratch (image vide) :

FROM alpine:3.19 AS builderRUN apk add --no-cache musl-dev# Construction avec liaison statiqueRUN cargo build --release --target x86_64-unknown-linux-musl

FROM scratchCOPY --from=builder /app/target/x86_64-unknown-linux-musl/release/my_app /my_appCOPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/CMD ["/my_app"]

Comparaison des tailles d'images :

• debian:bullseye-slim : ~80-150 Mo (dépend du nombre de bibliothèques système)
• alpine:3.19 : ~10-20 Mo (utilise musl libc au lieu de glibc)
• scratch : ~5-10 Mo (uniquement le binaire et les certificats)

Important : Lors de l'utilisation de scratch, il est nécessaire de s'assurer que votre application ne nécessite pas de bibliothèques dynamiques. Pour cela, utilisez la liaison statique avec la cible