Comment personnaliser les scripts de construction avec Capacitor CLI

Capacitor CLI vous permet de personnaliser le processus de construction de votre application pour les plateformes iOS, Android et web. En ajustant les scripts de construction, vous pouvez :

• Accélérer les mises à jour: Envoyer des modifications instantanément sans retard des magasins d'applications.
• Gestion des déploiements: Annuler les mises à jour ou cibler des groupes d'utilisateurs spécifiques.
• Protéger votre application: Utilisez l'encryption pour protéger les mises à jour.
• Optimiser les builds: Ajustez les paramètres pour répondre aux besoins spécifiques des plateformes.

Aperçu rapide des fonctionnalités clés : 

• Fichiers de configuration: Utilisez capacitor.config.json et package.json pour gérer les paramètres de build.
• Scripts personnalisés: Ajoutez des tâches pré et post-construction pour l'automatisation.
• Build Hooks: Exécutez code lors de certaines étapes du processus de construction.
• Variables d'environnement: Simplifiez les constructions spécifiques à l'environnement avec .env files.

Capgo, un outil de déploiement, améliore ce processus avec mises à jour automatiques, suivi de version, et optimisation de performances globale. Lisez-en davantage pour apprendre à configurer et personnaliser vos scripts de construction pour une efficacité maximale.

Introduire Capacitor Configurer

Processus de construction par défaut dans Capacitor

Comprendre comment Capacitor gère son processus de construction par défaut est crucial si vous souhaitez le personnaliser efficacement. En dessous, nous décomposerons le processus de construction de la Capacitor CLI et ses fichiers de configuration clés.

Étapes de construction standard

Capacitor utilise un processus étape par étape pour transformer votre application web en builds spécifiques au plateau. Voici ce qui se passe pendant le processus de construction par défaut :

Fichiers de configuration principaux

Deux fichiers de configuration clés déterminent comment Capacitor gère vos constructions :

capacitor.config.json
Ceci est le fichier de configuration principal de votre projet Capacitor. Il définit les paramètres importants pour vos builds :

{
  "appId": "com.example.app",
  "appName": "MyApp",
  "webDir": "dist",
  "bundledWebRuntime": false,
  "plugins": {
    "SplashScreen": {
      "launchShowDuration": 3000
    }
  }
}

• appId : Un identifiant unique pour votre application.
• appName : Le nom de votre application.
• webDir : Spécifie où Capacitor doit chercher les actifs web (par exemple, dist).
• plugins : Permet de configurer les paramètres spécifiques des plugins, comme les options de SplashScreen.

package.json
Ce fichier inclut les scripts de construction et les dépendances qui influencent le processus de construction :

{
  "scripts": {
    "build": "npm run build:web && cap sync",
    "build:web": "vite build",
    "cap:build": "cap build"
  }
}

• Le webDir paramètre indique à __CAPGO_KEEP_0__ où localiser vos actifs web compilés pour leur inclusion dans les builds natifs. capacitor.config.json tells Capacitor where to locate your compiled web assets for inclusion in the native builds.
• __CAPGO_KEEP_0__ se réinitialisera automatiquement lors de la prochaine construction. capacitor.config.jsonVous devez exécuter cap sync pour vous assurer que vos projets natifs sont mis à jour.

Ensuite, nous allons explorer comment vous pouvez modifier ces paramètres pour personnaliser vos builds encore plus.

Modification des scripts de construction

Vous pouvez adapter le processus de construction par défaut de Capacitor pour mieux répondre aux besoins de votre projet. Voici comment faire :

Paramètres du fichier de configuration

Vous pouvez ajuster le processus de construction en éditant le capacitor.config.json fichier. Voici un exemple de configuration :

{
  "appId": "com.example.app",
  "webDir": "www",
  "server": {
    "hostname": "localhost",
    "androidScheme": "https",
    "iosScheme": "https",
    "allowNavigation": ["*.example.com"]
  },
  "android": {
    "buildOptions": {
      "keystorePath": "release.keystore",
      "keystorePassword": "mypassword",
      "keystoreAlias": "release",
      "keystoreAliasPassword": "mypassword"
    }
  },
  "ios": {
    "scheme": "App",
    "automaticProvisioning": true
  }
}

Voici quelques paramètres clés que vous pouvez modifier :

• webDir: Spécifie où se trouvent vos actifs web compilés.
• server: Configure le serveur de développement, y compris l'hôte et les autorisations de navigation.
• android/ios: Permet des paramètres de construction spécifiques au plateforme, comme les détails de la clé de stockage pour Android ou les options de provisionnement pour iOS.

Créer des NPM Scripts

Pour rationaliser votre flux de travail, ajoutez des scripts personnalisés NPM à votre package.json fichier. Voici un exemple :

{
  "scripts": {
    "prebuild": "node ./scripts/prepare-env.js",
    "build": "npm run build:web && cap sync",
    "build:web": "vite build",
    "build:ios": "cap build ios --release",
    "build:android": "cap build android --release",
    "postbuild": "node ./scripts/notify-completion.js"
  }
}

