LaunchDarkly : qu'est-ce que c'est, les feature flags et comment ils fonctionnent

Qu'est-ce que LaunchDarkly ?

LaunchDarkly est une plateforme de gestion de feature flags fondée en 2014 par Catamorphic Corp. L'objectif principal du service est de donner aux équipes de développement la capacité d'activer, de désactiver et de configurer les fonctionnalités de l'application en temps réel sans déployer de nouveau code.

Contrairement à l'approche traditionnelle où le lancement d'une nouvelle fonctionnalité nécessite la publication d'une version dans l'app store, LaunchDarkly permet de modifier le comportement à distance. Pour le développement mobile, c'est particulièrement important : la révision dans l'App Store et Google Play prend de plusieurs heures à une journée, alors qu'un flag peut être basculé en quelques secondes.

Comment fonctionne la plateforme LaunchDarkly

L'architecture de LaunchDarkly repose sur trois composants : le serveur de flags, les SDK clients et le tableau de bord. Le serveur stocke les configurations des flags, les règles de ciblage et les segments d'utilisateurs. Le SDK maintient une connexion SSE persistante avec le serveur pour recevoir les mises à jour en temps réel.

Lorsqu'un flag est modifié dans le tableau de bord, le serveur envoie une mise à jour à tous les SDK connectés. La latence est de 200 à 500 millisecondes. En cas de perte de connexion, le SDK utilise le dernier état mis en cache jusqu'à ce que le canal soit restauré. Cela garantit que l'application continue de fonctionner avec les paramètres les plus récents disponibles au moment de la déconnexion.

Le tableau de bord de LaunchDarkly fournit une interface visuelle pour créer et gérer les flags. Le tableau de bord affiche l'état actuel de chaque flag, l'historique des modifications avec l'audit de qui a modifié la configuration et quand, ainsi que les métriques d'utilisation. Des règles séparées peuvent être configurées pour chaque environnement : un flag peut être activé à 100 % en staging et à 5 % en production.

Concepts clés de LaunchDarkly

Feature flag est un interrupteur nommé avec des règles et des cibles. Les flags peuvent être booléens, multivariés et JSON. Les règles définissent les conditions d'activation : par exemple, « activer pour 10 % des utilisateurs Android 12 d'Allemagne ». Les segments regroupent les utilisateurs par version d'OS, région, modèle d'appareil et attributs personnalisés.

Chaque flag a des environnements : développement, staging et production. Cela permet de tester une nouvelle fonctionnalité dans un environnement isolé avant de l'activer pour les utilisateurs réels. Les règles d'environnement sont configurées indépendamment : un flag peut être activé en staging et désactivé en production.

SDK et intégration avec les applications mobiles

LaunchDarkly fournit des SDK natifs pour Android, iOS, React Native et Flutter. Chaque SDK nécessite une configuration minimale : une clé SDK et un identifiant utilisateur. La bibliothèque gère automatiquement les connexions, la mise en cache et la gestion des erreurs.

Initialisation du SDK Android

Pour se connecter, créez une instance LDClient dans Application.onCreate. Le client accepte une configuration avec une clé mobile et le contexte utilisateur. Après initialisation, l'application appelle une variation de flag à n'importe quel endroit du code via la méthode boolVariation.

class MyApplication : Application() {
    private lateinit var ldClient: LDClient

    override fun onCreate() {
        super.onCreate()
        val config = LDConfig.Builder("mobile-key-abc123")
            .build()
        val user = LDUser.Builder("user-unique-id")
            .build()
        ldClient = LDClient.init(this, config, user)
    }
}

Lecture et abonnement aux changements de flags

Après initialisation, la vérification d'un flag se fait avec une seule méthode. BoolVariation renvoie la valeur selon les règles du flag. La valeur par défaut est utilisée si le SDK n'a pas pu obtenir la configuration. La méthode boolVariationDetail renvoie en plus la raison pour laquelle le flag a pris cette valeur.

val ldClient = LDClient.get()
val showNewFeature = ldClient.boolVariation(
    "new-checkout-flow",
    false
)
if (showNewFeature) {
    showNewCheckoutScreen()
} else {
    showLegacyCheckoutScreen()
}

Tests A/B et déploiement progressif via LaunchDarkly

Les tests A/B dans LaunchDarkly sont implémentés via des flags multivariés. Chaque variante se voit attribuer un pourcentage de trafic : par exemple, 50 % des utilisateurs voient l'ancien écran (variante A) et 50 % voient le nouveau (variante B). La plateforme fixe l'utilisateur, garantissant qu'il tombe toujours dans le même groupe.

Le déploiement progressif augmente progressivement le pourcentage d'utilisateurs ayant accès à une fonctionnalité. Un calendrier typique : 1 % — premier jour, 5 % — deuxième, 25 % — troisième, 100 % — après une semaine. Si une erreur est détectée, le flag est désactivé instantanément pour tout le monde. LaunchDarkly s'intègre avec Amplitude, Mixpanel et Google Analytics pour suivre les métriques de chaque variation.

