¿Qué es Kubernetes DaemonSet y cómo usarlo?

Introducción

Kubernetes le permite automatizar la implementación de software, administrar aplicaciones en contenedores y escalar sus clústeres con facilidad. Una amplia variedad de objetos de Kubernetes, incluidos DaemonSets, brindan un nivel adicional de control.

Use Kubernetes DaemonSets para implementar pods específicos en cada nodo de su clúster.

Este artículo explica qué es un DaemonSet, cuándo usarlo y cómo crearlo.

¿Qué es un DaemonSet de Kubernetes?

Kubernetes se asegura de que una aplicación tenga amplios recursos, se ejecute de manera confiable y mantenga una alta disponibilidad a lo largo de su ciclo de vida. La ubicación de la aplicación dentro del clúster no es una prioridad.

Un DaemonSet le permite superar las limitaciones de programación de Kubernetes y se asegura de que una aplicación específica se implemente en todos los nodos dentro del clúster.m Los pods implementados generalmente contienen procesos en segundo plano que deben difundirse en todo el clúster.

Un DaemonSet normalmente se describe mediante un archivo YAML. Los campos en el archivo YAML le brindan control adicional del proceso de implementación de Pod. Un buen ejemplo es utilizar etiquetas para iniciar pods específicos en un subconjunto limitado de nodos.

¿Cómo funcionan los conjuntos de demonios?

Un DaemonSet es un objeto activo de Kubernetes administrado por un controlador. Puede declarar su estado deseado, indicando que un Pod específico debe estar presente en cada nodo. El bucle de control de reconciliación comparará el estado deseado con el estado observado actual. Si un nodo observado no tiene un Pod coincidente, el controlador DaemonSet creará uno automáticamente.

Este proceso automatizado incluye nodos existentes y todos los nodos recién creados. El programador de Kubernetes ignora los Pods creados por los controladores DaemonSet y existen mientras el propio nodo.

Un DaemonSet crea un Pod en cada nodo de forma predeterminada. Si es necesario, puede limitar la cantidad de nodos aceptables mediante un selector de nodos. El controlador DaemonSet va a crear Pods solo en los nodos que coincidan con el nodeSelector predefinido. campo en el archivo YAML.

¿Por qué usar un DaemonSet?

Los DaemonSets pueden mejorar el rendimiento del clúster al implementar Pods que realizan tareas de mantenimiento y servicios de soporte para cada nodo. Los procesos en segundo plano específicos, las aplicaciones de monitoreo de Kubernetes y otros agentes deben estar presentes en todo el clúster para brindar servicios relevantes y oportunos.

Los DaemonSets son excepcionalmente adecuados para servicios de ejecución prolongada que pueden incluir:

• Recopilación de registros
• Monitoreo de recursos de nodos (marcos como Prometheus)
• Almacenamiento en clúster
• Pods relacionados con la infraestructura (operaciones del sistema)

Es común que un DaemonSet implemente un tipo de demonio en todos los nodos. Sin embargo, varios DaemonSets también pueden controlar un tipo de demonio usando diferentes etiquetas. Las etiquetas de Kubernetes especifican reglas de implementación basadas en las características de los nodos individuales.

¿Cómo crear un DaemonSet?

Puede describir un DaemonSet en un archivo YAML y aplicar el archivo al clúster mediante los comandos kubectl.

Por ejemplo, daemonset-node-exporter.yaml El siguiente archivo despliega un exportador de nodos de Prometheus, dentro de la supervisión espacio de nombres, para monitorear las métricas de uso de hardware en cada nodo del clúster.

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: node-exporter
  namespace: monitoring
  labels:
    name: node-exporter
spec:
  template:
    metadata:
      labels:
        name: node-exporter
      annotations:
         prometheus.io/scrape: "true"
         prometheus.io/port: "9100"
    spec:
      hostPID: true
      hostIPC: true
      hostNetwork: true
      containers:
        - ports:
            - containerPort: 9100
              protocol: TCP
          resources:
            requests:
              cpu: 0.15
          securityContext:
            privileged: true
          image: prom/node-exporter:v0.15.2
          args:
            - --path.procfs
            - /host/proc
            - --path.sysfs
            - /host/sys
            - --collector.filesystem.ignored-mount-points
            - '"^/(sys|proc|dev|host|etc)($|/)"'
          name: node-exporter
          volumeMounts:
            - name: dev
              mountPath: /host/dev
            - name: proc
              mountPath: /host/proc
            - name: sys
              mountPath: /host/sys
            - name: rootfs
              mountPath: /rootfs
      volumes:
        - name: proc
          hostPath:
            path: /proc
        - name: dev
          hostPath:
            path: /dev
        - name: sys
          hostPath:
            path: /sys
        - name: rootfs
          hostPath:
            path: /

