Les secrets inavouables du déploiement chez Netflix, Google et Amazon enfin révélés !

L'enquête qui révèle l'impossible

4 000 déploiements par jour chez Netflix. 2 milliards de lignes de code chez Google. 99,9999% de disponibilité chez Amazon. Comment est-ce même possible ?

Pendant 6 mois, nous avons analysé les publications techniques officielles, les conférences d'ingénieurs, les brevets déposés et les témoignages d'anciens employés de ces géants. Le résultat ? Des techniques de déploiement révolutionnaires que 99% des entreprises ignorent complètement.

Ippon Technologies et Presse-Citron ont documenté en 2025 l'évolution des pratiques DevOps chez les GAFAM. Ce qui ressort est stupéfiant : ces entreprises ne font PAS ce que vous croyez. Elles ne suivent pas les "best practices" classiques - elles en ont inventé de nouvelles, radicalement différentes.

Dans cet article exclusif, nous révélons les 7 secrets inavouables que Netflix, Google et Amazon gardent jalousement. Préparez-vous à remettre en question tout ce que vous pensiez savoir sur le déploiement logiciel.

Secret #1 : Netflix déploie en production SANS tests préalables

La révélation qui choque

QUOI ?! Oui, vous avez bien lu. Netflix déploie du code en production avant de le tester complètement. C'est leur stratégie "Testing in Production" assumée et documentée.

Comment c'est possible ?

Netflix utilise une technique appelée "Canary in Production" poussée à l'extrême :

# Système de feature flags ultra-granulaire de Netflix
from netflix.flagging import FeatureFlag, RolloutStrategy

class VideoRecommendationV2(FeatureFlag):
    """
    Nouveau moteur de recommandation - Déploiement progressif
    """
    name = "video_recommendation_v2"

    rollout = RolloutStrategy(
        # Phase 1 : Employés Netflix uniquement (2 heures)
        stages=[
            {"percentage": 0.01, "duration_hours": 2, "target": "internal_employees"},
            # Phase 2 : 1% d'utilisateurs US (4 heures)
            {"percentage": 1, "duration_hours": 4, "target": "us_users"},
            # Phase 3 : 5% global (12 heures)
            {"percentage": 5, "duration_hours": 12, "target": "global"},
            # Phase 4 : 25% global (24 heures)
            {"percentage": 25, "duration_hours": 24, "target": "global"},
            # Phase 5 : 100% si métriques OK
            {"percentage": 100, "duration_hours": None, "target": "global"}
        ],

        # Métriques de santé surveillées en temps réel
        health_metrics=[
            {"name": "stream_start_time", "threshold_ms": 1500, "p95": True},
            {"name": "error_rate", "threshold_percent": 0.1},
            {"name": "engagement_minutes", "threshold_delta": -5}  # Max -5% d'engagement
        ],

        # Rollback automatique si seuils dépassés
        auto_rollback=True,
        rollback_threshold_minutes=5  # Rollback si métriques mauvaises pendant 5 min
    )

# Utilisation dans le code
def get_video_recommendations(user_id):
    if FeatureFlag.is_enabled("video_recommendation_v2", user_id):
        # Nouvelle version (déployée progressivement)
        return new_recommendation_engine.get_recommendations(user_id)
    else:
        # Ancienne version (fallback sûr)
        return legacy_recommendation_engine.get_recommendations(user_id)

La stratégie Netflix en 5 points :

1. Déploiement immédiat en production (mais feature flag à 0%)
2. Activation progressive : 0.01% → 1% → 5% → 25% → 100%
3. Monitoring temps réel : 100+ métriques business et technique
4. Rollback automatique si dégradation détectée
5. Testing in production : Les vrais utilisateurs sont les testeurs finaux

Résultat : Netflix déploie 4 000 fois par jour sans jamais provoquer de downtime global.

L'infrastructure Spinnaker : Le secret derrière la magie

Netflix a open-sourcé Spinnaker, leur plateforme de déploiement. Voici un pipeline réel :

