Channels für Feature Flags und A/B-Tests nutzen

Das Channel-System von Capgo bietet eine flexible Möglichkeit, Nutzer zu segmentieren und den Zugriff auf Features zu steuern. Da Capgo kein integriertes Plan-Management oder A/B-Testing bietet, kannst du diese Funktionen umsetzen, indem du die Channel-Zuweisungen selbst verwaltest.

Channels verstehen

Mit Channels in Capgo kannst du:

• Gezielte Ansprache von Nutzergruppen mit unterschiedlichen Features
• A/B-Tests durch Zuweisung verschiedener Channels durchführen
• Features schrittweise ausrollen
• Beta-Testprogramme erstellen

Methoden zur Channel-Zuweisung

1. Backend-Zuweisung (Empfohlen)

Dies ist die sicherere Methode. Sie umfasst:

1. Die Device ID vom Updater abrufen
2. Diese an dein Backend senden
3. Dein Backend nutzt die Capgo API, um das Device zuzuweisen

So implementierst du es:

import { CapacitorUpdater } from '@capgo/capacitor-updater'

// Get device ID
const getDeviceId = async () => {
  const { deviceId } = await CapacitorUpdater.getDeviceId()
  return deviceId
}

// Send device ID to your backend
const assignToChannel = async (channel: string) => {
  const deviceId = await getDeviceId()
  // Your backend will call Capgo API to assign the device
  await yourBackend.assignDeviceToChannel(deviceId, channel)
}

Backend-Implementierung

Dein Backend muss:

1. Einen API Key im Capgo Dashboard abrufen
2. Die Capgo API aufrufen, um das Device einem Channel zuzuweisen

So erhältst du deinen API Key:

1. Logge dich in dein Capgo Dashboard ein
2. Gehe zu Settings > API Keys
3. Klicke auf „Generate New Key“
4. Wähle all Modus zur Verwaltung von Devices und Channels
5. Kopiere den generierten Key und speichere ihn sicher in deinen Backend-Umgebungsvariablen
   • Der Key ist ein 32-stelliger Hexadezimal-String
   • Es ist ein Secret Key, der niemals im clientseitigen code exponiert werden darf

Hier ist ein Node.js-Beispiel:

import axios from 'axios'

const CAPGO_API_KEY = 'your_api_key'
const CAPGO_API_URL = 'https://api.capgo.app'

async function assignDeviceToChannel(deviceId: string, channel: string) {
  try {
    const response = await axios.post(
      `${CAPGO_API_URL}/device`,
      {
        app_id: 'YOUR_APP_ID',
        device_id: deviceId,
        channel: channel
      },
      {
        headers: {
          'authorization': CAPGO_API_KEY,
          'Content-Type': 'application/json'
        }
      }
    )
    return response.data
  } catch (error) {
    console.error('Failed to assign device to channel:', error)
    throw error
  }
}

Das Backend sollte zudem:

• Die Berechtigungen des Nutzers validieren
• Alle Channel-Zuweisungen loggen
• Rate Limiting handhaben
• Retry-Logik für fehlgeschlagene Zuweisungen implementieren

2. Self-Assignment (weniger sicher)

Mit dieser Methode können sich Geräte direkt einem Channel zuweisen. Das ist nützlich zum Testen, aber weniger sicher für die Produktion:

import { CapacitorUpdater } from '@capgo/capacitor-updater'

// Assign device to channel
const assignToChannel = async (channel: string) => {
  await CapacitorUpdater.setChannel(channel)
}

// Get current channel
const getCurrentChannel = async () => {
  const { channel } = await CapacitorUpdater.getChannel()
  return channel
}

Bevor Nutzer sich selbst einem Channel zuweisen können, musst du diese Funktion im Capgo Dashboard aktivieren:

1. Gehe zum Bereich Channels in deinem Capgo Dashboard
2. Klicke auf den Namen des Kanals, den du verwalten möchtest
3. Aktiviere in den Channel-Einstellungen „Allow devices to self associate“
4. Änderungen speichern

Wenn diese Einstellung false ist, schlägt jeder Versuch, setChannel mit diesem Channel aufzurufen, fehl.

Feature Flags implementieren

Nutze Channels, um den Feature-Zugriff zu steuern:

const isFeatureEnabled = async (feature: string) => {
  // Example: Check if user is in beta channel
  const channel = await getCurrentChannel()
  return channel === 'beta'
}

A/B-Testing implementieren

Führe A/B-Tests durch, indem du User verschiedenen Channels zuweist:

const assignToABTest = async (userId: string) => {
  // Use consistent hashing to assign users
  const hash = await hashUserId(userId)
  const variant = hash % 2 === 0 ? 'variant-a' : 'variant-b'
  
  await assignToChannel(variant)
  return variant
}

Best Practices

1. Backend-Zuweisung nutzen: Nutze in der Produktion immer die Backend-Zuweisung
2. Konsistente Zuweisung: Nutze User-IDs oder andere stabile Identifier für eine konsistente Channel-Zuweisung
3. Monitoring: Verfolge die Feature-Nutzung und Performance-Metriken pro Channel
4. Schrittweise Rollouts: Beginne mit kleinen Nutzersegmenten und erweitere sie schrittweise
5. Klare Dokumentation: Dokumentiere deine Channel-Strategie und deren Zweck

Fazit

Durch die Nutzung des Channel-Systems von Capgo kannst du personalisiertere App-Erlebnisse schaffen und A/B-Tests durchführen. Nutze für den Produktivbetrieb für mehr Sicherheit und Kontrolle immer die Backend-Zuweisungsmethode.

Weitere Details zum Channel-Management findest du in unserer Channels-Dokumentation.

Weiterlesen: How to Use Channels for Feature Flags and A/B Testing

Wenn du es nutzt Channels für Feature Flags und A/B-Tests nutzen um Channel-Routing und Staged Rollout zu planen, verbinde es mit Kanäle für die Implementierungsdetails in Channels, Kanäle für die Implementierungsdetails in Channels, Kanäle für die Implementierungsdetails in Channels, Beta-Testing-Lösung für den Produkt-Workflow in der Beta-Testing-Lösung, und Version-Targeting-Lösung für den Produkt-Workflow in der Version-Targeting-Lösung.