Automatisation de la construction Android avec GitLab CI

Configurer la CI/CD pour les applications Capacitor peut être complexe et fastidieux. Voici ce dont vous avez besoin de savoir :

Prerequisites

Avant de commencer, vous devrez configurer :

Un compte GitLab avec accès administrateur
Votre application est déjà publiée sur Google Play Store avec une signature appropriée
Clés de signature Android et fichiers de clés de stockage
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
Connaissances de la configuration de Fastlane
Temps pour maintenir et déboguer la pipeline

Capgo Build pour CI/CD par Capgo

Sauter 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 la Capgo construction à partir de GitLab CI, GitHub Actions, Jenkins ou scripts locaux après votre construction web et npx cap sync.
Signage à partir de secrets CI: Gardez vos clés Android, vos alias de clés, vos mots de passe et votre JSON de compte de service Play Console dans vos propres secrets CI.
Pas de maintenance de l'exécuteur natif: Capgo fournit des environnements de build Android maintenus, vous n'avez donc pas à gérer les images SDK, les problèmes de cache Gradle ou les voies Fastlane.
Artéfacts et soumissionTéléchargez les artefacts signés pour les tests de qualité ou soumettez des builds de version à travers le Capgo CLI.

Pricing

Les plans Capgo commencent à 12$/mois
: Les minutes de construction supplémentaires sont facturées par minute par crédits
: Définissez la __CAPGO_KEEP_0__ construction dans CI/CD

: Définissez la construction Capgo dans CI/CD

Guide de configuration manuelle

Voici ce dont vous avez besoin pour faire ceci :

Étapes à suivre dans cet article

Copiez les fichiers Fastlane
Stockez vos secrets dans les secrets chiffrés de GitLab
Création et stockage de votre clé de compte Google Play service
Stockez votre clé de signature Android
Configurez votre fichier de workflow .yml de GitLab

1. Copiez 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 rassemblent une série d’« actions » qui exécutent des tâches que vous feriez normalement à l’aide d’Android Studio. Vous pouvez faire beaucoup de choses avec Fastlane, mais pour les besoins de cet article, 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 de GitLab CI/CD

GitLab fournit une méthode pour stocker des variables CI/CD chiffrées, similaire aux secrets de GitHub’s repository.

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

ANDROID_KEYSTORE_FILE : le fichier base64 codé .jks ou .keystore file used to sign your Android builds. This will either be the keystore file associated with your upload key (if using Play App Signing), or your app signing key.
MOT_DE_PASSE_KEystore: le mot de passe associé au fichier de clé de stockage
KEYSTORE_KEY_ALIAS : l'alias de la clé de magasin
KEYSTORE_KEY_ALIAS : l'alias de la clé de magasin
KEYSTORE_STORE_PASSWORD : le mot de passe de la clé privée
DEVELOPER_PACKAGE_NAME : votre ID d'application Android comme com.example.app

Créer une clé de compte Google Play Service

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

Allez sur le Console de Google Cloud
Créez un nouveau projet ou sélectionnez un projet existant
Activer le Google Play Android Developer API
Créer un compte de service :
- Allez dans « IAM & Admin » > « Comptes de service »
- Cliquez sur « Créer un compte de service »
- Donnez-lui un nom et une description
- Cliquez sur « Créer et continuer »
- Ignorer 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 « Trois points » > « Gérer les clés »
- Click “Add Key” > “Create new key”
- 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 »
- Cliquez sur « Inviter de nouveaux utilisateurs »
- Entrez l'adresse e-mail du compte de service (terminée par @*.iam.gserviceaccount.com)
- Accordez la permission « Sortie en production »
- Cliquez sur « Invitez 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 Configurer votre pipeline CI/CD GitLab

Configurez votre pipeline CI/CD GitLab

Create a .gitlab-ci.yml file at the root of your project to define your CI/CD pipeline. Below is an example of how you can structure your 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éclenchez le pipeline

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.

Make sure to adjust the paths and dependencies according to your project’s structure and requirements. This setup will help you automate the deployment of your Android app on GitLab CI/CD.

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 essentiels du développement d'applications, ce qui vous aide à livrer des applications Android de haute qualité plus efficacement.

Continuez avec la construction automatique d'Android avec GitLab Capacitor

Si vous utilisez La construction automatique d'Android avec GitLab Capacitor pour planifier l'automatisation de CI/CD, connectez-l’à 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 d'Capacitor Android avec GitLab