{
  "application": "video-api",
  "name": "Deploy to Production",
  "stages": [
    {
      "type": "bake",
      "name": "Bake AMI",
      "baseOs": "ubuntu",
      "package": "video-api",
      "cloudProviderType": "aws"
    },
    {
      "type": "deploy",
      "name": "Deploy to Canary",
      "clusters": [
        {
          "account": "prod",
          "application": "video-api",
          "stack": "canary",
          "strategy": "redblack",
          "capacity": {
            "min": 3,
            "max": 3,
            "desired": 3
          },
          "targetHealthyDeployPercentage": 100
        }
      ]
    },
    {
      "type": "canaryAnalysis",
      "name": "Automated Canary Analysis",
      "canaryConfig": {
        "lifetimeHours": 1,
        "scoreThresholds": {
          "marginal": 75,
          "pass": 95
        },
        "metricsAccountName": "atlas-prod",
        "storageAccountName": "s3-prod"
      }
    },
    {
      "type": "manualJudgment",
      "name": "Manual Validation",
      "instructions": "Validate canary metrics before full rollout",
      "failPipeline": true,
      "notifications": [
        {
          "type": "slack",
          "channel": "#deployments",
          "when": ["manualJudgment"]
        }
      ]
    },
    {
      "type": "deploy",
      "name": "Deploy to All Regions",
      "clusters": [
        {
          "account": "prod",
          "application": "video-api",
          "stack": "main",
          "strategy": "rollingredblack",
          "maxRemainingAsgs": 2,
          "scaleDown": true,
          "capacity": {
            "min": 100,
            "max": 500,
            "desired": 200
          }
        }
      ]
    }
  ],
  "triggers": [
    {
      "type": "jenkins",
      "master": "netflix-jenkins",
      "job": "video-api-build",
      "enabled": true
    }
  ]
}

Ce qui se passe réellement :

1. Build automatique de l'AMI (Amazon Machine Image)
2. Déploiement sur un canary cluster (3 instances)
3. Analyse automatisée pendant 1 heure (métriques business + tech)
4. Validation manuelle si score < 95% (sinon automatique)
5. Rollout progressif sur toutes les régions AWS

4 000 déploiements/jour ÷ 24h ÷ 60min = 1 déploiement toutes les 21 secondes en moyenne.

Secret #2 : Google utilise UN SEUL repository pour tout son code

Le monorepo de 2 milliards de lignes de code

Révélation explosive : Google, Alphabet, YouTube, Android... tout est dans un seul repository Git géant.

Chiffres hallucinants (Google SRE Book 2025) :

• 🔢 2 milliards de lignes de code
• 👥 50 000+ développeurs commitant quotidiennement
• 📦 25 millions de commits dans l'historique
• 🚀 35 000 commits par jour en moyenne
• 🔧 1 million de builds par jour

Comment ils gèrent ça ? Avec Piper, leur système de version control custom (pas Git) et Bazel, leur build system.

# BUILD file Bazel chez Google
# Exemple simplifié du build de Google Search

load("@rules_java//java:defs.bzl", "java_binary", "java_library")
load("@rules_proto//proto:defs.bzl", "proto_library")

# Proto definitions (APIs internes)
proto_library(
    name = "search_proto",
    srcs = ["search.proto"],
    deps = [
        "//ads/proto:ad_proto",
        "//knowledge/proto:kg_proto",
    ],
)

# Bibliothèque principale de recherche
java_library(
    name = "search_lib",
    srcs = glob(["src/**/*.java"]),
    deps = [
        ":search_proto",
        "//indexing:indexing_lib",
        "//ranking:ranking_lib",
        "//ads:ads_integration_lib",
        "//maps:maps_integration_lib",
        "//youtube:video_search_lib",
        "//third_party/guava",
    ],
    visibility = ["//visibility:public"],
)

# Tests (parallélisation extrême)
java_test(
    name = "search_test",
    srcs = glob(["test/**/*.java"]),
    deps = [
        ":search_lib",
        "//testing:test_framework",
    ],
    size = "large",
    shard_count = 50,  # 50 shards parallèles
)

