Docker et Go : conteneurisation d'applications de A à Z

Introduction : Pourquoi Docker et Go sont-ils le duo idéal ?

Go (Golang) et Docker sont deux outils qui ont transformé l'approche du développement et du déploiement des services backend. Go se compile en un seul fichier binaire statique, tandis que Docker permet d'empaqueter ce binaire dans un environnement isolé. Ensemble, ils offrent des conteneurs minimalistes, rapides et sécurisés, exécutables partout : du poste de travail du développeur à un cluster Kubernetes en production.

Dans cet article, nous passerons de zéro à une application Go prête pour la production, empaquetée dans Docker. Vous apprendrez à rédiger un Dockerfile, optimiser la taille de l'image, utiliser la construction multi-étapes et exécuter des conteneurs avec un service Go.

1. Bases : Application Go et Dockerfile simple

Commençons par un serveur HTTP simple en Go. Créons le fichier main.go :

package main

import (    "fmt"    "net/http")

func main() {    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {        fmt.Fprintf(w, "Bonjour depuis Go à l'intérieur de Docker !")    })

    fmt.Println("Le serveur tourne sur le port :8080")    http.ListenAndServe(":8080", nil)}

Écrivons maintenant un Dockerfile minimal :

FROM golang:1.22-alpine AS builder

WORKDIR /appCOPY go.mod go.sum ./RUN go mod downloadCOPY . .RUN go build -o server .

FROM alpine:3.19RUN apk --no-cache add ca-certificatesWORKDIR /root/COPY --from=builder /app/server .EXPOSE 8080CMD ["./server"]

Construisons l'image et lançons le conteneur :

docker build -t go-server .docker run -p 8080:8080 go-server

Ouvrez maintenant votre navigateur et allez sur http://localhost:8080 — vous verrez le message de bienvenue de l'application Go fonctionnant à l'intérieur du conteneur.

Pourquoi la construction multi-étapes ?

Dans la première étape, nous utilisons l'image officielle Go avec un ensemble complet d'outils pour la compilation. Dans la deuxième étape, nous utilisons Alpine Linux minimal, où seul le binaire final est copié. Cela permet d'obtenir une image d'environ 15-20 Mo au lieu de 500+ Mo si nous avions conservé l'image Go complète.

2. Optimisation de l'image : minimisation de la taille et de la vitesse de construction

Une petite image, ce n'est pas seulement une économie d'espace, mais aussi un chargement plus rapide et une surface d'attaque réduite. Examinons les techniques clés pour les applications Go.

2.1. Utilisation du .dockerignore

Créez un fichier .dockerignore à la racine du projet :

.git*.mdDockerfile.dockerignorenode_modules/test/

Cela empêche la copie de fichiers inutiles dans le contexte de construction et accélère le processus.

2.2. Mise en cache des dépendances

Dans notre Dockerfile, nous copions d'abord uniquement go.mod et go.sum, puis nous exécutons go mod download. Docker met en cache chaque couche, et tant que ces fichiers ne changent pas, les dépendances ne seront pas re-téléchargées à chaque modification du code.

2.3. CGO et compilation statique

Go utilise par défaut CGO pour certaines opérations (par exemple, les appels réseau système). Pour obtenir un binaire entièrement statique sans dépendances à libc, utilisez les flags de compilation :

RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o server .

Cela garantit que le binaire fonctionnera sur n'importe quelle distribution Linux, y compris les images minimales comme scratch.

2.4. Scratch — l'image de base la plus légère

Si votre application ne nécessite pas de shell, de ping ou d'autres utilitaires, utilisez l'image vide scratch :

FROM scratchCOPY --from=builder /app/server /EXPOSE 8080CMD ["/server"]

La taille d'une telle image sera égale à la taille du binaire lui-même — souvent moins de 10 Mo.

3. Docker Compose : application Go multi-conteneurs

Les applications réelles sont rarement composées d'un seul conteneur. Utilisons Docker Compose pour orchestrer plusieurs services :