Zielversion

Diese Anleitung erklärt, wie man automatisch den neuesten kompatiblen Bundle an Benutzer liefert, basierend auf ihrer nativen Appversion, ähnlich wie Ionic AppFlows Ansatz. Dies sichert eine vereinfachte Updateverwaltung und schnellere Rollouts, während gleichzeitig Kompatibilitätsprobleme verhindert werden.

Von Ionic AppFlow migrieren?

Wenn Sie aus Ionic AppFlow kommen, ist diese Anleitung besonders wichtig für Sie. AppFlow matchte automatisch Updates mit nativen Versionen ab, und Capgo bietet dieselbe Funktion mit noch mehr Kontrolle und Flexibilität. Siehe die AppFlow-Migrationsanleitung für Schritt-für-Schritt-Anweisungen zur Migration.

Übersicht

Capgo’s Versionsziel-System ermöglicht Ihnen:

• Kompatible Updates automatisch bereitzustellen für Benutzer auf der Grundlage ihrer native App-Version
• Vermeidung von Änderungen, die die App unbrauchbar machen von inkompatiblen App-Versionen
• Verwaltung mehrerer App-Versionen gleichzeitig ohne komplexes Logik
• Störungsfreie Bereitstellung von Updates für bestimmte Benutzersegmente

Warum Versionen Zielgruppe haben (Besonders für AppFlow-Nutzer)

Wenn Sie mit “Ionic AppFlow” vertraut sind, wissen Sie, wie wichtig es ist, sicherzustellen, dass Benutzer nur kompatible Updates erhalten. AppFlow hat automatisch Live-Update-Bundles an native App-Versionen angepasst, um inkompatible JavaScript-Code nicht an ältere native __CAPGO_KEEP_0__ zu liefern.code bietet die gleichen Sicherheitsgarantien

Capgo provides the same safety guaranteesMehr detaillierte Kontrolle über die Versionsabstimmung

• Mehrere Strategien (Kanäle, semver, native Einschränkungen)
• Bessere Sichtbarkeit in die Versionsverteilung
• __CAPGO_KEEP_0__ und __CAPGO_KEEP_1__ werden zusammen mit der Dashboard-Verwaltung gesteuert
• API and CLI control alongside dashboard management

Wenn Sie ältere native __CAPGO_KEEP_0__ haben

• Sie haben Benutzer auf verschiedenen Hauptversionen Ihrer App (z.B. v1.x, v2.x, v3.x).
• Sie müssen die Rückwärtskompatibilität aufrechterhalten, während Sie die Auswirkungen aufbrechende Änderungen umsetzen.
• Sie möchten verhindern, dass neuere Bundles ältere native code brechen.
• Sie migrieren die Benutzer allmählich von einer Version zur anderen
• Sie migrieren von AppFlow und möchten die gleiche Sicherheit bei Updates aufrechterhalten

Wie es funktioniert

Capgo verwendet eine mehrschichtige Ansatz, um Benutzer mit kompatiblen Updates zu verbinden:

1. Nativversionseinschränkungen: Verhindere, dass Bundles an inkompatible native Versionen geliefert werden
2. Kanalbasierte Routing: Routen Sie verschiedene App-Versionen zu verschiedenen Update-Kanälen
3. Semantic Versioning Kontrolle: Aktualisierungen automatisch über die Grenzen von Major/Minor/Patch blockieren
4. Geräteebene-Überschreibungen: Ziel spezifische Geräte oder Benutzergruppen

Versionen-Übereinstimmungs-Fluss

