Android Uygulamalarını Jenkins ile Otomatikleştirme: Kapsamlı Bir Rehber

Android Uygulamalarını Jenkins ile Otomatikleştirme: Kapsamlı Bir Rehber

Giriş

Günümüzün rekabetçi mobil uygulama pazarında, hızlı ve güvenilir bir şekilde uygulama geliştirmek ve dağıtmak, yazılım geliştirme ekipleri için kritik öneme sahiptir. Android uygulamaları geliştiren ekipler, kod yazma, derleme, test etme ve dağıtma gibi süreçleri sürekli olarak tekrarlamak zorundadır. Bu manuel süreçler, zaman alıcı olmanın yanı sıra hata yapma potansiyelini de artırır. İşte bu noktada Sürekli Entegrasyon (CI) ve Sürekli Dağıtım (CD) pratikleri devreye girer. CI/CD, yazılım geliştirme yaşam döngüsünü otomatikleştirerek, geliştiricilerin daha hızlı, daha güvenilir ve daha verimli bir şekilde çalışmasını sağlar.

Jenkins, açık kaynaklı ve genişletilebilir bir otomasyon sunucusu olarak, CI/CD süreçlerini uygulamak için en popüler araçlardan biridir. Esnek yapısı, zengin eklenti ekosistemi ve geniş topluluk desteği sayesinde Jenkins, Android uygulama geliştirme süreçlerini otomatikleştirmek için ideal bir platform sunar. Bu makale, Jenkins kullanarak Android uygulamalarını nasıl derleyeceğinizi, test edeceğinizi ve dağıtacağınızı adım adım açıklamayı hedeflemektedir. Başlangıç seviyesinden ileri seviyeye kadar tüm süreçleri kapsayacak, böylece geliştirme ekipleriniz için sağlam bir CI/CD altyapısı kurabileceksiniz.

CI/CD ve Jenkins Temelleri

Sürekli Entegrasyon (CI) ve Sürekli Dağıtım (CD) kavramları, modern yazılım geliştirmenin temel taşlarıdır. Bu pratikler, geliştirme süreçlerini hızlandırmak, hataları erken yakalamak ve yazılımın kalitesini artırmak için tasarlanmıştır.

Sürekli Entegrasyon (CI) Nedir?

Sürekli Entegrasyon (CI), geliştiricilerin kod değişikliklerini ana kod tabanına düzenli olarak entegre etmelerini gerektiren bir yazılım geliştirme pratiğidir. Her entegrasyon genellikle otomatik bir derleme ve bir dizi otomatik test ile doğrulanır. Bu, entegrasyon hatalarını erken tespit etmeye ve çözmeye yardımcı olur, böylece büyük entegrasyon sorunlarının önüne geçilir. Android geliştirme bağlamında CI, her kod değişikliğinde uygulamanın derlenmesi, lint kontrollerinin yapılması ve birim testlerinin çalıştırılması anlamına gelir.

Sürekli Dağıtım (CD) Nedir?

Sürekli Dağıtım (CD), CI’nın bir uzantısıdır ve yazılım değişikliklerinin otomatik olarak test edildikten ve onaylandıktan sonra üretim ortamına veya bir dağıtım kanalına (örneğin, Google Play Store, Firebase App Distribution) dağıtılması sürecidir. Sürekli Teslimat (Continuous Delivery) ise, yazılımın her zaman dağıtıma hazır olmasını sağlayan ancak manuel bir onay adımı gerektirebilen benzer bir kavramdır. Bu makalede her ikisini de kapsayacak şekilde “CD” terimini kullanacağız. Android için CD, test edilmiş APK veya AAB dosyalarının otomatik olarak hedef platformlara yüklenmesi anlamına gelir.

Jenkins Nedir ve Neden Android İçin Uygundur?

Jenkins, Java ile yazılmış, açık kaynaklı bir otomasyon sunucusudur. Yazılım projelerinin derlenmesi, test edilmesi, dağıtılması ve diğer otomasyon görevlerini gerçekleştirmek için kullanılır. Jenkins’in temel özellikleri şunlardır:

* Açık Kaynak ve Genişletilebilir: Geniş bir eklenti ekosistemine sahiptir, bu sayede hemen hemen her tür geliştirme aracı ve platformuyla entegre olabilir.
* Kullanıcı Dostu Arayüz: Web tabanlı arayüzü sayesinde kolayca yapılandırılabilir ve yönetilebilir.
* Dağıtılmış Yapı: Master-Agent mimarisi sayesinde iş yükünü birden fazla makineye dağıtabilir, bu da büyük projelerde performans ve ölçeklenebilirlik sağlar.
* Pipeline (Boru Hattı) Desteği: Jenkins Pipeline, tüm CI/CD sürecini kod olarak tanımlamanıza olanak tanır. Bu, süreçlerin sürüm kontrolü altında olmasını, tekrarlanabilirliğini ve anlaşılırlığını artırır.

