Setting Up Jenkins on Alpine Linux

Jenkins is the leading open-source automation server that enables developers to build, test, and deploy their software. Let’s set up a powerful CI/CD pipeline on Alpine Linux! 🚀

What is Jenkins?

Jenkins provides:

Continuous Integration: Automated builds and tests
Continuous Delivery: Automated deployment pipelines
Extensibility: 1000+ plugins available
Distributed Builds: Scale across multiple machines
Easy Configuration: Web-based setup

Prerequisites

Before installing Jenkins:

Alpine Linux system with root access
Java 11 or newer installed
Minimum 2GB RAM (4GB recommended)
10GB+ available disk space
Git installed for source control

Step 1: Install Java

Jenkins requires Java to run:

# Update packages
sudo apk update

# Install OpenJDK 11
sudo apk add openjdk11
sudo apk add openjdk11-jre

# Verify Java installation
java -version
javac -version

# Set JAVA_HOME
export JAVA_HOME=/usr/lib/jvm/java-11-openjdk
export PATH=$PATH:$JAVA_HOME/bin

Make Java settings permanent:

# Add to profile
echo 'export JAVA_HOME=/usr/lib/jvm/java-11-openjdk' >> ~/.profile
echo 'export PATH=$PATH:$JAVA_HOME/bin' >> ~/.profile

Step 2: Install Jenkins

Method 1: Using WAR File

# Create Jenkins directory
sudo mkdir -p /opt/jenkins
cd /opt/jenkins

# Download Jenkins WAR
sudo wget https://get.jenkins.io/war-stable/latest/jenkins.war

# Create Jenkins user
sudo adduser -D -s /bin/false jenkins
sudo chown -R jenkins:jenkins /opt/jenkins

Method 2: Using Package Manager

# Add Jenkins repository key
wget -q -O - https://pkg.jenkins.io/debian-stable/jenkins.io.key | sudo apt-key add -

# For Alpine, we'll use the WAR method as there's no official APK

Step 3: Create Jenkins Service

Create service script:

# Create init script
sudo nano /etc/init.d/jenkins

Add the following content:

#!/sbin/openrc-run

name="jenkins"
description="Jenkins Automation Server"

JENKINS_HOME="/var/lib/jenkins"
JENKINS_WAR="/opt/jenkins/jenkins.war"
JENKINS_LOG="/var/log/jenkins"
JENKINS_USER="jenkins"
JENKINS_PORT="8080"
JAVA_OPTS="-Xmx2048m -Djava.awt.headless=true"

pidfile="/var/run/jenkins.pid"
command="/usr/bin/java"
command_args="$JAVA_OPTS -jar $JENKINS_WAR --httpPort=$JENKINS_PORT --prefix=/jenkins"
command_user="$JENKINS_USER"
command_background="yes"

depend() {
    need net
    after firewall
}

start_pre() {
    checkpath --directory --owner $JENKINS_USER:$JENKINS_USER --mode 0755 \
        $JENKINS_HOME \
        $JENKINS_LOG \
        /var/run
}

Make it executable:

sudo chmod +x /etc/init.d/jenkins

Step 4: Configure Jenkins Environment

Create Directories

# Create Jenkins directories
sudo mkdir -p /var/lib/jenkins
sudo mkdir -p /var/log/jenkins
sudo mkdir -p /var/cache/jenkins

# Set ownership
sudo chown -R jenkins:jenkins /var/lib/jenkins
sudo chown -R jenkins:jenkins /var/log/jenkins
sudo chown -R jenkins:jenkins /var/cache/jenkins

Set Environment Variables

# Create Jenkins defaults file
sudo nano /etc/default/jenkins

Add configuration:

# Jenkins configuration
JENKINS_HOME="/var/lib/jenkins"
JENKINS_USER="jenkins"
JENKINS_PORT="8080"
JENKINS_ARGS="--prefix=/jenkins"

# Java options
JAVA_ARGS="-Djava.awt.headless=true"
JAVA_OPTS="-Xmx2048m -XX:MaxPermSize=512m"

# Security options
JENKINS_ENABLE_ACCESS_LOG="no"

Step 5: Start Jenkins

Start Service

# Start Jenkins
sudo rc-service jenkins start

# Enable on boot
sudo rc-update add jenkins default

# Check status
sudo rc-service jenkins status

Access Jenkins

# Get initial admin password
sudo cat /var/lib/jenkins/secrets/initialAdminPassword

