Jenkins pipeline en kubernetes

La tendencia ahora es hacer que las pipelines se ejecuten en contenedores que se crean y se destruyen dentro de un cluster kubernetes. Jenkins con el plugin Kuberentes cumple este objetivo.

En este post partimos de la base que contamos un cluster openshift y un registry docker para las imagenes y el objetivo sera crear una pipeline en la cual vamos buildear con kaniko un dockerfile y pushearlo a un registry docker.

Preparar el namespace

Lo primero sera loguearnos en el cluster y crear un namespace donde se levantataran los contendores donde se ejecutara el codigo de la pipeline.

Por defecto openshifh tiene activados contextos de seguridad que tenemos que desactivar para este ejemplo por lo que vamos a permitir cualquier uid dentro de los contenedores docker «oc adm policy add-scc-to-group anyuid system:authenticated»

oc login -u admin -p admin https://api.lab.okd.local:6443 --insecure-skip-tls-verify=true
oc new-project jenkins
oc project jenkins
oc create sa jenkins
oc policy add-role-to-user admin system:serviceaccount:jenkins:jenkins
oc adm policy add-scc-to-group anyuid system:authenticated

Configurar los secretos para docker registry

Ahora tenemos que añadir las credenciales del registry para que puedan pushear imagenes.

oc create secret docker-registry credentials --docker-server=myregistry.piensoluegoinstalo.com:5000 --docker-username=admin --docker-password=admin --docker-email=user@hotmail.com -n jenkins
oc secrets link default secrets/credentials
oc secrets link jenkins secrets/credentials

Conectar Jenkins con el cluster

Es muy comun pillar la imagen de jenkins pero por defecto no viene con un cliente de oc integrado. Para este ejemplo uso un dockerfile de jenkins tuneado.Dejo el link del Dockerfile
https://hub.docker.com/repository/docker/akaronte/jenkins-okd45

Este seria un ejemplo del docker compose, hay que dar permisos a la carpeta jenkins_home para que el docker pueda escribir

version: '3'
services:
  jenkins:
    image: akaronte/jenkins-okd45:latest
    container_name: "jenkins-okd45"
    restart: always
    privileged: true
    ports:
      - 8080:8080
      - 50000:50000
    volumes:
      - ./jenkins_home:/var/jenkins_home
      - /var/run/docker.sock:/var/run/docker.sock

Una vez iniciado Jenkins e instalado el plugins de Kubernetes no queda mas que introducir el token jenkins pueda loguearse y crear contenedores dentro del namespace.

oc get sa
oc describe sa jenkins
oc serviceaccounts get-token jenkins 

Pipeline

Cuando el nos funcione bien el «Test Conecction» ya podemos crear una nuevo Job con la siguiente pipeline.

pipeline {
  agent none
  stages {
    stage('Create Dokerfile') {
      agent {
        kubernetes {
          yaml '''
          apiVersion: v1
          kind: Pod
          metadata:
            name: debianpod
          spec:
            containers:
              - name: debianpod      
                image: debian:buster-slim
                imagePullPolicy: Always
                command: ["sleep", "10000"]
          '''
        }
      }
      steps {
        container("debianpod") {
          sh """
            cat > Dockerfile <<(EOF)
FROM debian:buster-slim
RUN apt-get update && apt-get install git -y
          """
          sh """
            cat Dockerfile
          """
        }
      }
      post{
        success {
          stash name: "Dockerfile", includes: "Dockerfile"
        }
        cleanup {
          echo "CLEAN"
          cleanWs()
        }
      }
    }
    stage('Kaniko build') {
      agent {
        kubernetes {
          yaml '''
          apiVersion: v1
          kind: Pod
          metadata:
            name: kaniko
          spec:
            serviceAccount: jenkins
            containers:
              - name: kaniko
                image: gcr.io/kaniko-project/executor:debug
                command:
                  - /busybox/cat
                imagePullPolicy: Always
                tty: true
                volumeMounts:
                  - name: jenkins-docker-cfg
                    mountPath: /kaniko/.docker
            volumes:
              - name: jenkins-docker-cfg
                projected:
                  sources:
                    - secret:
                        name: credentials
                        items:
                          - key: .dockerconfigjson
                            path: config.json
          '''
        }
      }
      steps {
        script{
          unstash "Dockerfile"
          container(name: 'kaniko', shell: '/busybox/sh') {
            sh """
            cat /home/jenkins/agent/workspace/${JOB_NAME}/Dockerfile
            """
            sh """
            #!/busybox/sh
            /kaniko/executor --insecure -v debug --skip-tls-verify -c `pwd` -f `pwd`/Dockerfile  --destination myregistry.piensoluegoinstalo.com:5000/kanikobuild:latest
            """
          }
        }
      }
      post{
        cleanup {
          echo "CLEAN"
          cleanWs()
        }
      }
    }
  }
}