Intervalli limite in Kubernetes

Su questa pagina

1. Prerequisiti
2. Cosa faremo?
3. Crea un LimitRange nello spazio dei nomi predefinito
4. Crea pod con limite e intervallo di CPU nello spazio dei nomi predefinito
   1. Pod con limite
   2. Pod con più CPU:
   3. Pod con meno CPU:
   4. Pod senza CPU:

   Con Limit Range, possiamo limitare il consumo e la creazione di risorse poiché per impostazione predefinita i container vengono eseguiti con risorse di calcolo illimitate su un cluster Kubernetes. Un pod può consumare la quantità di CPU e memoria definita dall'intervallo limite.

   Un Intervallo limite fornisce vincoli su:

   • Risorse minime e massime
   • Richiesta di archiviazione minima e massima per PersistentVolumeClaim
   • Un rapporto tra richiesta e limite per una risorsa in uno spazio dei nomi.
   • Imposta richiesta/limite predefinito per le risorse di calcolo

   Per saperne di più sui Limit Ranges, visita la documentazione ufficiale di Kubernetes qui.

   In questo articolo, creeremo un intervallo limite e vedremo come impostare i valori minimo e massimo per le risorse della CPU utilizzate da container e pod. Vedremo diversi scenari con limite e richiesta sulla CPU.

   Prerequisiti

   1. Cluster Kubernetes con almeno 1 nodo di lavoro.
      Se vuoi imparare a creare un cluster Kubernetes, fai clic qui. Questa guida ti aiuterà a creare un cluster Kubernetes con 1 master e 2 nodi su istanze AWS Ubuntu EC2.

   Che cosa faremo?

   1. Crea un LimitRange nello spazio dei nomi predefinito.
   2. Crea pod con limite e intervallo di CPU nello spazio dei nomi predefinito

   Crea un LimitRange nello spazio dei nomi predefinito

   Crea un file per definire un intervallo limite nello spazio dei nomi predefinito.

   vim set-limit-range.yml

   apiVersion: v1
   kind: LimitRange
   metadata:
     name: set-limit-range
   spec:
     limits:
     - max:
         cpu: "800m"
       min:
         cpu: "200m"
       type: Container

   

   Ottieni un elenco di intervalli di limiti esistenti nello spazio dei nomi predefinito e crea quello utilizzando il file creato nel passaggio precedente.

   kubectl get limitrange

   kubectl create -f set-limit-range.yml

   kubectl get limitrange

   kubectl describe limitrange set-limit-range

   

   Nella schermata sopra, si può vedere che abbiamo creato un intervallo limite che definisce la CPU come \Min=200m\ e \Max=800m\.

   Ciò significa che i pod nello spazio dei nomi predefinito non possono avere CPU \meno di Min=200m\ e \più di Max=800m\.

   Crea pod con limite e intervallo di CPU nello spazio dei nomi predefinito

   Pod con limite

   Crea una definizione di pod che richieda una CPU superiore a 200 me inferiore a 800 m

   vim pod-with-cpu-within-range.yml

   apiVersion: v1
   kind: Pod
   metadata:
     name: pod-with-cpu-within-range
   spec:
     containers:
     - name: pod-with-cpu-within-range
       image: nginx
       resources:
         limits:
           cpu: "800m"
         requests:
           cpu: "500m"

   

   Elenca i pod esistenti e crea un nuovo pod con il file creato nel passaggio precedente.

   kubectl get pods

   kubectl create -f pod-with-cpu-within-range.yml

   kubectl get pods

   kubectl describe pod pod-with-cpu-within-range

   

   Nello screenshot sopra, puoi vedere che il pod è stato creato con una richiesta e un limite di CPU definiti.

   Pod con più CPU:

   Questa volta creiamo un pod con limite CPU 1,5, ovvero più di 800 m.

   vim pod-with-cpu-more-than-limit.yml

   apiVersion: v1
   kind: Pod
   metadata:
     name: pod-with-cpu-more-than-limit
   spec:
     containers:
     - name: pod-with-cpu-more-than-limit
       image: nginx
       resources:
         limits:
           cpu: "1.5"
         requests:
           cpu: "500m"

   

   Ottieni un elenco di pod esistenti e prova a creare un nuovo pod con un limite di CPU \1,5\ superiore a \800 m\ rispetto a quanto definito nell'intervallo limite.

   kubectl get pods

   kubectl create -f pod-with-cpu-more-than-limit.yml

   

   Nello screenshot sopra, si può vedere che il pod non è stato creato.

   Pod con meno CPU:

   Ora proviamo a creare un pod che richieda \CPU=100m\ che sia inferiore a \200m\ che abbiamo definito nell'intervallo limite.

   vim pod-with-cpu-less-than-limit.yml

   apiVersion: v1
   kind: Pod
   metadata:
     name: pod-with-cpu-less-than-limit
   spec:
     containers:
     - name: pod-with-cpu-less-than-limit
       image: nginx
       resources:
         limits:
           cpu: "800m"
         requests:
           cpu: "100m"

   Ora ottieni un elenco dei pod esistenti e prova a creare un pod con il file di definizione precedente.

   kubectl get pods

   kubectl create -f pod-with-cpu-less-than-limit.yml

   Questa volta anche la creazione del pod fallirà poiché abbiamo richiesto CPU=100 m meno di 200 m che abbiamo definito l'intervallo limite.

   Pod senza CPU:

   In questo scenario non è possibile definire alcuna richiesta o limite per la CPU.

   vim pod-with-no-cpu.yml

   apiVersion: v1
   kind: Pod
   metadata:
     name: pod-with-no-cpu
   spec:
     containers:
     - name: pod-with-no-cpu
       image: vish/stress

   

   Ora proviamo a creare un pod e vediamone la descrizione.

   kubectl get pods

   kubectl create -f pod-with-no-cpu.yml

   kubectl describe pods pod-with-no-cpu

   

   Nello screenshot sopra, si può vedere che se non specifichiamo alcuna richiesta o limite per la CPU, il POD ottiene una CPU allocata pari al limite specificato nell'intervallo limite, ovvero in questo esempio, il pod ottiene il limite e la richiesta della CPU pari a 800m che è il limite specificato nell'intervallo limite

   Conclusione

   In questo articolo, abbiamo visto i passaggi per creare un intervallo limite nello spazio dei nomi predefinito. Abbiamo quindi provato diversi scenari per il limite di CPU e la richiesta nel pod.