• prebuild et : Utilisez-les pour des tâches telles que la configuration de l'environnement ou l'envoi de notifications lorsque la construction est terminée. postbuild: Commandes spécifiques au plateau pour construire des applications Android ou iOS.
• build:platformVous pouvez aller plus loin dans l'automatisation en ajoutant des hooks de construction.

Configuration des Hooks de Construction

Pour un contrôle plus avancé, utilisez les hooks de construction pour exécuter des __CAPGO_KEEP_0__ personnalisés à des points spécifiques du processus de construction. Voici un exemple de configuration dans

For more advanced control, use build hooks to execute custom code at specific points during the build process. Here’s an example setup in capacitor.config.ts:

import { CapacitorConfig } from '@capacitor/cli';

const config: CapacitorConfig = {
  appId: 'com.example.app',
  plugins: {
    CapacitorHooks: {
      beforeBuild: async () => {
        console.log('Running pre-build tasks...');
        // Add your pre-build tasks here
      },
      afterBuild: async () => {
        console.log('Running post-build tasks...');
        // Add your post-build tasks here
      }
    }
  }
};

export default config;

Valider les exigences avant le démarrage de la construction

• Transformer les actifs pendant le processus
• Utilisez-les pour des tâches telles que la configuration de l'environnement ou l'envoi de notifications lorsque la construction est terminée.
• Déclencher des notifications à des points clés
• Mettre à jour les numéros de version automatiquement
• Exécuter des tests automatisés de manière fluide

Cette approche vous offre une plus grande flexibilité et contrôle sur l'ensemble du cycle de construction.

Personnalisation de la construction avancée

Lorsque vous travaillez sur des projets plus importants, l'optimisation de votre processus de construction peut faire une grande différence. Voici comment gérer les constructions spécifiques à l'environnement et les personnalisations de plateforme de manière efficace.

Variables d'environnement

Configurer les variables d'environnement en créant des fichiers séparés pour chaque environnement : .env Configurez ensuite votre script de construction pour charger le fichier approprié en fonction de l'environnement :

• .env.development
• .env.staging
• .env.production

Vous pouvez encore ajuster ces paramètres pour les adapter aux exigences spécifiques de la plateforme.

import { defineConfig } from '@capacitor/cli';

export default defineConfig({
  ios: {
    buildConfig: {
      environment: process.env.BUILD_ENV || 'development',
      configurations: {
        development: {
          signing: {
            debug: true,
            automaticProvisioning: true
          }
        },
        production: {
          signing: {
            release: true,
            provisioningProfile: 'dist/profile.mobileprovision'
          }
        }
      }
    }
  }
});

Constructions spécifiques à la plateforme

Vous pouvez configurer les variables d'environnement en créant des fichiers séparés pour chaque environnement : __CAPGO_KEEP_0__

To personnaliser les builds pour Android et iOS, utilisez la structure suivante :

const platformConfig = {
  android: {
    buildType: process.env.BUILD_TYPE || 'debug',
    keystoreConfig: {
      path: process.env.KEYSTORE_PATH,
      password: process.env.KEYSTORE_PASSWORD,
      alias: process.env.KEYSTORE_ALIAS
    }
  },
  ios: {
    scheme: process.env.APP_SCHEME || 'App',
    xcodePreferences: {
      automaticSigning: false,
      developmentTeam: process.env.DEVELOPMENT_TEAM
    }
  }
};

Ces configurations vous permettent de personnaliser les builds pour chaque plateforme, garantissant des déploiements plus fluides.

D'autres conseils pour optimiser vos builds incluent :

• L'utilisation de mises à jour partielles pour économiser du temps lors des déploiements
• La configuration de la traçabilité des erreurs pour identifier rapidement les problèmes
• La création de systèmes de canaux pour les versions de test en bêta
• La mise en œuvre de la cryptage de bout en bout pour une distribution sécurisée

Lorsqu'ils sont associés à des outils comme Capgo pour les analyses et les mises à jour sécurisées, ces techniques vous donnent plus de contrôle sur votre processus de déploiement [1].

Problèmes de Script de Construction & Corrections

Lorsque vous travaillez avec des configurations de construction personnalisées, résoudre rapidement les erreurs est crucial pour maintenir le processus de construction en cours de manière fluide.

Réparez les Erreurs Fréquentes

Beaucoup de problèmes de script de construction proviennent de la configuration de l'environnement ou de problèmes de dépendances. Voici comment aborder certains d'entre eux :

Variables d'Environnement Manquantes

Si vous rencontrez une erreur comme celle-ci :

error: Cannot find environment configuration for BUILD_ENV

Vous pouvez la corriger en créant un fichier .env.local dans le répertoire racine de votre projet. Voici un exemple :

BUILD_ENV=development
CAPACITOR_PLATFORM=ios
BUILD_TYPE=debug

Échecs de Construction Spécifiques au Plateforme

Pour les erreurs de signature Android, utilisez cette commande :

npx cap build android --keystorePassword=$KEYSTORE_PASSWORD --keystoreAlias=$KEYSTORE_ALIAS

Pour les problèmes de profil de provisionnement iOS, essayez ceci :

npx cap build ios --configuration=release --type=development

