Comment utiliser le versionnage sémantique avec les mises à jour OTA Capgo

Envie de simplifier mises à jour d'app et le contrôle de version ? Versionnage sémantique (SemVer) combiné avec Capgoles mises à jour OTA (Over-The-Air) de Capacitor plus simple et plus rapide. Voici comment :

Les bases du versionnage sémantique : Les versions utilisent le format MAJOR.MINOR.PATCH:
- MAJEUR : Pour les modifications cassantes.
- MINEUR : Pour les nouvelles fonctionnalités rétrocompatibles.
- PATCH : Pour les correctifs de bugs.
Pourquoi utiliser SemVer avec Capgo ?
- Communication claire sur les mises à jour.
- Gestion des versions plus intelligente.
- Éviter les conflits de dépendances.
- Planification des releases organisée.
Capgo Setup Étapes :
1. Installer le plugin d’updater de Capgo.
2. Configurer la version de votre application dans capacitor.config.json et d’autres fichiers.
3. Initialisez avec votre clé API.
4. Utiliser Capgo CLI pour créer le bundle et envoyer les mises à jour.
Gérer les versions et les canaux:
- Utilisez des canaux distincts (par ex. « beta » pour les tests, « production » pour les releases stables).
- Contrôlez les politiques de mise à jour (patches en auto-update, approbation manuelle pour les changements majeurs).
- Options de rollback pour les mises à jour échouées.
Processus de déploiement :
- Mettez à jour les numéros de version selon les règles SemVer.
- Testez minutieusement avant de déployer.
- Utilisez les commandes CLI pour envoyer et distribuer les mises à jour.

Capgo garantit que les mises à jour atteignent les utilisateurs rapidement et de manière fiable, avec des outils pour gérer les interruptions et maintenir la stabilité. Idéal pour les équipes utilisant des workflows CI/CD pour automatiser les mises à jour.

Astuce rapide : Testez toujours les mises à jour et utilisez les canaux pour gérer efficacement les déploiements progressifs.

Versionnage sémantique | Level Up

Capgo Setup Guide

Interface du dashboard Capgo Live Update

Voici comment configurer Capgo pour gérer facilement les mises à jour OTA et le contrôle de version.

Étapes de configuration initiale

Commencez par installer le plugin de mise à jour Capgo:

npm install @capgo/capacitor-updater  
npx cap sync

Assurez-vous que votre capacitor.config.json le fichier utilise un format de version sémantique :

{ 
  "appId": "com.example.app", 
  "appName": "My App", 
  "version": "1.0.0" 
}

Pour les anciens projets, mettez à jour les détails de version dans ces emplacements :

package.json (cherchez le version champ)
android/app/build.gradle (mettez à jour versionName)
ios/App/App.xcodeproj/project.pbxproj (mettez à jour CURRENT_PROJECT_VERSION)

Une fois configuré, initialisez Capgo avec votre clé API :

npx @capgo/cli@latest init YOUR_API_KEY

Tableau de référence rapide :

Setup Phase	Action clé	Étape de vérification
Installation	Installer le plugin et synchroniser	Vérifier `package.json`
Configuration	Définir les numéros de version	Vérifier tous les fichiers
Initialisation	Se connecter avec la clé API	Tester l'état de la connexion
Build	Créer le bundle initial	Confirmer la réussite de l'upload

Intégration du contrôle de version

Capgo fonctionne bien avec les plateformes CI/CD, ce qui rend mises à jour automatisées simple. Les plateformes prises en charge incluent :

Si vous travaillez en développement local, vous pouvez désactiver les mises à jour automatiques en ajoutant ceci à votre configuration :

{ 
  "plugins": { 
    "CapacitorUpdater": { 
      "autoUpdate": false 
    } 
  } 
}

Cela garantit que Capgo n’écrasera pas vos modifications locales. Une fois votre configuration prête, envoyez votre première version :

npx @capgo/cli@latest bundle upload  
npx @capgo/cli@latest channel set production -s default

Enfin, informez le plugin natif de l’état du bundle dans le fichier principal de votre application :

import { CapacitorUpdater } from '@capgo/capacitor-updater';  
CapacitorUpdater.notifyAppReady();

Cette configuration garantit que votre application est prête pour des déploiements OTA et une gestion des versions fluides.

Utiliser la numérotation sémantique avec Capgo

Gestion des numéros de version

Capgo utilise la numérotation sémantique (SemVer) pour gérer les versions de l’application, au format MAJEUR.MINEUR.CORRECTIF. Voici comment ça fonctionne :

