Instalar Jenkins en Kubernetes

CI / CD (Continuous Integration / Continuous Deployment) es un concepto central del mundo DevOps. Nos ayuda a automatizar los procesos de desarrollo de software: construir, probar e implementar los códigos fuente.

Entre muchas herramientas de CI / CD, Jenkins es una de las herramientas de código abierto más conocidas que ayuda a configurar las canalizaciones para la integración y la implementación continuas.

Este tutorial le mostrará la forma de instalar Jenkins en un clúster de Kubernetes.

Preparando un clúster de Kubernetes

Hay muchas formas de configurar un clúster de Kubernetes. Puede utilizar los servicios de nube pública para aprovisionar su propio clúster en AWS, GCP, Linode, etc. Además, la forma más sencilla es instalar minikube en su máquina local.

Aquí, tengo un clúster de Kubernetes con 5 nodos aprovisionados mediante kubespray.

$ kubectl get node

Instalación de Jenkins

En primer lugar, crearemos un nuevo espacio de nombres para proporcionar el mecanismo de aislamiento para controlar el entorno de CI:

$ kubectl create namespace jenkins
namespace/jenkins created

Verificando que el espacio de nombres jenkins se creó correctamente ejecutando el siguiente comando:

$ kubectl get namespaces

Luego, creemos la implementación de Jenkins. Puede usar el siguiente archivo de manifiesto para crear una implementación de instancia única de Jenkins.

Creando el archivo `jenkins-deployment.yaml`:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: jenkins-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: jenkins
  template:
    metadata:
      labels:
        app: jenkins
    spec:
      containers:
      - name: jenkins
        image: jenkins/jenkins:lts
        ports:
          - name: http-port
            containerPort: 8080
          - name: jnlp-port
            containerPort: 50000
        volumeMounts:
          - name: jenkins-vol
            mountPath: /var/jenkins_vol
      volumes:
        - name: jenkins-vol
          emptyDir: {}

La implementación usa la imagen de Docker `jenkins / jenkins: lts` y expone los puertos` 8080` y `50000`.

Aplicar el manifiesto anterior:

$ kubectl create -f jenkins-deployment.yaml --namespace jenkins

Se necesitan unos minutos para extraer la imagen jenkins / jenkins: lts y hacer que el pod funcione. Verificación de que la implementación de Jenkins se implementó correctamente:

$ kubectl get pod -n jenkins                                                                                                                                                      

NAME                                  READY     STATUS   RESTARTS   AGE
jenkins-deployment-794699f9bc-rln7x   1/1 	Running  0      	  66s

Implementación del servicio Jenkins

Después de crear la implementación de Jenkins y el pod de Jenkins se está ejecutando, debe exponer la conexión al pod en ejecución mediante un servicio. En este tutorial, usaremos los servicios NodePort y ClusterIP.

Creemos el archivo `jenkins-svc.yaml` de la siguiente manera:

apiVersion: v1
kind: Service
metadata:
  name: jenkins
spec:
  type: NodePort
  ports:
    - port: 8080
      targetPort: 8080
      nodePort: 30000
  selector:
    app: jenkins

---
apiVersion: v1
kind: Service
metadata:
  name: jenkins-jnlp
spec:
  type: ClusterIP
  ports:
    - port: 50000
      targetPort: 50000
  selector:
    app: jenkins

Ahora, aplique el manifiesto anterior y cree el servicio en el espacio de nombres `jenkins`:

$ kubectl create -f jenkins-svc.yaml --namespace jenkins

Verifique que el servicio se esté ejecutando:

$ kubectl get svc --namespace jenkins                                                                                                                                                   	
NAME       	  TYPE    	CLUSTER-IP 	 EXTERNAL-IP   PORT(S)      	  AGE
jenkins    	  NodePort	10.233.2.81	     	   8080:30000/TCP   30s
jenkins-jnlp  ClusterIP 10.233.53.44     	   50000/TCP    	  30s

A partir de ahora, podemos acceder al panel de Jenkins mediante el servicio NodePort.

Acceder al panel de Jenkins

Se puede acceder al servicio NodePort desde el puerto `30000` en cualquier nodo trabajador del clúster de Kubernetes:

`http: // dirección_ip_nodo_trabajador: 30000`

Puede obtener la dirección IP de los nodos trabajadores mediante el siguiente comando:

$ kubectl get node -o wide

NAME	STATUS   ROLES	AGE	VERSION   INTERNAL-IP 	EXTERNAL-IP   OS-IMAGE         	KERNEL-VERSION   	CONTAINER-RUNTIME
node1   Ready	master   149m   v1.19.2   192.168.0.111       	Ubuntu 18.04.5 LTS   4.15.0-121-generic   docker://19.3.13
node2   Ready	master   148m   v1.19.2   192.168.0.112       	Ubuntu 18.04.5 LTS   4.15.0-121-generic   docker://19.3.13
node3   Ready	master   148m   v1.19.2   192.168.0.113       	Ubuntu 18.04.5 LTS   4.15.0-121-generic   docker://19.3.13
node4   Ready	   147m   v1.19.2   192.168.0.114       	Ubuntu 18.04.5 LTS   4.15.0-121-generic   docker://19.3.13
node5   Ready	   147m   v1.19.2   192.168.0.115       	Ubuntu 18.04.5 LTS   4.15.0-121-generic   docker://19.3.13

Por ejemplo, abramos el navegador web y vayamos a: `http: //192.168.0.111: 30000`

Para recuperar la contraseña de administrador, puede ejecutar el siguiente comando:

$ kubectl logs jenkins-deployment-794699f9bc-rln7x --namespace jenkins

Ingrese la contraseña de administrador, luego siga los siguientes pasos de configuración y accederá exitosamente al panel de Jenkins.

Conclusión

Jenkins es una herramienta CI / CD realmente poderosa para cualquier ingeniero de DevOps y también desarrollador de software. Este tutorial ha pasado por todos los pasos para implementar Jenkins en un clúster de Kubernetes. Gracias a Jenkins, seremos más productivos y nos ayuda a reducir el tiempo de creación, prueba e implementación de códigos.

Gracias por leer y deje su sugerencia en la sección de comentarios a continuación.