🚀 Jenkins CI/CD Server on AlmaLinux: Automate Your Software Delivery Pipeline

Welcome to the world of continuous integration and delivery! 🎉 Ready to automate your entire software pipeline? Jenkins is the most popular open-source automation server that makes CI/CD a breeze! It’s the platform that transforms manual deployments into automated workflows! Think of it as your development team’s best friend that never sleeps! 🚀✨

🤔 Why is Jenkins Important?

Jenkins revolutionizes software delivery! 🚀 Here’s why it’s amazing:

• 🔄 Continuous Integration - Automatically build and test code!
• 📦 Continuous Delivery - Deploy to production seamlessly!
• 🔌 1000+ Plugins - Integrate with everything!
• 📊 Pipeline as Code - Version control your workflows!
• 🎯 Distributed Builds - Scale across multiple machines!
• 🆓 Completely Free - Open source forever!

It’s like having a robot army for your deployments! 💰

🎯 What You Need

Before building your CI/CD pipeline, ensure you have:

• ✅ AlmaLinux 9 server
• ✅ Root or sudo access
• ✅ At least 2GB RAM (4GB recommended)
• ✅ 2 CPU cores minimum
• ✅ 10GB free disk space
• ✅ Java 11 or newer
• ✅ Love for automation! 🚀

📝 Step 1: System Preparation - Getting Ready!

Let’s prepare AlmaLinux 9 for Jenkins! 🏗️

# Update system packages
sudo dnf update -y

# Install Java 11 (Jenkins requirement)
sudo dnf install -y java-11-openjdk java-11-openjdk-devel

# Verify Java installation
java -version
# Should show: openjdk version "11.0.x"

# Set JAVA_HOME environment variable
echo 'export JAVA_HOME=/usr/lib/jvm/java-11-openjdk' >> ~/.bashrc
echo 'export PATH=$JAVA_HOME/bin:$PATH' >> ~/.bashrc
source ~/.bashrc

# Verify JAVA_HOME
echo $JAVA_HOME
# Should show: /usr/lib/jvm/java-11-openjdk

# Install additional tools
sudo dnf install -y wget git curl unzip

Configure firewall for Jenkins:

# Open Jenkins port
sudo firewall-cmd --permanent --add-port=8080/tcp
sudo firewall-cmd --reload

# Verify port is open
sudo firewall-cmd --list-ports
# Should show: 8080/tcp

Perfect! System is ready! 🎯

🔧 Step 2: Installing Jenkins - The Official Way!

Let’s install Jenkins from the official repository! 🚀

Add Jenkins Repository:

# Import Jenkins GPG key
sudo rpm --import https://pkg.jenkins.io/redhat-stable/jenkins.io-2023.key

# Add Jenkins repository
sudo wget -O /etc/yum.repos.d/jenkins.repo \
    https://pkg.jenkins.io/redhat-stable/jenkins.repo

# Verify repository
sudo dnf repolist | grep jenkins
# Should show: jenkins repository

Install Jenkins:

# Install Jenkins
sudo dnf install -y jenkins

# Enable Jenkins service
sudo systemctl enable jenkins

# Start Jenkins
sudo systemctl start jenkins

# Check status
sudo systemctl status jenkins
# Should show: active (running)

# View initial admin password
sudo cat /var/lib/jenkins/secrets/initialAdminPassword
# Save this password! You'll need it!

🌟 Step 3: Initial Setup - Your CI/CD Dashboard!

Time to configure Jenkins! 🎮

Access Jenkins Web UI:

# Get your server IP
ip addr show | grep inet
# Note your server IP address

# Access Jenkins
# URL: http://your-server-ip:8080
# Enter the initial admin password from earlier

Setup Wizard Steps:

1. Unlock Jenkins:

   • Enter initial admin password
   • Click “Continue”

2. Install Plugins:

   • Select “Install suggested plugins”
   • Wait for plugins to install (5-10 minutes)
   • Plugins include Git, Pipeline, Credentials, etc.

3. Create Admin User:

   • Username: admin
   • Password: YourSecurePassword
   • Full name: Jenkins Admin
   • Email: [email protected]

4. Instance Configuration:

   • Jenkins URL: http://your-server-ip:8080
   • Click “Save and Finish”

5. Start Using Jenkins! 🎉

Dashboard shows:

• 📊 New Item - Create jobs/pipelines
• 👥 People - User management
• 📈 Build History - Execution logs
• 🔧 Manage Jenkins - Configuration
• 📚 My Views - Custom dashboards

✅ Step 4: Creating Your First Pipeline - Let’s Build!

Time to create your first CI/CD pipeline! 🎯

Create Freestyle Project:

1. Click “New Item”
2. Enter name: Hello-World-Build
3. Select: “Freestyle project”
4. Click “OK”

Configure Build:

1. General Section:

   • Description: My first Jenkins build
   • Check: “Discard old builds”
   • Max builds: 10