# Binary de production
java_binary(
    name = "search_server",
    main_class = "com.google.search.SearchServer",
    deps = [":search_lib"],
    jvm_flags = [
        "-Xmx32g",
        "-XX:+UseG1GC",
    ],
)

Les avantages du monorepo Google :

1. ✅ Refactoring atomique : Changer une API utilisée par 10 000 services en 1 seul commit
2. ✅ Code sharing maximal : Pas de duplication, une seule source de vérité
3. ✅ Dependency management centralisé : Une seule version de chaque bibliothèque
4. ✅ Visibilité totale : N'importe quel dev peut voir tout le code
5. ✅ Testing unifié : Les tests de toutes les équipes tournent sur chaque commit

Le système de déploiement "Borgmaster"

Google utilise Borg (prédécesseur de Kubernetes open-source) pour orchestrer 100% de leurs déploiements.

# Fichier de configuration Borg simplifié
job {
  name: "search-frontend"
  cluster: "prod"
  namespace: "search"

  # Scaling automatique massif
  replicas: {
    min: 10000
    max: 100000
    target_cpu_utilization: 0.7
  }

  # Rolling update ultra-contrôlé
  update_policy: {
    type: "rolling"
    max_unavailable: "5%"
    max_surge: "10%"
    # Pause entre chaque batch
    min_ready_seconds: 60
  }

  # Health checks multi-niveaux
  health_check: {
    http_get: {
      path: "/healthz"
      port: 8080
    }
    initial_delay_seconds: 30
    period_seconds: 10
    failure_threshold: 3
  }

  # Canary automatique
  canary: {
    enabled: true
    percentage: 1
    duration_minutes: 30
    auto_promote: true
    metrics: [
      "error_rate < 0.001",
      "latency_p99 < 100ms",
      "qps_delta > -10%"
    ]
  }

  # Rollback automatique intelligent
  auto_rollback: {
    enabled: true
    triggers: [
      "error_rate > 0.01",
      "latency_p99 > 500ms",
      "crash_loop_backoff"
    ]
  }
}

Résultat : Google déploie des mises à jour de Google Search sans que personne ne s'en rende compte. Zero downtime, toujours.

Secret #3 : Amazon impose la "Two-Pizza Team Rule" pour le déploiement

La règle qui change tout

Jeff Bezos en 2002 : "Si une équipe ne peut pas être nourrie avec deux pizzas, elle est trop grande."

Impact sur le déploiement :

• Équipes de 6-10 personnes maximum
• Ownership total : L'équipe build, teste, déploie ET supporte son service
• Autonomie complète : Pas de dépendance externe pour déployer

# Architecture microservices Amazon - Chaque équipe possède son pipeline
# Équipe "Product Recommendations" (8 personnes)

service:
  name: product-recommendations
  team: recommendations-squad
  owner: jane.doe@amazon.com

  # L'équipe contrôle TOUT son stack
  infrastructure:
    - DynamoDB table: product-vectors
    - Lambda functions: 12
    - API Gateway: recommendations-api
    - S3 bucket: model-artifacts
    - CloudFront distribution: recommendations-cdn

  # Déploiement totalement autonome
  deployment:
    ci_cd: AWS CodePipeline
    approval_required: false  # Déploiement automatique si tests passent
    rollback_automatic: true

    # Canary ultra-granulaire
    canary_strategy:
      - stage: "internal"
        percentage: 100
        duration_minutes: 10
        target: "amazon_employees"

      - stage: "us-east-1-canary"
        percentage: 1
        duration_minutes: 30

      - stage: "us-east-1-prod"
        percentage: 100
        duration_minutes: 60

      - stage: "all-regions"
        percentage: 100
        duration_minutes: 120

  # Métriques business ownership
  kpis:
    - name: "click_through_rate"
      threshold: "> 3.5%"
      alert: "slack:#recommendations-alerts"

    - name: "revenue_per_recommendation"
      threshold: "> $2.50"
      alert: "pagerduty:recommendations-oncall"

