Cómo instalar Jenkins en Vultr Kubernetes Engine

Jenkins es un servidor de integración continua (CI) y entrega continua (CD) de código abierto que se utiliza para el desarrollo, la implementación y la automatización de proyectos. Los desarrolladores de software lo utilizan para crear, probar e implementar su software. Está escrito en Java y proporciona cientos de complementos para automatizar las pruebas y los cambios en una base de código más grande.

Esta guía le muestra cómo configurar Jenkins en Vultr Kubernetes Engine, que brinda muchos beneficios sobre la implementación basada en un servidor independiente. La implementación basada en Kubernetes es una solución muy rentable y también reduce el tiempo necesario para el desarrollo.

requisitos previos

  • Implemente una instancia Vultr Ubuntu 20.04 para usar como estación de trabajo de administración.

  • Implemente un clúster de Kubernetes en Vultr con al menos tres o más nodos con 2 GB de RAM y 2 CPU.

  • Instalar kubectl en la estación de trabajo de administración Vultr Ubuntu.

Realizará el resto de los pasos de esta guía desde su estación de trabajo de administración.

Verificar el clúster de Kubernetes

Antes de comenzar, verifique Vultr Kubernetes Cluster con el siguiente comando:

                      
                        kubectl cluster-info

                      
                    

Verá la información del clúster en el siguiente resultado:

                      
                        Kubernetes control plane is running at https://e4737bcd-3971-4624-b896-0181aae56bae.vultr-k8s.com:6443

CoreDNS is running at https://e4737bcd-3971-4624-b896-0181aae56bae.vultr-k8s.com:6443/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy

                      
                    

Para verificar el estado activo de todos los nodos del clúster, ejecute el siguiente comando:

                      
                        kubectl get nodes

                      
                    

Debería ver que todos los nodos están en estado listo:

                      
                        NAME                           STATUS   ROLES    AGE     VERSION

jenkins-cluster-136e69da18fb   Ready    <none>   3m21s   v1.25.4

jenkins-cluster-97b1dd155b22   Ready    <none>   3m21s   v1.25.4

jenkins-cluster-a329dcb28ac7   Ready    <none>   3m21s   v1.25.4

                      
                    

