Version-Tagging in Capacitor Apps

Version Tagging ist entscheidend für das Management von Capacitor Apps. Es ermöglicht reibungslose Updates, trackt Änderungen und erhöht die Zuverlässigkeit über iOS, Android und Web-Plattformen hinweg. Hier ein kurzer Überblick:

• Warum das wichtig ist: Trackt Updates, ermöglicht Rollbacks und sorgt für stabile Deployments.
• Semantische Versionierung: Nutze MAJOR.MINOR.PATCH um Breaking Changes, neue Features oder Bugfixes anzuzeigen.
• Plattformübergreifende Synchronisation: Align version numbers in package.json, iOS Info.plist, und Android build.gradle.
• Automatisierung: Updates automatisieren mit npm Skripten und CI/CD-Tools.
• Capgo Live Updates: Tools wie Capgo Updates innerhalb von 24 Stunden an 95 % der Nutzer ausliefern.
• Beta-Management: Nutze strukturierte Channels für Alpha-, Beta- und Produktionsversionen.

Schneller Vergleich

Version-Tagging vereinfacht App-Updates, hält Nutzer zufrieden und sorgt dafür, dass Entwickler Releases effektiv verwalten können.

So konfigurierst du AUTOMATISCH dein Capacitor Projekt ⚡️

Versions-Setup in Capacitor

Folge diesen Schritten für ein konsistentes Versionsmanagement über alle Plattformen deiner Capacitor App hinweg.

Version festlegen in package.json

Der package.json Diese Datei dient als Hauptquelle für die Versionsdetails deiner App. Hier ist ein Beispiel für die Einrichtung:

{
  "name": "your-app-name",
  "version": "1.2.3",
  "private": true,
  "dependencies": {
    "@capacitor/core": "5.5.0",
    "@capacitor/ios": "5.5.0",
    "@capacitor/android": "5.5.0"
  }
}

Nutze beim Aktualisieren der Versionsnummer die SemVer-Regeln (Semantic Versioning):

• Major-Version (1.x.x): Führt Breaking Changes ein.
• Minor-Version (x.2.x): Fügt neue Features hinzu, die abwärtskompatibel sind.
• Patch-Version (x.x.3): Behebt Bugs oder bringt kleine Verbesserungen.

Plattform-Versionen synchron halten

Für ein reibungsloses App-Deployment ist es wichtig, die Versionsnummern über alle Plattformen hinweg abzustimmen. Jede Plattform nutzt eine eigene Konfigurationsdatei für das Versioning:

Nachdem du die Version in package.json, nutze diesen Befehl, um die Änderungen mit den nativen Plattform-Konfigurationen zu synchronisieren:

npx cap sync

Versionsverwaltung mit Capacitor CLI

Capacitor CLI bietet hilfreiche Commands für die Versionsverwaltung:

# Check the current version of Capacitor
npx cap --version

# Update Capacitor core and platform dependencies
npm install @capacitor/core@latest
npm install @capacitor/ios@latest
npm install @capacitor/android@latest

# Sync version changes to native platforms
npx cap sync

Wenn du Capacitor CLI aktuell hältst, stellst du die Kompatibilität mit versionsspezifischen Features sicher und reduzierst mögliche Versionskonflikte. Mit diesen Schritten behältst du eine korrekte Versionierung in deiner App bei.

Semantic-Version-Setup

Semantic-Version-Grundlagen

Semantische Versionierung (SemVer) verwendet das Format MAJOR.MINOR.PATCH, wobei jeder Teil eine bestimmte Art von Änderung angibt:

Dieses System stellt sicher, dass Entwickler Updates klar kommunizieren können und dabei die Kompatibilität zwischen App-Versionen erhalten bleibt. Zum Beispiel signalisiert der Wechsel von 1.2.3 zu 2.0.0 Major-Updates mit Breaking Changes, die eine sorgfältige Planung erfordern.

Wann Versionsnummern aktualisiert werden sollten

So entscheidest du, welche Versionsnummer du aktualisierst:

„Wir setzen auf agile Entwicklung und @Capgo ist geschäftskritisch, um unseren Nutzern kontinuierlich Updates zu liefern!“ - Rodrigo Mantica [1]

Schauen wir uns nun an, wie man diese Updates automatisiert, um das Release-Management zu vereinfachen.

Automatisierung von Versions-Updates

Die Automatisierung von Versions-Updates kann Zeit sparen und Fehler in deinem Capacitor Projekt reduzieren. So richtest du es ein:

1. NPM Versions-Skripte

Füge diese Skripte deiner package.json Datei hinzu, um Versions-Updates einfach zu verwalten:

{
  "scripts": {
    "version:patch": "npm version patch",
    "version:minor": "npm version minor",
    "version:major": "npm version major"
  }
}