Android geliştirme için Jenkins’in uygun olmasının başlıca nedenleri:

* Gradle Entegrasyonu: Android projeleri genellikle Gradle build sistemini kullanır. Jenkins, Gradle eklentisi ve shell komutları aracılığıyla Gradle komutlarını kolayca çalıştırabilir.
* Ortam Değişkenleri Yönetimi: Android SDK ve JDK yollarını ortam değişkenleri olarak ayarlayarak tutarlı bir derleme ortamı sağlar.
* Kaynak Kodu Yönetimi (SCM) Entegrasyonu: Git, SVN gibi popüler SCM araçlarıyla sorunsuz entegrasyon sunar.
* Esnek Test ve Raporlama: Birim testleri, enstrümantasyon testleri ve lint raporlarını toplayıp yayınlayabilir.
* Artifact Yönetimi: Derlenmiş APK ve AAB dosyalarını otomatik olarak arşivleyebilir ve dağıtım için hazır hale getirebilir.

Ön Koşullar ve Ortam Kurulumu

Jenkins ile Android uygulamalarını derlemeye başlamadan önce, uygun bir ortamın kurulması gerekmektedir. Bu bölüm, Jenkins sunucusunun ve Android derleme ortamının nasıl kurulacağını açıklar.

Jenkins Kurulumu

Jenkins’i kurmak için birkaç farklı yöntem bulunmaktadır. Genellikle bir Linux sunucusu üzerinde kurulum tercih edilir, ancak Windows veya Docker konteyneri içinde de çalıştırılabilir.

1. İşletim Sistemi Seçimi: Ubuntu, Debian gibi Linux dağıtımları veya Windows Server tercih edilebilir. Bu rehberde genel adımlar anlatılacaktır.
2. Java Development Kit (JDK) Kurulumu: Jenkins Java ile çalıştığı için bir JDK’ye ihtiyaç duyar. OpenJDK 11 veya üstü önerilir.
* Linux (Ubuntu/Debian örneği):

sudo apt update
        sudo apt install openjdk-11-jdk

* JAVA_HOME ortam değişkenini ayarladığınızdan emin olun.
3. Jenkins İndirme ve Kurulumu:
* Linux (Debian tabanlı sistemler):

sudo wget -O /usr/share/keyrings/jenkins-keyring.asc \
          https://pkg.jenkins.io/debian-stable/jenkins.io-2023.key
        echo "deb [signed-by=/usr/share/keyrings/jenkins-keyring.asc] \
          https://pkg.jenkins.io/debian-stable binary/" | sudo tee \
          /etc/apt/sources.list.d/jenkins.list > /dev/null
        sudo apt-get update
        sudo apt-get install jenkins
        sudo systemctl start jenkins
        sudo systemctl enable jenkins

* Diğer işletim sistemleri için Jenkins’in resmi web sitesindeki talimatları takip edebilirsiniz.
4. İlk Yapılandırma:
* Jenkins varsayılan olarak 8080 portunda çalışır. Tarayıcınızdan http://:8080 adresine gidin.
* İlk açılışta sizden bir yönetici şifresi isteyecektir. Bu şifreyi /var/lib/jenkins/secrets/initialAdminPassword (Linux) veya C:\Program Files\Jenkins\secrets\initialAdminPassword (Windows) yolundaki dosyadan alabilirsiniz.
* “Install suggested plugins” seçeneğini seçerek temel eklentileri kurun. Daha sonra Git, Gradle, Pipeline, Blue Ocean gibi eklentileri manuel olarak da kurabilirsiniz.
* Yönetici kullanıcı oluşturma adımlarını tamamlayın.

Android Geliştirme Ortamı Kurulumu (Jenkins Agent üzerinde)

Jenkins, derleme işlemlerini genellikle “agent” adı verilen ayrı makinelerde çalıştırır. Bu, Jenkins master sunucusunun kaynaklarını serbest bırakır ve derleme ortamlarını izole etmenizi sağlar. Android derleme için bir Jenkins agent’ına aşağıdaki bileşenlerin kurulması gerekir:

1. JDK Kurulumu: Android SDK’nın gerektirdiği bir JDK sürümünü (genellikle OpenJDK 11 veya üstü) kurun. Bu, Jenkins master’daki JDK’den farklı olabilir.
2. Android SDK Kurulumu:
* Android SDK’yı manuel olarak indirin veya sdkmanager komutunu kullanarak kurun.
* Linux:

# SDK Tools'u indirin
        wget https://dl.google.com/android/repository/commandlinetools-linux-X.zip
        # İndirilen zip dosyasını bir dizine açın, örneğin /opt/android-sdk
        sudo mkdir -p /opt/android-sdk
        sudo unzip commandlinetools-linux-X.zip -d /opt/android-sdk
        # tools dizini içinde latest/bin dizinini oluşturun
        sudo mv /opt/android-sdk/cmdline-tools /opt/android-sdk/cmdline-tools/latest

* Ortam Değişkenleri:
ANDROID_HOME ve PATH ortam değişkenlerini ayarlayın. Bu değişkenler Jenkins agent kullanıcısının ortamında veya Jenkins global araç yapılandırmasında ayarlanmalıdır.

export ANDROID_HOME=/opt/android-sdk
        export PATH=$PATH:$ANDROID_HOME/cmdline-tools/latest/bin:$ANDROID_HOME/platform-tools

* Gerekli SDK Bileşenlerini Kurma: sdkmanager kullanarak gerekli platform araçlarını, build araçlarını ve Android platformlarını kurun.

sdkmanager "platform-tools" "build-tools;34.0.0" "platforms;android-34" # Gerekli sürümleri belirtin

* SDK Lisans Anlaşmalarını Kabul Etme: Bu adım çok önemlidir, aksi takdirde derleme sırasında hata alırsınız.

yes | sdkmanager --licenses

3. Gradle Kurulumu (İsteğe Bağlı): Android projeleri genellikle Gradle Wrapper kullandığı için manuel Gradle kurulumu genellikle gerekli değildir. Ancak, projenizde Gradle Wrapper yoksa veya belirli bir Gradle sürümünü kullanmanız gerekiyorsa, Gradle’ı kurup PATH‘e eklemeniz gerekebilir.
4. Git Kurulumu: Kaynak kodunu çekmek için Git kurulu olmalıdır.

sudo apt install git

Basit Bir Android Projesi Oluşturma (Örnek)

Jenkins ile derleme sürecini göstermek için basit bir Android projesine ihtiyacımız var. Android Studio kullanarak yeni bir “Empty Activity” projesi oluşturabilir ve bu projeyi bir Git deposuna yükleyebilirsiniz.

1. Android Studio ile Proje Oluşturma:
* Android Studio’yu açın.
* “New Project” seçeneğini tıklayın.
* “Empty Activity” şablonunu seçin ve “Next”e tıklayın.
* Uygulamanıza bir isim verin (örn. JenkinsDemoApp), paket adını ve kaydetme konumunu belirleyin. Minimum SDK sürümünü ve dilini (Kotlin veya Java) seçin.
* “Finish”e tıklayın.
2. Projenin Git Deposuna Yüklenmesi:
* Projenizi yerel bir Git deposuna başlatın:

cd JenkinsDemoApp
        git init
        git add .
        git commit -m "Initial commit of Jenkins Demo App"

* Projenizi GitHub, GitLab veya Bitbucket gibi uzak bir depoya yükleyin. Örneğin, GitHub için:

git remote add origin https://github.com/kullaniciadi/JenkinsDemoApp.git
        git branch -M main
        git push -u origin main

Bu proje, temel build.gradle dosyalarına sahip olacak ve Jenkins’in derleme komutlarını çalıştırması için hazır olacaktır.

Jenkins ile İlk Android Build İşlemi

Artık Jenkins sunucunuz ve Android derleme ortamınız hazır olduğuna göre, ilk Android build işlemini oluşturabiliriz. Bu bölümde, “Freestyle project” kullanarak basit bir derleme işlemi yapılandıracağız.

1. Yeni Bir Jenkins İşlemi Oluşturma:
* Jenkins paneline giriş yapın.
* Sol menüden “New Item” veya “Yeni Öğe” seçeneğine tıklayın.
* Öğeye bir isim verin (örn. Android-JenkinsDemoApp-Freestyle).
* “Freestyle project” veya “Serbest Stil Proje” seçeneğini seçin ve “OK” düğmesine tıklayın.

2. Genel Ayarlar:
* “General” sekmesinde, projeniz için kısa bir açıklama girebilirsiniz.
* “Restrict where this project can be run” seçeneğini işaretleyerek, bu işin yalnızca Android SDK’nın kurulu olduğu Jenkins agent’ı üzerinde çalışmasını sağlayabilirsiniz. Agent’ınıza bir etiket (label) verip buraya yazın (örn. android-agent).

