⚠️ Traduction non officielle - Cette documentation est une traduction communautaire non officielle de Docker.

Conteneuriser une application Golang

Table des matières

La conteneurisation vous aide à regrouper l'application et ses dépendances dans un seul paquet appelé conteneur. Ce paquet peut s'exécuter sur n'importe quelle plateforme sans se soucier de l'environnement. Dans cette section, vous apprendrez à conteneuriser une application Golang à l'aide de Docker.

Pour conteneuriser une application Golang, vous devez d'abord créer un Dockerfile. Le Dockerfile contient des instructions pour construire et exécuter l'application dans un conteneur. De plus, lors de la création d'un Dockerfile, vous pouvez suivre différents ensembles de bonnes pratiques pour optimiser la taille de l'image et la rendre plus sécurisée.

Création d'un Dockerfile

Créez un nouveau fichier nommé Dockerfile à la racine de votre application Golang. Le Dockerfile contient des instructions pour construire et exécuter l'application dans un conteneur.

Voici un Dockerfile pour une application Golang. Vous trouverez également ce fichier dans le répertoire go-prometheus-monitoring.

# Utiliser l'image officielle Golang comme base
FROM golang:1.24-alpine AS builder

# Définir les variables d'environnement
ENV CGO_ENABLED=0 \
    GOOS=linux \
    GOARCH=amd64

# Définir le répertoire de travail à l'intérieur du conteneur
WORKDIR /build

# Copier les fichiers go.mod et go.sum pour l'installation des dépendances
COPY go.mod go.sum ./

# Télécharger les dépendances
RUN go mod download

# Copier l'ensemble du code source de l'application
COPY . .

# Construire le binaire Go
RUN go build -o /app .

# Étape finale légère
FROM alpine:3.21 AS final

# Copier le binaire compilé de l'étape de construction
COPY --from=builder /app /bin/app

# Exposer le port de l'application
EXPOSE 8000

# Exécuter l'application
CMD ["bin/app"]

Comprendre le Dockerfile

Le Dockerfile se compose de deux étapes :

  1. Étape de construction: Cette étape utilise l'image officielle Golang comme base et définit les variables d'environnement nécessaires. Elle définit également le répertoire de travail à l'intérieur du conteneur, copie les fichiers go.mod et go.sum pour l'installation des dépendances, télécharge les dépendances, copie l'ensemble du code source de l'application et construit le binaire Go.

    Vous utilisez l'image golang:1.24-alpine comme image de base pour l'étape de construction. La variable d'environnement CGO_ENABLED=0 désactive CGO, ce qui est utile pour construire des binaires statiques. Vous définissez également les variables d'environnement GOOS et GOARCH sur linux et amd64, respectivement, pour construire le binaire pour la plateforme Linux.

  2. Étape finale: Cette étape utilise l'image officielle Alpine comme base et copie le binaire compilé de l'étape de construction. Elle expose également le port de l'application et exécute l'application.

    Vous utilisez l'image alpine:3.21 comme image de base pour l'étape finale. Vous copiez le binaire compilé de l'étape de construction vers l'image finale. Vous exposez le port de l'application à l'aide de l'instruction EXPOSE et exécutez l'application à l'aide de l'instruction CMD.

    Outre la construction en plusieurs étapes, le Dockerfile suit également les bonnes pratiques telles que l'utilisation des images officielles, la définition du répertoire de travail et la copie uniquement des fichiers nécessaires dans l'image finale. Vous pouvez optimiser davantage le Dockerfile en suivant d'autres bonnes pratiques.

Construire l'image Docker et exécuter l'application

Une fois que vous avez le Dockerfile, vous pouvez construire l'image Docker et exécuter l'application dans un conteneur.

Pour construire l'image Docker, exécutez la commande suivante dans le terminal :

$ docker build -t go-api:latest .

Après avoir construit l'image, vous pouvez exécuter l'application dans un conteneur à l'aide de la commande suivante :

$ docker run -p 8000:8000 go-api:latest

L'application commencera à s'exécuter à l'intérieur du conteneur, et vous pourrez y accéder à l'adresse http://localhost:8000. Vous pouvez également vérifier les conteneurs en cours d'exécution à l'aide de la commande docker ps.

$ docker ps

Résumé

Dans cette section, vous avez appris à conteneuriser une application Golang à l'aide d'un Dockerfile. Vous avez créé un Dockerfile en plusieurs étapes pour construire et exécuter l'application dans un conteneur. Vous avez également découvert les bonnes pratiques pour optimiser la taille de l'image Docker et la rendre plus sécurisée.

Informations connexes :

Prochaines étapes

Dans la section suivante, vous apprendrez à utiliser Docker Compose pour connecter et exécuter plusieurs services ensemble afin de surveiller une application Golang avec Prometheus et Grafana.

Connexion des services avec Docker Compose »