Automatic Android Builds dengan GitLab CI

Setup CI/CD untuk aplikasi Capacitor bisa jadi rumit dan memakan waktu. Berikut hal yang perlu Anda ketahui:

Prerequisites

Sebelum memulai, Anda perlu menyiapkan:

Akun GitLab dengan akses admin
Aplikasi sudah rilis di Google Play Store dengan signing yang benar
Android signing key dan file keystore
Proyek Google Cloud Console dengan API Play Store aktif
Service account dengan izin yang sesuai
Pemahaman workflow GitLab CI/CD
Pengetahuan konfigurasi Fastlane
Waktu untuk maintenance dan debug pipeline

Capgo Build untuk CI/CD oleh Capgo

Lewati maintenance Fastlane, Gradle runner, keystore, dan upload-script. Capgo Build menjalankan signed Native Build Android dari pipeline CI/CD Anda:

Bekerja dengan pipeline Anda: Trigger Capgo Build dari GitLab CI, GitHub Actions, Jenkins, atau skrip lokal setelah web build Anda dan npx cap sync.
Signing dari CI secrets: Simpan Android keystore, key alias, password, dan JSON service account Play Console di CI secrets Anda sendiri.
Tanpa maintenance native runner: Capgo Build menyediakan environment Android build yang terkelola, jadi Anda tidak perlu mengelola SDK images, masalah Gradle cache, atau Fastlane lanes.
Artifacts dan submission: Download signed artifacts untuk QA atau submit release build melalui Capgo CLI.

Harga

Paket Capgo mulai dari $12/bulan
Termasuk OTA updates dan sekitar 15 native builds per bulan
Tambahan menit build ditagih per menit melalui credit

Setup Capgo Build di CI/CD

Panduan Setup Manual

Berikut langkah-langkah yang perlu Anda lakukan:

Langkah-langkah dalam postingan ini

Salin file Fastlane
Simpan secret Anda di GitLab encrypted secrets
Membuat & menyimpan Google Play service account key
Simpan Android signing key Anda
Setup file workflow .yml GitLab Anda

1. Salin file Fastlane

Fastlane adalah library Ruby yang dibuat untuk mengotomatisasi tugas pengembangan mobile yang umum. Dengan Fastlane, Anda bisa mengonfigurasi "lanes" kustom yang membundel serangkaian "actions" untuk menjalankan tugas yang biasanya dilakukan di Android Studio. Anda bisa melakukan banyak hal dengan Fastlane, namun untuk tutorial ini, kita hanya akan menggunakan beberapa core actions saja.

Buat folder Fastlane di root project Anda dan salin file berikut: 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

Menyimpan Secret Anda di GitLab CI/CD Variables

GitLab menyediakan cara untuk menyimpan variabel CI/CD terenkripsi, mirip dengan repository secrets milik GitHub. Untuk menyimpan informasi sensitif Anda dengan aman.

Buka Settings pada proyek GitLab Anda.
Navigasi ke CI/CD > Variables
Tambahkan variabel berikut:

ANDROID_KEYSTORE_FILE: file base64-encoded .jks atau .keystore yang digunakan untuk menandatangani Android build Anda. Ini bisa berupa file keystore yang terkait dengan upload key (jika menggunakan Play App Signing), atau app signing key Anda.
KEYSTORE_KEY_PASSWORD: password yang terkait dengan file keystore
KEYSTORE_KEY_ALIAS: alias keystore Anda
KEYSTORE_STORE_PASSWORD: password private key
DEVELOPER_PACKAGE_NAME: ID aplikasi Android Anda seperti com.example.app
PLAY_CONFIG_JSON: JSON service account key dalam format base64.

Cara Membuat Google Play Service Account Key

Untuk membuat PLAY_CONFIG_JSON secret, ikuti langkah-langkah berikut:

Buka Google Cloud Console
Buat proyek baru atau pilih proyek yang sudah ada
Aktifkan Google Play Android Developer API
Buat service account:
- Buka “IAM & Admin” > “Service Accounts”
- Klik “Create Service Account”
- Berikan nama dan deskripsi
- Klik “Create and Continue”
- Lewati penugasan role dan klik “Done”
Generate JSON key:
- Cari service account Anda di daftar
- Klik menu tiga titik > “Manage keys”
- Klik “Add Key” > “Create new key”
- Pilih format JSON
- Klik “Create”
Berikan akses service account ke aplikasi Anda di Play Console:
- Buka Play Console
- Navigasi ke “Users and permissions”
- Klik “Invite new users”
- Masukkan email service account (berakhiran @*.iam.gserviceaccount.com)
- Berikan izin “Release to production”
- Klik “Invite user”

Konversi JSON key ke base64:

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

Tambahkan string base64-encoded sebagai PLAY_CONFIG_JSON variabel di GitLab

Setup Pipeline GitLab CI/CD Anda

Buat file .gitlab-ci.yml di root project untuk mendefinisikan pipeline CI/CD. Berikut adalah contoh struktur pipeline Anda:


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

Trigger Pipeline

Setiap kali Anda push tag baru ke repositori GitLab, GitLab CI/CD akan otomatis men-trigger pipeline yang telah ditentukan untuk build dan deploy aplikasi Android Anda menggunakan Fastlane.

Pastikan untuk menyesuaikan path dan dependency sesuai struktur serta kebutuhan project Anda. Setup ini akan membantu mengotomatiskan deployment aplikasi Android Anda di GitLab CI/CD.

Kesimpulan

Dengan mengonfigurasi GitLab CI/CD menggunakan Docker image mingc/android-build-box, Anda dapat mengotomatiskan proses build aplikasi Android, sehingga workflow pengembangan jadi lebih efisien dan andal. Otomatisasi ini menghemat waktu Anda untuk fokus pada aspek inti pengembangan aplikasi, yang pada akhirnya membantu Anda merilis aplikasi Android berkualitas tinggi dengan lebih cepat.

Lanjutkan dari Automatic Capacitor Android build dengan GitLab

Jika Anda menggunakan Build Android Capacitor Otomatis dengan GitLab untuk merencanakan otomatisasi CI/CD, hubungkan dengan CI/CD Capgo untuk workflow produk di Capgo CI/CD, Capgo Native Build untuk workflow produk di Capgo Native Builds, Integrasi Capgo untuk alur kerja produk di Integrasi Capgo, Integrasi CI/CD untuk detail implementasi di Integrasi CI/CD, dan Integrasi GitHub Actions untuk detail implementasi di Integrasi GitHub Actions.