2. Source Code Management:

   • Select: “Git”
   • Repository URL: https://github.com/example/hello-world.git
   • Branch: */main

3. Build Triggers:

   • Check: “Poll SCM”
   • Schedule: H/5 * * * * (every 5 minutes)

4. Build Steps:

   • Click “Add build step” → “Execute shell”

   echo "=== Starting Build ==="
   echo "Build number: $BUILD_NUMBER"
   echo "Workspace: $WORKSPACE"
   
   # Example build commands
   echo "Running tests..."
   # npm test
   
   echo "Building application..."
   # npm run build
   
   echo "Build completed successfully!"

5. Save the job

Run the Build:

1. Click “Build Now” 🚀
2. Watch build progress in Build History
3. Click build number for details
4. View “Console Output” for logs

🌟 Step 5: Creating Pipeline as Code - Modern CI/CD!

Let’s create a declarative pipeline! 🎯

Create Pipeline Job:

1. New Item → Name: Application-Pipeline
2. Select: “Pipeline”
3. Click “OK”

Write Jenkinsfile:

In Pipeline section, add:

pipeline {
    agent any
    
    environment {
        APP_NAME = 'MyApp'
        APP_VERSION = '1.0.0'
    }
    
    stages {
        stage('Checkout') {
            steps {
                echo '=== Checking out code ==='
                git branch: 'main', 
                    url: 'https://github.com/example/myapp.git'
            }
        }
        
        stage('Build') {
            steps {
                echo '=== Building application ==='
                sh '''
                    echo "Building ${APP_NAME} version ${APP_VERSION}"
                    # npm install
                    # npm run build
                '''
            }
        }
        
        stage('Test') {
            steps {
                echo '=== Running tests ==='
                sh '''
                    echo "Testing application..."
                    # npm test
                    # npm run test:coverage
                '''
            }
        }
        
        stage('Deploy to Staging') {
            steps {
                echo '=== Deploying to staging ==='
                sh '''
                    echo "Deploying to staging server..."
                    # scp -r dist/* user@staging:/var/www/
                    # ssh user@staging "sudo systemctl restart app"
                '''
            }
        }
        
        stage('Approval') {
            steps {
                input message: 'Deploy to production?', 
                      ok: 'Deploy'
            }
        }
        
        stage('Deploy to Production') {
            steps {
                echo '=== Deploying to production ==='
                sh '''
                    echo "Deploying to production..."
                    # scp -r dist/* user@prod:/var/www/
                    # ssh user@prod "sudo systemctl restart app"
                '''
            }
        }
    }
    
    post {
        success {
            echo 'Pipeline completed successfully!'
            // Send success notification
        }
        failure {
            echo 'Pipeline failed!'
            // Send failure alert
        }
        always {
            echo 'Cleaning up workspace...'
            cleanWs()
        }
    }
}

Save and Run Pipeline:

1. Save the pipeline
2. Click “Build Now”
3. Watch stages execute in Stage View
4. Approve deployment when prompted

🎮 Quick Examples

Example 1: Docker Build Pipeline

pipeline {
    agent any
    
    stages {
        stage('Build Docker Image') {
            steps {
                script {
                    docker.build("myapp:${env.BUILD_NUMBER}")
                }
            }
        }
        
        stage('Push to Registry') {
            steps {
                script {
                    docker.withRegistry('https://registry.example.com', 'docker-creds') {
                        docker.image("myapp:${env.BUILD_NUMBER}").push()
                        docker.image("myapp:${env.BUILD_NUMBER}").push('latest')
                    }
                }
            }
        }
        
        stage('Deploy Container') {
            steps {
                sh '''
                    docker stop myapp || true
                    docker rm myapp || true
                    docker run -d --name myapp -p 3000:3000 myapp:${BUILD_NUMBER}
                '''
            }
        }
    }
}

Example 2: Multi-Branch Pipeline

Create Jenkinsfile in your repository:

pipeline {
    agent any
    
    stages {
        stage('Build') {
            steps {
                echo "Building branch: ${env.BRANCH_NAME}"
                sh 'make build'
            }
        }
        
        stage('Test') {
            steps {
                sh 'make test'
            }
        }
        
        stage('Deploy') {
            when {
                branch 'main'
            }
            steps {
                echo 'Deploying to production...'
                sh 'make deploy'
            }
        }
    }
}

Then create Multi-branch Pipeline in Jenkins to auto-discover branches!

Example 3: Parallel Execution

pipeline {
    agent any
    
    stages {
        stage('Parallel Tests') {
            parallel {
                stage('Unit Tests') {
                    steps {
                        sh 'npm run test:unit'
                    }
                }
                stage('Integration Tests') {
                    steps {
                        sh 'npm run test:integration'
                    }
                }
                stage('E2E Tests') {
                    steps {
                        sh 'npm run test:e2e'
                    }
                }
            }
        }
    }
}

🚨 Fix Common Problems