Instalar Jenkins en Kubernetes

  1. Primero, cree el espacio de nombres de Jenkins:

                              
                                # kubectl create namespace jenkins-namespace
    
                              
                            

    Producción.

                              
                                namespace/jenkins-namespace created
    
                              
                            
  2. A continuación, cree un serviceAccount.yaml expediente.

                              
                                # nano serviceAccount.yaml
    
                              
                            

    Agregue las siguientes configuraciones para crear una cuenta de servicio llamada jenkins-account y une el clusterRole a la cuenta de servicio.

                              
                                ---
    
    apiVersion: rbac.authorization.k8s.io/v1
    
    kind: ClusterRole
    
    metadata:
    
      name: jenkins-account
    
    rules:
    
      - apiGroups: [""]
    
        resources: ["*"]
    
        verbs: ["*"]
    
    
    
    ---
    
    apiVersion: v1
    
    kind: ServiceAccount
    
    metadata:
    
      name: jenkins-account
    
      namespace: jenkins-namespace
    
    
    
    ---
    
    apiVersion: rbac.authorization.k8s.io/v1
    
    kind: ClusterRoleBinding
    
    metadata:
    
      name: jenkins-account
    
    roleRef:
    
      apiGroup: rbac.authorization.k8s.io
    
      kind: ClusterRole
    
      name: jenkins-account
    
    subjects:
    
    - kind: ServiceAccount
    
      name: jenkins-account
    
      namespace: jenkins-namespace
    
                              
                            
  3. Aplique la configuración anterior a Kubernetes Cluster.

                              
                                # kubectl apply -f serviceAccount.yaml
    
                              
                            

    Producción.

                              
                                clusterrole.rbac.authorization.k8s.io/jenkins-account created
    
    serviceaccount/jenkins-account created
    
    clusterrolebinding.rbac.authorization.k8s.io/jenkins-account created
    
                              
                            
  4. Cree un archivo de configuración de volumen.

                              
                                # nano volume.yaml
    
                              
                            

    Agregue la siguiente configuración para el volumen persistente.

                              
                                kind: StorageClass
    
    apiVersion: storage.k8s.io/v1
    
    metadata:
    
      name: jenkins-storage
    
    provisioner: kubernetes.io/no-provisioner
    
    volumeBindingMode: WaitForFirstConsumer
    
    
    
    ---
    
    apiVersion: v1
    
    kind: PersistentVolume
    
    metadata:
    
      name: jenkins-pv-volume
    
      labels:
    
        type: local
    
    spec:
    
      storageClassName: jenkins-storage
    
      claimRef:
    
        name: jenkins-pv-claim
    
        namespace: jenkins-namespace
    
      capacity:
    
        storage: 10Gi
    
      accessModes:
    
        - ReadWriteOnce
    
      local:
    
        path: /opt
    
      nodeAffinity:
    
        required:
    
          nodeSelectorTerms:
    
          - matchExpressions:
    
            - key: kubernetes.io/hostname
    
              operator: In
    
              values:
    
              - jenkins-cluster-136e69da18fb
    
    
    
    ---
    
    apiVersion: v1
    
    kind: PersistentVolumeClaim
    
    metadata:
    
      name: jenkins-pv-claim
    
      namespace: jenkins-namespace
    
    spec:
    
      storageClassName: jenkins-storage
    
      accessModes:
    
        - ReadWriteOnce
    
      resources:
    
        requests:
    
          storage: 3Gi
    
                              
                            

    Nota: Reemplace la jenkins-cluster-136e69da18fb con cualquiera de sus nodos de clúster.

    Si necesita saber el nombre de host de su nodo trabajador, ejecute el siguiente comando.

                              
                                # kubectl get nodes
    
                              
                            

    La configuración anterior creará un PersistentVolume volumen en un nodo de clúster dentro del /opt directorio. También deberá definir correctamente el nombre del nodo trabajador para que el pod de Jenkins se programe en el nodo específico.

  5. Cree un volumen persistente en el clúster de Kubernetes mediante el kubectl dominio.

                              
                                # kubectl create -f volume.yaml
    
                              
                            

    Producción.

                              
                                storageclass.storage.k8s.io/jenkins-storage created
    
    persistentvolume/jenkins-pv-volume created
    
    persistentvolumeclaim/jenkins-pv-claim created
    
                              
                            
  6. Crear un deployment.yaml expediente.

                              
                                # nano deployment.yaml
    
                              
                            

    Agregue la siguiente configuración de manifiesto.

                              
                                apiVersion: apps/v1
    
    kind: Deployment
    
    metadata:
    
      name: jenkins
    
      namespace: jenkins-namespace
    
    spec:
    
      replicas: 1
    
      selector:
    
        matchLabels:
    
          app: jenkins-server
    
      template:
    
        metadata:
    
          labels:
    
            app: jenkins-server
    
        spec:
    
          securityContext:
    
                fsGroup: 1000 
    
                runAsUser: 1000
    
          serviceAccountName: jenkins-account
    
          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-pv-claim
    
                              
                            

    El archivo de configuración anterior:

    • Crea una implementación de Jenkins utilizando la última imagen de Jenkins y abre puertos 8080 y 50000 para aceptar conexiones de los trabajadores de Jenkins.

    • Monta el volumen persistente en el /var/jenkins_home directorio para almacenar datos de Jenkins.

    • Definir liveness probes para comprobar el estado de salud del contenedor.

    • Definir readiness probes para saber cuándo un contenedor puede empezar a aceptar tráfico.

  7. Aplique la implementación anterior al clúster de Kubernetes.

                              
                                # kubectl apply -f deployment.yaml
    
                              
                            

    Producción.

                              
                                deployment.apps/jenkins created
    
                              
                            

    Espere un tiempo para extraer la imagen de Jenkins y poner en marcha el pod de Jenkins.

  8. Verifique el estado del pod de Jenkins.

                              
                                # kubectl get deployments -n jenkins-namespace
    
                              
                            

    Producción.

                              
                                NAME      READY   UP-TO-DATE   AVAILABLE   AGE
    
    jenkins   1/1     1            1           94s
    
                              
                            
  9. Obtenga información detallada sobre la implementación de Jenkins.

                              
                                # kubectl describe deployments --namespace=jenkins-namespace
    
                              
                            

    Producción.

                              
                                Name:                   jenkins
    
    Namespace:              jenkins-namespace
    
    CreationTimestamp:      Tue, 22 Nov 2022 21:03:42 +0530
    
    Labels:                 <none>
    
    Annotations:            deployment.kubernetes.io/revision: 1
    
    Selector:               app=jenkins-server
    
    Replicas:               1 desired | 1 updated | 1 total | 1 available | 0 unavailable
    
    StrategyType:           RollingUpdate
    
    MinReadySeconds:        0
    
    RollingUpdateStrategy:  25% max unavailable, 25% max surge
    
    Pod Template:
    
      Labels:           app=jenkins-server
    
      Service Account:  jenkins-account
    
      Containers:
    
       jenkins:
    
        Image:       jenkins/jenkins:lts
    
        Ports:       8080/TCP, 50000/TCP
    
        Host Ports:  0/TCP, 0/TCP
    
        Limits:
    
          cpu:     1
    
          memory:  2Gi
    
        Requests:
    
          cpu:        500m
    
          memory:     500Mi
    
        Liveness:     http-get https://:8080/login delay=90s timeout=5s period=10s #success=1 #failure=5
    
        Readiness:    http-get https://:8080/login delay=60s timeout=5s period=10s #success=1 #failure=3
    
        Environment:  <none>
    
        Mounts:
    
          /var/jenkins_home from jenkins-data (rw)
    
      Volumes:
    
       jenkins-data:
    
        Type:       PersistentVolumeClaim (a reference to a PersistentVolumeClaim in the same namespace)
    
        ClaimName:  jenkins-pv-claim
    
        ReadOnly:   false
    
    Conditions:
    
      Type           Status  Reason
    
      ----           ------  ------
    
      Available      True    MinimumReplicasAvailable
    
      Progressing    True    NewReplicaSetAvailable
    
    OldReplicaSets:  <none>
    
    NewReplicaSet:   jenkins-7b95fb694 (1/1 replicas created)
    
    Events:
    
      Type    Reason             Age   From                   Message
    
      ----    ------             ----  ----                   -------
    
      Normal  ScalingReplicaSet  19m   deployment-controller  Scaled up replica set jenkins-7b95fb694 to 1
    
                              
                            

