Configura i cgroup scrivibili per i container

Autopilot Standard

Puoi consentire ai carichi di lavoro Google Kubernetes Engine (GKE) di gestire le risorse, come CPU e memoria, per i processi secondari utilizzando l'API cgroups di Linux. Questo documento mostra come fornire ai container l'accesso in lettura/scrittura all'API cgroups senza eseguirli in modalità con privilegi.

Quando utilizzare i cgroup scrivibili

Per impostazione predefinita, Kubernetes fornisce a tutti i container Linux l'accesso in sola lettura all'API cgroups montando il file system /sys/fs/cgroup in ogni container. Se vuoi, puoi consentire a GKE di montare questo file system in modalità di lettura/scrittura in pod specifici per consentire ai processi root di gestire e limitare le risorse per i processi secondari.

Questi cgroup scrivibili contribuiscono a migliorare l'affidabilità in applicazioni come Ray che eseguono processi di sistema e codice utente nello stesso container. Scrivendo nel file system /sys/fs/cgroup, Ray può riservare porzioni delle risorse di un container per i processi critici. Puoi utilizzare i cgroup scrivibili per migliorare l'affidabilità di queste applicazioni senza il rischio per la sicurezza di utilizzare la modalità con privilegi per i container.

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti operazioni:

Attiva l'API Google Kubernetes Engine.

Attiva l'API Google Kubernetes Engine

Se vuoi utilizzare Google Cloud CLI per questa attività, installala e poi inizializza gcloud CLI. Se hai già installato gcloud CLI, scarica l'ultima versione eseguendo il comando gcloud components update. Le versioni precedenti di gcloud CLI potrebbero non supportare l'esecuzione dei comandi in questo documento.
Nota: per le installazioni esistenti di gcloud CLI, assicurati di impostare la proprietà compute/region. Se utilizzi principalmente cluster zonali, imposta invece compute/zone. Se imposti una località predefinita, puoi evitare errori in gcloud CLI come il seguente: One of [--zone, --region] must be supplied: Please specify location. Potresti dover specificare la posizione in determinati comandi se la posizione del cluster è diversa da quella predefinita che hai impostato.

Assicurati di avere un cluster Autopilot o Standard che esegue la versione 1.34.1-gke.2541000 o successive. Per creare un nuovo cluster, vedi Crea un cluster Autopilot.
Assicurati che il cluster utilizzi cgroup v2. Per maggiori informazioni, consulta la pagina Eseguire la migrazione dei nodi a cgroup v2 di Linux.

Abilita i cgroup scrivibili per i nodi

Attiva i cgroup scrivibili sui pool di nodi personalizzando la configurazione di containerd. Puoi applicare questa configurazione all'intero cluster o a pool di nodi specifici nei cluster Standard.

Nel file di configurazione di containerd, aggiungi una sezione writableCgroups e imposta il campo enabled su true. Per saperne di più, consulta Personalizzare la configurazione di containerd nei nodi GKE.

writableCgroups:
  enabled: true

Specifica il file di configurazione aggiornato quando crei o aggiorni un cluster o un pool di nodi.

Utilizzare i cgroup scrivibili nei carichi di lavoro

Dopo aver abilitato i cgroup scrivibili per il cluster o i pool di nodi, configura i tuoi carichi di lavoro in modo che soddisfino tutti i seguenti requisiti:

Seleziona un nodo con cgroup scrivibili abilitati.
Abilita i cgroup scrivibili per uno o più container nel pod.
Utilizza la classe di qualità del servizio (QoS) garantita soddisfacendo una delle seguenti condizioni:
- Per i workload che specificano le risorse a livello di pod, imposta valori uguali per resources.requests e resources.limits nella specifica del pod.
- Per i carichi di lavoro che specificano le risorse per ogni container, imposta valori uguali per resources.requests e resources.limits nella specifica di ogni container nel pod, inclusi i container init.

Per configurare questi requisiti:

Per selezionare i nodi con i cgroup scrivibili abilitati, aggiungi l'etichetta node.gke.io/enable-writable-cgroups: "true" al campo spec.nodeSelector nella specifica del pod:
```
node.gke.io/enable-writable-cgroups: "true"
```
Per attivare i cgroup scrivibili per il tuo workload, aggiungi una delle seguenti etichette al campo metadata.annotations nella specifica del pod:
- Attiva per l'intero pod:
```
node.gke.io/enable-writable-cgroups: "true"
```
- Attivare per un container specifico nel pod:
```
node.gke.io/enable-writable-cgroups.CONTAINER_NAME: "true"
```
  Sostituisci CONTAINER_NAME con il nome del container.
Per configurare la classe QoS Guaranteed per il pod, specifica richieste e limiti di CPU e memoria uguali per ogni container nel pod o per l'intero pod, come nel seguente esempio:
```
resources:
  requests:
    cpu: "100m"
    memory: "100Mi"
  limits:
    cpu: "100m"
    memory: "100Mi"
```
Devi specificare richieste e limiti uguali per ogni container, anche se abiliti i cgroup scrivibili solo per uno dei container nel pod.

La specifica finale del pod dovrebbe essere simile agli esempi seguenti.

Questo esempio abilita i cgroup scrivibili per tutti i container nel pod:

apiVersion: v1
kind: Pod
metadata:
  name: writable-cgroups-pod
  annotations:
    node.gke.io/enable-writable-cgroups: "true"
spec:
  nodeSelector:
    node.gke.io/enable-writable-cgroups: "true"
  containers:
  - name: container
    image: busybox:stable
    command: ["/bin/sh", "-c"]
    args:
    -   |
      trap 'echo "Caught SIGTERM, exiting..."; exit 0' TERM
      echo "Waiting for termination signal..."
      while true; do sleep 1; done
  resources:
    requests:
      cpu: "100m"
      memory: "100Mi"
    limits:
      cpu: "100m"
      memory: "100Mi"

Questo esempio abilita i cgroup scrivibili per un container specifico in un pod multi-container:

apiVersion: v1
kind: Pod
metadata:
  name: writable-cgroups-per-container
  annotations:
    node.gke.io/enable-writable-cgroups.busybox-container: "true"
spec:
  nodeSelector:
    node.gke.io/enable-writable-cgroups: "true"
  containers:
  - name: busybox-container
    image: busybox:stable
    command: ["/bin/sh", "-c"]
    args:
    -   |
      trap 'echo "Caught SIGTERM, exiting..."; exit 0' TERM
      echo "Waiting for termination signal..."
      while true; do sleep 1; done
    resources:
      requests:
        cpu: "100m"
        memory: "100Mi"
      limits:
        cpu: "100m"
        memory: "100Mi"
  - name: container-disabled
    image: busybox:stable
    command: ["/bin/sh", "-c"]
    args:
    -   |
      trap 'echo "Caught SIGTERM, exiting..."; exit 0' TERM
      echo "Waiting for termination signal..."
      while true; do sleep 1; done
    resources:
      requests:
        cpu: "100m"
        memory: "100Mi"
      limits:
        cpu: "100m"
        memory: "100Mi"

Verifica che il file system cgroup sia scrivibile

Per verificare le autorizzazioni sul file system /sys/fs/cgroup per un pod o un container:

Identifica un Pod che vuoi controllare. Puoi utilizzare uno dei pod di esempio della sezione Utilizzare cgroup scrivibili nei workload.
Crea una sessione shell nel pod:
```
kubectl exec -it POD_NAME -- /bin/sh
```
Sostituisci POD_NAME con il nome del pod.
Descrivi il file system cgroup montato:
```
mount | grep cgroup
```
L'output è simile al seguente:
```
cgroup on /sys/fs/cgroup type cgroup2 (rw,nosuid,nodev,noexec,relatime)
```
In questo output, rw indica che il file system è scrivibile. Se nell'output viene visualizzato ro, il file system è di sola lettura.

Passaggi successivi

Personalizzare la configurazione di containerd