{"id":78,"date":"2018-10-17T03:23:57","date_gmt":"2018-10-17T03:23:57","guid":{"rendered":"https:\/\/www.appservgrid.com\/paw92\/index.php\/2018\/10\/17\/set-up-a-ci-cd-pipeline-with-a-jenkins-pod-in-kubernetes-part-2-linux-com\/"},"modified":"2018-10-17T03:23:57","modified_gmt":"2018-10-17T03:23:57","slug":"set-up-a-ci-cd-pipeline-with-a-jenkins-pod-in-kubernetes-part-2-linux-com","status":"publish","type":"post","link":"https:\/\/www.appservgrid.com\/paw92\/index.php\/2018\/10\/17\/set-up-a-ci-cd-pipeline-with-a-jenkins-pod-in-kubernetes-part-2-linux-com\/","title":{"rendered":"Set Up a CI\/CD Pipeline with a Jenkins Pod in Kubernetes (Part 2) | Linux.com"},"content":{"rendered":"

In Part 1<\/a> of our series, we got our local Kubernetes cluster up and running with Docker, Minikube, and kubectl. We set up an image repository, and tried building, pushing, and deploying a container image with code changes we made to the Hello-Kenzan app. It\u2019s now time to automate this process. <\/p>\n

In Part 2, we\u2019ll set up continuous delivery for our application by running Jenkins in a pod in Kubernetes. We\u2019ll create a pipeline using a Jenkins 2.0 Pipeline script that automates building our Hello-Kenzan image, pushing it to the registry, and deploying it in Kubernetes. That\u2019s right: we are going to deploy pods from a registry pod using a Jenkins pod. While this may sound like a bit of deployment alchemy, once the infrastructure and application components are all running on Kubernetes, it makes the management of these pieces easy since they\u2019re all under one ecosystem. <\/p>\n

With Part 2, we\u2019re laying the last bit of infrastructure we need so that we can run our Kr8sswordz Puzzle in Part 3.<\/p>\n

Read all the articles in the series:<\/em><\/p>\n\n\n\n
\"RyHz4CL2OgRH4G8M7BLPxwZ7MMAZh-DpmmEuXBoa\"<\/td>\n\n

This tutorial only runs locally in Minikube and will not work on the cloud. You\u2019ll need a computer running an up-to-date version of Linux or macOS. Optimally, it should have 16 GB of RAM. Minimally, it should have 8 GB of RAM. For best performance, reboot your computer and keep the number of running apps to a minimum. <\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Creating and Building a Pipeline in Jenkins <\/h2>\n

Before you begin, you\u2019ll want to make sure you\u2019ve run through the steps in Part 1, in which we set up our image repository running in a pod (to do so quickly, you can run the npm part1 automated script detailed below<\/a>). <\/p>\n

If you previously stopped Minikube, you\u2019ll need to start it up again. Enter the following terminal command, and wait for the cluster to start:<\/p>\n

minikube start<\/p>\n

You can check the cluster status and view all the pods that are running. <\/p>\n

kubectl cluster-info<\/p>\n

kubectl get pods –all-namespaces<\/p>\n

Make sure that the registry pod has a Status of Running. <\/p>\n

We are ready to build out our Jenkins infrastructure. <\/p>\n

Remember, you don\u2019t actually have to type the commands below\u2014just press Enter at each step and the script will enter the command for you!<\/p>\n

1. First, let’s build the Jenkins image we’ll use in our Kubernetes cluster. <\/p>\n

docker build -t 127.0.0.1:30400\/jenkins:latest <\/p>\n

-f applications\/jenkins\/Dockerfile applications\/jenkins<\/p>\n

2. Once again we’ll need to set up the Socat Registry proxy container to push images, so let’s build it. Feel free to skip this step in case the socat-registry image already exists from Part 1 (to check, run docker images<\/em>). <\/p>\n

docker build -t socat-registry -f applications\/socat\/Dockerfile applications\/socat<\/p>\n

3. Run the proxy container from the image. <\/p>\n

docker stop socat-registry; docker rm socat-registry; <\/p>\n

docker run -d -e “REG_IP=`minikube ip`” -e “REG_PORT=30400” <\/p>\n

–name socat-registry -p 30400:5000 socat-registry<\/p>\n\n\n\n
\"n-z3awvRgVXCO-QIpllgiqXOWtsTeePM62asXPD5\"<\/td>\n\n

This step will fail if local port 30400 is currently in use by another process. You can check if there\u2019s any process currently using this port by running the command
lsof -i :30400<\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

4. With our proxy container up and running, we can now push our Jenkins image to the local repository.<\/p>\n

docker push 127.0.0.1:30400\/jenkins:latest<\/p>\n

You can see the newly pushed Jenkins image in the registry UI using the following command.<\/p>\n

minikube service registry-ui<\/p>\n

5. The proxy\u2019s work is done, so you can go ahead and stop it.<\/p>\n

docker stop socat-registry<\/p>\n

6. Deploy Jenkins, which we\u2019ll use to create our automated CI\/CD pipeline. It will take the pod a minute or two to roll out. <\/p>\n

kubectl apply -f manifests\/jenkins.yaml; kubectl rollout status deployment\/jenkins<\/p>\n

Inspect all the pods that are running. You\u2019ll see a pod for Jenkins now.<\/p>\n

kubectl get pods<\/p>\n\n\n\n
\"_YIHeGg141vkuJmdJZBO0zN2s3pjLdDMgo5pfQFe\"<\/td>\n\n

Jenkins as a CD tool needs special rights in order to interact with the Kubernetes cluster, so we\u2019ve setup RBAC<\/a> (Role Based Access Control) authorization for it inside the jenkins.yaml deployment manifest. RBAC consists of a Role, a ServiceAccount and a Binding object that binds the two together. Here\u2019s how we configured Jenkins with these resources:<\/p>\n

Role: For simplicity we leveraged the pre-existing ClusterRole “cluster-admin” which by default has unlimited access to the cluster. (In a real life scenario you might want to narrow down Jenkins’ access rights by creating a new role with the least privileged PolicyRule.)<\/p>\n

ServiceAccount: We created a new ServiceAccount named “Jenkins\u201d. The property “automountServiceAccountToken” has been set to true; this will automatically mount the authentication resources needed for a kubeconfig context to be setup on the pod (i.e. Cluster info, User represented by a token and a Namespace). <\/p>\n

RoleBinding: We created a ClusterRoleBinding that binds together the “Jenkins” serviceAccount to the “cluster-admin” ClusterRole.<\/p>\n

Lastly, we tell our Jenkins deployment to run as the Jenkins ServiceAccount.<\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n\n\n\n
\"n-z3awvRgVXCO-QIpllgiqXOWtsTeePM62asXPD5\"<\/td>\n\n

Notice our Jenkins deployment has an initContainer. This is a container that will run to completion before the main container is deployed on our pod. The job of this init container is to create a kubeconfig file based on the provided context and to share it with the main Jenkins container through an \u201cemptyDir\u201d volume.<\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

7. Open the Jenkins UI in a web browser.<\/p>\n

minikube service jenkins<\/p>\n

8. Display the Jenkins admin password with the following command, and right-click to copy it.<\/p>\n

kubectl exec -it `kubectl get pods –selector=app=jenkins <\/p>\n

–output=jsonpath={.items..metadata.name}` cat <\/p>\n

\/var\/jenkins_home\/secrets\/initialAdminPassword<\/p>\n

9. Switch back to the Jenkins UI. Paste the Jenkins admin password in the box and click Continue. Click Install suggested plugins. Plugins have actually been pre-downloaded during the Jenkins image build, so this step should finish fairly quickly.<\/p>\n\n\n\n
\"RyHz4CL2OgRH4G8M7BLPxwZ7MMAZh-DpmmEuXBoa\"<\/td>\n\n

One of the plugins being installed is Kubernetes Continuous Deploy<\/a>, which allows Jenkins to directly interact with the Kubernetes cluster rather than through kubectl commands. This plugin was pre-downloaded with the Jenkins image build. <\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

10. Create an admin user and credentials, and click Save and Continue. (Make sure to remember these credentials as you will need them for repeated logins.)<\/p>\n

\"s7KGWbFBCOau5gi7G05Fs_mjAtBOVNy7LlEQ4wTL\" <\/p>\n

11. On the Instance Configuration page, click Save and Finish. On the next page, click Restart (if it appears to hang for some time on restarting, you may have to refresh the browser window). Login to Jenkins. <\/p>\n

12. Before we create a pipeline, we first need to provision the Kubernetes Continuous Deploy plugin with a kubeconfig file that will allow access to our Kubernetes cluster. In Jenkins on the left, click on Credentials, select the Jenkins store, then Global credentials (unrestricted), and Add Credentials on the left menu<\/p>\n

13. The following values must be entered precisely as indicated: <\/p>\n