Che cos'è Kubernetes DaemonSet e come utilizzarlo?

Introduzione

Kubernetes ti consente di automatizzare la distribuzione del software, gestire le applicazioni containerizzate e ridimensionare i tuoi cluster con facilità. Un'ampia gamma di oggetti Kubernetes, inclusi DaemonSets, fornisce un ulteriore livello di controllo.

Usa Kubernetes DaemonSets per distribuire pod specifici in ogni singolo nodo del tuo cluster.

Questo articolo spiega cos'è un DaemonSet, quando usarlo e come crearlo.

Cos'è un DaemonSet Kubernetes?

Kubernetes assicura che un'applicazione disponga di risorse abbondanti, funzioni in modo affidabile e mantenga un'elevata disponibilità per tutto il suo ciclo di vita. La posizione dell'app all'interno del cluster non è una priorità.

Un DaemonSet ti consente di superare i limiti di pianificazione di Kubernetes e assicura che un'app specifica venga distribuita su tutti i nodi all'interno del cluster.m I pod distribuiti di solito contengono processi in background che devono essere diffusi nell'intero cluster.

Un DaemonSet viene in genere descritto utilizzando un file YAML. I campi nel file YAML ti danno un maggiore controllo del processo di distribuzione del Pod. Un buon esempio è l'utilizzo delle etichette per avviare Pod specifici su un sottoinsieme limitato di nodi.

Come funzionano i DaemonSet?

Un DaemonSet è un oggetto Kubernetes attivo gestito da un controller. Puoi dichiarare lo stato desiderato, indicando che un Pod specifico deve essere presente su ogni nodo. Il ciclo di controllo della riconciliazione confronterà lo stato desiderato con lo stato attuale osservato. Se un nodo osservato non ha un Pod corrispondente, il controller DaemonSet ne creerà uno automaticamente.

Questo processo automatizzato include i nodi esistenti e tutti i nodi appena creati. I Pod creati dai controller DaemonSet vengono ignorati dallo scheduler Kubernetes e esistono fintanto che il nodo stesso.

Un DaemonSet crea un Pod su ogni nodo per impostazione predefinita. Se necessario, puoi limitare il numero di nodi accettabili utilizzando un selettore di nodi. Il controller DaemonSet creerà pod solo sui nodi che corrispondono al nodeSelector predefinito campo nel file YAML.

Perché usare un DaemonSet?

I DaemonSet possono migliorare le prestazioni del cluster distribuendo Pod che eseguono attività di manutenzione e servizi di supporto su ogni nodo. Specifici processi in background, app di monitoraggio Kubernetes e altri agenti devono essere presenti in tutto il cluster per fornire servizi pertinenti e tempestivi.

I DaemonSet sono particolarmente adatti per servizi di lunga durata che possono includere:

• Raccolta registri
• Monitoraggio delle risorse del nodo (framework come Prometheus)
• Archiviazione cluster
• Pod relativi alle infrastrutture (operazioni di sistema)

È comune per un DaemonSet distribuire un tipo di demone su tutti i nodi. Tuttavia, più DaemonSet possono anche controllare un tipo di demone utilizzando etichette diverse. Le etichette Kubernetes specificano le regole di distribuzione in base alle caratteristiche dei singoli nodi.

Come creare un DaemonSet?

Puoi descrivere un DaemonSet in un file YAML e applicare il file al cluster utilizzando i comandi kubectl.

Ad esempio, il daemonset-node-exporter.yaml il file seguente distribuisce un esportatore di nodi Prometheus all'interno del monitoraggio namespace, per monitorare le metriche di utilizzo dell'hardware su ogni nodo del cluster.

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: /

Accedi all'interfaccia della riga di comando di Kubernetes e applica il file YAML appena creato:

kubectl apply -f daemonset-node-exporter.yaml

Il sistema conferma che il DaemonSet è stato creato.

Dopo aver inviato il daemonset-node-exporter DaemonSet, conferma il suo stato attuale con il describe comando:

kubectl describe daemonset node-exporter -n monitoring

L'output offre informazioni di base su DaemonSet e indica che il pod è stato distribuito su tutti i nodi disponibili.

Puoi inoltre confermarlo elencando tutti i pod in esecuzione con il seguente comando:

kubectl get pod -o wide -n monitoring

Il DaemonSet ora distribuirà continuamente node-exporter Pod a tutti i nodi appena creati.

Come limitare DaemonSet a nodi specifici

I DaemonSet creano pod su ogni nodo del cluster per impostazione predefinita, a meno che i selettori di nodo non li vincolino. Inizialmente, è necessario aggiungere il set di etichette desiderato a un sottoinsieme di nodi.

Raggiungi questo obiettivo utilizzando l'kubectl label comando. Aggiungi il ssd=true etichetta al node01 nodo con il seguente comando:

kubectl label nodes node01 ssd=true

I selettori di nodi fanno parte di nodeSelector campo all'interno del file YAML DaemonSet. Nell'esempio seguente, un DaemonSet distribuirà Nginx solo su nodi etichettati come 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

Aggiunta di ssd=true label in un nuovo nodo distribuirà nginx-ssd-storage Pod a quel nodo. Se un'etichetta viene rimossa da un nodo, il controller DaemonSet rimuove anche il Pod.

Come aggiornare un DaemonSet?

Il OnDelete la strategia di aggiornamento era l'unico modo per aggiornare i Pod gestiti da un DaemonSet nelle prime versioni di Kubernetes (prima della versione 1.6). Un OnDelete approccio richiede di eliminare ogni Pod manualmente. Solo allora DaemonSet è in grado di creare un nuovo Pod utilizzando la nuova configurazione.

Le versioni recenti di Kubernetes utilizzano gli aggiornamenti in sequenza per impostazione predefinita. La strategia di aggiornamento viene definita utilizzando spec.updateStrategy.type campo. Il valore predefinito è RollingUpdate .

La strategia di aggiornamento continuo rimuove i vecchi Pod e ne crea invece di nuovi. Il processo è automatico e controllato. L'eliminazione e la creazione di tutti i Pod contemporaneamente può causare indisponibilità e tempi di fermo prolungati.

Due parametri consentono di controllare il processo di aggiornamento:

• minReadySeconds definisce il periodo tra gli aggiornamenti del Pod. Il valore è definito in secondi e l'impostazione di un intervallo di tempo ragionevole garantisce la salute del Pod prima che il sistema proceda all'aggiornamento del Pod successivo.
• updateStrategy.rollingUpdate.maxUnavailable permette di definire il numero di Pod che possono essere aggiornati contemporaneamente. Il valore di questo parametro dipende fortemente dal tipo di applicazione distribuita. È necessario bilanciare velocità e sicurezza per garantire un'elevata disponibilità.

Usa il kubectl rollout comando per verificare lo stato di un aggiornamento in sequenza di DaemonSet:

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

Il sistema osserva gli aggiornamenti di DaemonSet e ti informa sullo stato di implementazione corrente di node-exporter DaemonSet.

Come eliminare un DaemonSet?

Rimuovere un DaemonSet utilizzando kubectl delete comando. Assicurati di specificare correttamente il nome del DaemonSet che desideri eliminare:

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

Questo comando dovrebbe essere usato con attenzione. L'eliminazione di un DaemonSet ripulisce anche tutti i pod che il DaemonSet in questione ha distribuito.