3. Kaynak Kodu Yönetimi (SCM):
* “Source Code Management” bölümünde “Git” seçeneğini işaretleyin.
* “Repository URL” alanına Android projenizin Git deposu URL’sini yapıştırın (örn. https://github.com/kullaniciadi/JenkinsDemoApp.git).
* Eğer depo özel ise, “Credentials” açılır menüsünden kimlik bilgilerinizi ekleyin. “Add” -> “Jenkins” seçeneğiyle “Username with password” veya “SSH Username with private key” ekleyebilirsiniz.
“Branches to build” bölümünde /main veya */master gibi derlemek istediğiniz branch’i belirtin.

4. Build Tetikleyicileri:
* “Build Triggers” bölümünde, derlemenin ne zaman tetikleneceğini belirleyebilirsiniz:
Poll SCM: Belirli aralıklarla SCM’yi kontrol eder ve değişiklik varsa derlemeyi başlatır. Örneğin, H/15 * her 15 dakikada bir kontrol eder.
* GitHub hook trigger for GITScm polling: GitHub webhooks ile entegrasyon için kullanılır. Git deposunda bir push olayı olduğunda derlemeyi otomatik olarak başlatır. Bu, daha verimli bir yaklaşımdır.

5. Build Adımları (Execute Shell/Batch Command):
* “Build Steps” bölümünde “Add build step” -> “Execute shell” (Linux/macOS) veya “Execute Windows batch command” (Windows) seçeneğini seçin.
* Android projenizi derlemek için Gradle Wrapper kullanacağız. Projenizin kök dizininde gradlew (Linux/macOS) veya gradlew.bat (Windows) betiği bulunur.
* Temizleme ve Hata Ayıklama APK’sı Derleme:

#!/bin/bash
        export ANDROID_HOME=/opt/android-sdk # Jenkins agent'ınızdaki SDK yolu
        export PATH=$PATH:$ANDROID_HOME/cmdline-tools/latest/bin:$ANDROID_HOME/platform-tools

        ./gradlew clean assembleDebug

* export ANDROID_HOME ve export PATH satırları, Jenkins’in doğru SDK’yı bulmasını sağlar. Bu değişkenler Jenkins global yapılandırmasında da ayarlanabilir.
* clean görevi önceki derleme çıktılarını temizler.
* assembleDebug görevi, hata ayıklama (debug) APK’sını derler.

6. Post-Build Adımları:
* “Post-build Actions” bölümünde “Add post-build action” seçeneğini seçin:
* Archive the artifacts: Derlenmiş APK dosyasını Jenkins’in derleme geçmişinde saklamak için kullanılır.
“Files to archive” alanına app/build/outputs/apk/debug/.apk yazın. Bu, derlenen tüm debug APK dosyalarını arşivleyecektir.
* E-mail Notification: Derlemenin başarılı veya başarısız olması durumunda e-posta bildirimi göndermek için yapılandırılabilir.

7. Kaydet ve Çalıştır:
* “Save” düğmesine tıklayarak işi kaydedin.
* Sol menüden “Build Now” veya “Şimdi Oluştur” seçeneğine tıklayarak ilk derlemeyi başlatın.
* Derleme başladıktan sonra, “Build History” bölümündeki derleme numarasının yanındaki oka tıklayıp “Console Output” seçeneğini seçerek derleme loglarını takip edebilirsiniz.

Başarılı bir derleme sonucunda, arşivlenmiş APK dosyasını derleme sayfasında “Artifacts” bölümünde bulabilirsiniz.

Gelişmiş Jenkins Pipeline ile Android Build

Freestyle projeler basit derlemeler için yeterli olsa da, daha karmaşık CI/CD süreçleri, sürüm kontrolü altında tutulabilirlik ve daha iyi yönetilebilirlik için Jenkins Pipeline tercih edilir. Pipeline, tüm derleme sürecini bir Jenkinsfile içinde kod olarak tanımlamanıza olanak tanır.

Neden Pipeline?

* Kod Olarak Altyapı (Infrastructure as Code): CI/CD sürecinizi kod olarak tanımlarsınız, bu da sürüm kontrolü altında tutulmasını, tekrarlanabilirliğini ve paylaşılabilirliğini sağlar.
* Sürüm Kontrolü: Jenkinsfile projenizin kaynak koduyla birlikte Git deposunda saklanır. Bu, derleme sürecinin kendisinin de sürüm kontrolü altında olduğu anlamına gelir.
* Esneklik ve Genişletilebilirlik: Daha karmaşık iş akışları, paralel adımlar, koşullu mantık ve manuel onay adımları kolayca tanımlanabilir.
* Okunabilirlik: Süreç, aşamalı (stages) bir yapıda tanımlandığı için daha anlaşılır ve takip edilebilir olur.

Jenkinsfile Oluşturma

Jenkinsfile, projenizin kök dizinine yerleştirilen bir metin dosyasıdır. İki ana Pipeline syntax’ı vardır: Declarative (bildirimsel) ve Scripted (betiksel). Declarative Pipeline daha modern ve okunabilir olduğu için genellikle tercih edilir.

Örnek Bir Jenkinsfile:

Aşağıda, bir Android projesi için tipik bir Declarative Pipeline örneği verilmiştir. Bu örnek, ortam kurulumu, testler, derleme ve arşivleme adımlarını içerir.

// Jenkinsfile
pipeline {
    agent { label 'android-agent' } // Bu pipeline'ın çalışacağı Jenkins agent'ını belirtir

    environment {
        // Android SDK ve Java yollarını burada tanımlayın
        // Bu yollar Jenkins agent'ınızdaki gerçek yollarla eşleşmelidir
        ANDROID_HOME = '/opt/android-sdk'
        JAVA_HOME = '/usr/lib/jvm/java-11-openjdk-amd64' // Veya agent'ınızdaki JDK yolu
        PATH = "${ANDROID_HOME}/cmdline-tools/latest/bin:${ANDROID_HOME}/platform-tools:${JAVA_HOME}/bin:${PATH}"
    }

    stages {
        stage('Checkout') {
            steps {
                echo 'Checking out source code...'
                git branch: 'main', credentialsId: 'github-credentials', url: 'https://github.com/kullaniciadi/JenkinsDemoApp.git'
                // 'github-credentials' Jenkins Credentials'da tanımlanmış olmalıdır.
                // Eğer depo public ise credentialsId satırı kaldırılabilir.
            }
        }

        stage('Environment Setup') {
            steps {
                echo 'Setting up Android environment...'
                // SDK lisanslarını kabul etme (eğer daha önce yapılmadıysa)
                sh 'yes | sdkmanager --licenses'
            }
        }

        stage('Lint and Static Analysis') {
            steps {
                echo 'Running Android Lint...'
                sh './gradlew lintDebug'
                // Lint raporlarını arşivle
                archiveArtifacts artifacts: 'app/build/reports/lint-results-debug.xml', fingerprint: true
            }
        }

        stage('Unit Tests') {
            steps {
                echo 'Running Unit Tests...'
                sh './gradlew testDebugUnitTest'
                // Test raporlarını yayınla
                junit 'app/build/test-results/testDebugUnitTest/*.xml'
            }
        }

        stage('Build Debug APK') {
            steps {
                echo 'Building Debug APK...'
                sh './gradlew assembleDebug'
            }
        }

        stage('Build Release AAB (Signed)') {
            // Bu aşama için imzalama bilgileri Jenkins Credentials'da saklanmalı
            // ve build.gradle dosyasına güvenli bir şekilde aktarılmalıdır.
            // Örnek: Jenkins Credentials'da 'KEYSTORE_PASSWORD', 'KEY_ALIAS' ve 'KEY_PASSWORD' adında Secret Text tanımlayın.
            // build.gradle (app/build.gradle) dosyanızda imzalama bloğu şöyle olabilir:
            /*
            android {
                ...
                signingConfigs {
                    release {
                        storeFile file(System.getenv("KEYSTORE_PATH") ?: "keystore.jks") // Keystore dosyasının yolu
                        storePassword System.getenv("KEYSTORE_PASSWORD") ?: "default_store_password"
                        keyAlias System.getenv("KEY_ALIAS") ?: "default_key_alias"
                        keyPassword System.getenv("KEY_PASSWORD") ?: "default_key_password"
                    }
                }
                buildTypes {
                    release {
                        ...
                        signingConfig signingConfigs.release
                    }
                }
            }
            */
            // Keystore dosyasını Jenkins agent'ına güvenli bir şekilde aktarmak gereklidir.
            // Bu genellikle Jenkins Credentials ile File tipi secret olarak veya agent'ta sabit bir konumda tutularak yapılır.

            when {
                // Sadece 'main' branch'inde bu aşamayı çalıştır
                branch 'main'
            }
            steps {
                echo 'Building Signed Release AAB...'
                withCredentials([
                    file(credentialsId: 'android-keystore-file', variable: 'KEYSTORE_PATH'), // Keystore dosyasını bağla
                    string(credentialsId: 'KEYSTORE_PASSWORD', variable: 'KEYSTORE_PASSWORD'),
                    string(credentialsId: 'KEY_ALIAS', variable: 'KEY_ALIAS'),
                    string(credentialsId: 'KEY_PASSWORD', variable: 'KEY_PASSWORD')
                ]) {
                    sh './gradlew bundleRelease'
                }
            }
        }

        stage('Archive Artifacts') {
            steps {
                echo 'Archiving build artifacts...'
                archiveArtifacts artifacts: 'app/build/outputs/apk/debug/.apk, app/build/outputs/bundle/release/.aab', fingerprint: true
            }
        }

        stage('Deploy to Firebase App Distribution') {
            when {
                // Sadece 'main' branch'inde ve başarılı buildlerde dağıt
                branch 'main'
                expression { currentBuild.currentResult == 'SUCCESS' }
            }
            steps {
                echo 'Deploying to Firebase App Distribution...'
                // Firebase App Distribution eklentisi veya fastlane ile entegrasyon
                // Örnek: fastlane kullanıyorsanız
                // sh 'bundle install && bundle exec fastlane firebase_distribute'
                // Veya Firebase CLI doğrudan:
                // sh "firebase appdistribution:distribute app/build/outputs/bundle/release/*.aab --app  --release-notes 'New build from Jenkins' --groups 'testers'"
                // Firebase CLI için 'FIREBASE_TOKEN' ortam değişkeni veya Jenkins Credentials ile kimlik doğrulama gerekir.
            }
        }
    }

    post {
        always {
            echo 'Pipeline finished.'
            // Temizleme işlemleri
            sh 'rm -rf build'
        }
        success {
            echo 'Build successful! Sending notifications...'
            // Başarılı bildirimler (e-posta, Slack vb.)
            // mail to: 'dev@example.com', subject: "Android Build SUCCESS: ${env.JOB_NAME} #${env.BUILD_NUMBER}"
        }
        failure {
            echo 'Build failed! Sending notifications...'
            // Başarısız bildirimler
            // mail to: 'dev@example.com', subject: "Android Build FAILED: ${env.JOB_NAME} #${env.BUILD_NUMBER}"
        }
    }
}

Jenkins İşlemi Yapılandırması (Pipeline projesi)

1. Yeni Bir Jenkins İşlemi Oluşturma:
* Jenkins paneline giriş yapın.
* “New Item” seçeneğine tıklayın.
* Öğeye bir isim verin (örn. Android-JenkinsDemoApp-Pipeline).
* “Pipeline” seçeneğini seçin ve “OK” düğmesine tıklayın.
2. Genel Ayarlar:
* Açıklama girin.
* “Restrict where this project can be run” seçeneğini işaretleyerek android-agent etiketini kullanın.
3. Pipeline Tanımı:
* “Pipeline” bölümüne gidin.
* “Definition” açılır menüsünden “Pipeline script from SCM” seçeneğini seçin.
* “SCM” olarak “Git”i seçin.
* “Repository URL” ve “Credentials” bilgilerini Freestyle projesindeki gibi doldurun.
“Branches to build” kısmına /main yazın.
* “Script Path” alanına Jenkinsfile yazın (eğer Jenkinsfile projenizin kök dizininde ise). Farklı bir yolda ise, o yolu belirtin (örn. jenkins/Jenkinsfile).
4. Kaydet ve Çalıştır:
* “Save” düğmesine tıklayın.
* “Build Now” ile pipeline’ı başlatın.
* “Pipeline Stage View” veya “Blue Ocean” arayüzü sayesinde pipeline’ın aşamalarını görsel olarak takip edebilirsiniz.

Keystore Yönetimi: Release APK/AAB imzalama için Keystore dosyasının ve şifrelerinin güvenli bir şekilde yönetilmesi kritik öneme sahiptir. Jenkins Credentials Manager, bu bilgileri güvenli bir şekilde saklamak için kullanılır. withCredentials bloğu, bu bilgileri pipeline adımlarına ortam değişkenleri olarak enjekte etmenin güvenli bir yoludur. Keystore dosyasını Jenkins agent’ına güvenli bir şekilde aktarmak için Jenkins File Credential tipi kullanılabilir veya dosya agent’ta sabit bir yolda tutulup yolu Jenkinsfile içinde belirtilebilir.

Ek Entegrasyonlar ve İpuçları

Jenkins ve Android CI/CD sürecinizi daha da güçlendirmek için çeşitli ek entegrasyonlar ve optimizasyonlar yapabilirsiniz.

Test Otomasyonu

* Unit Testler: gradlew test komutuyla çalıştırılan birim testler, hızlı geri bildirim sağlar ve hataları erken yakalar. Jenkins Pipeline’da junit adımıyla test raporlarını yayınlayabilirsiniz.

junit 'app/build/test-results/testDebugUnitTest/*.xml'

* Enstrümantasyon Testleri: UI testleri (örneğin Espresso) gibi enstrümantasyon testleri, gerçek bir cihaz veya emülatör üzerinde çalıştırılmalıdır. Jenkins agent’ında bir Android emülatörünü başlatmak veya fiziksel cihazlara bağlanmak daha karmaşık olabilir. AVD (Android Virtual Device) Manager ile Jenkins agent’ında sanal cihaz oluşturup başlatabilir ve gradlew connectedDebugAndroidTest komutuyla testleri çalıştırabilirsiniz. Bu genellikle daha fazla kaynak gerektirir.

Kod Kalitesi Araçları

* Android Lint: Android Lint, kodunuzdaki potansiyel hataları ve stil sorunlarını bulur. gradlew lintDebug komutuyla çalıştırılabilir ve raporları arşivlenebilir.
* Detekt / SonarQube: Detekt (Kotlin için) veya SonarQube gibi statik analiz araçları, kod kalitesini artırmak için daha derinlemesine analizler sunar. Jenkins eklentileri aracılığıyla veya doğrudan komut satırından entegre edilebilirler.

Bildirimler

* E-posta: Jenkins’in yerleşik e-posta bildirimleri eklentisi ile derleme durumu hakkında ekiplere otomatik e-postalar gönderebilirsiniz.
* Slack/Microsoft Teams: Popüler mesajlaşma platformları için Jenkins eklentileri bulunur. Derleme durumunu, bağlantıları ve diğer bilgileri doğrudan ilgili kanallara gönderebilirsiniz.

Güvenlik

* Keystore Yönetimi: Release derlemeleri için kullanılan Keystore dosyaları ve şifreleri, asla doğrudan Jenkinsfile içine veya Git deposuna eklenmemelidir. Jenkins Credentials Manager, bu hassas bilgileri güvenli bir şekilde saklamak için en iyi çözümdür.
* Ortam Değişkenleri: Hassas bilgiler (API anahtarları, token’lar) doğrudan Jenkinsfile içinde tanımlanmamalı, bunun yerine Jenkins Credentials veya ortam değişkenleri aracılığıyla güvenli bir şekilde enjekte edilmelidir.
* Kullanıcı ve Rol Yönetimi: Jenkins’in kendi kullanıcı ve rol tabanlı yetkilendirme sistemi vardır. Hangi kullanıcının hangi işleri yapılandırabileceğini veya çalıştırabileceğini kısıtlayarak güvenliği artırabilirsiniz.

Docker ile Jenkins Agent

* Tutarlı Ortamlar: Docker konteynerleri kullanarak Jenkins agent’ları için tutarlı ve izole derleme ortamları oluşturabilirsiniz. Android SDK, JDK ve diğer tüm bağımlılıkları içeren bir Docker imajı oluşturarak, her derleme için aynı ortamı garanti edersiniz.
* Dockerfile Örneği:

FROM openjdk:11-jdk

    ENV ANDROID_SDK_ROOT /opt/android-sdk
    ENV PATH $PATH:$ANDROID_SDK_ROOT/cmdline-tools/latest/bin:$ANDROID_SDK_ROOT/platform-tools

    # Install Android SDK Command-line Tools
    RUN mkdir -p ${ANDROID_SDK_ROOT}/cmdline-tools && \
        wget -q https://dl.google.com/android/repository/commandlinetools-linux-X.zip -O android-sdk-tools.zip && \
        unzip -q android-sdk-tools.zip -d ${ANDROID_SDK_ROOT}/cmdline-tools && \
        mv ${ANDROID_SDK_ROOT}/cmdline-tools/cmdline-tools ${ANDROID_SDK_ROOT}/cmdline-tools/latest && \
        rm android-sdk-tools.zip

    # Accept Android SDK licenses
    RUN yes | sdkmanager --licenses

    # Install necessary SDK components
    RUN sdkmanager "platform-tools" "build-tools;34.0.0" "platforms;android-34"

    # Install Git
    RUN apt-get update && apt-get install -y git

    # Set working directory
    WORKDIR /home/jenkins

Bu Dockerfile ile bir imaj oluşturup Jenkins’in Docker eklentisi veya Kubernetes eklentisi ile dinamik olarak agent’lar sağlayabilirsiniz.

Performans Optimizasyonu

* Paralel Build Adımları: Jenkins Pipeline, farklı derleme aşamalarını (örn. birim testleri ve lint analizi) paralel olarak çalıştırmanıza olanak tanır, bu da toplam derleme süresini azaltır.
* Gradle Önbellekleme: Gradle, derleme performansını artırmak için önbellekleme kullanır. Jenkins agent’ında Gradle önbelleğini koruyarak veya Docker volume’larını kullanarak önbelleği kalıcı hale getirebilirsiniz.
* Jenkins Agent Kaynakları: Jenkins agent’larının yeterli CPU, RAM ve disk alanına sahip olduğundan emin olun. Özellikle büyük Android projeleri ve enstrümantasyon testleri için yeterli kaynaklar kritik öneme sahiptir.

Sorun Giderme ve Yaygın Hatalar

Jenkins ile Android derleme süreçlerinde karşılaşabileceğiniz bazı yaygın sorunlar ve çözümleri:

* JAVA_HOME veya ANDROID_HOME Sorunları: En sık karşılaşılan sorunlardan biridir. Bu ortam değişkenlerinin Jenkins agent’ında doğru şekilde ayarlandığından ve Jenkins kullanıcısının erişebildiğinden emin olun. echo $JAVA_HOME veya echo $ANDROID_HOME komutlarını Jenkins shell adımında çalıştırarak doğrulayabilirsiniz.
* SDK Lisans Kabulü Hataları: Failed to install the following Android SDK components veya You have not accepted the license agreements gibi hatalar alıyorsanız, yes | sdkmanager --licenses komutunu Jenkins agent’ında çalıştırmayı unutmuşsunuz demektir.
* Gradle Daemon Sorunları: Gradle daemon, derleme sürelerini hızlandırmak için arka planda çalışır. Bazen takılabilir veya bellek sorunları yaşayabilir. gradlew --stop komutuyla daemon’u durdurup tekrar deneyebilirsiniz.
* Bellek Yetersizliği: Özellikle büyük projelerde veya testler çalıştırılırken Jenkins agent’ı veya Gradle işlemi bellek yetersizliği yaşayabilir. JVM’ye daha fazla bellek ayırmak için _JAVA_OPTIONS="-Xmx2048m" gibi ortam değişkenleri kullanabilir veya agent’a daha fazla RAM ekleyebilirsiniz.
* Yetkilendirme Sorunları (Git, Keystore): Git deposuna erişim veya Keystore dosyasına erişim izinleri nedeniyle hatalar alabilirsiniz. Jenkins Credentials’ın doğru yapılandırıldığından ve agent’ın dosya izinlerine sahip olduğundan emin olun.
* Jenkins Loglarını Okuma: Herhangi bir sorunla karşılaştığınızda, Jenkins’in “Console Output” bölümündeki logları dikkatlice inceleyin. Hata mesajları genellikle sorunun kök nedenini gösterir.

Sonuç

Android uygulamalarını Jenkins ile otomatikleştirmek, geliştirme ekiplerinin verimliliğini, uygulama kalitesini ve dağıtım hızını önemli ölçüde artırır. Sürekli Entegrasyon ve Sürekli Dağıtım pratikleri sayesinde, kod değişiklikleri hızlı bir şekilde entegre edilir, otomatik testlerle doğrulanır ve güvenilir bir şekilde dağıtıma hazır hale getirilir.

Bu makalede, Jenkins’in temel kurulumundan başlayarak, bir Android derleme ortamının nasıl hazırlanacağını, Freestyle ve Pipeline projeleriyle basit ve gelişmiş derleme süreçlerinin nasıl yapılandırılacağını ayrıntılı bir şekilde ele aldık. Ayrıca, test otomasyonu, kod kalitesi araçları, güvenlik, Docker entegrasyonu gibi ek konulara ve yaygın sorun giderme ipuçlarına değindik.

Jenkins’in esnekliği ve geniş eklenti ekosistemi, Android geliştirme süreçlerinizi tamamen özelleştirmenize ve otomatikleştirmemize olanak tanır. Başlangıçta biraz çaba gerektirse de, kurulan sağlam bir CI/CD altyapısı, uzun vadede geliştirme sürecinize büyük değer katacak ve ekiplerinizin daha yenilikçi işlere odaklanmasını sağlayacaktır. Unutmayın, CI/CD bir yolculuktur ve sürekli iyileştirme gerektirir. Süreçlerinizi düzenli olarak gözden geçirin, yeni araçları ve pratikleri entegre edin ve otomasyonun faydalarını en üst düzeye çıkarın.