Version majeure (X.0.0) : Incrémenter le numéro MAJOR pour les modifications qui cassent la compatibilité.
Version mineure (1.X.0) : Incrémenter le numéro MINOR pour les nouvelles fonctionnalités qui restent compatibles.
Version de correctif (1.0.X) : Incrémenter le numéro PATCH pour les correctifs de bugs qui n’affectent pas la compatibilité.

Type de version	Quand incrémenter	Comportement de la mise à jour automatique
Majeure (X.0.0)	Pour les modifications cassantes de API	Nécessite une approbation manuelle
Mineure (1.X.0)	Pour les nouvelles fonctionnalités	Configurable dans Capgo
Correctif (1.0.X)	Pour les correctifs de bugs	Généralement automatique

En respectant les règles de SemVer, vous simplifiez la gestion des versions et assurez des mises à jour plus fluides sur vos canaux de déploiement.

Recommandations pour le contrôle de version

Capgo vous permet de gérer efficacement vos déploiements en configurant des canaux distincts pour les différentes étapes de votre workflow.

Gestion des versions par canal: Organisez votre processus de déploiement en créant des canaux distincts pour le test et la production. Par exemple :
- Utilisez un canal « beta » (ex : 1.2.0-beta) pour tester les nouvelles fonctionnalités.
- Gardez un canal « production » (ex : 1.2.0) pour les releases stables.
- Ajoutez des canaux spécifiques à une plateforme (ex : « ios-hotfix » en version 1.2.1) pour traiter des problèmes propres à une plateforme.
Configuration de la politique de mise à jour: Contrôlez l'application des mises à jour via les options de configuration de Capgo. Par exemple :
```
{
  "plugins": {
    "CapacitorUpdater": {
      "disableAutoUpdate": "minor"
    }
  }
}
```
Cette configuration garantit que les utilisateurs reçoivent automatiquement les patchs, tandis que les mises à jour mineures et majeures nécessitent une approbation manuelle.
Stratégie de rollback de version: Utilisez des identifiants de pré-release pour conserver des options de rollback claires. Cette approche vous permet de revenir à une version précédente en cas de problème, tout en gardant un versioning cohérent sur tous les canaux.

Ces bonnes pratiques simplifient la gestion des mises à jour, le test des nouvelles fonctionnalités et le maintien de la stabilité de votre déploiement.

sbb-itb-f9944d2

Déploiement de mises à jour OTA

Une fois votre configuration de gestion des versions prête, suivez ces étapes pour déployer efficacement les mises à jour OTA.

Préparation de la mise à jour

Commencez par mettre à jour la version dans package.json et capacitor.config.json. Assurez-vous que la version respecte le format SemVer (MAJEUR.MINEUR.CORRECTION) :

Bug Fix: Augmenter le numéro PATCH (ex. : 1.0.1 → 1.0.2)
New Feature: Augmenter le numéro MINOR (ex. : 1.0.0 → 1.1.0)
Breaking change: Augmentez le numéro majeur (ex. : 1.0.0 → 2.0.0)

Testez minutieusement votre build et confirmez que l'app communique avec le serveur via notifyAppReady.

Ensuite, déterminez votre stratégie de mise à jour. Vous pouvez choisir parmi :

Mise à jour auto: Appliquez automatiquement les exigences de version minimale.
Contrôle manuel: Spécifiez des exigences de version exactes pour les mises à jour.
Basé sur les canaux: Utilisez des canaux pour les tests et les déploiements progressifs.

Commandes de mise à jour Capgo CLI

Use Capgo’s CLI to deploy your update with ease. Here’s how:

# Initialize Capgo in your project
npx @capgo/cli@latest init [apikey]

# Upload your update bundle
npx @capgo/cli bundle upload [appId]

# Add a new distribution channel
npx @capgo/cli channel add [channelName] [appId]

Capgo garantit un déploiement sécurisé grâce au chiffrement de bout en bout et à une gestion sûre des clés.

