Construction automatique des builds Android avec GitLab CI

La mise en place de la CI/CD pour les applications Capacitor peut être complexe et chronophage. Voici ce dont vous avez besoin de savoir :

Prérequis

Avant de commencer, vous devrez configurer :

A un compte GitLab avec accès administrateur
Votre application déjà publiée sur Google Play Store avec une signature appropriée
Clés et fichiers de clés de signature Android
Projet Google Cloud Console avec Play Store API activé
Compte de service avec les permissions appropriées
Compréhension des workflows CI/CD de GitLab
Connaissance de la configuration de Fastlane
Temps pour maintenir et déboguer la pipeline

Capgo Build pour CI/CD par Capgo

Évitez la maintenance de Fastlane, du runner Gradle, de la clé de signature et de l'upload-script. Capgo Build exécute des builds natifs Android signés à partir de votre pipeline CI/CD existant :

Fonctionne avec votre pipeline : Déclenchez Capgo Build à partir de GitLab CI, GitHub Actions, Jenkins ou scripts locaux après votre build web et npx cap sync.
Signature à partir de secrets CI : Gardez les clés de magasin Android, les alias de clés, les mots de passe et le JSON de compte de service de console Play dans vos propres secrets CI.
Pas de maintenance de l'exécuteur natif : Capgo Build fournit des environnements de build Android maintenus, vous n'avez donc pas à gérer SDK images, les problèmes de cache Gradle ou les voies de Fastlane.
Artéfacts et soumission : Téléchargez les artéfacts signés pour les tests de qualité ou soumettez les builds de lancement à travers le Capgo CLI.

Tarification

Les plans Capgo commencent à 12 $/mois
Comprennent les mises à jour OTA et environ 15 builds natifs par mois
Les minutes de build supplémentaires sont facturées par minute à l'aide de crédits

Configurer Capgo dans l'environnement CI/CD

Guide de configuration manuelle

Voici ce que vous devez faire :

Étapes à suivre dans le post

Copier les fichiers Fastlane
Stockez vos secrets dans les secrets GitLab chiffrés
Créer et stocker votre clé de compte de service Google Play
Stockez votre clé de signature Android
Configurer votre flux de travail GitLab .yml

1. Copier les fichiers Fastlane

Fastlane est une bibliothèque Ruby créée pour automatiser les tâches de développement mobile courantes. En utilisant Fastlane, vous pouvez configurer des « chemins » personnalisés qui regroupent une série d'« actions » qui exécutent des tâches que vous effectueriez normalement à l'aide d'Android Studio. Vous pouvez faire beaucoup de choses avec Fastlane, mais pour les besoins de ce tutoriel, nous utiliserons uniquement une poignée d'actions de base.

Créez un dossier Fastlane à la racine de votre projet et copiez les fichiers suivants : Fastlane

default_platform(:android)

KEYSTORE_KEY_ALIAS = ENV["KEYSTORE_KEY_ALIAS"]
KEYSTORE_KEY_PASSWORD = ENV["KEYSTORE_KEY_PASSWORD"]
KEYSTORE_STORE_PASSWORD = ENV["KEYSTORE_STORE_PASSWORD"]

