Kubernetes plugin , additional description - unix1998/technical_notes GitHub Wiki

the Kubernetes plugin for Jenkins can be used to provide dynamic Jenkins agents on various Kubernetes-based environments, including OpenShift, Amazon EKS (Elastic Kubernetes Service), and Azure AKS (Azure Kubernetes Service). Here’s a brief overview of how the plugin can be utilized across these platforms:

Kubernetes Plugin for Jenkins

The Kubernetes plugin for Jenkins allows Jenkins to dynamically provision and manage agent pods in a Kubernetes cluster. This helps in scaling Jenkins agents up and down based on the workload, optimizing resource utilization.

Using Kubernetes Plugin with Different Kubernetes Environments

OpenShift

OpenShift, being a Kubernetes distribution, is fully compatible with the Kubernetes plugin for Jenkins. OpenShift provides additional features like integrated CI/CD pipelines, enhanced security policies, and developer-friendly tools.

  1. Installation and Configuration:

    • Install Jenkins on OpenShift either by using the OpenShift Jenkins template or by deploying Jenkins manually.
    • Configure the Kubernetes plugin in Jenkins by providing the OpenShift cluster’s API URL, credentials, and other required settings.
    • Ensure that Jenkins has the necessary permissions to create and manage pods in the OpenShift cluster.

  2. Dynamic Agents:

    • Define pod templates in the Jenkins configuration. These templates describe the containers that will be created as part of the agent pods.
    • Use OpenShift-specific configurations if needed, such as setting up service accounts, security contexts, and persistent storage.

Amazon EKS (Elastic Kubernetes Service)

Amazon EKS is a managed Kubernetes service provided by AWS, making it easy to run Kubernetes without needing to manage the control plane.

  1. Setup:

    • Deploy Jenkins in an EKS cluster.
    • Configure the Kubernetes plugin with the EKS cluster’s API endpoint and credentials (typically using AWS IAM roles and policies).

  2. Dynamic Agents:

    • Define pod templates and configure the Kubernetes plugin to use these templates to spin up agent pods on demand.
    • Ensure the Jenkins master node has the necessary IAM roles and permissions to interact with the EKS cluster.

Azure AKS (Azure Kubernetes Service)

Azure AKS is a managed Kubernetes service from Microsoft Azure, simplifying Kubernetes management and providing seamless integration with Azure services.

  1. Setup:

    • Deploy Jenkins in an AKS cluster.
    • Configure the Kubernetes plugin with the AKS cluster’s API server endpoint and Azure Active Directory credentials.

  2. Dynamic Agents:

    • Define pod templates in Jenkins to provision dynamic agent pods within the AKS cluster.
    • Ensure appropriate Azure roles and permissions are assigned to Jenkins for managing resources in the AKS cluster.

Example of Configuring the Kubernetes Plugin

Here’s a generic example of configuring the Kubernetes plugin for Jenkins to use dynamic agents:

  1. Install the Kubernetes Plugin:

    • Go to the Jenkins dashboard, navigate to “Manage Jenkins” > “Manage Plugins” > “Available”, and search for “Kubernetes”. Install the plugin.

  2. Configure Kubernetes Cloud:

    • Navigate to “Manage Jenkins” > “Configure System”.
    • Scroll down to the “Cloud” section and click “Add a new cloud” > “Kubernetes”.
    • Configure the Kubernetes cloud with the following details:
      • Kubernetes URL: The API endpoint of your Kubernetes cluster.
      • Kubernetes Namespace: The namespace where Jenkins will create agent pods.
      • Jenkins URL: The URL of your Jenkins instance.
      • Credentials: Provide the credentials needed to access the Kubernetes cluster (e.g., Kubernetes service account, AWS IAM role, Azure AD credentials).

  3. Define Pod Templates:

    • In the Kubernetes cloud configuration, add pod templates. Each template can include multiple containers with different configurations.