Crear servicio de Kubernetes para acceso externo

En este punto, Jenkins se implementó y ejecutó correctamente en el clúster de Kubernetes. Sin embargo, no puede acceder a Jenkins desde la máquina remota. En este caso, deberá crear un servicio y vincularlo a la implementación de Jenkins.

  1. Primero, crea un service.yaml archivo usando el siguiente comando:

                              
                                # nano service.yaml
    
                              
                            

    Agregue las siguientes configuraciones para exponer el puerto 8080 de la vaina Jenkins a babor 32000 .

                              
                                apiVersion: v1
    
    kind: Service
    
    metadata:
    
      name: jenkins-service
    
      namespace: jenkins-namespace
    
      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: 32000
    
                              
                            
  2. A continuación, implemente la configuración del servicio en la implementación de Jenkins.

                              
                                # kubectl apply -f service.yaml
    
                              
                            

    Producción.

                              
                                service/jenkins-service created
    
                              
                            
  3. Verifique el estado del servicio de Jenkins.

                              
                                # kubectl get services --namespace jenkins-namespace
    
                              
                            

    Producción.

                              
                                NAME              TYPE       CLUSTER-IP       EXTERNAL-IP   PORT(S)          AGE
    
    jenkins-service   NodePort   10.103.86.99   <none>        8080:32000/TCP   6s
    
                              
                            

Acceder a la interfaz web de Jenkins

En este punto, Jenkins está instalado y escucha en el puerto 32000 para acceso externo. Ahora, deberá recuperar la dirección IP del nodo del clúster para acceder a la interfaz web de Jenkins.

  1. Primero, obtenga una dirección IP de nodo usando el kubectl dominio.

                              
                                # kubectl get nodes -o wide
    
                              
                            

    Obtendrá la IP externa de todos los nodos en el siguiente resultado.

                              
                                NAME                           STATUS   ROLES    AGE   VERSION   INTERNAL-IP   EXTERNAL-IP    OS-IMAGE                       KERNEL-  
    
    VERSION    CONTAINER-RUNTIME
    
    jenkins-cluster-7e8eba45f3a6   Ready    <none>   23m   v1.25.4   10.46.96.6    65.20.79.223   
                                
                                  Debian
                                
                                 GNU/Linux 10 (buster)   4.19.0-22-amd64   containerd://1.6.9
    
    jenkins-cluster-a45a12e27a63   Ready    <none>   23m   v1.25.4   10.46.96.5    65.20.79.2     Debian GNU/Linux 10 (buster)   4.19.0-22-amd64   containerd://1.6.9
    
    jenkins-cluster-cfacc64361f5   Ready    <none>   23m   v1.25.4   10.46.96.4    65.20.74.173   Debian GNU/Linux 10 (buster)   4.19.0-22-amd64   containerd://1.6.9
    
                              
                            
  2. Luego, abra su navegador web y acceda a Jenkins usando la URL https://node-external-ip:32000 . Se le pedirá que proporcione la contraseña de administrador inicial.

  3. Obtenga los detalles del pod de Jenkins usando el siguiente comando.

                              
                                # kubectl get pods --namespace=jenkins-namespace
    
                              
                            

    Producción.

                              
                                NAME                      READY   STATUS    RESTARTS   AGE
    
    jenkins-7b95fb694-5xqnp   1/1     Running   0          20m
    
                              
                            
  4. Consulte los registros del pod de Jenkins para recuperar la contraseña de administrador de Jenkins.

                              
                                # kubectl logs jenkins-7b95fb694-5xqnp --namespace=jenkins-namespace
    
                              
                            

    Producción.

                              
                                *************************************************************
    
    
    
    Jenkins initial setup is required. An admin user has been created and a password generated.
    
    Please use the following password to proceed to installation:
    
    
    
    a1f057cba5f6440f863b6e5a57d880fa
    
    
    
    This may also be found at: /var/jenkins_home/secrets/initialAdminPassword
    
    
    
    *************************************************************
    
                              
                            
  5. Copie la contraseña del resultado anterior e ingrésela en la pantalla de contraseña de administrador inicial de Jenkins para continuar con la instalación de Jenkins.

Conclusión

Esta guía le muestra cómo instalar y configurar Jenkins en Vultr Kubernetes Engine. Jenkins es un componente central de las canalizaciones de CI/CD. Le ayuda a realizar operaciones muy complejas y aumentar la productividad. Para obtener más información, consulte el Jenkins oficial documentación .

Título del artículo Nombre (opcional) Correo electrónico (opcional) Descripción

Enviar sugerencia

Related Posts