Tagging des versions dans les apps Capacitor

Le tagging de version est essentiel pour gérer les Capacitor apps. Il garantit des mises à jour fluides, suit les changements et améliore la fiabilité de l'app sur iOS, Android et le web. Voici un aperçu rapide :

• Pourquoi c'est important: Suit les mises à jour, permet les rollbacks et assure des déploiements stables.
• Versionnage sémantique : Utilisez MAJEUR.MINEUR.CORRECTIF to indicate breaking changes, new features, or bug fixes.
• Synchronisation multiplateforme: Alignez les numéros de version dans package.json, iOS Info.plist, et Android build.gradle.
• Automatisation: Automatiser les mises à jour avec les scripts npm et les outils CI/CD.
• Live Update(s) : des outils comme Capgo livrer des mises à jour à 95 % des utilisateurs en 24 heures.
• Gestion des versions bêta: utilisez des canaux structurés pour les versions alpha, bêta et de production.

Comparaison rapide

Le tagging de version simplifie mises à jour d'app, garde les utilisateurs satisfaits et permet aux développeurs de gérer les releases efficacement.

Comment configurer AUTOMATIQUEMENT votre Capacitor projet ⚡️

Configuration des versions dans Capacitor

Suivez ces étapes pour garantir une gestion cohérente des versions sur toutes les plateformes de votre application Capacitor.

Définir la version dans package.json

Le package.json ce fichier sert de source principale pour les détails de version de votre application. Voici un exemple de configuration :

{
  "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"
  }
}

Lors de la mise à jour du numéro de version, appliquez les règles de versioning sémantique (SemVer) :

• Version majeure (1.x.x) : introduit des changements cassants.
• Version mineure (x.2.x) : Ajoute de nouvelles fonctionnalités rétrocompatibles.
• Version patch (x.x.3) : Corrige des bugs ou apporte de petites améliorations.

Synchroniser les versions des plateformes

Il est important d'aligner les numéros de version sur toutes les plateformes pour un déploiement fluide. Chaque plateforme possède son propre fichier de configuration pour le versioning :

Après avoir mis à jour la version dans package.json, utilisez cette commande pour synchroniser les modifications avec les configurations des plateformes natives :

npx cap sync

Utiliser Capacitor CLI pour la gestion des versions

Le Capacitor CLI propose des commandes utiles pour gérer les versions :

# 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

Garder vos Capacitor CLI à jour garantit la compatibilité avec les fonctionnalités propres à chaque version et limite les incompatibilités potentielles. Ces étapes vous aideront à conserver un versionnage correct dans votre application.

Configuration du versionnage sémantique

Les bases du versionnage sémantique

Versionnage sémantique (SemVer) utilise le format MAJEUR.MINEUR.CORRECTIF, où chaque partie correspond à un type de changement précis :

Ce système permet aux développeurs de communiquer clairement les mises à jour tout en préservant la compatibilité entre les versions de l'app. Par exemple, passer de 1.2.3 vers 2.0.0 signale des mises à jour majeures et incompatibles qui exigent une planification minutieuse.

Quand mettre à jour les numéros de version

Voici comment décider quel numéro de version mettre à jour :

« Nous pratiquons le développement agile et @Capgo est essentiel pour livrer en continu à nos utilisateurs ! » - Rodrigo Mantica [1]

Voyons maintenant comment automatiser ces mises à jour pour simplifier la gestion des releases.

Automatisation des mises à jour de version

Automatiser les mises à jour de version peut faire gagner du temps et réduire les erreurs dans votre projet Capacitor. Voici comment le configurer :

1. Scripts de version NPM

Ajoutez ces scripts à votre package.json file to manage version updates easily:

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

2. Intégration CI/CD
   Intégrez les mises à jour de version dans votre pipeline CI/CD. Capgo prend en charge des outils comme GitHub Actions GitHub, GitLab CI, et Jenkins, ce qui simplifie l'automatisation du processus.

« @Capgo est un incontournable pour les développeurs qui veulent gagner en productivité en contournant les longues revues de correctifs. » - Bessie Cooper [1]

Méthodes de tags de version

Tags de version Git

Les tags de version Git sont un moyen fiable de suivre les releases d'applications Capacitor. Pour créer des tags clairs et informatifs, combinez le versionnage sémantique avec une brève description :

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

Pour garder une cohérence dans votre équipe, utilisez un format de tags standardisé :

Intégration du numéro de build

Les numéros de build permettent de suivre chaque build individuel au sein d'une version. Pour iOS comme pour Android, incrémentez le numéro de build à chaque soumission :

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

Le numéro de build doit toujours être incrémenté, même si la version reste identique. Chaque soumission sur les stores est ainsi identifiée de façon unique, tout en gardant un versioning clair pour les utilisateurs.

Gestion des versions bêta

La gestion des versions bêta nécessite un processus structuré pour distribuer les builds de test. Capgo système de canaux simplifie cela avec les étapes suivantes :

1. Configuration du canal

Créez des canaux distincts pour chaque phase de test :

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

2. Contrôler l'accès utilisateur