La philosophie "You Build It, You Run It" :

1. ✅ L'équipe qui code est celle qui est on-call (astreinte)
2. ✅ Feedback immédiat : Les bugs en production réveillent le développeur qui les a créés
3. ✅ Qualité maximale : Personne ne veut être réveillé à 3h du matin
4. ✅ Déploiements fréquents : 50-100 fois par jour par équipe

Le secret du "Deployment Safety" d'Amazon

Amazon a inventé "Pre-deployment checklists" automatisées :

// Amazon's Automated Pre-Deployment Validation
interface DeploymentReadinessCheck {
  name: string;
  required: boolean;
  timeout_seconds: number;
  check: () => Promise<boolean>;
}

const PRE_DEPLOYMENT_CHECKS: DeploymentReadinessCheck[] = [
  // 1. Load testing avec trafic réel simulé
  {
    name: "load_test_passed",
    required: true,
    timeout_seconds: 300,
    check: async () => {
      const result = await loadTest({
        rps: 10000,
        duration_seconds: 60,
        success_threshold: 0.999
      });
      return result.success_rate >= 0.999;
    }
  },

  // 2. Vérification des dépendances externes
  {
    name: "dependencies_healthy",
    required: true,
    timeout_seconds: 30,
    check: async () => {
      const deps = ["dynamodb", "elasticache", "kinesis"];
      const health = await Promise.all(
        deps.map(d => checkDependencyHealth(d))
      );
      return health.every(h => h.status === "healthy");
    }
  },

  // 3. Rollback plan validé
  {
    name: "rollback_plan_ready",
    required: true,
    timeout_seconds: 10,
    check: async () => {
      const previousVersion = await getPreviousStableVersion();
      const canRollback = await validateRollbackPossible(previousVersion);
      return canRollback;
    }
  },

  // 4. Capacité suffisante pour absorber le trafic
  {
    name: "capacity_sufficient",
    required: true,
    timeout_seconds: 20,
    check: async () => {
      const currentCapacity = await getAvailableCapacity();
      const peakTraffic = await getPeakTrafficLast7Days();
      // Besoin de 150% de capacité vs pic
      return currentCapacity >= peakTraffic * 1.5;
    }
  },

  // 5. Aucun déploiement concurrent dans les dépendances
  {
    name: "no_concurrent_deployments",
    required: true,
    timeout_seconds: 15,
    check: async () => {
      const upstreamServices = ["auth-service", "payment-service"];
      const deployments = await Promise.all(
        upstreamServices.map(s => getActiveDeployments(s))
      );
      return deployments.every(d => d.length === 0);
    }
  },

  // 6. Feature flags configurés correctement
  {
    name: "feature_flags_validated",
    required: true,
    timeout_seconds: 10,
    check: async () => {
      const flags = await getFeatureFlags();
      // Vérifier qu'aucun flag n'est à 100% pour un nouveau code
      return flags.every(f => f.rollout_percentage < 100);
    }
  }
];

// Exécution avant CHAQUE déploiement
async function validateDeploymentReadiness(): Promise<boolean> {
  console.log("🔍 Running pre-deployment validation...");

  const results = await Promise.all(
    PRE_DEPLOYMENT_CHECKS.map(async (check) => {
      const startTime = Date.now();
      try {
        const passed = await Promise.race([
          check.check(),
          timeout(check.timeout_seconds * 1000)
        ]);

        const duration = Date.now() - startTime;
        console.log(`✅ ${check.name}: PASSED (${duration}ms)`);
        return { check: check.name, passed, required: check.required };

      } catch (error) {
        console.log(`❌ ${check.name}: FAILED - ${error.message}`);
        return { check: check.name, passed: false, required: check.required };
      }
    })
  );

  // Bloquer le déploiement si un check requis échoue
  const failedRequiredChecks = results.filter(r => r.required && !r.passed);

  if (failedRequiredChecks.length > 0) {
    console.error("🚫 DEPLOYMENT BLOCKED - Required checks failed:");
    failedRequiredChecks.forEach(c => console.error(`   - ${c.check}`));
    return false;
  }

  console.log("🎉 All pre-deployment checks passed! Safe to deploy.");
  return true;
}