« @Capgo est un moyen intelligent de faire des pushes code à chaud (et pas pour tout l'argent du monde comme avec @AppFlow) 🙂 »

Une fois déployée, vous pouvez suivre les mises à jour via le dashboard de Capgo. Les mises à jour atteignent généralement les utilisateurs en quelques minutes après l’ouverture de l’application. Le processus fonctionne ainsi :

L’application vérifie les mises à jour.
Télécharge la mise à jour en arrière-plan.
Marque la nouvelle version comme active lorsque l’utilisateur quitte l’application.
Applique la mise à jour au prochain lancement.

Pour des déploiements de niveau entreprise, vous pouvez vouloir intégrer une automatisation CI/CD.

« Nous pratiquons le développement agile et @Capgo est indispensable pour livrer en continu à nos utilisateurs ! »

Résolution de problèmes et conseils

Problèmes de gestion des versions

Gérer le versionnage sémantique dans Capgo peut parfois compliquer le déploiement des mises à jour. Pour éviter d'écraser votre travail de développement, configurez ce qui suit dans votre capacitor.config.json fichier :

{ 
  "plugins": { 
    "CapacitorUpdater": { 
      "autoUpdate": false 
    } 
  } 
}

Si une mise à jour échoue, voici ce que vous pouvez faire :

Définissez autoUpdate vers false pendant le développement.
Désinstallez l’application.
Réinstallez-l’avec la version corrigée.
Réactivez les mises à jour automatiques une fois que tout est stable.

Pour les mises à jour de version majeure, utilisez disableAutoUpdateBreaking flag et écoutez l’ majorAvailable event to handle updates properly:

CapacitorUpdater.addListener('majorAvailable', (info) => {
  console.log(`Major update available: ${info.version}`);
  // Add your update prompt logic here
});

En combinant ces configurations avec de bonnes pratiques d'équipe, vous pouvez maintenir la cohérence des versions et réduire les erreurs.

Gestion des versions en équipe

Une fois les mises à jour individuelles gérées, il est crucial pour les équipes d'établir des pratiques de contrôle de version rigoureuses.

« Tester chaque changement avant de le fusionner avec le dépôt principal renforcera la stabilité et évitera des erreurs coûteuses » [4]

Voici quelques méthodes pour garantir la cohérence :

Définissez une branche comme le dépôt principal pour servir de source de vérité.
Utilisez des canaux Capgo distincts pour les environnements de développement et de production.
Automatisez l'upload des versions via des pipelines CI/CD.
Documentez tous les changements code avec des messages de commit clairs et détaillés.

Pour les équipes plus grandes, la matrice de gestion des versions suivante peut aider à organiser les mises à jour :

Environnement	Canal	Mise à jour auto	Format de version
Développement	dev	Désactivé	0.x.x
Scénographie	bêta	Activé	x.x.x-beta
la production	stable	Activé	x.x.x

Étapes de récupération d'une mise à jour

Même avec des précautions, les mises à jour peuvent échouer. Si cela arrive, suivez ces étapes de récupération :

Revenez à un bundle stable précédent.
Incrémentez les numéros de version pour toute nouvelle correction (note : les numéros de version ne peuvent pas être réutilisés après suppression) [2].
Verify updates during app startup to ensure they work as expected.

Le module de mise à jour de Capgo est conçu pour gérer les interruptions. Par exemple, si le serveur est inaccessible ou si une mise à jour est supprimée, l’application continue de fonctionner normalement [3]. De plus, les requêtes réseau échouées sont automatiquement réessayées au prochain lancement de l’application [3]. Cette résilience intégrée minimise les temps d’arrêt et garantit un fonctionnement plus fluide.

Résumé

Le Semantic Versioning, combiné à Capgo, a rendu les mises à jour OTA des applications Capacitor plus efficaces. Avec 947,6 millions de mises à jour livrées et 1 400 applications en production utilisant ce système [1], les processus de déploiement sont devenus 81 % plus efficaces [1]. Cette configuration permet aux développeurs de déployer des mises à jour rapidement et de manière contrôlée, en évitant les délais des stores.

Voici ce que disent les développeurs :

« Nous avons déployé Capgo mises à jour OTA en production pour notre base de +5000 utilisateurs. Le fonctionnement est très fluide : presque tous nos utilisateurs sont à jour quelques minutes seulement après le déploiement de l'OTA sur @Capgo.” - colenso [1]

Le système de versionnage MAJOR.MINOR.PATCH facilite la communication des changements cassants, des nouvelles fonctionnalités et des correctifs [5]. C’est particulièrement utile pour les équipes qui gèrent plusieurs releases par semaine via la plateforme de Capgo.

de Capgo solution chiffrée, intégré aux outils CI/CD, est également abordable – réduisant les coûts de jusqu’à 26 100 $ sur cinq ans [1]. Ses canaux personnalisables garantissent que les mises à jour atteignent les bons utilisateurs au bon moment.

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

Continuez avec Comment utiliser le versionnage sémantique avec les mises à jour OTA de Capgo

Si vous utilisez Comment utiliser le versionnage sémantique avec les mises à jour OTA Capgo 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.