graph TD
    A[User Opens App] --> B{Check Device Override}
    B -->|Override Set| C[Use Override Channel]
    B -->|No Override| D{Check defaultChannel in App}
    D -->|Has defaultChannel| E[Use App's defaultChannel]
    D -->|No defaultChannel| F[Use Cloud Default Channel]
    C --> G{Check Version Constraints}
    E --> G
    F --> G
    G -->|Compatible| H[Deliver Update]
    G -->|Incompatible| I[Skip Update]

Strategie 1: Channel-basierte Versionen-Route

Dies ist die empfohlene Vorgehensweise für das Management von Änderungen und großen Versionsupdates. Es ähnelt dem AppFlow-Delivery-Modell.

Beispiel-Szenario

• App v1.x (100.000 Nutzer) → production Kanal
• App v2.x (50.000 Nutzer mit Änderungen, die zum Absturz führen) → v2 Kanal
• App v3.x (10.000 Beta-Nutzer) → v3 Kanal

Implementierung

Schritt 1: Konfigurieren Sie Kanäle für jede Hauptversion

// capacitor.config.ts for version 1.x builds
import { CapacitorConfig } from '@capacitor/cli';

const config: CapacitorConfig = {
  appId: 'com.example.app',
  appName: 'Example App',
  plugins: {
    CapacitorUpdater: {
      autoUpdate: true,
      defaultChannel: 'production', // or omit for default
    }
  }
};

export default config;

// capacitor.config.ts for version 2.x builds
const config: CapacitorConfig = {
  appId: 'com.example.app',
  appName: 'Example App',
  plugins: {
    CapacitorUpdater: {
      autoUpdate: true,
      defaultChannel: 'v2', // Routes v2 users automatically
    }
  }
};

// capacitor.config.ts for version 3.x builds
const config: CapacitorConfig = {
  appId: 'com.example.app',
  appName: 'Example App',
  plugins: {
    CapacitorUpdater: {
      autoUpdate: true,
      defaultChannel: 'v3', // Routes v3 users automatically
    }
  }
};

Schritt 2: Erstellen von Kanälen

# Create channels for each major version
npx @capgo/cli channel create production
npx @capgo/cli channel create v2
npx @capgo/cli channel create v3

# Enable self-assignment so apps can switch channels
npx @capgo/cli channel set production --self-assign
npx @capgo/cli channel set v2 --self-assign
npx @capgo/cli channel set v3 --self-assign

Schritt 3: Hochladen von Versionsspezifischen Paketen

# For v1.x users (from v1-maintenance branch)
git checkout v1-maintenance
npm run build
npx @capgo/cli bundle upload --channel production

# For v2.x users (from v2-maintenance or main branch)
git checkout main
npm run build
npx @capgo/cli bundle upload --channel v2

# For v3.x users (from beta/v3 branch)
git checkout beta
npm run build
npx @capgo/cli bundle upload --channel v3

Automatische Routing

Wenn Benutzer die App öffnen, verbinden sie sich automatisch mit ihrem zugewiesenen Kanal auf der Grundlage des defaultChannel in ihrem installierten App-Paket. Keine JavaScript-code-Änderungen erforderlich!

Vorteile

• Keine code-Änderungen - Das Routing erfolgt automatisch
• Scharfe Trennung - Jede Version hat seinen eigenen Update-Pipeline
• Flexible Zielgruppen - Aktualisierungen auf spezifische Versionsgruppen pushen
• Sichere Rollouts - Bruchteile werden niemals in inkompatible Versionen geliefert

Strategie 2: Semantische Versionskontrolle

Verwenden Sie die semantische Versionskontrolle von Capgo , um Aktualisierungen über Versionsgrenzen hinweg zu verhindern

Auto-Update über Hauptversionen deaktivieren

# Create a channel that blocks major version updates
npx @capgo/cli channel create stable --disable-auto-update major

Diese Konfiguration bedeutet:

• Benutzer auf der Anwendungsversion 1.2.3 werden Updates bis zu 1.9.9
• Benutzer werden NICHT Version 2.0.0 automatisch
• Verhindert, dass sich ältere native code durch Bruchänderungen beeinträchtigen

Granulares Kontrollmöglichkeiten

# Block minor version updates (1.2.x won't get 1.3.0)
npx @capgo/cli channel set stable --disable-auto-update minor

# Block patch updates (1.2.3 won't get 1.2.4)
npx @capgo/cli channel set stable --disable-auto-update patch

# Allow all updates
npx @capgo/cli channel set stable --disable-auto-update none

Semantic Versioning Required

Diese Strategie funktioniert nur, wenn Sie für Ihre App-Versionen die semantische Versionierung (semver) einhalten. Stellen Sie sicher, dass Ihre Versionsnummern dem Format entsprechen. MAJOR.MINOR.PATCH Strategy 3: Native Version Constraints

Abschnitt: Strategie 3: Native Version Constraints

Mit nativeVersion Delay Condition

Abschnitt: Mit nativeVersion Delay Condition

Terminalfenster

# This bundle requires native version 2.0.0 or higher
npx @capgo/cli bundle upload \
  --channel production \
  --native-version "2.0.0"

Wie es funktioniert

Geräte auf der native Version 1.x erhalten diese Bundle NICHT. Nur Geräte auf 2.0.0+ erhalten es. Dies ist perfekt für Updates, die neue native APIs oder Plugins erfordern.

Anwendungsfälle

1. Neuer Native-Plugin erforderlich

   # Bundle needs Camera plugin added in v2.0.0
   npx @capgo/cli bundle upload --native-version "2.0.0"

2. Native API-Änderungen

   # Bundle uses new Capacitor 6 APIs
   npx @capgo/cli bundle upload --native-version "3.0.0"

3. Schrittweise Migration

   # Test bundle only on latest native version
   npx @capgo/cli bundle upload \
     --channel beta \
     --native-version "2.5.0"

Strategie 4: Vermeidung von automatischen Downgrades

Verhindere, dass Benutzer Pakete erhalten, die älter sind als ihre aktuelle native Version.

Aktivieren Sie in den Kanal-Einstellungen

In the Capgo dashboard:

1. Kanäle → Wählen Sie Ihren Kanal aus Aktivieren
2. In der __CAPGO_KEEP_0__-Oberfläche: → Kanäle → Wählen Sie Ihren Kanal aus “Automatisches Herunterstufen unter Native deaktivieren”
3. Änderungen speichern

Oder über CLI:

npx @capgo/cli channel set production --disable-downgrade

Beispiel

• Gerät des Benutzers: Native-Version 1.2.5
• Kanalbundle: Version 1.2.3
• ErfolgUpdate wird blockiert (würde zu einer Herunterstufung führen)

Dies ist nützlich, wenn:

• Benutzer haben eine neuere Version manuell aus dem App Store installiert
• Sie müssen sicherstellen, dass die Benutzer immer die neuesten Sicherheitspatches haben
• Sie möchten Regressionsfehler verhindern

Strategie 5: Geräteebene-Zielgruppierung

Überschreiben Sie die Kanalzuweisung für bestimmte Geräte oder Benutzergruppen

Zwingen Sie eine spezifische Version für die Testung

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

// Force beta testers to use v3 channel
async function assignBetaTesters() {
  const deviceId = await CapacitorUpdater.getDeviceId()

  // Check if user is beta tester
  if (isBetaTester(userId)) {
    await CapacitorUpdater.setChannel({ channel: 'v3' })
  }
}

Übersicht Geräteüberschreibung

In der Capgo-Übersicht:

1. Zu Geräte → Gerät finden
2. Klicken Kanal setzen oder Version setzen
3. Überschreiben mit spezifischem Kanal oder Bundle-Version
4. Das Gerät erhält Updates von der überschriebenen Quelle

Test-Updates

Verwenden Sie Geräte-Überschreibungen, um Updates auf Ihrem eigenen Gerät zu testen, bevor Sie sie allen Benutzern bereitstellen.

Vollständiger AppFlow-Workflow

Hier ist ein vollständiges Beispiel, das alle Strategien kombiniert:

1. Initialisierung (App v1.0.0)

# Create production channel with semver controls
npx @capgo/cli channel create production \
  --disable-auto-update major \
  --disable-downgrade

capacitor.config.ts

const config: CapacitorConfig = {
  plugins: {
    CapacitorUpdater: {
      autoUpdate: true,
      defaultChannel: 'production',
    }
  }
};

2. Freigabe von Änderungen (App v2.0.0)

# Create v2 channel for new version
npx @capgo/cli channel create v2 \
  --disable-auto-update major \
  --disable-downgrade \
  --self-assign

# Create git branch for v1 maintenance
git checkout -b v1-maintenance
git push origin v1-maintenance

// capacitor.config.ts for v2.0.0
const config: CapacitorConfig = {
  plugins: {
    CapacitorUpdater: {
      autoUpdate: true,
      defaultChannel: 'v2', // New users get v2 channel
    }
  }
};

3. Aktualisierungen auf beide Versionen pushen

# Update v1.x users (bug fix)
git checkout v1-maintenance
# Make changes
npx @capgo/cli bundle upload \
  --channel production \
  --native-version "1.0.0"

# Update v2.x users (new feature)
git checkout main
# Make changes
npx @capgo/cli bundle upload \
  --channel v2 \
  --native-version "2.0.0"

4. Versionen verteilen

Verwende das Capgo-Dashboard, um zu überwachen:

• Wie viele Benutzer sind auf v1 vs v2
• Zuordnungsquoten pro Version
• Fehler oder Abstürze pro Version

5. Veraltetes Version deaktivieren

Wenn die Verwendung von v1 unter der Schwellenwert liegt:

# Stop uploading to production channel
# Optional: Delete v1 maintenance branch
git branch -d v1-maintenance

# Move all remaining users to default
# (They'll need to update via app store)

Kanal-Vorrang

Wenn mehrere Kanal-Konfigurationen existieren, verwendet Capgo folgende Vorrangfolge:

1. Geräte-Übernahme (Dashboard oder API) - Höchster Priorität
2. Cloud-Übernahme via setChannel() rufen
3. Standardkanal in capacitor.config.ts
4. Standardkanal (Cloud-Einstellung) - Niedrigste Priorität

Vorrangbeispiel

Wenn eine App eines Benutzers defaultChannel: 'v2' aber Sie überschreiben Sie ihre Geräte zu 'beta' im Dashboard, erhalten sie Updates von dem 'beta' Kanal.

Gute Praktiken

1. Stellen Sie immer defaultChannel für Hauptversionen fest

// ✅ Good: Each major version has explicit channel
// v1.x → production
// v2.x → v2
// v3.x → v3

// ❌ Bad: Relying on dynamic channel switching
// All versions → production, switch manually

2. Verwenden Sie semantische Versionsierung

# ✅ Good
1.0.0 → 1.0.1 → 1.1.0 → 2.0.0

# ❌ Bad
1.0 → 1.1 → 2 → 2.5

3. Halten Sie separate Branches

# ✅ Good: Separate branches per major version
main (v3.x)
v2-maintenance (v2.x)
v1-maintenance (v1.x)

# ❌ Bad: Single branch for all versions

4. Vor dem Rollout testen

# Test on beta channel first
npx @capgo/cli bundle upload --channel beta

# Monitor for issues, then promote to production
npx @capgo/cli bundle upload --channel production

5. Versionen verfolgen

Überprüfen Sie regelmäßig Ihre Dashboard:

• Stellen sich die Benutzer auf neue native Versionen um?
• Bekommen alte Versionen noch viel Traffic?
• Sollten Sie alte Kanäle deaktivieren?

Vergleich mit Ionic AppFlow

Für Teams, die von Ionic AppFlowhier ist, wie die Version für Capgo vergleicht:

Funktion	Ionic AppFlow	Capgo
Version-basierte Routing	Automatische basierend auf nativer Version	Automatische via defaultChannel + mehrere Strategien
Semantische Versionsnummer	Grundlegende Unterstützung	Erweitert mit --disable-auto-update (Major/Minor/Patch)
Native Versionenbeschränkungen	Manuelle Konfiguration in AppFlow-Dashboard	Eingebaut --native-version Flagge in CLI
Kanalverwaltung	Web-UI + CLI	Web-UI + CLI + API
Geräteüberschreibungen	Eingeschränkte Geräteebene-Kontrolle	Vollständige Kontrolle über Dashboard/API
Automatisches Downgradeprevention	Ja	Ja über --disable-downgrade
Multi-Version-Wartung	Manuelle Branchen- und Kanalverwaltung	Automatisiert mit Vorrang des Kanals
Selbsthosting	Nein	Ja (vollständige Kontrolle)
Versionen-Analyse	Grundlegend	Detaillierte pro-Version-Metriken

AppFlow Parität und Weiteres

Capgo bietet alle Versionenziel-Fähigkeiten, die AppFlow bot, plus zusätzliche Steuermechanismen. Wenn Sie sich auf AppFlows automatische Versionsabstimmung verlassen haben, finden Sie __CAPGO_KEEP_0__ genauso sicher mit mehr Flexibilität. that AppFlow offered, plus additional control mechanisms. If you relied on AppFlow’s automatic version matching, you’ll find Capgo equally safe with more flexibility.

Abschnitt 'Fehlersuche'

Abschnitt 'Benutzer erhalten keine Updates'

Kanalzuweisung

1. : Überprüfen Sie, ob das Gerät auf der richtigen Kanal ist: Überprüfen Sie, ob das Gerät auf der richtigen Kanal ist

   const channel = await CapacitorUpdater.getChannel()
   console.log('Current channel:', channel)

2. Versionseinschränkungen: Überprüfe, ob das Bundle native Versionseinschränkungen hat

   • Zur Dashboard → Bundles → Überprüfe die Spalte „Native Version“

3. Semver-Einstellungen: Überprüfe die Einstellungen des Kanals disable-auto-update Terminalfenster

   npx @capgo/cli channel list

4. : Überprüfe, ob das Gerät eine manuelle Überschreibung hatZur Dashboard → Geräte → Suche nach Gerät → Überprüfe Kanal/Versoin

   • setting

Fehlerhaftes Bundle wurde zur falschen Version geliefert

1. Überprüfen Sie die Standardkanal: Stellen Sie sicher, dass der richtige Kanal capacitor.config.ts
2. Überprüfen Sie das Bundle-Upload: Bestätigen Sie, dass das Bundle zum beabsichtigten Kanal hochgeladen wurde
3. Überprüfen Sie die Native Version: Bestätigen Sie, dass die Flagge richtig verwendet wurde --native-version Änderungen, die alte Versionen betreffen

Abschnitt: Änderungen, die alte Versionen betreffen

1. Abschnitt: Eilmaßnahmen: Geräte überschreiben, um das Bundle zu sichern
   • Zentrale Oberfläche → Geräte → Mehrere Geräte auswählen → Version setzen
2. Langfristige Lösung: Erstelle kanalisierte Versionen und halte separate Branchen
3. Prävention: Teste Updates immer auf repräsentativen Geräten vor der Rollout

Migration von Ionic AppFlow

Wenn Sie von Ionic AppFlow migrieren Ionic AppFlow, Versionen zielen in Capgo, ähnlich wie zuvor, aber mit mehr Flexibilität:

Konzeptkarte

AppFlow-Konzept	Capgo Äquivalent	Hinweise
Veröffentlichungs-Kanal	Capgo Kanal	Das gleiche Konzept, aber mächtiger
Native Versionssperre	--native-version Flagge	Mehr detailierte Kontrolle
Kanalpriorität	Kanalvorrang (Übergeordnet → Cloud → Standard)	Mehr transparente Vorrangigkeit
Ziel für die Bereitstellung	Kanal + semver steuert	Mehrere Strategien verfügbar
Produktionskanal	production Kanal (oder beliebiger Name)	Flexible Namensgebung
Git-basierte Bereitstellung	CLI Paket hochladen von Branch	Selbe Workflow
Automatische Versionsübereinstimmung	defaultChannel + Versionsbeschränkungen	Verbessert mit mehreren Strategien

Schlüsselunterschiede für AppFlow-Nutzer

1. Mehr Kontrolle: Capgo bietet Ihnen mehrere Strategien (Kanäle, semver, native Version), die kombiniert werden können
2. Bessere Sichtbarkeit: Das Dashboard zeigt die Versionsverteilung und Kompatibilitätsprobleme
3. API-Zugriff: Vollständige programmatische Kontrolle über die Versionszielsetzung
4. Selbst-Hosting: Option, Ihren eigenen Update-Server mit gleicher Versionslogik zu betreiben

Migrationschritte

1. Karten Sie Ihre AppFlow-Kanäle zu Capgo-Kanälen (üblicherweise 1:1)
2. Setzen Sie defaultChannel in capacitor.config.ts für jede Hauptversion
3. Konfigurieren Sie semver-Regeln wenn Sie eine automatische Blockierung an Versionsgrenzen wünschen
4. Hochladen von Versionsspezifischen Paketen mit --native-version Flagge
5. Überwachen Sie die Versionsverteilung in Capgo Dashboard

Vollständiger Migrationsleitfaden

Für einen vollständigen Migrationsleitfaden einschließlich SDK-Ersatz und API-Mapping, siehe den AppFlow zu Capgo-Migrationsleitfaden.

Fortgeschrittene Muster

Schrittweise Umstellung nach Version

// Gradually migrate v1 users to v2
async function migrateUsers() {
  const deviceId = await CapacitorUpdater.getDeviceId()
  const rolloutPercentage = 10 // Start with 10%

  // Hash device ID to get deterministic percentage
  const hash = hashCode(deviceId) % 100

  if (hash < rolloutPercentage) {
    // User is in rollout group - migrate to v2
    await CapacitorUpdater.setChannel({ channel: 'v2' })
  }
}

Funktionsschalter nach Version

// Enable features based on native version
async function checkFeatureAvailability() {
  const info = await CapacitorUpdater.getDeviceId()
  const nativeVersion = info.nativeVersion

  if (compareVersions(nativeVersion, '2.0.0') >= 0) {
    // Enable features requiring v2.0.0+
    enableNewCameraFeature()
  }
}

A/B-Testung zwischen Versionen

// Run A/B tests within same native version
async function assignABTest() {
  const nativeVersion = await getNativeVersion()

  if (nativeVersion.startsWith('2.')) {
    // Only A/B test on v2 users
    const variant = Math.random() < 0.5 ? 'v2-test-a' : 'v2-test-b'
    await CapacitorUpdater.setChannel({ channel: variant })
  }
}

Zusammenfassung

Capgo bietet mehrere Strategien für versionsspezifische Update-Übermittlung:

1. Kanalbasierte RoutingAutomatische Versionsabtrennung via __CAPGO_KEEP_0__ defaultChannel
2. Semantic Versioning: Verhindere Updates über Major/Minor/Patch-Grenzen
3. Nativversionseinschränkungen: Mindestnativeversion für Bundles anfordern
4. Auto-Downgrade-Verhinderung: Nie ältere Bundles an neuere native Versionen liefern
5. Geräteüberschreibungen: Manuelle Kontrolle für Testen und Zielsetzen

Durch die Combination dieser Strategien können Sie AppFlow-Style-aktualisierungen mit noch mehr Flexibilität und Kontrolle erreichen. Wählen Sie die Vorgehensweise, die am besten zu der Versions- und Bereitstellungsworkflow Ihres Apps passt.

Weitere Informationen zu bestimmten Funktionen:

• Breaking Changes Guide - Detaillierte Kanalversionierungstrategie
• Kanalverwaltung - Vollständige Kanal-Konfigurationsreferenz
• Updateverhalten - Verzögertes native Version und Bedingungen