Métriques et expériences

La plateforme fournit un système d'expériences intégré qui calcule automatiquement la signification statistique des différences entre les variantes. Métriques disponibles : conversion, rétention, nombre de sessions, erreurs et événements personnalisés. Les résultats sont affichés dans le tableau de bord avec visualisation des intervalles de confiance. Les expériences peuvent être exécutées à la fois sur le trafic de production et sur des segments d'utilisateurs dédiés.

L'intégration de LaunchDarkly avec les plateformes d'analyse est un autre avantage. Les données des flags sont automatiquement envoyées à Amplitude, Mixpanel, Google Analytics ou à un pipeline de données personnalisé via l'API Data Export. Cela permet de créer des rapports sur l'impact de chaque fonctionnalité sur les métriques clés de l'application. LaunchDarkly prend également en charge les webhooks pour notifier les systèmes externes des changements d'état des flags.

Exemple d'intégration du SDK LaunchDarkly dans Android

Parcourons le cycle complet : ajout de la dépendance, initialisation et vérification d'un flag pour la télémétrie des crashs. La fonctionnalité doit être active uniquement pour les testeurs, pas pour les utilisateurs réels. Le SDK LaunchDarkly pour Android est disponible via Maven Central. La version 5.x prend en charge Kotlin Coroutines et Jetpack Compose pour la réception réactive des mises à jour de flags.

Pour les applications iOS, LaunchDarkly prend en charge Swift Package Manager et CocoaPods. Le SDK Swift utilise async/await pour l'initialisation asynchrone et le framework Combine pour l'abonnement aux changements. Les deux SDK (Android et iOS) prennent en charge la synchronisation en arrière-plan et la mise en cache dans le stockage local pour le fonctionnement hors ligne.

Dépendance dans build.gradle

// app/build.gradle
dependencies {
    implementation "com.launchdarkly:launchdarkly-android-sdk:5.2.0"
}

Vérification du flag dans CrashReporter

Dans la classe CrashReporter, nous vérifions le flag crash-reporting-enabled. Si le flag est activé pour l'utilisateur actuel, nous commençons à envoyer les rapports de crash. Le SDK recevra automatiquement le nouvel état lorsqu'il changera sur le serveur, mais une seule vérification suffit pour l'initialisation.

class CrashReporter {
    fun init() {
        val client = LDClient.get()
        if (client.boolVariation("crash-reporting-enabled", false)) {
            Crashlytics.start()
        }
    }
}

Scénarios courants et anti-patrons

Scénarios réussis : gestion du flux de paiement avec désactivation instantanée en cas de défaillance du fournisseur, déploiement progressif des modifications d'interface utilisateur avec surveillance des métriques, personnalisation du contenu par segments. Selon le blog officiel de LaunchDarkly, les équipes réduisent le temps de récupération après erreur de plusieurs heures à quelques minutes.

Anti-patrons : utiliser des flags pour une logique conditionnelle permanente (les flags sont temporaires), stocker des secrets dans les attributs des flags, créer des règles qui se chevauchent. Recommandation : supprimez le flag du code après la fin du déploiement — cela évite la dette technique et la complexité de la base de code. Une autre erreur courante est d'utiliser des flags comme interrupteurs à longue durée de vie qui ne sont jamais supprimés du code après la stabilisation de la fonctionnalité.

Une stratégie de gestion des flags appropriée inclut un plan de suppression pour chaque nouveau flag. LaunchDarkly fournit des outils intégrés pour détecter les flags inutilisés : un flag est considéré comme inutilisé si le SDK n'a pas vérifié sa valeur depuis plus de 30 jours. Ces flags sont marqués dans le tableau de bord et peuvent être supprimés du code en toute sécurité.

Quand éviter LaunchDarkly

Pour les petits projets avec une seule équipe, LaunchDarkly peut être excessif — un simple conditionnel dans le code ou Firebase Remote Config suffit. Choisissez la plateforme lorsque vous avez besoin de segmentation complexe, d'audit des modifications, d'expériences A/B ou de gestion multi-équipe des flags. Pour les startups et les projets MVP, LaunchDarkly propose un plan Starter gratuit avec des limites sur le nombre de flags et de MAU.

La compatibilité de LaunchDarkly avec les outils existants est un critère de sélection important. La plateforme s'intègre avec Jira, Slack, PagerDuty, Datadog et d'autres services via des webhooks et des API. Les équipes qui utilisent déjà ces outils bénéficient d'une intégration transparente sans infrastructure supplémentaire pour la surveillance et les alertes en cas de changement d'état des flags. LaunchDarkly prend également en charge un fournisseur Terraform pour la gestion des flags en tant que code (Flags as Code) — cela permet de stocker la configuration des flags dans Git et de passer par une revue de code avant application.