Jenkins Mac Build Agent: संपूर्ण सेटअप गाइड

1. Jenkins के लिए एक समर्पित Mac क्यों?

Jenkins सबसे व्यापक रूप से उपयोग किया जाने वाला CI/CD प्लेटफ़ॉर्म है, जो 50% से अधिक एंटरप्राइज़ बिल्ड पाइपलाइनों को चलाता है। हालांकि, Jenkins के साथ iOS ऐप्स बनाने के लिए macOS की आवश्यकता होती है, और macOS केवल Apple हार्डवेयर पर ही कानूनी रूप से चल सकता है। एक समर्पित Mac Mini M4 आपको देता है:

2. पूर्वापेक्षाएं

• MyRemoteMac से एक Mac Mini M4 ($85/माह से)
• एक Jenkins controller (Linux, Docker या किसी भी क्लाउड VM पर हो सकता है)
• आपके Mac Mini तक SSH एक्सेस
• Mac Mini पर Xcode इंस्टॉल किया गया (Xcode इंस्टॉलेशन चरणों के लिए हमारी GitHub Actions गाइड देखें)

3. चरण 1: macOS पर Java JDK इंस्टॉल करें

Jenkins agents को एक Java Runtime Environment की आवश्यकता होती है। आसान प्रबंधन के लिए हम Homebrew के माध्यम से इंस्टॉल किए गए JDK 17 (LTS) या JDK 21 (LTS) का उपयोग करने की अनुशंसा करते हैं।

# Install Homebrew if not already present
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> ~/.zprofile
eval "$(/opt/homebrew/bin/brew shellenv)"

# Install Java JDK 17 (recommended for Jenkins)
brew install openjdk@17

# Create the symlink for system Java wrappers
sudo ln -sfn /opt/homebrew/opt/openjdk@17/libexec/openjdk.jdk \
  /Library/Java/JavaVirtualMachines/openjdk-17.jdk

# Add to PATH
echo 'export PATH="/opt/homebrew/opt/openjdk@17/bin:$PATH"' >> ~/.zprofile
source ~/.zprofile

# Verify Java installation
java -version
# openjdk version "17.0.13" 2024-10-15
# OpenJDK Runtime Environment Homebrew (build 17.0.13+0)
# OpenJDK 64-Bit Server VM Homebrew (build 17.0.13+0, mixed mode, sharing)

4. चरण 2: Jenkins Agent कॉन्फ़िगर करें

एक Jenkins agent को कनेक्ट करने के दो प्राथमिक तरीके हैं: JNLP (agent से controller तक इनबाउंड कनेक्शन) और SSH (controller से agent तक आउटबाउंड कनेक्शन)। हम दोनों को कवर करते हैं।

विधि A: SSH Agent (अनुशंसित)

यह सबसे विश्वसनीय तरीका है। Jenkins, SSH के माध्यम से Mac से कनेक्ट होता है और agent प्रक्रिया को दूरस्थ रूप से प्रबंधित करता है।

# On the Mac Mini: Create a dedicated Jenkins user
sudo dscl . -create /Users/jenkins
sudo dscl . -create /Users/jenkins UserShell /bin/zsh
sudo dscl . -create /Users/jenkins RealName "Jenkins Agent"
sudo dscl . -create /Users/jenkins UniqueID 550
sudo dscl . -create /Users/jenkins PrimaryGroupID 20
sudo dscl . -create /Users/jenkins NFSHomeDirectory /Users/jenkins
sudo mkdir -p /Users/jenkins
sudo chown jenkins:staff /Users/jenkins

# Set a password for the jenkins user
sudo dscl . -passwd /Users/jenkins "STRONG_PASSWORD_HERE"

# Create SSH directory and add the Jenkins controller's public key
sudo mkdir -p /Users/jenkins/.ssh
sudo sh -c 'echo "ssh-rsa YOUR_JENKINS_CONTROLLER_PUBLIC_KEY" > /Users/jenkins/.ssh/authorized_keys'
sudo chmod 700 /Users/jenkins/.ssh
sudo chmod 600 /Users/jenkins/.ssh/authorized_keys
sudo chown -R jenkins:staff /Users/jenkins/.ssh

