Auparavant, la sortie d’un logiciel signifiait une fenêtre de maintenance et des doigts croisés. Les équipes modernes utilisent des stratégies qui rendent les versions routinières, et le choix déploiement bleu-vert ou canari est l’un des premiers auxquels vous serez confronté. Les deux réduisent les risques, mais de manière opposée : l’un prépare un remplacement complet, tandis que l’autre teste petit à petit auprès de vrais utilisateurs.

Ce guide explique comment chacun fonctionne et ce qu’il coûte en pratique. Nous avons exécuté les petits exemples de routage utilisateur et de restauration dans Python 3.13, et le résultat provient de cette exécution. Les exemples Kubernetes sont illustratifs et nous ne les avons pas exécutés. Considérez les pourcentages et les seuils comme des exemples de départ à adapter.

La réponse courte

Avec le déploiement bleu-vert, vous exécutez deux environnements de production identiques. L’un sert les utilisateurs pendant que vous déployez et testez la nouvelle version sur l’autre, puis vous basculez tout le trafic en un seul geste.

Avec le déploiement Canary, la nouvelle version s’exécute à côté de l’ancienne. Vous lui envoyez un petit pourcentage du trafic réel, comparez les résultats et augmentez la part étape par étape jusqu’à ce qu’il serve tout le monde. Le nom vient des mineurs canaris autrefois utilisés comme avertissement précoce d’un danger.

Bleu-vert vs canari côte à côte

Comment fonctionne le déploiement bleu-vert

1. Blue est en ligne et dessert tout le trafic.
2. Déployez la nouvelle version sur green, qui ne reçoit aucun trafic utilisateur.
3. Testez minutieusement le vert, dans l’environnement de production réel, à l’aide de tests de fumée et d’utilisateurs internes.
4. Basculez le routeur, l’équilibreur de charge ou le DNS pour envoyer le trafic au vert.
5. Regardez attentivement, le bleu étant toujours en marche et prêt.
6. Si quelque chose ne va pas, revenez en arrière. Si tout va bien, le bleu devient le prochain environnement inactif.

Dans Kubernetes, vous pouvez effectuer le changement en modifiant le sélecteur d’un service, afin que le trafic soit déplacé vers des pods étiquetés différemment :

apiVersion: v1
kind: Service
metadata:
  name: shop
spec:
  selector:
    app: shop
    version: green   # was: blue
  ports:
    - port: 80
      targetPort: 8000

Forces : C’est conceptuellement simple, vous pouvez tester la configuration de production exacte avant que les utilisateurs ne la voient, et la restauration est presque instantanée. Faiblesses : Une infrastructure en double peut être coûteuse, un bug qui échappe à vos tests atteint tout le monde en même temps, et les sessions ouvertes et le travail en cours nécessitent une attention particulière pendant le changement. Si vous utilisez DNS pour le commutateur, les enregistrements mis en cache peuvent le retarder. Vous êtes nouveau dans les concepts ? Consultez notre Tutoriel Kubernetes pour les débutants.

Comment fonctionne le déploiement Canary

1. Déployez la nouvelle version avec la version stable.
2. Acheminez une petite part du trafic, par exemple 5 %, vers les Canaries.
3. Comparez les taux d’erreur, la latence et les mesures commerciales avec la version stable.
4. Si vous êtes en bonne santé, augmentez à 25 %, puis 50 %, puis 100 %.
5. Si quelque chose se dégrade, renvoyez tout le trafic vers la version stable.

De nombreuses équipes démarrent un canari avec le personnel interne, puis une région à faible risque, et ensuite seulement le grand public.

Forces : Une mauvaise version n’affecte qu’un petit groupe, et vous apprenez du trafic réel qu’aucun environnement de test ne peut entièrement reproduire. Faiblesses : Vous avez besoin de routages basés sur un pourcentage et de métriques par version, les déploiements prennent plus de temps et deux versions fonctionnent ensemble pendant un certain temps. Un petit canari peut également être trop silencieux pour émettre un signal significatif, en particulier aux heures de faible trafic.

Routage utilisateur stable

Choisir une version au hasard à chaque requête donne aux utilisateurs une expérience déroutante, car ils peuvent basculer entre l’ancienne et la nouvelle. Une solution courante consiste à hacher un ID utilisateur stable dans un bucket, afin que chaque utilisateur obtienne toujours la même réponse :

import hashlib

def bucket(user_id):
    digest = hashlib.sha256(user_id.encode()).hexdigest()
    return int(digest, 16) % 100

def version_for(user_id, canary_percent):
    return "v2" if bucket(user_id) < canary_percent else "v1"

users = [f"user-{i}" for i in range(10000)]
for percent in (5, 25, 50, 100):
    share = sum(version_for(u, percent) == "v2" for u in users) / len(users)
    print(percent, round(share * 100, 1))

# 5 5.0
# 25 24.5
# 50 49.9
# 100 100.0

La part réelle a suivi de près l’objectif. Cette méthode a deux autres propriétés utiles, et notre exécution a confirmé les deux. Le même utilisateur recevait toujours la même version. Et tous les membres du groupe de 5 % étaient toujours inclus à 25 %, donc personne qui possédait déjà la nouvelle version n’a été relégué au fur et à mesure du déploiement.