2. CI/CD-Integration
   Integriere Versions-Updates in deine CI/CD-Pipeline. Capgo unterstützt Tools wie GitHub Aktionen, GitLab CI, und Jenkins, was die Automatisierung des Prozesses vereinfacht.

„@Capgo ist ein Must-have für Entwickler, die durch das Umgehen langwieriger Bugfix-Reviews produktiver werden wollen.“ - Bessie Cooper [1]

Methoden zum Version-Tagging

Git-Versions-Tags

Git Version Tags sind ein zuverlässiger Weg, um Capacitor App-Releases zu tracken. Um klare und informative Tags zu erstellen, kombiniere Semantic Versioning mit einer kurzen Beschreibung:

git tag -a v1.2.3 -m "Release v1.2.3: Added offline mode support"

Um die Konsistenz im Team zu wahren, nutze ein standardisiertes Tagging-Format:

Build-Nummer-Integration

Build-Nummern helfen dabei, einzelne Builds innerhalb jeder Version zu tracken. Erhöhe sowohl bei iOS als auch bei Android die Build-Nummer bei jeder Einreichung:

{
  "ios": {
    "version": "1.2.3",
    "build": "10234"
  },
  "android": {
    "version": "1.2.3",
    "versionCode": "10234"
  }
}

Die Build-Nummer sollte immer steigen, auch wenn die Version gleich bleibt. So wird jede App-Store-Einreichung eindeutig identifiziert, während die Versionierung für Nutzer klar bleibt.

Beta-Version-Management

Das Verwalten von Beta-Versionen erfordert einen strukturierten Prozess, um Test-Builds zu verteilen. Capgo Channel-System vereinfacht das mit folgenden Schritten:

1. Channel-Setup

Erstelle separate Channels für jede Testphase:

{
  "beta": {
    "version": "1.3.0-beta.1",
    "users": "beta-testers"
  },
  "production": {
    "version": "1.2.3",
    "users": "all"
  }
}

2. Nutzerzugriff steuern

Richte Berechtigungen ein, um zu kontrollieren, wer Zugriff auf Beta-Versionen bekommt. So erhalten nur freigegebene Tester Beta-Builds, während Nutzer in der Produktion stabile Releases bekommen.

3. Versionsfortschritt

Nutze ein klares Versionssystem, um die Entwicklungsphasen zu tracken:

Dieser Ansatz gewährleistet gründliche Tests und reibungslose Übergänge zwischen den Entwicklungsphasen, wodurch das Version-Tracking während des gesamten Prozesses organisiert und transparent bleibt.

App-Version anzeigen

Präzise Versionsinformationen in deiner App anzuzeigen ist entscheidend, um Nutzer auf dem Laufenden zu halten und Updates effektiv zu verwalten.

Version mit Capacitor abrufen

Du kannst Versionsdetails mit Capacitor über diesen code abrufen:

import { App } from '@capacitor/app';

async function getAppInfo() {
  const info = await App.getInfo();
  console.log(`Version: ${info.version}`);
  console.log(`Build: ${info.build}`);
}

Für einen effizienteren Ansatz erstelle eine wiederverwendbare Funktion:

export const getVersionString = async () => {
  const info = await App.getInfo();
  return `v${info.version} (${info.build})`;
};

Diese Funktion vereinfacht das Anzeigen der Versionsinformationen in der Benutzeroberfläche deiner App.

UI-Implementierung der Version

Hier ist ein Beispiel, wie du die Versionsanzeige in eine Settings-Komponente integrierst:

@Component({
  selector: 'app-settings',
  template: `
    <div class="version-info">
      <span>Version: {{ versionString }}</span>
      <span *ngIf="updateAvailable" class="update-badge">
        Update Available
      </span>
    </div>
  `
})

Typische Orte für Versionsdetails sind:

Neben der Anzeige von Versionsinfos kann die Integration eines Update-Check-Systems die User Experience verbessern.

Update-Check-System

Ein Update-Check-System stellt sicher, dass Nutzer Zugriff auf die neuesten Features und Fixes haben. Capgo bietet Echtzeit-Benachrichtigungen und kontrollierte Update-Channels, um diesen Prozess zu steuern:

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

async function checkForUpdates() {
  const current = await CapacitorUpdater.current();
  const latest = await CapacitorUpdater.getLatest();

  if (current.version !== latest.version) {
    await CapacitorUpdater.download({
      version: latest.version
    });
  }
}

„Wir setzen auf agile Entwicklung und @Capgo ist geschäftskritisch, um unseren Nutzern kontinuierlich Updates zu liefern!“ - Rodrigo Mantica [1]

Du kannst auch eine Benachrichtigung für Nutzer hinzufügen, wie zum Beispiel diese:

@Component({
  template: `
    <update-modal 
      [version]="newVersion"
      [features]="updateFeatures"
      (updateNow)="performUpdate()"
    />
  `
})

Für Enterprise-Apps ermöglicht das Channel-System von Capgo die gezielte Steuerung der Update-Verteilung:

Diese Methode sichert die App-Stabilität und trackt die Update-Performance über das Analytics-Dashboard von Capgo.

Lösungen für das Versionsmanagement

Schauen wir uns fortgeschrittene Lösungen für ein effektives App-Versionsmanagement genauer an.

Optionen für Version-Tools

Bei der Wahl von Version-Control-Tools ist es wichtig, auf solche zu setzen, die Updates vereinfachen, dein code absichern und sowohl App Store Releases als auch Live Updates unterstützen.

Hier sind die wichtigsten Features im Überblick:

Ein herausragendes Tool in diesem Bereich ist Capgo, das Funktionen bietet, die speziell für Folgendes entwickelt wurden: Capacitor Apps.

Capgo Version-Control-Features

Capgo bietet robuste Funktionen fürs Versionsmanagement, darunter:

• 23,5 Mio. erfolgreich ausgelieferte Updates
• 95 % der Nutzer aktualisieren innerhalb von 24 Stunden
• 82 % globale Erfolgsrate
• 434 ms durchschnittliche API-Antwortzeit weltweit

Hier ein Beispiel, wie du Capgo zur Versionskontrolle nutzt:

// Capgo version control example
import { CapacitorUpdater } from '@capgo/capacitor-updater';

const versionControl = {
  async checkVersion() {
    const current = await CapacitorUpdater.current();
    return current.version;
  },

  async deployUpdate(version: string) {
    await CapacitorUpdater.setChannel({
      channel: 'production',
      version: version
    });
  }
};

„Wir testen gerade @Capgo, da Appcenter den Live-Update-Support für Hybrid-Apps eingestellt hat und @AppFlow viel zu teuer ist.“ - Simon Flack [1]

Lösungen für jede Teamgröße

Capgo bietet flexible Pläne für Teams jeder Größe, damit Versionsmanagement skalierbar und effizient bleibt.

Für größere Teams ermöglicht das Channel-System von Capgo eine präzise Kontrolle über das Version-Deployment:

const enterpriseVersionControl = {
  channels: {
    production: 'stable-releases',
    beta: 'early-access',
    internal: 'development'
  },

  async deployToChannel(channel: string, version: string) {
    await CapacitorUpdater.setChannel({
      channel: channel,
      version: version
    });
  }
};

„Wir setzen auf agile Entwicklung und @Capgo ist geschäftskritisch, um unseren Nutzern kontinuierlich Updates zu liefern!“ - Rodrigo Mantica [1]

Capgo bietet zudem ein Analytics-Dashboard, um die Verbreitungsrate von Versionen zu überwachen und Probleme frühzeitig zu erkennen. Dank integrierter Verschlüsselung und anpassbarer Hosting-Optionen können Teams die Sicherheit gewährleisten, während sie ihre Deployment-Workflows skalieren.

Fazit

Version Tagging zu verstehen ist der Schlüssel zur Vereinfachung von Entwicklungs- und Deployment-Prozessen. Hier ist eine kurze Zusammenfassung der wichtigsten Konzepte und Schritte für den Einstieg.

Wichtigste Erkenntnisse

Version Tagging hilft Entwicklern, reibungslose und zuverlässige Updates zu gewährleisten. Eine ordnungsgemäße Versionskontrolle bietet klare Vorteile:

Diese Ergebnisse unterstreichen die Bedeutung effektiver Tools für das Versionsmanagement.

So geht's los

Um diese Vorteile zu nutzen, folge diesen Schritten:

• Version-Tracking einrichten: Nutze Semantic Versioning in deiner package.json Datei und integriere die nötigen Plugins.
• Update-Checks hinzufügen: Implementiere Systeme, um Version-Updates zu prüfen und zu tracken.
• Distribution Channels konfigurieren: Erstelle separate Umgebungen für Production, Beta und Development.

Nutze schließlich ein live update System, um schnelle und sichere Deployments zu garantieren.

Weiterlesen: Version Tagging in Capacitor Apps

Wenn du es nutzt Version-Tagging in Capacitor Apps um Rollbacks und die Versionskontrolle zu planen, verbinde es mit Rollbacks für die Implementierungsdetails in Rollbacks, Version-Targeting für die Implementierungsdetails in Version Targeting, Update-Verhalten für die Implementierungsdetails im Update-Verhalten, Bundle für die Implementierungsdetails im Bundle und Capgo Live Updates für den Produkt-Workflow in Capgo Live Updates.