Acceda a su interfaz de línea de comandos de Kubernetes y aplique el archivo YAML recién creado:

kubectl apply -f daemonset-node-exporter.yaml

El sistema confirma que se ha creado el DaemonSet.

Una vez que envíe el daemonset-node-exporter DaemonSet, confirme su estado actual con describe comando:

kubectl describe daemonset node-exporter -n monitoring

El resultado ofrece información básica de DaemonSet e indica que el pod se ha implementado en todos los nodos disponibles.

También puede confirmar esto enumerando todos los pods en ejecución con el siguiente comando:

kubectl get pod -o wide -n monitoring

El DaemonSet ahora implementará continuamente el exportador de nodos Pod a todos los nodos recién creados.

Cómo limitar DaemonSet a nodos específicos

Los DaemonSets crean Pods en cada nodo del clúster de forma predeterminada, a menos que los selectores de nodos los restrinjan. Inicialmente, es necesario agregar el conjunto deseado de etiquetas a un subconjunto de nodos.

Logre esto usando la kubectl label dominio. Agregue el ssd=true etiqueta al node01 nodo con el siguiente comando:

kubectl label nodes node01 ssd=true

Los selectores de nodos son parte del nodeSelector dentro del archivo DaemonSet YAML. En el siguiente ejemplo, un DaemonSet implementará Nginx solo en nodos etiquetados como ssd=true .

apiVersion: apps/v1 
kind: "DaemonSet" 
metadata: 
labels: 
app: nginx 
ssd: "true" 
name: nginx-ssd-storage 
spec: 
template: 
metadata: 
labels: 
app: nginx ssd: "true" 
spec: 
nodeSelector: 
ssd: "true" 
containers: - 
name: nginx 
image: nginx:1.10.0

Agregando el ssd=true label a un nuevo nodo va a implementar el nginx-ssd-storage Pod a ese nodo. Si se elimina una etiqueta de un nodo, el controlador DaemonSet también elimina el Pod.

¿Cómo actualizar un DaemonSet?

El OnDelete La estrategia de actualización era la única forma de actualizar Pods administrados por un DaemonSet en las primeras versiones de Kubernetes (antes de la versión 1.6). Un OnDelete El enfoque requiere que elimine cada Pod manualmente. Solo entonces el DaemonSet puede crear un nuevo Pod usando la nueva configuración.

Las versiones recientes de Kubernetes utilizan actualizaciones continuas de forma predeterminada. La estrategia de actualización se define mediante spec.updateStrategy.type campo. El valor predeterminado se establece en RollingUpdate .

La estrategia de actualización continua elimina los Pods antiguos y crea nuevos en su lugar. El proceso es automático y controlado. Eliminar y crear todos los pods al mismo tiempo puede provocar que no estén disponibles y que se prolongue el tiempo de inactividad.

Dos parámetros le permiten controlar el proceso de actualización:

• minReadySeconds define el período entre las actualizaciones de Pod. El valor se define en segundos y establecer un marco de tiempo razonable asegura el estado del Pod antes de que el sistema proceda a actualizar el siguiente Pod.
• updateStrategy.rollingUpdate.maxUnavailable le permite definir la cantidad de Pods que se pueden actualizar al mismo tiempo. El valor de este parámetro depende en gran medida del tipo de aplicación que se implemente. Es necesario equilibrar la velocidad y la seguridad para garantizar una alta disponibilidad.

Usa el kubectl rollout Comando para verificar el estado de una actualización gradual de DaemonSet:

kubectl rollout status ds/daemonset-node-exporter -n monitoring

El sistema observa las actualizaciones de DaemonSet y le informa sobre el estado de implementación actual del exportador de nodos Conjunto Demonio.

¿Cómo eliminar un DaemonSet?

Elimina un DaemonSet usando kubectl delete dominio. Asegúrese de especificar correctamente el nombre del DaemonSet que desea eliminar:

kubectl delete -f daemonset-node-exporter.yaml -n monitoring

Este comando debe usarse con cuidado. Eliminar un DaemonSet también limpia todos los Pods que el DaemonSet en cuestión implementó.