Dans les systèmes réels, un maillage de services, un équilibreur de charge ou un outil tel qu’Argo Rollouts ou Flagger gère généralement ce routage, vous n’avez donc pas besoin de l’écrire vous-même. Il est toujours utile de comprendre ce qu’ils font.

Automatiser la décision

Un canari ne fonctionne que si quelqu’un compare réellement les versions. Les contrôles automatisés sont plus fiables qu’une personne qui regarde des graphiques. Voici l’idée de base, en comparant le taux d’erreur de Canary avec celui de la version stable :

def should_rollback(canary_errors, canary_total, base_errors, base_total,
                    tolerance=1.5, min_requests=500):
    if canary_total < min_requests:
        return False   # not enough data to decide
    return (canary_errors / canary_total) > (base_errors / base_total) * tolerance

should_rollback(3, 100, 10, 5000)        # False: too few requests
should_rollback(30, 1000, 100, 10000)    # True:  3% against 1%
should_rollback(12, 1000, 100, 10000)    # False: 1.2% is within tolerance

Notez le premier cas. Son taux d’erreur semble élevé, mais avec seulement 100 requêtes, ce n’est pas encore une preuve suffisante. Les vrais outils appliquent des statistiques plus précises et examinent plusieurs signaux ensemble :

Le problème de la base de données

Le code de l’application peut être échangé en quelques secondes, mais pas les données. Les deux stratégies partagent généralement une base de données. Ainsi, lors d’un déploiement et après une restauration, l’ancienne et la nouvelle version doivent toutes deux fonctionner avec le même schéma.

La réponse standard est le modèle d’expansion et de contraction. Supposons que vous souhaitiez renommer name en full_name :

1. Développez : ajoutez la nouvelle colonne. L’ancien code n’est pas affecté.
2. Migrer : publier le code qui écrit dans les deux colonnes et remplit les anciennes lignes.
3. Switch : code de version qui lit la nouvelle colonne.
4. Contrat : une fois que rien n’utilise l’ancienne colonne, supprimez-la dans une version ultérieure.

Cela nécessite plusieurs versions, mais chaque étape peut être annulée en toute sécurité. L’exécution de RENAME COLUMN en une seule fois briserait la version attendue par l’autre nom. Soyez également prudent avec les modifications de schéma de longue durée, car elles peuvent détenir des verrous. Pour en savoir plus, consultez les transactions SQL.

Rolling et autres stratégies

Un déploiement Kubernetes effectue une mise à jour continue par défaut, ce qui convient à de nombreux services. Une mise à jour continue évolue également progressivement, mais sa part est liée au nombre d’instances et elle n’analyse pas par elle-même les résultats ni ne s’arrête sur de mauvaises mesures.

Qu’en est-il des indicateurs de fonctionnalités ?

Le déploiement place le code sur les serveurs et la version met une fonctionnalité à la disposition des utilisateurs. Les indicateurs de fonctionnalité les séparent, en vous permettant d’activer une fonctionnalité pour des utilisateurs choisis sans rien déployer. Ils fonctionnent très bien avec les deux stratégies : déployer avec le drapeau éteint, puis l’activer progressivement. Ils ne remplacent pas ces stratégies, puisqu’un flag ne peut pas vous protéger d’une version qui plante au démarrage. N’oubliez pas de supprimer les anciens indicateurs, car ils s’accumulent sous forme de dette technique.

Comment choisir

Ils peuvent également être combinés. Certaines équipes déploient un environnement vert, puis y déplacent progressivement le trafic, obtenant ainsi un environnement propre et un rayon d’explosion limité. Quel que soit votre choix, automatisez-le via votre pipeline CI/CD, comme l’explique notre guide des actions GitHub.

Erreurs courantes

• Apporter des modifications de schéma avec rupture. La restauration n’aide pas si l’ancien code ne peut pas lire les données.
• N’avoir aucun critère de restauration. Décidez de ce que « mauvais » signifie avant le début de la version, et non pendant un incident.
• Laisser dériver les environnements. Si le vert diffère du bleu, vos tests le prouvent moins. Définissez les deux avec l’infrastructure en tant que code.
• Mesurer uniquement les mesures techniques. Une version peut être sans erreur tout en interrompant le paiement.
• Ne jamais pratiquer le rollback. Répétez-le pour qu’il fonctionne lorsque vous êtes sous pression.
• Oublier les tâches en arrière-plan. Les travailleurs et les tâches planifiées ont également besoin d’un plan lors d’un changement.

Pour conclure

Le bleu-vert vous offre un changement propre et rapide. Canary vous offre une petite exposition mesurée. Si votre surveillance est encore basique, commencez par des mises à jour progressives ou bleu-vert, et investissez dans des métriques par version avant d’essayer Canaries. Répétez ensuite une restauration sur votre prochaine version, y compris la base de données. Ce seul exercice tend à révéler ce qui doit réellement être corrigé.

Questions fréquentes

Continuez à apprendre