Dockeriser votre API Go avec des versions en plusieurs étapes

Très bien, l'équipe ! Nous faisons passer notre API Go au niveau supérieur en la la dockerisant et, plus important encore, en la rendant légère et efficace avec des builds en plusieurs étapes. À la fin de cet article, vous disposerez d’une API non seulement portable mais également optimisée pour des déploiements plus rapides. ?

Pourquoi des constructions en plusieurs étapes ? ?

Les builds en plusieurs étapes nous permettent de conserver notre image Docker finale légère en séparant l'environnement build de l'environnement runtime. Pour les applications Go, cela est particulièrement utile car nous pouvons créer l'application en une seule étape (avec tous les outils et dépendances nécessaires), puis copier uniquement le binaire résultant dans une image finale plus petite.

Avantages des constructions en plusieurs étapes :

• Taille d'image plus petite : en supprimant les dépendances de construction inutiles, nous nous retrouvons avec une image qui représente une fraction de la taille.
• Déploiement plus rapide : une image plus petite signifie des téléchargements et des déploiements plus rapides.
• Surface d'attaque réduite : moins de composants dans l'environnement d'exécution signifie moins de vulnérabilités potentielles.

Étape 1 : écriture du fichier Docker avec des versions en plusieurs étapes

Créons un Dockerfile qui tire parti d'une construction en plusieurs étapes. Cela nous aidera à optimiser notre API Go pour la production en réduisant la taille de l'image finale.

Créez un Dockerfile à la racine de votre projet avec le contenu suivant :

# Build stage
FROM golang:1.21.0-alpine3.17 AS builder
WORKDIR /app
COPY . .

# Install dependencies and build the application
RUN go mod download
RUN go build -o main .

# Run stage (lightweight)
FROM alpine:3.18.3
WORKDIR /app

# Copy the binary from the builder stage
COPY --from=builder /app/main .

# Expose the API port
EXPOSE 8000

# Run the binary
CMD ["/app/main"]

Répartition du Dockerfile :

1. Étape de construction :

   • Nous commençons par l'image officielle Go Alpine, qui est plus petite que l'image Go standard.
   • Toutes les dépendances sont téléchargées et nous compilons l'application en binaire (principal) à l'aide de go build.

2. Étape d'exécution :

   • Nous passons à une image Alpine encore plus légère, qui ne contient pas le compilateur Go ni d'autres dépendances de build.
   • Le binaire compilé est copié depuis l'étape de création et nous exposons le port 8000 pour permettre l'accès à notre API.

Avec cette approche, notre image finale contient uniquement ce qui est nécessaire pour exécuter l'API, ce qui donne une image nettement plus petite.

Étape 2 : créer et exécuter le conteneur Docker

Maintenant que nous avons notre fichier Docker optimisé, créons et exécutons l'image Docker.

1. Créer l'image Docker :

   docker build -t my-go-api .

1. Exécuter le conteneur Docker :

   docker run -p 8000:8000 my-go-api

Vous devriez voir votre API s'exécuter sur http://localhost:8000, tout comme sur votre ordinateur local !

Étape 3 : Optimiser davantage avec l'image Scratch (facultatif)

Pour encore optimisation supplémentaire, vous pouvez remplacer l'étape d'exécution Alpine par l'image scratch. L'image de travail est complètement vide (pas de système d'exploitation, pas d'utilitaires), ce qui donne une taille d'image encore plus petite. Cependant, cela signifie également que vous n’aurez accès à aucun outil de débogage à l’intérieur du conteneur.

Voici à quoi ressemblerait le Dockerfile avec l'image scratch :

# Build stage
FROM golang:1.21.0-alpine3.17 AS builder
WORKDIR /app
COPY . .

RUN go mod download
RUN go build -o main .

# Run stage
FROM scratch
WORKDIR /app

COPY --from=builder /app/main .

EXPOSE 8000

CMD ["/app/main"]

Cette approche peut réduire la taille finale de votre image à seulement 10-15 Mo ! Cependant, gardez à l’esprit que l’utilisation de Scratch est mieux adaptée aux applications très basiques et autonomes.

Étape 4 : tester le conteneur optimisé ?

Testons notre conteneur pour nous assurer qu'il fonctionne comme prévu :

curl http://localhost:8000/books

Si votre API répond correctement, alors félicitations ! Vous avez optimisé et conteneurisé avec succès votre API Go avec Docker. ?

Avantages des constructions en plusieurs étapes en production

• Déploiement efficace : des images plus petites signifient des temps d'extraction plus rapides, ce qui peut être critique dans les environnements de production.
• Économies de ressources : grâce à des empreintes de stockage et de mémoire réduites, vos coûts d'infrastructure restent faibles.
• Sécurité : moins de composants dans l'image finale réduisent le potentiel de vulnérabilités.

Quelle est la prochaine étape ?

Maintenant que votre API est prête pour Docker et optimisée pour la production, vous êtes prêt pour des déploiements et une mise à l'échelle fluides ! La prochaine fois, nous passerons à la vitesse supérieure et nous plongerons dans les tests unitaires pour Go, en nous assurant que votre API est non seulement déployable, mais aussi solide comme le roc. ??

Gardez également un œil sur mon dépôt ThrottleX GitHub pour les mises à jour : je publierai bientôt un tutoriel sur l'intégration de mon limiteur de débit personnalisé !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!