# Create a workspace directory
sudo mkdir -p /Users/jenkins/workspace
sudo chown jenkins:staff /Users/jenkins/workspace

अब Jenkins में agent कॉन्फ़िगर करें:

1. Manage Jenkins > Nodes > New Node पर जाएं
2. नाम mac-mini-m4 पर सेट करें
3. Remote root directory को /Users/jenkins/workspace पर सेट करें
4. Labels: mac macos apple-silicon m4 ios
5. Launch method: Launch agents via SSH
6. Host: आपके Mac Mini का IP पता
7. Credentials: Mac पर authorized_keys से मेल खाने वाली SSH private key जोड़ें

विधि B: JNLP Agent (इनबाउंड)

इस विधि का उपयोग तब करें जब Jenkins controller, Mac तक सीधे नहीं पहुंच सकता (उदाहरण के लिए, Mac एक फ़ायरवॉल के पीछे है)। agent कनेक्शन शुरू करता है।

# First, create the node in Jenkins UI:
# Manage Jenkins > Nodes > New Node
# Launch method: "Launch agent by connecting it to the controller"
# Note the secret token from the node configuration page

# On the Mac Mini, download the agent JAR:
mkdir -p ~/jenkins-agent && cd ~/jenkins-agent
curl -sO https://your-jenkins-url/jnlpJars/agent.jar

# Test the agent connection
java -jar agent.jar \
  -url https://your-jenkins-url \
  -secret YOUR_AGENT_SECRET \
  -name "mac-mini-m4" \
  -workDir "/Users/jenkins/workspace"

JNLP Agent को एक launchd सर्विस के रूप में चलाएं

# Create the launchd plist file
cat > ~/Library/LaunchAgents/com.jenkins.agent.plist <<'EOF'
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.jenkins.agent</string>
    <key>ProgramArguments</key>
    <array>
        <string>/opt/homebrew/opt/openjdk@17/bin/java</string>
        <string>-jar</string>
        <string>/Users/jenkins/jenkins-agent/agent.jar</string>
        <string>-url</string>
        <string>https://your-jenkins-url</string>
        <string>-secret</string>
        <string>YOUR_AGENT_SECRET</string>
        <string>-name</string>
        <string>mac-mini-m4</string>
        <string>-workDir</string>
        <string>/Users/jenkins/workspace</string>
    </array>
    <key>RunAtLoad</key>
    <true/>
    <key>KeepAlive</key>
    <true/>
    <key>StandardOutPath</key>
    <string>/Users/jenkins/jenkins-agent/stdout.log</string>
    <key>StandardErrorPath</key>
    <string>/Users/jenkins/jenkins-agent/stderr.log</string>
</dict>
</plist>
EOF

# Load the service
launchctl load ~/Library/LaunchAgents/com.jenkins.agent.plist

# Verify it's running
launchctl list | grep jenkins

5. चरण 3: iOS Build Pipeline बनाएं

अपने रिपॉजिटरी रूट में एक Jenkinsfile बनाएं। यह डिक्लेरेटिव पाइपलाइन आपके iOS ऐप को बनाती, टेस्ट करती और वैकल्पिक रूप से आर्काइव करती है।