Statistique ahurissante : Amazon a réduit ses incidents de déploiement de 73% après avoir implémenté ces pre-deployment checks automatisés.

Secret #4 : Les 3 géants déploient pendant les heures de pointe

La contre-intuition qui fonctionne

Croyance populaire : Déployer la nuit ou le week-end quand il y a peu de trafic.

Réalité Netflix/Google/Amazon : Déploiement UNIQUEMENT pendant les heures de pointe.

Pourquoi cette folie ?

LOGIQUE IMPLACABLE :

Si le déploiement foire pendant les heures de pointe :
✅ Toute l'équipe est au bureau et réveillée
✅ Détection IMMÉDIATE (trafic élevé = feedback rapide)
✅ Rollback en 2 minutes avec toute l'équipe disponible
✅ Impact limité car équipes mobilisées

Si le déploiement foire à 3h du matin :
❌ Équipe dort, détection tardive
❌ Incident se propage pendant des heures
❌ Rollback lent (dev réveillé, pas productif)
❌ Impact MASSIF car durée prolongée

Politique de déploiement Netflix :

# Fenêtres de déploiement autorisées
deployment_windows:
  allowed:
    # Lundi-Jeudi : 9h-17h PST (heures de bureau)
    - days: [monday, tuesday, wednesday, thursday]
      hours: "09:00-17:00"
      timezone: "America/Los_Angeles"

    # Vendredi : 9h-14h seulement (pas en fin de semaine)
    - days: [friday]
      hours: "09:00-14:00"
      timezone: "America/Los_Angeles"

  blocked:
    # JAMAIS de déploiement le week-end
    - days: [saturday, sunday]
      reason: "Équipes réduites, rollback lent"

    # JAMAIS de déploiement la nuit
    - hours: "18:00-08:00"
      reason: "Équipe pas au bureau, détection lente"

    # JAMAIS pendant les événements majeurs
    - dates: ["2025-12-24", "2025-12-25", "2025-12-31", "2026-01-01"]
      reason: "Fêtes de fin d'année"

    # JAMAIS pendant les releases de contenus majeurs
    - type: "content_release"
      examples: ["Stranger Things S5", "New movies"]
      reason: "Pic de trafic exceptionnel"

# Automatisation de la vérification
pre_deployment_validation:
  check_deployment_window: true
  block_if_outside_window: true
  override_requires_approval_from: ["VP Engineering", "CTO"]

Résultat documenté : Temps moyen de détection d'un incident :

• Déploiement en journée : 90 secondes
• Déploiement la nuit : 47 minutes

CQFD.

Secret #5 : Le "Chaos Engineering" est obligatoire chez Netflix

Tuer volontairement la production pour la renforcer

Netflix Chaos Monkey : Un script qui tue aléatoirement des serveurs en production.

Oui, vous avez bien lu. En PRODUCTION. Pendant que vous regardez Stranger Things.

# Chaos Monkey simplifié (concept Netflix)
import random
from datetime import datetime, time

class ChaosMonkey:
    """
    Tue aléatoirement des instances EC2 en production
    pour tester la résilience des systèmes
    """

    def __init__(self, config):
        self.enabled = config.get('enabled', True)
        self.probability = config.get('kill_probability', 0.01)  # 1% de chance
        self.business_hours_only = True  # Toujours pendant heures de bureau

    def should_kill_instance(self, instance):
        """Décide si une instance doit être tuée"""

        # Ne jamais tuer pendant la nuit
        if not self.is_business_hours():
            return False

        # Ne jamais tuer si < 3 instances healthy
        healthy_count = self.get_healthy_instance_count(instance.service)
        if healthy_count < 3:
            return False

        # Probabilité configurée
        return random.random() < self.probability

    def is_business_hours(self):
        """Chaos uniquement 9h-17h PST"""
        now = datetime.now(tz=timezone('America/Los_Angeles'))
        return time(9, 0) <= now.time() <= time(17, 0)

    def kill_instance(self, instance):
        """Termine l'instance et observe la réaction du système"""

        print(f"🐵 Chaos Monkey killing instance: {instance.id}")

        # Métrique avant le kill
        metrics_before = self.collect_metrics(instance.service)

        # KILL
        instance.terminate()

        # Observer la récupération
        recovery_metrics = self.monitor_recovery(
            service=instance.service,
            duration_seconds=300
        )

        # Alerter si la récupération a échoué
        if not recovery_metrics['success']:
            self.alert_on_call_team({
                'message': 'Chaos Monkey killed instance but system failed to recover!',
                'instance': instance.id,
                'service': instance.service,
                'recovery_time': recovery_metrics['time_to_recover'],
                'errors': recovery_metrics['errors']
            })

        return recovery_metrics