Après avoir appliqué les corrections, assurez-vous que vos modifications sont solides en exécutant des tests de construction approfondis.

Testez les scripts de construction

Une fois les erreurs résolues, validez vos scripts de construction avec ces étapes :

• Vérification automatique : Exécutez des commandes clés pour confirmer que le processus de construction fonctionne comme prévu.

npm run build
npx cap sync
npx cap copy

• Validation de l'environnement : Vérifiez les variables d'environnement manquantes avant de démarrer la construction.

const requiredVars = ['BUILD_ENV', 'KEYSTORE_PATH'];
requiredVars.forEach(varName => {
  if (!process.env[varName]) {
    throw new Error(`Missing required env var: ${varName}`);
  }
});

• Débogage des scripts de construction : Ajoutez des scripts détaillés pour attraper les problèmes potentiels pendant la construction.

{
  "scripts": {
    "build:debug": "NODE_ENV=development npx cap build --verbose",
    "build:release": "NODE_ENV=production npx cap build --verbose"
  }
}

Conseils supplémentaires pour la mise en œuvre de tests :

• Utilisez Docker conteneurs pour isoler les builds.
• Validez les fichiers de configuration avant de démarrer le processus.
• Testez avec plusieurs versions de Node.js. Confirmez que les exigences spécifiques au plateau sont remplies.
• Surveillez la performance de la construction pour des améliorations possibles.
• __CAPGO_KEEP_0__

Capgo __CAPGO_KEEP_0__ Tableau de bord d'actualisation en temps réel Interface

Capgo améliore considérablement les scripts de construction en automatisant la mise en ligne, augmentant l'efficacité et simplifiant le processus.

Mises à jour rapides des applications

Capgo se distingue par ses performances d'actualisation impressionnantes :

• 95% des utilisateurs actifs reçoivent des mises à jour dans les 24 heures.
• Taux de réussite de 82% pour la livraison de mises à jour à l'échelle mondiale.
• Un temps de réponse moyen de API de 434ms à l'échelle mondiale La plateforme utilise des mises à jour partielles, ce qui signifie que seuls les changements sont téléchargés. Cette approche réduit l'utilisation de la bande passante et accélère le processus d'actualisation. De plus, tout le processus de construction est entièrement automatisé, ce qui économise du temps et de l'effort..

Automatisation de la construction

__CAPGO_KEEP_0__ fonctionne en toute transparence avec les principaux plateformes CI/CD, offrant une variété d'intégrations :

Capgo

Configuration d'une mise en ligne automatique coûte généralement autour de $300 par mois, ce qui est beaucoup plus abordable par rapport aux solutions traditionnelles qui peuvent aller jusqu'à $6,000 par an.

Normes de sécurité

Capgo donne la priorité à la sécurité avec un cadre robuste qui comprend :

• Chiffrement de bout en bout des packages de mise à jour.
• Gestion des clés sécurisée.
• Conformité aux lignes directrices d'Apple et de Google.

Fonctionnalités de contrôle de version

• Options de retrait instantané.
• Suivi de la version de déploiement.
• La gestion des canaux d'actualisation pour les versions en phase de test.

Cette sécurité a été rigoureusement testée sur des centaines d'applications d'entreprise. Pour les équipes ayant besoin d'une sécurité supplémentaire, Capgo propose également des solutions auto-hébergées avec des configurations personnalisables.

Le système de canaux de Capgo permet une distribution flexible des mises à jour. Les développeurs peuvent cibler des groupes d'utilisateurs spécifiques avec différentes versions, parfait pour les tests de beta ou les lancements progressifs.

Résumé

Vue d'ensemble des étapes de construction

Les scripts de construction personnalisés permettent des déploiements automatisés et cohérents en exploitant les appels de fonctions de construction, les variables d'environnement et les commandes spécifiques au plateau. Ces processus créent une base solide pour les améliorations de déploiement rendues possibles avec Capgo.

Avantages de Capgo

Capgo simplifie le déploiement, ayant réussi à livrer plus de 23,5 millions d'actualisations sur 750 applications de production. [1]Son système d'actualisation partiel réduit à la fois la consommation de bande passante et le temps de déploiement.

La plateforme fournit des mises à jour rapides, une optimisation de performances mondiale, une encryption de bout en bout pour la sécurité et un système de distribution basé sur des canaux flexible. Cette configuration prend en charge les mises à jour ciblées, les tests de beta et le respect des lignes directrices des magasins d'applications tout en maintenant un cadre de sécurité solide.

Continuez de la section Comment personnaliser les scripts de construction avec Capacitor CLI

Si vous utilisez How to Customize Build Scripts avec Capacitor CLI pour planifier l'automatisation CI/CD, le connecter avec Capgo CI/CD pour le flux de travail du produit dans Capgo CI/CD, Capgo Builds natifs pour le flux de travail du produit dans Capgo Builds natifs, Capgo Intégrations pour le flux de travail du produit dans Capgo Intégrations, L'intégration CI/CD pour les détails d'implémentation dans L'intégration CI/CD, et GitHub Intégration d'actions pour les détails d'implémentation dans GitHub Intégration d'actions.