Builds Android automatiques avec GitLab CI

Configurer la CI/CD pour les apps Capacitor peut être complexe et chronophage. Voici ce qu'il faut savoir :

Prerequisites

Avant de commencer, vous devrez configurer :

Un compte GitLab avec accès admin
Votre application déjà publiée sur le Play Store avec une signature correcte
Clé de signature Android et fichiers keystore
Projet Google Cloud Console avec API activé pour le Play Store
Compte de service avec les permissions adéquates
Compréhension des workflows GitLab CI/CD
Connaissance de la configuration Fastlane
Temps de maintenance et de debug du pipeline

Capgo Build pour CI/CD par Capgo

Évitez la maintenance de Fastlane, du runner Gradle, du keystore et du script d'upload. Build Capgo exécute des builds natifs Android signés depuis votre pipeline CI/CD existant :

Compatible avec votre pipeline: Déclenchez un Capgo Build depuis GitLab CI, GitHub Actions, Jenkins ou des scripts locaux après votre build web et npx cap sync.
Signature via les secrets CI: Conservez vos keystores Android, alias de clés, mots de passe et JSON du compte de service Play Console dans vos secrets CI.
Aucune maintenance de runner natif: Capgo Build fournit des environnements de build Android maintenus, vous évitant ainsi de gérer les images SDK, les problèmes de cache Gradle ou les lanes Fastlane.
Artifacts et soumission: Téléchargez des artifacts signés pour la QA ou soumettez des builds de release via Capgo CLI.

Tarifs

Les plans Capgo démarrent à 12 $/mois
Inclut les mises à jour OTA et environ 15 builds natifs par mois
Les minutes de build supplémentaires sont facturées à la minute via des crédits

Configurez Capgo Build dans votre CI/CD

Guide de configuration manuelle

Voici ce que vous devez faire :

Étapes à suivre dans l'article

Copier les fichiers Fastlane
Stocker vos secrets dans les secrets chiffrés de GitLab
Créer et stocker la clé de votre compte de service Google Play
Stocker votre clé de signature Android
Configurer votre fichier de workflow .yml GitLab

1. Copier les fichiers Fastlane

Fastlane est une bibliothèque Ruby créée pour automatiser les tâches courantes du développement mobile. Avec Fastlane, vous pouvez configurer des « lanes » personnalisées qui regroupent une série d'« actions » pour effectuer les tâches que vous feriez normalement via Android Studio. Vous pouvez faire énormément de choses avec Fastlane, mais pour ce tutoriel, nous n'utiliserons que quelques actions de base.

Créez un dossier Fastlane à la racine de votre projet et copiez-y 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

Stocker vos secrets dans les variables GitLab CI/CD

GitLab permet de stocker des variables CI/CD chiffrées, comme les secrets de dépôt de GitHub, afin de conserver vos informations sensibles en toute sécurité.

Accédez aux paramètres de votre projet GitLab.
Rendez-vous dans CI/CD > Variables
Ajoutez les variables suivantes :

ANDROID_KEYSTORE_FILE : le fichier .jks ou .keystore encodé en base64 utilisé pour signer vos builds Android. Il s’agit soit du fichier keystore associé à votre clé d’upload (si vous utilisez Play App Signing), soit de votre clé de signature d’application.
KEYSTORE_KEY_PASSWORD : le mot de passe associé au fichier keystore
KEYSTORE_KEY_ALIAS : l’alias du keystore
KEYSTORE_STORE_PASSWORD : le mot de passe de la clé privée
DEVELOPER_PACKAGE_NAME : l’ID de votre application Android, par exemple com.example.app
PLAY_CONFIG_JSON : la clé JSON du compte de service encodée en base64.

Créer une clé de compte de service Google Play

Pour générer le PLAY_CONFIG_JSON secret, suivez ces étapes :

Allez sur la Console Google Cloud
Créez un nouveau projet ou sélectionnez un projet existant
Activez l’API Google Play Android Developer
Créez un compte de service :
- Accédez à « IAM & Admin » > « Service Accounts »
- Cliquez sur « Create Service Account »
- Donnez-lui un nom et une description
- Cliquez sur « Créer et continuer »
- Ignorez l'attribution de rôl’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 clé »
- Choisissez le format JSON
- Cliquez sur « Créer »
Accordez au compte de service l'accès à votre application dans la Play Console :
- Accéder à Play Console
- Accédez à « Utilisateurs et autorisations »
- Cliquez sur « Inviter de nouveaux utilisateurs »
- Saisissez l'e-mail du compte de service (se terminant par @*.iam.gserviceaccount.com)
- Accordez la permission « Release to production »
- Cliquez 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 PLAY_CONFIG_JSON variable dans GitLab

Configurer votre pipeline GitLab CI/CD

Créez un fichier .gitlab-ci.yml à la racine de votre projet pour définir votre pipeline CI/CD. Voici un exemple de structure pour votre 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

Déclencher le pipeline

Dès que vous poussez un nouveau tag sur votre dépôt GitLab, GitLab CI/CD déclenche automatiquement le pipeline défini, qui compile et déploie votre application Android avec Fastlane.

Assurez-vous d'adapter les chemins et les dépendances à la structure et aux besoins de votre projet. Cette configuration vous aidera à automatiser le déploiement de votre application Android sur GitLab CI/CD.

Conclusion

En configurant GitLab CI/CD avec l'image Docker mingc/android-build-box, vous automatisez le build de votre application Android, ce qui rend votre workflow de développement plus efficace et fiable. Cette automatisation vous libère du temps pour vous concentrer sur l'essentiel du développement d'applications et vous aide à livrer plus efficacement des applications Android de haute qualité.

Continuer avec le build Android automatique Capacitor via GitLab

Si vous utilisez Build Android Capacitor automatique avec GitLab pour planifier l'automatisation CI/CD, et le connecter avec CI/CD Capgo pour le workflow produit dans le CI/CD de Capgo, Capgo Native Build pour le workflow produit dans les Native Builds de Capgo, Intégrations Capgo pour le workflow produit dans les intégrations de Capgo, Intégration CI/CD pour le détail d'implémentation dans l'intégration CI/CD, et Intégration GitHub Actions pour les détails d'implémentation de l'intégration GitHub Actions.