Déploiement d'une application Go sur Kubernetes : guide de base

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

Go (Golang) et Kubernetes sont deux outils clés du développement moderne. Go, créé chez Google, est un langage compilé, typé statiquement, parfait pour créer des microservices haute performance. Kubernetes, quant à lui, est le standard de facto pour l'orchestration de conteneurs. Leur combinaison offre un écosystème puissant : vous écrivez un code Go léger et rapide, vous l'empaquetez dans une image Docker, et Kubernetes gère son lancement, sa mise à l'échelle et sa reprise.

Dans ce guide, nous allons déployer étape par étape une simple application Go sur Kubernetes. Vous apprendrez à écrire un Dockerfile, à créer des manifestes Deployment et Service, et à les appliquer dans un cluster. Cet article est destiné aux développeurs qui connaissent déjà les bases de Go et ont une compréhension élémentaire de Docker.

Étape 1 : Création et conteneurisation de l'application Go

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

package main

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

func main() {    port := os.Getenv("PORT")    if port == "" {        port = "8080"    }    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {        fmt.Fprintf(w, "Hello from Go on Kubernetes!")    })    http.ListenAndServe(":"+port, nil)}

Ce code écoute sur le port défini par la variable d'environnement PORT (par défaut 8080) et renvoie un simple message.

Construction de l'image Docker

Créons maintenant un Dockerfile pour une construction multi-étapes – cela réduira la taille de l'image finale :

# Étape de constructionFROM golang:1.21-alpine AS builderWORKDIR /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:v1 .docker push yourusername/go-k8s-app:v1

Étape 2 : Manifeste Deployment

Kubernetes utilise des manifestes YAML pour décrire l'état souhaité du cluster. Créez un fichier deployment.yaml :

apiVersion: apps/v1kind: Deploymentmetadata:  name: go-app-deployment  labels:    app: go-appspec:  replicas: 3  selector:    matchLabels:      app: go-app  template:    metadata:      labels:        app: go-app    spec:      containers:      - name: go-app        image: yourusername/go-k8s-app:v1        ports:        - containerPort: 8080        env:        - name: PORT          value: "8080"        readinessProbe:          httpGet:            path: /            port: 8080          initialDelaySeconds: 5          periodSeconds: 10        livenessProbe:          httpGet:            path: /            port: 8080          initialDelaySeconds: 15          periodSeconds: 20

Analyse des champs clés :

• replicas: 3 — Kubernetes maintiendra 3 instances (pods) en fonctionnement de l'application.
• readinessProbe — vérifie si le pod est prêt à recevoir du trafic (requêtes sur /).
• livenessProbe — vérifie si le pod est vivant ; sinon, Kubernetes le redémarrera.

Étape 3 : Manifeste Service

Pour rendre l'application accessible à l'intérieur du cluster ou depuis l'extérieur, un Service est nécessaire. Créez service.yaml :

apiVersion: v1kind: Servicemetadata:  name: go-app-servicespec:  selector:    app: go-app  ports:    - protocol: TCP      port: 80      targetPort: 8080  type: LoadBalancer

• selector — lie le service aux pods ayant le label