podTemplate(label: 'mypod', containers: [
    containerTemplate(name: 'maven', image: 'maven:3.6.3-jdk-11', ttyEnabled: true, command: 'cat'),
    containerTemplate(name: 'node', image: 'node:12-alpine', ttyEnabled: true, command: 'cat')
]) {
    node('mypod') {
        stage('Build') {
            container('maven') {
                sh 'mvn clean install'
            }
        }
        stage('Test') {
            container('node') {
                sh 'npm install && npm test'
            }
        }
    }
}

Conclusion

The Kubernetes plugin for Jenkins is versatile and can be used across various managed Kubernetes services such as OpenShift, Amazon EKS, and Azure AKS. By configuring this plugin, you can leverage the scalability and flexibility of Kubernetes to manage Jenkins agents dynamically, optimizing resource usage and improving CI/CD pipeline efficiency.

without Kubernetes jenkin plugin example ############################################3

we can use helm install or oc apply -f commands within a Jenkins pipeline to deploy applications to a Kubernetes or OpenShift cluster without the need for the Kubernetes plugin for Jenkins. Here’s how you can do it:

Using helm install in Jenkins Pipeline

Helm is a package manager for Kubernetes that helps you manage Kubernetes applications. You can use Helm commands in your Jenkins pipeline to deploy your application.

Example Jenkins Pipeline with Helm

pipeline {
    agent any
    environment {
        KUBECONFIG = credentials('kubeconfig-id') // Assuming you have the kubeconfig stored in Jenkins credentials
    }
    stages {
        stage('Build') {
            steps {
                sh 'mvn clean package' // Example for a Maven build
            }
        }
        stage('Deploy') {
            steps {
                withCredentials([file(credentialsId: 'kubeconfig-id', variable: 'KUBECONFIG')]) {
                    sh 'helm repo update'
                    sh 'helm install myapp ./mychart --namespace mynamespace'
                }
            }
        }
    }
}

Using oc apply in Jenkins Pipeline

OpenShift’s oc command can be used to interact with the OpenShift cluster and deploy applications using YAML configuration files.

Example Jenkins Pipeline with oc apply

pipeline {
    agent any
    environment {
        KUBECONFIG = credentials('kubeconfig-id') // Assuming you have the kubeconfig stored in Jenkins credentials
    }
    stages {
        stage('Build') {
            steps {
                sh 'mvn clean package' // Example for a Maven build
            }
        }
        stage('Deploy') {
            steps {
                withCredentials([file(credentialsId: 'kubeconfig-id', variable: 'KUBECONFIG')]) {
                    sh 'oc apply -f deployment.yaml'
                    sh 'oc apply -f service.yaml'
                    sh 'oc apply -f route.yaml'
                }
            }
        }
    }
}

Detailed Steps

1. Configuring Jenkins with Kubernetes/OpenShift Access

  • Credentials: Ensure Jenkins has the necessary credentials to access the Kubernetes/OpenShift cluster. This could be a kubeconfig file stored in Jenkins credentials.
  • Install CLI Tools: Make sure the Jenkins agents have kubectl, helm, or oc installed.

2. Jenkinsfile for Helm Deployment

  • KUBECONFIG Environment Variable: Use the Jenkins credentials to set the KUBECONFIG environment variable so that the commands can authenticate with the cluster.
  • Build Stage: Include a stage for building your application (e.g., using Maven or Gradle).
  • Deploy Stage: Use sh steps to run the helm install command for deploying your Helm chart.

3. Jenkinsfile for oc apply Deployment

  • KUBECONFIG Environment Variable: Same as above, use the Jenkins credentials to set the KUBECONFIG environment variable.
  • Build Stage: Include a stage for building your application.
  • Deploy Stage: Use sh steps to run oc apply commands to deploy your application using the provided YAML files.

Benefits of This Approach

  • Simplicity: You don’t need to install and configure the Kubernetes plugin for Jenkins.
  • Flexibility: You can use any commands that you normally use in your terminal directly in the Jenkins pipeline.
  • Control: You have full control over the deployment process and can customize it as needed.

Conclusion

Using helm install or oc apply -f commands in Jenkins pipelines provides a straightforward and flexible method to deploy applications to Kubernetes or OpenShift clusters without relying on the Kubernetes plugin for Jenkins. This approach leverages the native CLI tools for deployment, making it easy to integrate with your existing CI/CD pipelines.