Running a Local Jenkins Server for CI/CD Pipelines

Continuous Integration and Continuous Deployment (CI/CD) are essential practices for modern software development. Jenkins, an open-source automation server, is a popular choice for implementing CI/CD pipelines. This guide will walk you through installing and configuring Jenkins locally, automating .NET and Angular deployments, and integrating Jenkins with Docker and Kubernetes for seamless containerized workflows.

Why Use Jenkins for CI/CD?

Jenkins offers several advantages:

• Automated Build and Deployment: Streamlines software release cycles.
• Scalability: Supports distributed builds with master-agent architecture.
• Extensibility: Thousands of plugins to integrate with various tools.
• Cross-Platform Support: Runs on Windows, macOS, and Linux.

Prerequisites

Before setting up Jenkins, ensure you have:

• A machine with Windows, Linux, or macOS.
• Java (JDK 11 or later) installed.
• Admin privileges for installation.

Step 1: Install and Configure Jenkins Locally

Install Jenkins on Windows

1. Download the latest Jenkins LTS from Jenkins Website.
2. Run the installer and follow the setup wizard.
3. Choose default plugins for quick setup.
4. Retrieve the administrator password from:

   C:\ProgramData\Jenkins\.jenkins\secrets\initialAdminPassword
   

5. Set up an admin user and configure basic settings.

Install Jenkins on Linux/macOS

1. Update the system:

   sudo apt update && sudo apt install openjdk-11-jdk -y
   

2. Add Jenkins repository and install Jenkins:

   wget -q -O - https://pkg.jenkins.io/debian/jenkins.io.key | sudo apt-key add -
   sudo sh -c 'echo deb http://pkg.jenkins.io/debian-stable binary/ > /etc/apt/sources.list.d/jenkins.list'
   sudo apt update && sudo apt install jenkins -y
   

3. Start and enable Jenkins:

   sudo systemctl start jenkins
   sudo systemctl enable jenkins
   

4. Retrieve the initial admin password:

   sudo cat /var/lib/jenkins/secrets/initialAdminPassword
   

5. Set up an admin user and install recommended plugins.

Step 2: Automate .NET and Angular Deployments

Install .NET and Angular on Jenkins Server

1. Install .NET SDK:

   wget https://dotnet.microsoft.com/download/dotnet/scripts/v1/dotnet-install.sh
   chmod +x dotnet-install.sh
   ./dotnet-install.sh --version latest
   

2. Install Node.js and Angular CLI:

   sudo apt install -y nodejs npm
   npm install -g @angular/cli
   

Create Jenkins Pipeline for .NET Applications

1. Navigate to Jenkins Dashboard → New Item → Pipeline.
2. Add a Jenkinsfile to your repository:

   pipeline {
       agent any
       stages {
           stage('Build') {
               steps {
                   sh 'dotnet build --configuration Release'
               }
           }
           stage('Test') {
               steps {
                   sh 'dotnet test'
               }
           }
           stage('Deploy') {
               steps {
                   sh 'dotnet publish -c Release -o /var/www/myapp'
               }
           }
       }
   }
   

3. Save and run the pipeline.

Create Jenkins Pipeline for Angular Applications

1. Navigate to Jenkins Dashboard → New Item → Pipeline.
2. Add a Jenkinsfile:

   pipeline {
       agent any
       stages {
           stage('Install Dependencies') {
               steps {
                   sh 'npm install'
               }
           }
           stage('Build') {
               steps {
                   sh 'ng build --prod'
               }
           }
           stage('Deploy') {
               steps {
                   sh 'scp -r dist/* user@server:/var/www/html/'
               }
           }
       }
   }
   

3. Save and trigger the pipeline.

Step 3: Integrate Jenkins with Docker and Kubernetes

Install Docker on Jenkins Server

sudo apt install -y docker.io
sudo systemctl start docker
sudo systemctl enable docker
sudo usermod -aG docker jenkins

Restart Jenkins:

sudo systemctl restart jenkins

Configure Jenkins for Docker Builds

1. Install Docker Pipeline Plugin from Jenkins Plugin Manager.
2. Update your Jenkinsfile:

   pipeline {
       agent {
           docker {
               image 'mcr.microsoft.com/dotnet/sdk:latest'
           }
       }
       stages {
           stage('Build & Run Tests') {
               steps {
                   sh 'dotnet build --configuration Release'
                   sh 'dotnet test'
               }
           }
       }
   }
   

Deploy Applications to Kubernetes

1. Install kubectl:

   sudo apt install -y kubectl
   

2. Configure Kubernetes context:

   aws eks --region <region> update-kubeconfig --name <cluster-name>
   

3. Create a Jenkins pipeline to deploy to Kubernetes:

   pipeline {
       agent any
       stages {
           stage('Build Docker Image') {
               steps {
                   sh 'docker build -t myapp:latest .'
               }
           }
           stage('Push to Registry') {
               steps {
                   sh 'docker tag myapp:latest myrepo/myapp:latest'
                   sh 'docker push myrepo/myapp:latest'
               }
           }
           stage('Deploy to Kubernetes') {
               steps {
                   sh 'kubectl apply -f k8s/deployment.yaml'
               }
           }
       }
   }
   

Conclusion

Setting up a local Jenkins server enables robust CI/CD pipelines for .NET and Angular applications. Integrating Docker and Kubernetes further enhances scalability and deployment automation. By following this guide, you can streamline your development and deployment processes efficiently.

Would you like assistance with setting up automated tests in Jenkins? Let me know!