# Access Jenkins
# http://your-server-ip:8080

Step 6: Initial Setup Wizard

Unlock Jenkins: Enter the initial admin password
Install Plugins: Select “Install suggested plugins” or customize
Create Admin User: Set up your administrator account
Configure URL: Set Jenkins URL (important for links in notifications)

Step 7: Configure Security

Enable Security

Navigate to Manage Jenkins → Configure Global Security:

// Example security configuration
jenkins.security.GlobalSecurityConfiguration

// Enable security
useSecurity = true

// Configure authentication
realm = new HudsonPrivateSecurityRealm(false)

// Configure authorization
authorizationStrategy = new FullControlOnceLoggedInAuthorizationStrategy()

Configure Users

# Add users via UI or script
# Manage Jenkins → Manage Users → Create User

Set Up CSRF Protection

// Enable CSRF protection
jenkins.setCrumbIssuer(new DefaultCrumbIssuer(true))

Step 8: Install Essential Plugins

Via UI

Navigate to Manage Jenkins → Manage Plugins:

Essential plugins:

Git Plugin
Pipeline
Blue Ocean
Docker Pipeline
Credentials Binding
Workspace Cleanup
Build Timeout
Timestamper

Via CLI

# Download Jenkins CLI
wget http://localhost:8080/jnlpJars/jenkins-cli.jar

# Install plugins
java -jar jenkins-cli.jar -s http://localhost:8080/ install-plugin git pipeline-model-definition docker-workflow

Step 9: Configure Build Tools

Install Build Dependencies

# Install common build tools
sudo apk add git maven gradle npm nodejs python3 py3-pip

# Install Docker for containerized builds
sudo apk add docker
sudo rc-update add docker boot
sudo adduser jenkins docker

Configure Tool Locations

In Jenkins: Manage Jenkins → Global Tool Configuration

// Example tool configuration
tools {
    maven 'Maven 3.6.3'
    jdk 'JDK 11'
    git 'Default'
}

Step 10: Create First Pipeline

Create Pipeline Job

Click New Item
Enter name and select Pipeline
Configure pipeline

Simple Pipeline Example

pipeline {
    agent any
    
    stages {
        stage('Checkout') {
            steps {
                git 'https://github.com/your-repo/your-project.git'
            }
        }
        
        stage('Build') {
            steps {
                sh 'mvn clean compile'
            }
        }
        
        stage('Test') {
            steps {
                sh 'mvn test'
            }
        }
        
        stage('Package') {
            steps {
                sh 'mvn package'
            }
        }
        
        stage('Deploy') {
            steps {
                echo 'Deploying application...'
                // Add deployment steps
            }
        }
    }
    
    post {
        always {
            cleanWs()
        }
        success {
            echo 'Pipeline succeeded!'
        }
        failure {
            echo 'Pipeline failed!'
        }
    }
}

Declarative Pipeline with Docker

pipeline {
    agent {
        docker {
            image 'maven:3.8-openjdk-11-slim'
            args '-v /root/.m2:/root/.m2'
        }
    }
    
    environment {
        DOCKER_REGISTRY = 'docker.io'
        APP_NAME = 'myapp'
    }
    
    stages {
        stage('Build') {
            steps {
                sh 'mvn clean package'
            }
        }
        
        stage('Test') {
            steps {
                sh 'mvn test'
                junit 'target/surefire-reports/*.xml'
            }
        }
        
        stage('Build Docker Image') {
            steps {
                script {
                    docker.build("${DOCKER_REGISTRY}/${APP_NAME}:${BUILD_NUMBER}")
                }
            }
        }
        
        stage('Push to Registry') {
            when {
                branch 'main'
            }
            steps {
                script {
                    docker.withRegistry('https://registry.hub.docker.com', 'docker-credentials') {
                        docker.image("${DOCKER_REGISTRY}/${APP_NAME}:${BUILD_NUMBER}").push()
                        docker.image("${DOCKER_REGISTRY}/${APP_NAME}:${BUILD_NUMBER}").push('latest')
                    }
                }
            }
        }
    }
}

Step 11: Configure Distributed Builds

Set Up Build Agents

On agent machine:

# Install Java
sudo apk add openjdk11-jre

# Create agent directory
mkdir -p ~/jenkins-agent

# Download agent.jar from Jenkins master
# http://jenkins-master:8080/jnlpJars/agent.jar

Connect Agent