platform :android do
    desc "Deploy a beta version to the Google Play"
    private_lane :verify_changelog_exists do |version_code: |
      changelog_path = "android/metadata/en-US/changelogs/#{version_code}.txt"
      UI.user_error!("Missing changelog file at #{changelog_path}") unless File.exist?(changelog_path)
      UI.message("Changelog exists for version code #{version_code}")
    end

    private_lane :verify_upload_to_staging do |version_name: |
      UI.message "Skipping staging verification step"
    end
    lane :beta do
				keystore_path = "#{Dir.tmpdir}/build_keystore.keystore"
				File.write(keystore_path, Base64.decode64(ENV['ANDROID_KEYSTORE_FILE']))
				json_key_data = Base64.decode64(ENV['PLAY_CONFIG_JSON'])
				previous_build_number = google_play_track_version_codes(
					package_name: ENV['DEVELOPER_PACKAGE_NAME'],
					track: "internal",
					json_key_data: json_key_data,
				)[0]

				current_build_number = previous_build_number + 1
				sh("export NEW_BUILD_NUMBER=#{current_build_number}")
        gradle(
          task: "clean bundleRelease",
          project_dir: 'android/',
          print_command: false,
          properties: {
            "android.injected.signing.store.file" => "#{keystore_path}",
            "android.injected.signing.store.password" => "#{KEYSTORE_STORE_PASSWORD}",
            "android.injected.signing.key.alias" => "#{KEYSTORE_KEY_ALIAS}",
            "android.injected.signing.key.password" => "#{KEYSTORE_KEY_PASSWORD}",
						'versionCode' => current_build_number
          })
        upload_to_play_store(
					package_name: ENV['DEVELOPER_PACKAGE_NAME'],
					json_key_data: json_key_data,
          track: 'internal',
          release_status: 'completed',
          skip_upload_metadata: true,
          skip_upload_changelogs: true,
          skip_upload_images: true,
          skip_upload_screenshots: true,
        )
    end
    lane :build do
      gradle(
        task: "clean bundleRelease",
        project_dir: 'android/',
        print_command: false,
        properties: {
          "android.injected.signing.store.file" => "#{keystore_path}",
          "android.injected.signing.store.password" => "#{KEYSTORE_STORE_PASSWORD}",
          "android.injected.signing.key.alias" => "#{KEYSTORE_KEY_ALIAS}",
          "android.injected.signing.key.password" => "#{KEYSTORE_KEY_PASSWORD}",
        })
    end
    lane :prod_release do
      build_gradle = File.read("../android/app/build.gradle")

      verify_changelog_exists(version_code: build_gradle.match(/versionCode (\d+)/)[1])
      verify_upload_to_staging(version_name: build_gradle.match(/versionName '([\d\.]+)'/)[1])

      supply(
        track_promote_to: 'beta',
        skip_upload_apk: true,
        skip_upload_aab: true,
        skip_upload_metadata: false,
        skip_upload_changelogs: false,
        skip_upload_images: false,
        skip_upload_screenshots: false
      )
    end
end

Stockez vos secrets dans les variables GitLab CI/CD

GitLab propose une méthode pour stocker des variables CI/CD chiffrées, similaires aux secrets de votre dépôt GitHub.

Allez dans les paramètres de votre projet GitLab.
Naviguez vers CI/CD > Variables
Ajoutez les variables suivantes :

ANDROID_KEYSTORE_FILE : le fichier encodé en base64 .jks ou .keystore utilisé pour signer vos builds Android. Il s'agira soit du fichier clé associé à votre clé de téléversement (si vous utilisez Play App Signing), soit de votre clé de signature d'application.
KEYSTORE_KEY_PASSWORD : le mot de passe associé au fichier clé
KEYSTORE_KEY_ALIAS : l'alias de la clé de stockage
KEYSTORE_STORE_PASSWORD : le mot de passe de la clé privée
DÉVELOPPEUR_PACKAGE_NAME : votre ID d'application Android comme com.example.app
PLAY_CONFIG_JSON: La clé JSON du compte d'utilisateur Google encodée en base64.

Création d'un compte d'utilisateur Google Play

Pour générer la clé secrète, suivez ces étapes : PLAY_CONFIG_JSON Allez sur le