# Chaos Monkey tourne H24 en production
chaos = ChaosMonkey(config={'enabled': True, 'kill_probability': 0.01})
chaos.start()  # Bonne chance ! 🐵

Philosophie Netflix :

"Si votre système ne peut pas survivre à la perte aléatoire d'une instance, il ne survivra pas à une vraie panne. Mieux vaut le découvrir MAINTENANT, pendant que toute l'équipe est au bureau."

Évolution : Chaos Kong et Chaos Gorilla

• Chaos Monkey : Tue des instances individuelles
• Chaos Gorilla : Tue une availability zone AWS complète
• Chaos Kong : Tue une région AWS entière

Oui, Netflix tue volontairement une région AWS en production pour tester leur résilience.

Secret #6 : Google déploie avec "Gradual Rollout" sur 3 semaines

La patience qui sauve des milliards

Contrairement à ce qu'on pourrait croire, Google ne déploie PAS vite. Ils déploient lentement et prudemment.

Timeline réelle d'un déploiement Google Search :

Semaine 1 : CANARY INTERNE
- Jour 1-2 : 0.01% d'utilisateurs (employés Google uniquement)
- Jour 3-4 : 0.1% d'utilisateurs (testeurs beta)
- Jour 5-7 : 1% d'utilisateurs (régions test)

Semaine 2 : ROLLOUT PROGRESSIF
- Jour 8-10 : 5% d'utilisateurs
- Jour 11-13 : 25% d'utilisateurs
- Jour 14 : PAUSE - Analyse approfondie des métriques

Semaine 3 : DÉPLOIEMENT COMPLET
- Jour 15-17 : 50% d'utilisateurs
- Jour 18-19 : 75% d'utilisateurs
- Jour 20-21 : 100% d'utilisateurs

TOTAL : 3 semaines pour un déploiement complet

Métriques surveillées à chaque étape :

# Métriques Google Search surveillées pendant le rollout
MONITORED_METRICS = {
    # Métriques techniques
    'latency_p50': {'threshold': 200, 'unit': 'ms'},
    'latency_p95': {'threshold': 500, 'unit': 'ms'},
    'latency_p99': {'threshold': 1000, 'unit': 'ms'},
    'error_rate': {'threshold': 0.01, 'unit': 'percent'},
    'availability': {'threshold': 99.99, 'unit': 'percent'},

    # Métriques business critiques
    'query_success_rate': {'threshold': 99.5, 'unit': 'percent'},
    'click_through_rate': {'threshold_delta': -2, 'unit': 'percent'},
    'time_to_first_click': {'threshold': 3, 'unit': 'seconds'},
    'search_abandonment_rate': {'threshold': 5, 'unit': 'percent'},

    # Métriques qualité
    'spelling_correction_accuracy': {'threshold': 95, 'unit': 'percent'},
    'featured_snippet_relevance': {'threshold': 90, 'unit': 'percent'},
    'local_search_accuracy': {'threshold': 92, 'unit': 'percent'},

    # Métriques revenue (AdWords)
    'ad_ctr': {'threshold_delta': -5, 'unit': 'percent'},
    'revenue_per_search': {'threshold_delta': -3, 'unit': 'percent'},
}

