Déploiement d'une application Go sur Kubernetes : guide étape par étape

Introduction : pourquoi Go et Kubernetes forment un duo idéal

Go (Golang) et Kubernetes constituent le standard moderne pour construire et déployer une architecture de microservices. Go se compile en un binaire statique, ne nécessite pas de dépendances sur la machine cible, démarre rapidement et utilise efficacement la mémoire. Kubernetes, quant à lui, assure l'automatisation du déploiement, de la mise à l'échelle et de la gestion des conteneurs.

Dans ce guide, nous allons parcourir en pratique le cycle complet de déploiement d'une simple application Go sur Kubernetes. Vous apprendrez à écrire un Dockerfile, à créer des manifestes pour Kubernetes (Deployment, Service, ConfigMap) et à lancer l'application dans un cluster. Tous les exemples de code peuvent être immédiatement utilisés dans vos propres projets.

1. Préparation de l'application Go pour la conteneurisation

Pour commencer, créons un simple serveur HTTP en Go qui répondra aux requêtes et affichera un message de bienvenue. Il est important que l'application écoute sur le port que nous spécifierons via une variable d'environnement. C'est une pratique courante pour Kubernetes.

Créez le fichier main.go :

package main

import (    "fmt"    "log"    "net/http"    "os")

func main() {    port := os.Getenv("PORT")    if port == "" {        port = "8080"    }

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {        name := os.Getenv("APP_NAME")        if name == "" {            name = "Go App"        }        fmt.Fprintf(w, "Bonjour de %s ! Nous travaillons sur le port %s", name, port)    })

    log.Printf("Serveur démarré sur le port %s", port)    log.Fatal(http.ListenAndServe(":"+port, nil))}

Ce code lit les variables d'environnement PORT et APP_NAME, ce qui nous permettra de configurer l'application de manière flexible via ConfigMap dans Kubernetes.

2. Création du Dockerfile pour l'application Go

Pour le déploiement sur Kubernetes, nous avons besoin d'une image Docker. Utilisons une construction multi-étapes (multi-stage build) – cela réduira la taille de l'image et améliorera la sécurité.

Créez le fichier Dockerfile :

# Étape de constructionFROM golang:1.22-alpine AS builder

WORKDIR /appCOPY go.mod go.sum ./RUN go mod downloadCOPY . .RUN CGO_ENABLED=0 GOOS=linux go build -o /app/server .

# Image finaleFROM alpine:latestRUN apk --no-cache add ca-certificatesWORKDIR /root/COPY --from=builder /app/server .EXPOSE 8080CMD ["./server"]

Construisez l'image et envoyez-la dans un registre (par exemple, Docker Hub) :

docker build -t yourusername/go-k8s-app:latest .docker push yourusername/go-k8s-app:latest

3. Manifestes Kubernetes : Deployment, Service, ConfigMap

Créons maintenant les manifestes pour déployer l'application dans le cluster. Il est recommandé de les stocker dans un dossier k8s/.

3.1. ConfigMap pour la configuration

Externalisons les paramètres de l'application dans un ConfigMap – cela permettra de les modifier sans reconstruire l'image.

Fichier k8s/configmap.yaml :

apiVersion: v1kind: ConfigMapmetadata:  name: go-app-configdata:  APP_NAME: "Mon application Go"  PORT: "8080"

3.2. Deployment – description du pod

Le Deployment gère les réplicas du pod et assure les mises à jour sans temps d'arrêt.

Fichier k8s/deployment.yaml :

apiVersion: apps/v1kind: Deploymentmetadata:  name: go-app-deployment  labels:    app: go-appspec:  replicas: 2  selector:    matchLabels:      app: go-app  template:    metadata:      labels:        app: go-app    spec:      containers:      - name: go-app        image: yourusername/go-k8s-app:latest        ports:        - containerPort: 8080        envFrom:        - configMapRef:            name: go-app-config        livenessProbe:          httpGet:            path: /            port: 8080          initialDelaySeconds: 5          periodSeconds: 10\