Déploiements Canary en Go : un déploiement sécurisé sans crainte

Déploiements Canary avec Go : comment publier des mises à jour sans crainte ni risque

Imaginez : vous avez passé des années à construire une architecture, à écrire des tests, à configurer la surveillance. Et voilà — la mise en production. Un clic, et la nouvelle version part en production. Le cœur bat la chamade, les doigts tremblent. Cela vous dit quelque chose ? Et si je vous disais que vous pouvez déployer une nouvelle version sur seulement 5 % des utilisateurs, observer les métriques, et ensuite seulement la déployer pour tout le monde ? Sans temps d'arrêt, sans panique, avec un contrôle total.

Cela s'appelle un déploiement canary. Le nom vient des mineurs qui emmenaient des canaris avec eux — l'oiseau mourait du gaz avant les humains, avertissant du danger. Dans le monde DevOps, ces « canaris » sont les premiers 5 à 10 % des utilisateurs qui reçoivent la nouvelle version. Si quelque chose ne va pas — on revient en arrière sans que les problèmes soient remarqués.

Dans cet article, nous allons voir comment implémenter un déploiement canary en Go avec des exemples de code réels, un équilibreur de charge et des métriques. C'est parti !

Pourquoi Go pour le déploiement canary ?

Go est un langage créé pour les microservices. Il se compile en un binaire statique, ne nécessite pas de dépendances sur le serveur et se met facilement à l'échelle. Mais surtout, Go offre une prise en charge intégrée de la concurrence et d'excellentes bibliothèques pour les serveurs HTTP, ce qui en fait un candidat idéal pour implémenter un routage intelligent du trafic.

• Performances — un serveur Go traite des milliers de requêtes par seconde sur un seul cœur.
• Simplicité de déploiement — un seul binaire, pas de machines virtuelles ni d'interpréteurs.
• Écosystème riche — des packages pour les métriques (Prometheus), le tracing (OpenTelemetry) et l'équilibrage de charge.

Si vous écrivez déjà en Go et souhaitez automatiser le déploiement — la stratégie canary deviendra votre meilleure amie.

Architecture du déploiement canary en Go

Imaginons que nous ayons un microservice en Go qui traite les requêtes des utilisateurs. Habituellement, nous déployons la nouvelle version immédiatement sur toutes les instances. Avec l'approche canary, nous exécutons la nouvelle version en parallèle de l'ancienne, mais nous n'y dirigeons qu'une partie du trafic.

Voici un schéma simplifié :

1. Version stable (v1) — fonctionne sur 90 % des instances.
2. Version canary (v2) — exécutée sur 10 % des instances.
3. Équilibreur de charge — répartit le trafic proportionnellement.
4. Surveillance — compare les métriques (latence, erreurs, débit).
5. Décision manuelle ou automatique — on déploie v2 à 100 % ou on revient en arrière.

On peut implémenter cela de différentes manières : via Kubernetes (Service Mesh), via Nginx avec des poids personnalisés, ou en écrivant son propre équilibreur de charge en Go. Nous allons suivre la troisième voie — elle offre un contrôle total et est parfaite pour l'apprentissage.

Écrire un équilibreur de charge canary en Go

Écrivons un simple reverse-proxy qui dirigera les requêtes vers deux backends : stable et canary. Nous définirons le poids de la version canary via un fichier de configuration ou une variable d'environnement.

package main

import (    "log"    "math/rand"    "net/http"    "net/http/httputil"    "net/url"    "os"    "strconv")

type CanaryProxy struct {    stable       *httputil.ReverseProxy    canary       *httputil.ReverseProxy    canaryWeight int // pourcentage du trafic vers canary (0-100)}

func NewCanaryProxy(stableURL, canaryURL string, weight int) *CanaryProxy {    stableTarget, _ := url.Parse(stableURL)    canaryTarget, _ := url.Parse(canaryURL)

    return &CanaryProxy{        stable:       httputil.NewSingleHostReverseProxy(stableTarget),        canary:       httputil.NewSingleHostReverseProxy(canaryTarget),        canaryWeight: weight,    }}

func (p *CanaryProxy) ServeHTTP(w http.ResponseWriter, r *http.Request) {    // Décision basée sur un nombre aléatoire    if rand.Intn(100) <