Déploiement de Go sur Kubernetes : guide de base pour débutants

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

Go (Golang) et Kubernetes (K8s) sont faits l'un pour l'autre. Kubernetes lui-même est écrit en Go, donc la boîte à outils native, les performances et la simplicité de déploiement font de cette combinaison la norme pour les microservices modernes. Si vous débutez tout juste dans le DevOps ou souhaitez automatiser le déploiement de votre application Go, ce guide vous aidera à franchir toutes les étapes : de l'écriture d'un simple serveur HTTP en Go à son exécution dans un cluster Kubernetes.

Dans cet article, nous aborderons :

\n
• La construction d'une application Go dans une image Docker
\n
• La création de manifestes Kubernetes minimaux (Deployment, Service, Ingress)
\n
• Le déploiement et la vérification du bon fonctionnement
\n

Il est supposé que vous avez déjà installé docker, kubectl et minikube (ou que vous avez accès à n'importe quel cluster K8s).

Étape 1 : Écrire une application Go simple

Créons un serveur HTTP de base qui répondra aux requêtes. Créez un fichier main.go :

package main\n\nimport (\n    "fmt"\n    "net/http"\n    "os"\n)\n\nfunc main() {\n    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {\n        fmt.Fprintf(w, "Bonjour de Go ! Version : %s", os.Getenv("APP_VERSION"))\n    })\n\n    port := os.Getenv("PORT")\n    if port == "" {\n        port = "8080"\n    }\n\n    fmt.Printf("Serveur démarré sur le port %s\\n", port)\n    http.ListenAndServe(":"+port, nil)\n}\n

Cette application lit la variable d'environnement APP_VERSION (peut être définie lors du déploiement) et écoute sur le port spécifié dans PORT. Testons-la localement :

go run main.go\n# Ouvrez votre navigateur sur http://localhost:8080\n

Créer un module Go

Initialisez le module pour faciliter la construction :

go mod init my-go-app\n

Étape 2 : Conteneurisation avec Docker

Pour déployer sur Kubernetes, il faut empaqueter l'application dans une image Docker. Nous utilisons une construction multi-étapes (multi-stage build) pour que l'image soit minimale.

Créez un fichier Dockerfile :

# Étape de construction\nFROM golang:1.22-alpine AS builder\nWORKDIR /app\nCOPY go.mod ./\nCOPY main.go ./\nRUN go build -o my-app .\n\n# Image finale\nFROM alpine:3.19\nWORKDIR /app\nCOPY --from=builder /app/my-app .\nEXPOSE 8080\nCMD ["./my-app"]\n

Construisez l'image et vérifiez :

docker build -t my-go-app:v1 .\ndocker run -p 8080:8080 my-go-app:v1\n# http://localhost:8080\n

Étape 3 : Manifestes Kubernetes

Préparons maintenant les fichiers YAML pour le déploiement dans le cluster. Nous allons créer trois ressources : Deployment (gestion des pods), Service (accès réseau) et Ingress (accès externe).

3.1. Deployment

Créez un fichier deployment.yaml :

apiVersion: apps/v1\nkind: Deployment\nmetadata:\n  name: go-app-deployment\n  labels:\n    app: go-app\nspec:\n  replicas: 2\n  selector:\n    matchLabels:\n      app: go-app\n  template:\n    metadata:\n      labels:\n        app: go-app\n    spec:\n      containers:\n      - name: go-app\n        image: my-go-app:v1\n        ports:\n        - containerPort: 8080\n        env:\n        - name: APP_VERSION\n          value: "1.0.0"\n        - name: PORT\n          value: "8080"\n        livenessProbe:\n          httpGet:\n            path: /\n            port: 8080\n          initialDelaySeconds: 5\n          periodSeconds: 10\n

Ici, nous avons défini 2 réplicas, une sonde de vivacité (liveness probe) et des variables d'environnement.

3.2. Service

Créez un fichier service.yaml pour l'accès interne :

apiVersion: v1\nkind: Service\nmetadata:\n  name: go-app-service\nspec:\n  selector:\n    app: go-app\n  ports:\n  - protocol: TCP\n    port: 80\n    targetPort: 8080\n  type: ClusterIP\n

3.3. Ingress

Créez un fichier ingress.yaml pour l'accès externe :

apiVersion: networking.k8s.io/v1\nkind: Ingress\nmetadata:\n  name: go-app-ingress\nspec:\n  rules:\n  - host: go-app.local\n    http:\n      paths:\n      - path: /\n        pathType: Prefix\n        backend:\n          service:\n            name: go-app-service\n            port:\n              number: 80\n

Étape 4 : Déploiement sur Kubernetes

Appliquez les manifestes dans l'ordre suivant :

kubectl apply -f deployment.yaml\nkubectl apply -f service.yaml\nkubectl apply -f ingress.yaml\n

Vérifiez l'état des ressources :

kubectl get pods\nkubectl get services\nkubectl get ingress\n

Pour tester localement avec Minikube, activez le complément Ingress :

minikube addons enable ingress\n

Ajoutez l'entrée suivante à votre fichier /etc/hosts :

$(minikube ip) go-app.local\n

Ouvrez maintenant http://go-app.local dans votre navigateur. Vous devriez voir le message "Bonjour de Go ! Version : 1.0.0".

Conclusion

Félicitations ! Vous avez déployé avec succès une application Go sur Kubernetes. Ce flux de travail de base peut être étendu avec des fonctionnalités avancées telles que ConfigMaps, Secrets, Horizontal Pod Autoscaler, ou des pipelines CI/CD. La combinaison Go + Kubernetes offre une évolutivité et une fiabilité élevées pour les applications modernes.

N'oubliez pas de nettoyer les ressources après les tests :

kubectl delete -f ingress.yaml\nkubectl delete -f service.yaml\nkubectl delete -f deployment.yaml\n