Problem 1: Jenkins Won’t Start

Symptom: Service fails to start 😰

Fix:

# Check Jenkins logs
sudo journalctl -u jenkins -n 50

# Common issue: Java not found
which java
# If not found, reinstall Java

# Check port conflict
sudo netstat -tlnp | grep 8080
# If occupied, change port in:
sudo vi /etc/sysconfig/jenkins
# JENKINS_PORT="8081"

# Restart Jenkins
sudo systemctl restart jenkins

Problem 2: Build Failures

Symptom: Jobs fail immediately 🔴

Fix:

# Check workspace permissions
sudo chown -R jenkins:jenkins /var/lib/jenkins/workspace

# Install build tools
sudo dnf install -y nodejs npm maven gradle

# Add Jenkins to docker group (if using Docker)
sudo usermod -aG docker jenkins
sudo systemctl restart jenkins

# Check environment variables
# In job configuration, add:
# Environment variables:
# PATH+EXTRA=/usr/local/bin:/opt/tools/bin

Problem 3: Plugin Issues

Symptom: Plugins won’t install or update 🔌

Fix:

# Update Jenkins
sudo dnf update jenkins

# Clear plugin cache
sudo rm -rf /var/lib/jenkins/plugins/*.tmp
sudo rm -rf /var/lib/jenkins/plugins/*.bak

# Restart Jenkins
sudo systemctl restart jenkins

# Manual plugin install
# Download .hpi file from https://plugins.jenkins.io/
# Upload via Manage Jenkins → Manage Plugins → Advanced

📋 Simple Commands Summary

💡 Tips for Success

🚀 Performance Optimization

Make Jenkins super fast:

# Increase heap memory
sudo vi /etc/sysconfig/jenkins
# JENKINS_JAVA_OPTIONS="-Xmx2g -Xms1g"

# Enable build executors
# Manage Jenkins → Configure System
# # of executors: 4

# Use pipeline caching
# In Jenkinsfile:
options {
    skipDefaultCheckout()
    timestamps()
    buildDiscarder(logRotator(numToKeepStr: '10'))
}

🔒 Security Best Practices

Keep Jenkins secure:

1. Enable security - Use matrix-based security! 🔐
2. HTTPS only - Configure SSL certificates! 🔑
3. Strong passwords - Enforce password policy! 🛡️
4. Limit access - Use role-based permissions! 👥
5. Regular updates - Keep Jenkins updated! 📦

# Setup HTTPS with reverse proxy
sudo dnf install -y nginx

# Configure nginx
cat << 'EOF' > /etc/nginx/conf.d/jenkins.conf
server {
    listen 443 ssl;
    server_name jenkins.example.com;
    
    ssl_certificate /etc/ssl/certs/jenkins.crt;
    ssl_certificate_key /etc/ssl/private/jenkins.key;
    
    location / {
        proxy_pass http://localhost:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}
EOF

sudo systemctl restart nginx

📊 Monitoring and Backup

Keep Jenkins healthy:

# Automated backup script
cat << 'EOF' > /usr/local/bin/backup-jenkins.sh
#!/bin/bash
BACKUP_DIR="/backup/jenkins"
DATE=$(date +%Y%m%d)

# Create backup directory
mkdir -p $BACKUP_DIR

# Stop Jenkins
sudo systemctl stop jenkins

# Backup Jenkins home
tar -czf $BACKUP_DIR/jenkins-$DATE.tar.gz /var/lib/jenkins/

# Start Jenkins
sudo systemctl start jenkins

# Keep only last 7 backups
find $BACKUP_DIR -name "*.tar.gz" -mtime +7 -delete

echo "Backup completed: jenkins-$DATE.tar.gz"
EOF

chmod +x /usr/local/bin/backup-jenkins.sh
# Add to cron: 0 2 * * * /usr/local/bin/backup-jenkins.sh

🏆 What You Learned

You’re now a Jenkins CI/CD expert! 🎓 You’ve successfully:

• ✅ Installed Jenkins on AlmaLinux 9
• ✅ Configured initial setup
• ✅ Created freestyle projects
• ✅ Built pipelines as code
• ✅ Set up continuous integration
• ✅ Implemented deployment workflows
• ✅ Mastered automation pipelines

Your CI/CD platform is production-ready! 🚀

🎯 Why This Matters

Jenkins transforms software delivery! With your CI/CD server, you can:

• 🚀 Deploy faster - Automate everything!
• 🛡️ Reduce errors - Consistent processes!
• 📊 Track everything - Full visibility!
• 👥 Collaborate better - Shared pipelines!
• 💰 Save time - Let Jenkins do the work!

You’re not just building software - you’re automating the entire delivery pipeline! Every commit is tested, every deployment is tracked! 🎭

Keep automating, keep delivering, and remember - with Jenkins, continuous delivery is just a pipeline away! ⭐

May your builds be green and your deployments smooth! 🚀🎯🙌