Jenkins — vad det är, systemarkitektur och konfiguration av CI/CD-server

Vad är Jenkins och varför behövs det i mobilutveckling

Jenkins är en CI/CD-server med öppen källkod skriven i Java för automatisering av byggande, testning och leverans av programvara. Inom mobilutveckling gör Jenkins det möjligt för team att automatiskt bygga iOS- och Android-applikationer, köra enhets- och UI-tester, signera byggen och leverera dem till App Store eller Google Play utan manuella operationer.

Behovet av Jenkins uppstår när projektet växer ur lokala byggen och kräver regelbundna kodintegrationer från flera utvecklare. Manuellt byggande av varje commit tar tid och är felbenäget — Jenkins löser detta problem genom att starta automatiska pipelines vid varje ändring i repository.

Enligt JetBrains Developer Ecosystem 2025-rapporten använder 54% av mobila team Jenkins som primär CI/CD-plattform. Systemet stödjer alla språk och plattformar tack vare plugin-arkitekturen — för Android finns Gradle och SDK Manager, för iOS — Xcode Integration och Keychain Manager.

Använd Jenkins i projekt där fullständig kontroll över bygginfrastrukturen, anpassning av varje steg i CI/CD-processen och integration med företagets säkerhetssystem krävs.

Jenkins arkitektur: Master, Agenter och Pipeline-funktion

Jenkins-arkitekturen är byggd på Master-Agent-modellen. Master-servern hanterar konfiguration, uppgiftsschemaläggning och webbgränssnitt, medan agenter utför själva byggena på dedikerade eller temporära maskiner. Denna arkitektur möjliggör samtidigt byggande av iOS-applikation på macOS-agent och Android-applikation på Linux-agent från samma Master-server.

Master och Agent i Jenkins

Jenkins Master-nod lagrar alla inställningar, plugin-program och bygghistorik i hemkatalogen $JENKINS_HOME. Agenter ansluter till Master via SSH, JNLP eller WebSocket och får uppgifter från kön. För mobilutveckling rekommenderas att avsätta separata macOS-agenter för iOS-byggen och Linux-agenter för Android-byggen med installerade SDK och verktyg.

Varje agent kan vara en permanent server eller en dynamisk Docker-container. Enligt CloudBees-dokumentation minskar distribution av byggen över 5 agenter den totala CI/CD-pipelinetiden med 70% vid 10 parallella uppgifter.

Pipeline som kod

Jenkins Pipeline är definitionen av hela CI/CD-processen i form av kod som lagras i repository tillsammans med projektet. Pipeline beskrivs i Jenkinsfile och stödjer två syntaxer: Declarative (strukturerad, med fördefinierade block) och Scripted (flexibel, baserad på Groovy med fullständig kontroll över exekveringsflödet).

Deklarativ syntax rekommenderas för de flesta mobila projekt eftersom den ger läsbarhet och förutsägbarhet. Scripted Pipeline passar för komplexa scenarier med dynamiska parallella steg, anpassad felhantering och villkorslogik baserad på miljövariabler.

Jenkins Pipeline: deklarativ och skriptad syntax

Jenkins Pipeline stödjer två syntaxer som bestämmer hur stegen i CI/CD-processen beskrivs. Deklarativ syntax använder en blockstruktur med nyckelorden pipeline, stages, stage och steps, vilket gör den intuitiv för nya användare. Skriptad syntax är baserad på Groovy och ger fullständig kontroll över exekvering genom villkorssatser och loopar.

Deklarativ Pipeline skapar automatiskt Sandbox — en säker miljö för att köra Groovy-skript. Detta begränsar åtkomst till farliga metoder i Java och Groovy, vilket är kritiskt för företagsmiljöer där pipelinesäkerhet kontrolleras av administratören.

Struktur för deklarativ Pipeline

Deklarativ Pipeline bygger på fyra nyckelblock: pipeline (rotblock), agent(angivelse av agent), stages (sekvens av steg) och post (åtgärder efter slutförande). Varje stage innehåller steps med byggkommandon, och post-blocket definierar åtgärder vid framgång, misslyckande eller instabil byggstatus.

Blocket post är särskilt användbart för mobila projekt — här kan man konfigurera sändning av meddelanden till Slack vid byggmisslyckande eller arkivering av IPA- och APK-artefakter efter framgångsrikt slutförande. Jenkins utför post-åtgärder garanterat, även om pipeline avbröts manuellt.

// Deklarativ Pipeline för iOS-applikation
pipeline {
    agent { label 'macos' }
    stages {
        stage('Build') {
            steps {
                sh 'xcodebuild -workspace App.xcworkspace -scheme App clean build'
            }
        }
        stage('Test') {
            steps {
                sh 'xcodebuild -workspace App.xcworkspace -scheme App test'
            }
        }
    }
}

Scripted Pipeline tillhandahåller blocket node istället för agent och möjliggör användning av Groovy-konstruktioner för dynamisk förgrening. Denna syntax är bekväm för pipelines där uppsättningen av steg beror på byggparametrar eller resultat från tidigare steg.

// Scripted Pipeline med parallella steg
node('macos') {
    stage('Parallel Builds') {
        parallel(
            ios: { buildIOS() },
            android: { buildAndroid() }
        )
    }
}
def buildIOS() {
    sh 'fastlane ios build'
}

Jenkinsfile: CI/CD-konfiguration för iOS-projekt