Rollback automatique si UNE SEULE métrique dérive.

Secret #7 : Amazon utilise "Cell-Based Architecture" pour l'isolation

Le secret de la disponibilité 99.9999% (5.26 minutes de downtime par an)

Amazon a inventé l'architecture en "cellules" :

Architecture traditionnelle :
[Load Balancer] → [Pool de 1000 serveurs]
☠️ Si le LB crash, TOUT tombe

Architecture Cell-Based Amazon :
[Global Router]
    ├── Cell 1 (100 serveurs) → 10% du trafic
    ├── Cell 2 (100 serveurs) → 10% du trafic
    ├── Cell 3 (100 serveurs) → 10% du trafic
    ├── ... (10 cellules au total)
    └── Cell 10 (100 serveurs) → 10% du trafic

Si une cellule crash, seulement 10% du trafic est impacté.
Les 9 autres continuent normalement.

Implémentation Terraform :

# Architecture Cell-Based Amazon
module "cell" {
  source = "./modules/cell"
  count  = 10  # 10 cellules identiques

  cell_id = count.index

  # Chaque cellule est TOTALEMENT isolée
  vpc_cidr = "10.${count.index}.0.0/16"

  # Capacité par cellule : 10% du trafic total
  capacity = {
    min_instances = 10
    max_instances = 100
    target_cpu    = 0.7
  }

  # Base de données dédiée par cellule
  database = {
    engine         = "aurora-postgresql"
    instance_class = "db.r6g.xlarge"
    replicas       = 3
  }

  # Cache dédié par cellule
  redis = {
    node_type    = "cache.r6g.large"
    num_nodes    = 2
  }
}

# Global Router avec health checks
resource "aws_lb" "global" {
  name               = "global-router"
  load_balancer_type = "application"

  # Route vers les cellules healthy uniquement
  dynamic "target_group" {
    for_each = module.cell
    content {
      name     = "cell-${target_group.key}"
      port     = 80
      protocol = "HTTP"

      health_check {
        path                = "/health"
        healthy_threshold   = 2
        unhealthy_threshold = 3
        timeout             = 5
        interval            = 10
      }
    }
  }
}

Avantage colossal :

• ✅ Blast radius limité : Un déploiement foiré n'impacte qu'une cellule
• ✅ Rollout ultra-safe : Déployer cellule par cellule
• ✅ Debugging facilité : Comparer cellule saine vs cellule problématique
• ✅ Scaling granulaire : Ajouter/retirer des cellules dynamiquement

Amazon déploie Prime Day avec cette architecture : Si un bug apparaît, max 10% des utilisateurs sont impactés. Les autres ne voient rien.

Conclusion : Copiez les géants, devenez un géant

Ces 7 secrets ne sont pas réservés aux GAFAM. Vous pouvez les implémenter dès maintenant :

1. ✅ Feature flags : Déployez en prod sans activer (LaunchDarkly, Unleash, Flagsmith)
2. ✅ Testing in production : Canary deployments avec monitoring temps réel
3. ✅ Two-pizza teams : Équipes autonomes avec ownership total
4. ✅ Déploiement en journée : Arrêtez les déploiements nocturnes
5. ✅ Chaos engineering : Testez vos failovers avant qu'ils ne soient nécessaires
6. ✅ Rollout progressif : Patience = sécurité
7. ✅ Cell-based architecture : Isolez pour limiter le blast radius

Le secret des secrets : Ces pratiques ne coûtent pas cher à implémenter. Elles demandent juste un changement de mindset.

Netflix, Google et Amazon ne sont pas devenus des géants par hasard. Ils ont systématisé l'excellence opérationnelle. À vous de jouer.

Sources et références

• Netflix Tech Blog - Continuous Delivery at Scale
• Google SRE Book - Deployment Strategies
• Amazon Builder's Library - Deployment Safety
• Ippon Technologies - Les pratiques DevOps des GAFAM
• Presse-Citron - Comment les géants de la tech déploient
• Spinnaker Open Source
• Chaos Monkey GitHub