Cómo instalar Jenkins en Kubernetes

Introducción

Jenkins es una integración continua herramienta que automatiza gran parte del proceso de desarrollo de software. Varios equipos de desarrollo que trabajan en múltiples proyectos en un entorno de microservicios complejo pueden ejercer presión sobre los recursos limitados. Jenkins lo ayuda a entregar un producto final impecable a tiempo.

Un clúster de Kubernetes agrega una nueva capa de automatización a Jenkins. Kubernetes se asegura de que los recursos se utilicen de manera eficaz y de que sus servidores y la infraestructura subyacente no se sobrecarguen.

Este tutorial le mostrará cómo instalar Jenkins en un clúster de Kubernetes.

Requisitos previos

• Acceso a una línea de comando/terminal
• Clúster de Kubernetes
• Una herramienta de línea de comandos de kubectl completamente configurada en su máquina local

Instalación de Jenkins en el clúster de Kubernetes

La capacidad de Kubernetes para orquestar la implementación de contenedores garantiza que Jenkins siempre tenga la cantidad adecuada de recursos disponibles. El siguiente ejemplo muestra cómo usar un conjunto de archivos YAML para instalar Jenkins en un clúster de Kubernetes. . Los archivos YAML se rastrean y editan fácilmente y se pueden reutilizar indefinidamente.

Cree un espacio de nombres para la implementación de Jenkins

Un espacio de nombres distinto proporciona una capa adicional de aislamiento y más control sobre el entorno de integración continua. Cree un espacio de nombres para la implementación de Jenkins escribiendo el siguiente comando en su terminal:

kubectl create namespace jenkins

El nombre del espacio de nombres debe ser una etiqueta compatible con DNS. Este ejemplo usa el nombre jenkins .

Use el siguiente comando para enumerar los espacios de nombres existentes:

kubectl get namespaces

El resultado confirma que jenkins el espacio de nombres se creó con éxito.

Crear una cuenta de servicio

Las cuentas de servicio proporcionan identidades que se utilizan para controlar los procesos de pod. Use un editor de texto para crear un archivo YAML donde almacenará las declaraciones de la cuenta de servicio:

nano sa-jenkins.yaml

El archivo define la función del clúster con permisos administrativos. También crea una nueva cuenta de servicio llamada admin y lo vincula con el rol de clúster definido previamente.

---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: admin
rules:
  - apiGroups: [""]
    resources: ["*"]
    verbs: ["*"]

---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: admin
  namespace: jenkins

---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: admin
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: admin
subjects:
- kind: ServiceAccount
  name: admin
  namespace: jenkins

Guarda el archivo y cierra. Aplicar la configuración con kubectl apply .

kubectl apply -f sa-jenkins.yaml

Crear reclamo de volumen persistente y volumen persistente de Jenkins

La función de un volumen persistente es almacenar datos básicos de Jenkins y preservarlos más allá de la vida útil de un pod. Cree un archivo YAML que definirá los componentes relacionados con el almacenamiento de la implementación:

nano volume-jenkins.yaml

En la primera sección, el archivo declara el local-storage clase de almacenamiento. La segunda sección define el jenkins-pv volumen persistente, mientras que el tercero crea una reclamación de volumen persistente jenkins-pvc que estará vinculado a jenkins-pv volumen.

kind: StorageClass
apiVersion: storage.k8s.io/v1
metadata:
  name: local-storage
provisioner: kubernetes.io/no-provisioner
volumeBindingMode: WaitForFirstConsumer

---
apiVersion: v1
kind: PersistentVolume
metadata:
  name: jenkins-pv
  labels:
    type: local
spec:
  storageClassName: local-storage
  claimRef:
    name: jenkins-pvc
    namespace: jenkins
  capacity:
    storage: 10Gi
  accessModes:
    - ReadWriteOnce
  local:
    path: /mnt
  nodeAffinity:
    required:
      nodeSelectorTerms:
      - matchExpressions:
        - key: kubernetes.io/hostname
          operator: In
          values:
          - minikube

---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: jenkins-pvc
  namespace: jenkins
spec:
  storageClassName: local-storage
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 3Gi

Guarda el archivo y cierra. A continuación, aplique el archivo.

kubectl apply -f volume-jenkins.yaml

Crear y aplicar el archivo de implementación de Jenkins

Cree un archivo YAML para almacenar la información de implementación de Jenkins.

nano deploy-jenkins.yaml