För iOS-projekt kräver Jenkinsfile en macOS-agent med installerat Xcode, CocoaPods eller Swift Package Manager och Fastlane. En typisk pipeline inkluderar steg: installation av beroenden, bygga, köra tester, kodsignering och leverans till TestFlight eller App Store.

Den viktigaste egenskapen för iOS-byggen i Jenkins är hanteringen av certifikat och provisioning-profiler. Det rekommenderas att använda Fastlane Match för automatisk hämtning av certifikat från repository eller Jenkins Credentials Binding-plugin för säker lagring av nycklar.

pipeline {
    agent { label 'macos' }
    environment {
        MATCH_PASSWORD = credentials('match-password')
    }
    stages {
        stage('Install Dependencies') {
            steps {
                sh 'pod install --repo-update'
            }
        }
        stage('Build and Test') {
            steps {
                sh 'fastlane scan'
                sh 'fastlane gym'
            }
        }
        stage('Deploy to TestFlight') {
            when { branch 'main' }
            steps {
                sh 'fastlane upload_testflight'
            }
        }
    }
}

För iOS enhetstester, använd xcodebuild test med angivelse av simulator. Jenkins stödjer publicering av XCTest-rapporter via JUnit-plugin — konvertera .xcresult till XML-format för inbäddning av testresultat i byggdashboarden.

Jenkinsfile: CI/CD-konfiguration för Android-projekt

Android-byggen i Jenkins utförs på Linux-agenter med installerat Java JDK, Android SDK, Gradle och emulatorer. Pipeline inkluderar steg: linter-kontroll, enhetstester, APK- eller AAB-bygge, instrumentella tester på emulator och publicering i Google Play Console.

För hantering av Android SDK, använd sdkmanager i Jenkinsfile för installation av nödvändiga plattformar och build-tools. Det rekommenderas att cacha .gradle- och .android-kataloger mellan byggen för att påskynda efterföljande körningar.

pipeline {
    agent { label 'linux' }
    stages {
        stage('Lint Check') {
            steps {
                sh './gradlew lint'
            }
        }
        stage('Unit Tests') {
            steps {
                sh './gradlew testDebugUnitTest'
            }
        }
        stage('Build APK') {
            steps {
                sh './gradlew assembleDebug'
            }
            post {
                success {
                    archiveArtifacts artifacts: '**/build/outputs/apk/**/*.apk'
                }
            }
        }
    }
}

Instrumentella tester på Android kräver en igång emulator. Jenkins stödjer Android Emulator-plugin som automatiskt skapar och startar emulatorn före tester. För fysiska enheter, använd Firebase Test Lab — integration är tillgänglig via Google Cloud SDK-plugin.

Jenkins-plugin för automatisering av byggen

Jenkins plugin-system är plattformens främsta fördel. Över 1800 plugin-program täcker alla CI/CD-steg: från integration med versionshanteringssystem till driftsättning i molntjänster. Varje plugin lägger till nya steg i pipeline och utökar webbgränssnittet med ytterligare konfigurationssidor.

För mobilutveckling är en uppsättning plugin-program för hantering av inloggningsuppgifter obligatorisk: Credentials Binding för lagring av App Store Connect-tokens och Google Play-tjänstkonton. Xcode Integration-plugin lägger till byggsteg för iOS-applikationer från Jenkins UI.

Docker Pipeline-pluginen möjliggör körning av varje byggsteg i en separat container, vilket garanterar reproducerbarhet av miljön och eliminerar problemet med miljöskillnader. För Android-byggen, använd bilder med förinstallerat Android SDK från Gradle-communityn.

Jenkins vs Travis CI: jämförelse för mobila team

Valet mellan Jenkins och Travis CI beror på teamstorlek, budget och infrastrukturkrav. Jenkins är en självhanterad lösning med full kontroll som kräver en dedikerad server och administratör. Travis CI är en molntjänst med betalning per användning som inte kräver serverhantering.

För startups och små team är Travis CI att föredra — noll infrastrukturkostnader, enkel integration med GitHub och färdiga byggen för iOS och Android. För företagsprojekt ger Jenkins fördelar: egna runners på macOS, efterlevnad av företagens säkerhetspolicyer och detaljerad pipeline-konfiguration via Jenkinsfile.

Enligt Stack Overflow Survey 2025 använder Jenkins 42% av professionella utvecklare jämfört med 12% för Travis CI. Travis CI förblir dock populär i open source-gemenskapen tack vare gratisplanen för offentliga repositories och minimal inträdesbarriär.

Fördelar med Jenkins i CI/CD-processer

Jenkins erbjuder en uppsättning fördelar som gör det till CI/CD-standard för mobilutveckling. Den kostnadsfria MIT-licensen möjliggör obegränsad användning av servern i kommersiella projekt, och öppen källkod garanterar oberoende från leverantör och möjlighet till säkerhetsgranskning.

Master-Agent-arkitekturen ger horisontell skalbarhet — tillägg av en ny agent ökar pipeline-genomströmningen linjärt. Jenkins stödjer dynamiska agenter i Kubernetes via Jenkins X, vilket möjliggör automatisk skapande och förstöring av byggare efter behov.

Plugin-ekosystemet täcker alla moderna verktyg: Docker, Kubernetes, Fastlane, SonarQube, GitLab, Bitbucket. Om ett färdigt plugin saknas kan man skriva en egen förlängning i Java eller använda Pipeline Shared Libraries för återanvändning av kod mellan projekt.