# Run agent
java -jar agent.jar -jnlpUrl http://jenkins-master:8080/computer/agent-name/slave-agent.jnlp -secret [secret-key] -workDir ~/jenkins-agent

Step 12: Backup and Restore

Backup Script

#!/bin/sh
# Jenkins backup script

JENKINS_HOME="/var/lib/jenkins"
BACKUP_DIR="/backup/jenkins"
DATE=$(date +%Y%m%d_%H%M%S)

# Create backup directory
mkdir -p $BACKUP_DIR

# Stop Jenkins
sudo rc-service jenkins stop

# Backup Jenkins home
tar -czf $BACKUP_DIR/jenkins_backup_$DATE.tar.gz -C $JENKINS_HOME .

# Start Jenkins
sudo rc-service jenkins start

# Remove old backups (keep last 7)
find $BACKUP_DIR -name "jenkins_backup_*.tar.gz" -mtime +7 -delete

echo "Backup completed: $BACKUP_DIR/jenkins_backup_$DATE.tar.gz"

Restore Procedure

# Stop Jenkins
sudo rc-service jenkins stop

# Restore backup
tar -xzf /backup/jenkins/jenkins_backup_20240101.tar.gz -C /var/lib/jenkins

# Fix permissions
sudo chown -R jenkins:jenkins /var/lib/jenkins

# Start Jenkins
sudo rc-service jenkins start

Step 13: Monitoring and Maintenance

Enable Monitoring

// Install monitoring plugins
// - Monitoring Plugin
// - Metrics Plugin
// - Prometheus Plugin

Health Check Script

#!/bin/sh
# Jenkins health check

JENKINS_URL="http://localhost:8080"

# Check if Jenkins is responding
if curl -s -o /dev/null -w "%{http_code}" $JENKINS_URL | grep -q "200"; then
    echo "✓ Jenkins is accessible"
else
    echo "✗ Jenkins is not responding"
    exit 1
fi

# Check disk space
DISK_USAGE=$(df -h /var/lib/jenkins | awk 'NR==2 {print $5}' | sed 's/%//')
if [ $DISK_USAGE -gt 80 ]; then
    echo "⚠ Warning: Disk usage is high: ${DISK_USAGE}%"
fi

# Check Jenkins jobs
curl -s $JENKINS_URL/api/json?tree=jobs[name,color] | jq '.jobs[] | select(.color=="red")'

Step 14: Security Hardening

Implement Security Best Practices

// Security configuration script
import jenkins.model.*
import hudson.security.*

def instance = Jenkins.getInstance()

// Disable CLI over remoting
instance.getDescriptor("jenkins.CLI").get().setEnabled(false)

// Enable agent to master security subsystem
instance.injector.getInstance(AdminWhitelistRule.class).setMasterKillSwitch(false)

// Disable JNLP
instance.setSlaveAgentPort(-1)

// Save configuration
instance.save()

Configure HTTPS

# Generate SSL certificate
openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
    -keyout jenkins.key -out jenkins.crt

# Configure Jenkins for HTTPS
JENKINS_ARGS="--httpPort=-1 --httpsPort=8443 --httpsKeyStore=jenkins.jks --httpsKeyStorePassword=password"

Troubleshooting

Common Issues

Jenkins Won’t Start

# Check logs
tail -f /var/log/jenkins/jenkins.log

# Check Java
java -version

# Check permissions
ls -la /var/lib/jenkins

Out of Memory

# Increase heap size in /etc/default/jenkins
JAVA_OPTS="-Xmx4096m -XX:MaxPermSize=1024m"

Plugin Issues

# Safe mode
java -jar jenkins.war --httpPort=8080 --prefix=/jenkins --safe

Best Practices

Regular Backups: Automate Jenkins home backups
Security Updates: Keep Jenkins and plugins updated
Resource Limits: Set appropriate memory limits
Pipeline as Code: Use Jenkinsfile in repositories
Credentials Management: Use Jenkins credentials store
Monitoring: Implement comprehensive monitoring
Documentation: Document your CI/CD processes

Conclusion

You’ve successfully set up Jenkins on Alpine Linux! Your CI/CD server is now ready to:

✅ Automate builds and tests
✅ Deploy applications
✅ Integrate with version control
✅ Scale with distributed builds
✅ Provide continuous delivery

Jenkins on Alpine Linux provides a lightweight yet powerful automation platform. Happy building! 🔧

Setting Up Jenkins on Alpine Linux 🔧

Table of Contents