Continuous Integration and Continuous Deployment (CI/CD) are essential practices in modern software development, enabling teams to deliver code changes more frequently and reliably. Kubernetes, with its powerful orchestration capabilities, is an excellent platform for implementing CI/CD pipelines. In this section, we will explore how to set up and manage CI/CD pipelines using Kubernetes.

1. Continuous Integration (CI): The practice of automatically integrating code changes from multiple contributors into a shared repository several times a day.
2. Continuous Deployment (CD): The practice of automatically deploying every change that passes the automated tests to production.
3. Pipeline: A set of automated processes that software goes through to get from version control into the hands of users.
4. Jenkins: An open-source automation server that is widely used for building CI/CD pipelines.
5. GitLab CI/CD: A built-in CI/CD tool in GitLab that allows you to run automated tests and deploy code.

1. Create a Namespace for Jenkins:

   kubectl create namespace jenkins
   

2. Deploy Jenkins using Helm:

   helm repo add jenkinsci https://charts.jenkins.io
   helm repo update
   helm install jenkins jenkinsci/jenkins --namespace jenkins
   

3. Access Jenkins:

   • Get the Jenkins admin password:

     kubectl get secret --namespace jenkins jenkins -o jsonpath="{.data.jenkins-admin-password}" | base64 --decode
     

   • Port-forward to access Jenkins UI:

     kubectl --namespace jenkins port-forward svc/jenkins 8080:8080
     

   • Open your browser and go to http://localhost:8080 and log in with the admin password.

1. Install Required Plugins:

   • Go to Manage Jenkins -> Manage Plugins.
   • Install plugins like Kubernetes, Git, Pipeline, and any other necessary plugins.

2. Configure Kubernetes Plugin:

   • Go to Manage Jenkins -> Configure System.
   • Under Cloud, add a new Kubernetes cloud.
   • Configure the Kubernetes cloud with your cluster details.

1. Create a New Pipeline Job:

   • Go to New Item, enter a name, and select Pipeline.

2. Define the Pipeline Script:

   • Use the following example script to define a simple CI/CD pipeline:

   pipeline {
       agent {
           kubernetes {
               label 'jenkins-slave'
               yaml """
               apiVersion: v1
               kind: Pod
               spec:
                 containers:
                 - name: jnlp
                   image: jenkins/inbound-agent
                   args: ['\$(JENKINS_SECRET)', '\$(JENKINS_NAME)']
                 - name: build
                   image: maven:3.6.3-jdk-8
                   command:
                   - cat
                   tty: true
               """
           }
       }
       stages {
           stage('Build') {
               steps {
                   container('build') {
                       sh 'mvn clean install'
                   }
               }
           }
           stage('Test') {
               steps {
                   container('build') {
                       sh 'mvn test'
                   }
               }
           }
           stage('Deploy') {
               steps {
                   container('build') {
                       sh 'kubectl apply -f k8s/deployment.yaml'
                   }
               }
           }
       }
   }
   

1. Push Code to Repository:

   • Ensure your code repository has a Jenkinsfile with the pipeline script.
   • Push your code to the repository.

2. Run the Pipeline:

   • Go to the Jenkins job and click Build Now.
   • Monitor the pipeline execution and ensure it completes successfully.

1. Set Up GitLab Runner on Kubernetes:

   • Follow the GitLab Runner documentation to deploy a GitLab Runner on your Kubernetes cluster.

2. Create a .gitlab-ci.yml File:

   • Define a simple CI/CD pipeline in your repository:

   stages:
     - build
     - test
     - deploy
   
   build:
     stage: build
     script:
       - mvn clean install
   
   test:
     stage: test
     script:
       - mvn test
   
   deploy:
     stage: deploy
     script:
       - kubectl apply -f k8s/deployment.yaml
   

3. Push Code to GitLab:

   • Push your code and the .gitlab-ci.yml file to your GitLab repository.

4. Monitor Pipeline Execution:

   • Go to your GitLab project and monitor the pipeline execution under CI/CD -> Pipelines.

1. Deploy GitLab Runner:

   kubectl create namespace gitlab-runner
   helm repo add gitlab https://charts.gitlab.io
   helm repo update
   helm install --namespace gitlab-runner gitlab-runner gitlab/gitlab-runner
   

2. Register GitLab Runner:

   • Follow the instructions provided by the Helm chart to register the runner with your GitLab instance.

3. Push Code and Monitor:

   • Ensure your repository has the .gitlab-ci.yml file.
   • Push your code and monitor the pipeline execution in GitLab.

• Incorrect Kubernetes Configuration: Ensure your Kubernetes cluster is correctly configured and accessible from Jenkins or GitLab Runner.
• Pipeline Script Errors: Validate your pipeline scripts for syntax errors and correct paths.
• Resource Limits: Set appropriate resource limits for your CI/CD jobs to avoid overloading your cluster.

In this section, we covered the basics of setting up CI/CD pipelines using Jenkins and GitLab CI/CD on Kubernetes. We explored how to deploy Jenkins, configure it, and create a pipeline. Additionally, we provided a practical exercise to set up a CI/CD pipeline using GitLab CI/CD. By mastering these concepts, you can automate your software delivery process, ensuring faster and more reliable deployments.