Console de Cloud Google Créez un nouveau projet ou sélectionnez un projet existant
Activer le développeur Android Google Play __CAPGO_KEEP_0__
Enable the Google Play Android Developer API
Allez dans « IAM & Admin » > « Comptes d'utilisateur »
- Cliquez sur « Créer un compte d'utilisateur »
- Nommez-le et ajoutez une description
- Enable the Google Play Android Developer __CAPGO_KEEP_0__
- Clicker sur « Créer et continuer »
- Passer par la mise en œuvre du rôle et cliquez sur « Terminé »
Générez une clé JSON :
- Trouvez votre compte de service dans la liste
- Cliquez sur le menu des trois points > « Gérer les clés »
- Cliquez sur « Ajouter une clé » > « Créer une nouvelle clé »
- Choisissez le format JSON
- Cliquez sur « Créer »
Accordez au compte de service l'accès à votre application dans le console de jeu :
- Allez à Console de jeu
- Naviguez vers « Utilisateurs et permissions »
- Clickez sur « Inviter de nouveaux utilisateurs »
- Entrez l'adresse e-mail du compte de service (qui se termine par @*.iam.gserviceaccount.com)
- Accordez la permission « Déploiement en production »
- Clickez sur « Inviter un utilisateur »

Convertissez la clé JSON en base64 :

base64 -i path/to/your/service-account-key.json | pbcopy

Ajoutez la chaîne encodée en base64 comme variable dans GitLab PLAY_CONFIG_JSON Configurer votre pipeline CI/CD GitLab

Créez un fichier .gitlab-ci.yml à la racine de votre projet pour définir votre pipeline CI/CD. Voici un exemple de la structure que vous pouvez utiliser :

Déclenchez la Pipeline


image: mingc/android-build-box:latest

stages:
  - build
  - upload_to_capgo
  - build_and_upload_android

build:
  stage: build
  tags:
    - saas-linux-xlarge-amd64
  cache:
    - key:
        files:
          - bun.lockb
      paths:
        - .node_modules/
  script:
    - npm install
    - npm run build
  artifacts:
    paths:
      - node_modules/
      - dist/
  only:
    - master

upload_to_capgo:
  stage: upload_to_capgo
  tags:
    - saas-linux-xlarge-amd64
  script:
    - npx @capgo/cli@latest bundle upload -a $CAPGO_TOKEN -c dev
  dependencies:
    - build
  when: manual
  only:
    - master

build_and_upload_android:
  tags:
    - saas-linux-xlarge-amd64
  stage:    build_and_upload_android
  cache:
    - key:
        files:
          - android/gradle/wrapper/gradle-wrapper.properties
      paths:
        - ~/.gradle/caches/
  script:
    - npx cap sync android
    - npx cap copy android
    - bundle exec fastlane android beta # We do create a tag for the build to trigger XCode cloud builds
  dependencies:
    - build
  when: manual
  only:
    - master

Chaque fois que vous publiez une nouvelle étiquette dans votre dépôt GitLab, GitLab CI/CD déclenchera automatiquement la pipeline définie, qui construira et déployera votre application Android à l'aide de Fastlane.

Assurez-vous de réajuster les chemins et les dépendances en fonction de la structure et des besoins de votre projet. Cette configuration vous aidera à automatiser le déploiement de votre application Android sur GitLab CI/CD.

Clickez sur « Inviter de nouveaux utilisateurs »

Conclusion

En configurant GitLab CI/CD avec l'image Docker mingc/android-build-box, vous pouvez automatiser le processus de construction de l'application Android, ce qui rend votre flux de développement plus efficace et fiable. Cette automatisation libère votre temps pour vous concentrer sur les aspects clés du développement d'applications, ce qui vous aide finalement à livrer des applications Android de haute qualité de manière plus efficace.

Continuez de l'automatisation automatique Capacitor d'applications Android avec GitLab

Si vous utilisez Automatisation automatique Capacitor d'applications Android avec GitLab pour planifier l'automatisation CI/CD, connectez-la avec Capgo CI/CD pour le flux de workflow du produit dans Capgo CI/CD, Capgo Builds natifs pour le flux de workflow du produit dans Capgo Builds natifs, Capgo Intégrations pour le flux de workflow du produit dans Capgo Intégrations, Intégration CI/CD pour les détails d'implémentation dans l'intégration CI/CD, et GitHub Actions d'intégration pour les détails d'implémentation dans GitHub Actions d'intégration.

Construction automatique de l'Capacitor de l'Android avec GitLab