Constructions Android automatiques avec GitLab CI

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

Prérequis

Avant de commencer, vous devrez configurer :

Un compte GitLab avec accès administrateur
Votre application déjà publiée sur Google Play Store avec un signe approprié
Clé de signature Android et fichiers de clé de stockage
Projet Google Cloud Console avec le magasin Play 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 nécessaire pour maintenir et déboguer la pipeline

Capgo Construction par Capgo pour les CI/CD

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

Compatibilité avec votre pipeline: Déclenchez Capgo Construction à partir de GitLab CI, d'GitHub Actions, Jenkins ou de scripts locaux après votre build web et npx cap sync.
Signature à partir de secrets CI: Gardez les coffres de clés Android, les alias de clés, les mots de passe et le JSON du compte de service de la console Google Play dans vos propres secrets CI.
Aucune maintenance du lanceur natif: Capgo Construction fournit des environnements de construction Android maintenus, vous n'avez donc pas à gérer les images SDK, les problèmes de cache Gradle ou les voies de Fastlane.
Artificats et soumission: Téléchargez les artefacts signés pour la QA ou soumettez les builds de version à travers le Capgo CLI.

Prix

Capgo plans start at $12/month
Les plans __CAPGO_KEEP_0__ commencent à 12 $/mois
Comprend les mises à jour OTA et environ 15 builds natifs par mois

Set up Capgo Build in CI/CD

context":"Page/area: Capgo Builder / native cloud build product page. Role: Website copy sentence. Seen in: page native-build.astro. Message key `native_build_builder_build_minutes` (Native Build Builder Build Minutes)."

Configurez __CAPGO_KEEP_0__ Build dans CI/CD

Guide de configuration manuelle

Ici, voici ce que vous devez faire :
Étapes à suivre dans l'article ci-dessous : : Copiez les fichiers Fastlane : Stockez vos secrets dans les secrets chiffrés de GitLab
Créer & stocker 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 « voies » personnalisées qui rassemblent une série d'« actions » qui exécutent des tâches que vous effectueriez normalement à l'aide d'Android Studio. Vous pouvez faire beaucoup 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 de GitLab CI/CD

GitLab fournit un moyen de stocker des variables CI/CD chiffrées, similaires aux secrets de repository de GitHub . Pour stocker vos informations sensibles de manière sécurisée.

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

ANDROID_KEYSTORE_FILE : le fichier base64-encodé .jks ou .keystore le fichier utilisé pour signer vos builds Android. Cela sera soit le fichier de clé de stockage associé à votre clé d'upload (si vous utilisez Play App Signing), ou votre clé de signature d'application.
KEYSTORE_KEY_PASSWORD : le mot de passe associé au fichier de clé de stockage
KEYSTORE_KEY_ALIAS : l'alias de la clé de stockage
KEYSTORE_STORE_PASSWORD : le mot de passe de la clé privée
DEVELOPER_PACKAGE_NAME : votre ID d'application Android comme par exemple com.example.app
PLAY_CONFIG_JSON : La clé JSON de service base64 codée.

Créer une clé de service Google Play

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

Allez sur le Console Cloud Google
Créez un nouveau projet ou sélectionnez-en un existant
Activer le développeur Android Google Play API
Créez 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 »
- Omettre 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 »
- 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 »
- Cliquez sur « Inviter de nouveaux utilisateurs »
- Entrez l'adresse e-mail du compte de service (se termine par @*.iam.gserviceaccount.com)
- Accordez la permission « Lancer en production »
- Cliquez sur « Inviter l'utilisateur »

Convertissez la clé JSON en base64 :

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

Ajoutez la chaîne base64 encodée en tant que PLAY_CONFIG_JSON variable dans GitLab

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 structure de pipeline que vous pouvez utiliser :


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 la pipeline

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 modifier 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.

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é de manière plus efficace.

Keep going from Automatic Capacitor Android build with GitLab

Si vous utilisez Automatic Capacitor Android build with GitLab pour planifier l'automatisation de CI/CD, connectez-l’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 Integrations for the product workflow in Capgo Integrations, Intégration CI/CD pour le détail d'implémentation dans Intégration CI/CD, et GitHub Actions Integration for the implementation detail in GitHub Actions Integration.