Configurez les permissions pour contrôler qui accède aux versions bêta. Cela garantit que seuls les testeurs approuvés reçoivent les builds bêta, tandis que les utilisateurs en production reçoivent des releases stables.

3. Progression des versions

Utilisez un système de progression des versions clair pour suivre les étapes de développement :

Cette approche garantit des tests rigoureux et des transitions fluides entre les différentes étapes de développement, en maintenant un suivi des versions organisé et transparent tout au long du processus.

Affichage de la version de l'app

Afficher des informations de version exactes dans votre app est essentiel pour informer les utilisateurs et gérer efficacement les mises à jour.

Récupérer la version avec Capacitor

Vous pouvez récupérer les détails de version avec Capacitor et ce code :

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

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

Pour une approche plus simple, créez une fonction réutilisable :

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

Cette fonction simplifie l'affichage des informations de version dans l'interface de votre app.

Implémentation de l'UI de version

Voici un exemple pour intégrer l'affichage de la version dans un composant de paramètres :

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

Les endroits courants pour afficher les détails de version sont :

En plus d'afficher les infos de version, intégrer un système de vérification des mises à jour peut améliorer l'expérience utilisateur.

Vérification des mises à jour

Un système de vérification des mises à jour garantit aux utilisateurs l'accès aux dernières fonctionnalités et correctifs. Capgo fournit des notifications en temps réel et des canaux de mise à jour contrôlés pour gérer ce processus :

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
    });
  }
}

« Nous pratiquons le développement agile et @Capgo est essentiel pour livrer en continu à nos utilisateurs ! » - Rodrigo Mantica [1]

You can also add a user-facing update notification, like this:

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

Pour les applications d'entreprise, le système de canaux de Capgo vous permet de contrôler la distribution des mises à jour :

Cette méthode garantit la fiabilité de l’application tout en suivant les performances des mises à jour via le dashboard d’analyse de Capgo.

Solutions de gestion de version

Plongeons dans des solutions avancées pour gérer efficacement les versions de l’application.

Options des outils de version

Lors du choix d’outils de contrôle de version, il est essentiel de privilégier ceux qui simplifient les mises à jour, sécurisent votre code et prennent en charge à la fois les publications sur les stores et les live updates.

Voici les fonctionnalités clés à rechercher :

Un outil incontournable dans ce domaine est Capgo, qui propose des fonctionnalités conçues spécifiquement pour apps Capacitor.

Capgo Fonctionnalités de gestion de versions

Capgo offre des capacités de gestion de version robustes, notamment :

• 23,5 M de mises à jour réussies
• 95 % des utilisateurs mis à jour en 24 h
• 82 % de réussite globale
• 434 ms de temps de réponse moyen pour API partout

Voici un exemple d'utilisation de Capgo pour la gestion des versions :

// 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
    });
  }
};

« Nous testons actuellement @Capgo depuis qu'Appcenter a arrêté le support des live updates sur les apps hybrides et qu'@AppFlow est bien trop cher. » - Simon Flack [1]

Solutions par taille d'équipe

Capgo propose des plans flexibles pour toutes les tailles d'équipes, rendant la gestion des versions évolutive et efficace.

Pour les équipes plus grandes, le système de canaux de Capgo permet un contrôle précis du déploiement des versions :

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

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

« Nous pratiquons le développement agile et @Capgo est essentiel pour livrer en continu à nos utilisateurs ! » - Rodrigo Mantica [1]

Capgo inclut également un dashboard d'analytics pour suivre les taux d'adoption des versions et détecter rapidement les problèmes potentiels. Grâce au chiffrement intégré et aux options d'hébergement personnalisables, les équipes peuvent maintenir la sécurité tout en faisant évoluer leurs workflows de déploiement.

Conclusion

Comprendre le versionnage par tags est essentiel pour simplifier vos processus de développement et de déploiement. Voici un récapitulatif des concepts clés et des étapes pour bien démarrer.

Points clés

Le versionnage aide les développeurs à maintenir des mises à jour fluides et fiables. Un contrôle de version efficace offre des avantages clairs :

Ces résultats soulignent l’importance d’utiliser des outils de gestion des versions efficaces.

Comment commencer

Pour mettre ces avantages en pratique, suivez ces étapes :

• Configurez le suivi des versions : utilisez le versionnage sémantique dans votre package.json fichier et intégrez les plugins nécessaires.
• Ajoutez des vérifications de mise à jour: implémentez des systèmes pour vérifier et suivre les mises à jour de version.
• Configurez les canaux de distribution: créez des environnements distincts pour la production, la bêta et le développement.

Enfin, envisagez d'ajouter un système live update pour garantir des déploiements à la fois rapides et sécurisés.

Continuer avec l'étiquetage des versions dans les apps Capacitor

Si vous utilisez Tagging des versions dans les apps Capacitor pour planifier le rollback et le contrôle de version, connectez-l’à Rollbacks pour les détails d'implémentation dans Rollbacks, Ciblage de version pour les détails d'implémentation dans Version Targeting, Comportement de mise à jour pour les détails d'implémentation du comportement des mises à jour, bundle pour les détails d'implémentation du bundle, et Live Updates Capgo pour le workflow produit dans Capgo Live Updates.