El archivo de implementación en este ejemplo utiliza el jenkins/jenkins:lts Imagen de Docker y crea 1 réplica que se expondrá en puerto 8080 .

apiVersion: apps/v1
kind: Deployment
metadata:
  name: jenkins
  namespace: jenkins
spec:
  replicas: 1
  selector:
    matchLabels:
      app: jenkins-server
  template:
    metadata:
      labels:
        app: jenkins-server
    spec:
      securityContext:
            fsGroup: 1000 
            runAsUser: 1000
      serviceAccountName: admin
      containers:
        - name: jenkins
          image: jenkins/jenkins:lts
          resources:
            limits:
              memory: "2Gi"
              cpu: "1000m"
            requests:
              memory: "500Mi"
              cpu: "500m"
          ports:
            - name: httpport
              containerPort: 8080
            - name: jnlpport
              containerPort: 50000
          livenessProbe:
            httpGet:
              path: "/login"
              port: 8080
            initialDelaySeconds: 90
            periodSeconds: 10
            timeoutSeconds: 5
            failureThreshold: 5
          readinessProbe:
            httpGet:
              path: "/login"
              port: 8080
            initialDelaySeconds: 60
            periodSeconds: 10
            timeoutSeconds: 5
            failureThreshold: 3
          volumeMounts:
            - name: jenkins-data
              mountPath: /var/jenkins_home         
      volumes:
        - name: jenkins-data
          persistentVolumeClaim:
              claimName: jenkins-pvc

Los volumeMounts La sección del archivo monta el volumen persistente creado en el paso anterior. El livenessProbe y readinessProbe Las secciones declaran sondeos que reinician los pods fallidos y detectan cuando los pods están listos.

Salga del archivo y guarde los cambios. Use el archivo recién creado para implementar Jenkins:

kubectl apply -f deploy-jenkins.yaml

Crear y aplicar el archivo de servicio de Jenkins

Un servicio de Kubernetes es una abstracción que expone a Jenkins a la red más amplia. Nos permite mantener una conexión persistente con el pod independientemente de los cambios que se produzcan dentro del clúster.

Crea un archivo YAML en el que definirás el servicio:

nano service-jenkins.yaml

Agrega el siguiente contenido:

apiVersion: v1
kind: Service
metadata:
  name: jenkins-svc
  namespace: jenkins
  annotations:
      prometheus.io/scrape: 'true'
      prometheus.io/path:   /
      prometheus.io/port:   '8080'
spec:
  selector: 
    app: jenkins-server
  type: NodePort  
  ports:
    - port: 8080
      targetPort: 8080
      nodePort: 44000

Guarda el archivo y cierra. Ahora cree el servicio escribiendo:

kubectl apply -f jenkins-service.yaml

Ahora puede acceder al panel de control de Jenkins.

Acceder al panel de control de Jenkins

Antes de proceder a iniciar Jenkins, verifique si todos los componentes que implementó funcionan según lo previsto. Usa el kubectl get all comando y especifique el espacio de nombres correcto:

kubect get all -n jenkins

El ejemplo muestra una implementación que funciona correctamente:

• El pod está marcado como READY y Running .
• La dirección IP y los puertos del clúster del servicio se han asignado correctamente.
• La implementación está marcada como READY y AVAILABLE .
• Se alcanzó el número deseado de réplicas (1).

Vaya a su navegador y acceda al nodo utilizando su dirección IP y el puerto que definió en el archivo de servicio. Si no conoce la dirección IP de su nodo, búsquela en el resultado del siguiente comando:

kubectl get nodes -o yaml

La dirección IP del nodo se encuentra en status sección de la salida.

Usando la información del ejemplo, la dirección del tablero de Jenkins es:

http://192.168.49.2:44000

Para acceder a Jenkins, inicialmente debe ingresar sus credenciales. El nombre de usuario predeterminado para nuevas instalaciones es admin .

Para obtener la contraseña:

1. Busque el nombre del pod en la salida de kubectl get all comando anterior.

2. Una vez que localice el nombre del pod, utilícelo para acceder a los registros del pod.

kubectl logs jenkins-56c9d59dc-pv8kc --namespace jenkins

3. Busque la contraseña al final del registro, formateada como una cadena alfanumérica larga.

Ha instalado correctamente Jenkins en su clúster de Kubernetes y puede usarlo para crear canalizaciones de desarrollo nuevas y eficientes.