pipeline {
    agent { label 'mac && m4' }

    environment {
        SCHEME       = 'MyApp'
        WORKSPACE    = 'MyApp.xcworkspace'
        DESTINATION  = 'platform=iOS Simulator,name=iPhone 16 Pro,OS=18.2'
        DERIVED_DATA = "${WORKSPACE_DIR}/DerivedData"
    }

    options {
        timeout(time: 30, unit: 'MINUTES')
        buildDiscarder(logRotator(numToKeepStr: '20'))
    }

    stages {
        stage('Checkout') {
            steps {
                checkout scm
            }
        }

        stage('Install Dependencies') {
            steps {
                sh '''
                    # Select Xcode version
                    sudo xcode-select -s /Applications/Xcode-16.2.app/Contents/Developer
                    xcodebuild -version

                    # Install CocoaPods dependencies
                    if [ -f "Podfile" ]; then
                        pod install --repo-update
                    fi
                '''
            }
        }

        stage('Build') {
            steps {
                sh '''
                    xcodebuild build \
                        -workspace "${WORKSPACE}" \
                        -scheme "${SCHEME}" \
                        -destination "${DESTINATION}" \
                        -derivedDataPath "${DERIVED_DATA}" \
                        CODE_SIGNING_ALLOWED=NO \
                        | xcbeautify
                '''
            }
        }

        stage('Test') {
            steps {
                sh '''
                    xcodebuild test \
                        -workspace "${WORKSPACE}" \
                        -scheme "${SCHEME}" \
                        -destination "${DESTINATION}" \
                        -derivedDataPath "${DERIVED_DATA}" \
                        -resultBundlePath "TestResults.xcresult" \
                        -parallel-testing-enabled YES \
                        | xcbeautify
                '''
            }
            post {
                always {
                    archiveArtifacts artifacts: 'TestResults.xcresult/**', allowEmptyArchive: true
                }
            }
        }

        stage('Archive') {
            when {
                branch 'main'
            }
            steps {
                sh '''
                    xcodebuild archive \
                        -workspace "${WORKSPACE}" \
                        -scheme "${SCHEME}" \
                        -archivePath "${DERIVED_DATA}/MyApp.xcarchive" \
                        -destination "generic/platform=iOS" \
                        | xcbeautify
                '''
            }
        }
    }

    post {
        success {
            echo 'Build and tests passed!'
        }
        failure {
            echo 'Build or tests failed.'
        }
        cleanup {
            sh 'xcrun simctl shutdown all 2>/dev/null || true'
        }
    }
}

6. चरण 4: डिप्लॉयमेंट के लिए Fastlane एकीकृत करें

Fastlane, कोड साइनिंग और TestFlight डिप्लॉयमेंट को सरल बनाता है। अपनी Jenkinsfile में एक deploy stage जोड़ें:

# Install Fastlane on the Mac Mini (one-time setup)
brew install fastlane

# Or via Ruby:
gem install fastlane -NV

अपनी Jenkinsfile में एक deploy stage जोड़ें:

        stage('Deploy to TestFlight') {
            when {
                branch 'main'
            }
            environment {
                APP_STORE_CONNECT_API_KEY_ID     = credentials('app-store-key-id')
                APP_STORE_CONNECT_API_ISSUER_ID  = credentials('app-store-issuer-id')
                APP_STORE_CONNECT_API_KEY_CONTENT = credentials('app-store-key-content')
                MATCH_PASSWORD                   = credentials('match-password')
            }
            steps {
                sh '''
                    fastlane beta
                '''
            }
        }

और एक मेल खाती fastlane/Fastfile बनाएं:

default_platform(:ios)

platform :ios do
  desc "Push a new beta build to TestFlight"
  lane :beta do
    setup_ci

    # Fetch code signing certificates via match
    match(type: "appstore", readonly: true)

    # Increment build number
    increment_build_number(
      build_number: ENV["BUILD_NUMBER"]
    )

    # Build the app
    build_app(
      workspace: "MyApp.xcworkspace",
      scheme: "MyApp",
      export_method: "app-store",
      derived_data_path: "DerivedData"
    )

    # Upload to TestFlight
    upload_to_testflight(
      skip_waiting_for_build_processing: true,
      api_key: app_store_connect_api_key(
        key_id: ENV["APP_STORE_CONNECT_API_KEY_ID"],
        issuer_id: ENV["APP_STORE_CONNECT_API_ISSUER_ID"],
        key_content: ENV["APP_STORE_CONNECT_API_KEY_CONTENT"]
      )
    )
  end
end

7. सुरक्षा सर्वोत्तम अभ्यास

8. सामान्य प्रश्न

संबंधित गाइड्स