Disabilita la porta di sola lettura kubelet nei cluster GKE

Autopilot Standard

---

Questa pagina mostra come disabilitare la porta non sicura di sola lettura kubelet nei cluster Google Kubernetes Engine (GKE) per ridurre il rischio di accessi non autorizzati al kubelet e come eseguire la migrazione delle applicazioni verso una porta più sicura.

Nei cluster Kubernetes, compreso GKE, il processo kubelet in esecuzione sui nodi gestisce un'API di sola lettura utilizzando la porta non sicura 10255. Kubernetes non esegue alcun controllo di autenticazione o autorizzazione su questa porta. Il kubelet gestisce gli stessi endpoint sulla porta 10250, più sicura e autenticata.

Disabilita la porta di sola lettura kubelet e cambia eventuali carichi di lavoro che utilizzano la porta 10255 in modo che utilizzino la porta più sicura 10250.

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti attività:

• Abilita l'API Google Kubernetes Engine.
Abilita l'API Google Kubernetes Engine
• Se vuoi utilizzare Google Cloud CLI per questa attività, installa e quindi initialize gcloud CLI. Se hai già installato gcloud CLI, ottieni la versione più recente eseguendo gcloud components update.
  Nota: per le installazioni esistenti di gcloud CLI, assicurati di impostare le proprietà compute/region e compute/zone. Se imposti località predefinite, puoi evitare errori in gcloud CLI, come quelli che seguono: One of [--zone, --region] must be supplied: Please specify location.

Requisiti

• Puoi disabilitare la porta di sola lettura kubelet non sicura solo in GKE 1.26.4-gke.500 o versioni successive.

Verifica l'utilizzo non sicuro delle porte ed esegui la migrazione delle applicazioni

Prima di disabilitare la porta di sola lettura non sicura, esegui la migrazione delle applicazioni in esecuzione che utilizzano la porta alla porta più sicura di sola lettura. I carichi di lavoro che potrebbero richiedere la migrazione includono pipeline di metriche personalizzate e carichi di lavoro che accedono agli endpoint kubelet.

• Per i carichi di lavoro che devono accedere alle informazioni fornite dall'API kubelet sul nodo, come le metriche, utilizza la porta 10250.
• Per i carichi di lavoro che ricevono informazioni da Kubernetes tramite l'API kubelet sul nodo, ad esempio l'elenco dei pod sul nodo, utilizza invece l'API Kubernetes.

Controlla se le applicazioni utilizzano una porta di sola lettura kubelet non sicura

Questa sezione mostra come verificare l'utilizzo non sicuro delle porte nel tuo cluster.

Controlla l'utilizzo delle porte in modalità Autopilot

Per verificare l'utilizzo delle porte in un cluster Autopilot, assicurati di avere almeno un carico di lavoro che non sia un DaemonSet in esecuzione nel cluster. Se esegui i passaggi seguenti su un cluster Autopilot vuoto, i risultati potrebbero non essere validi.

1. Salva il seguente manifest come read-only-port-metrics.yaml:

   apiVersion: v1
   kind: Namespace
   metadata:
     name: node-metrics-printer-namespace
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRole
   metadata:
     name: node-metrics-printer-role
   rules:
   - apiGroups:
     - ""
     resources:
     - nodes/metrics
     verbs:
     - get
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRoleBinding
   metadata:
     name: node-metrics-printer-binding
   roleRef:
     apiGroup: rbac.authorization.k8s.io
     kind: ClusterRole
     name: node-metrics-printer-role
   subjects:
   - kind: ServiceAccount
     name: node-metrics-printer-sa
     namespace: node-metrics-printer-namespace
   ---
   apiVersion: v1
   kind: ServiceAccount
   metadata:
     name: node-metrics-printer-sa
     namespace: node-metrics-printer-namespace
   ---
   apiVersion: apps/v1
   kind: DaemonSet
   metadata:
     name: node-metrics-printer
     namespace: node-metrics-printer-namespace
   spec:
     selector:
       matchLabels:
         app: node-metrics-printer
     template:
       metadata:
         labels:
           app: node-metrics-printer
       spec:
         serviceAccountName: node-metrics-printer-sa
         containers:
         - name: metrics-printer
           image: us-docker.pkg.dev/cloud-builders/ga/v1/curl:latest
           command: ["sh", "-c"]
           args:
           - 'while true; do curl -s --cacert "${CA_CERT}" -H "Authorization: Bearer $(cat ${TOKEN_FILE})" "https://${NODE_ADDRESS}:10250/metrics"|grep kubelet_http_requests_total; sleep 20; done'
           env:
           - name: CA_CERT
             value: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
           - name: TOKEN_FILE
             value: /var/run/secrets/kubernetes.io/serviceaccount/token
           - name: NODE_ADDRESS
             valueFrom:
               fieldRef:
                 fieldPath: status.hostIP
   

   Questo file manifest esegue le seguenti operazioni:

   1. Crea uno spazio dei nomi e configura i ruoli RBAC per consentire la lettura delle metriche dei nodi.
   2. Esegue il deployment di un DaemonSet che controlla le metriche kubelet per la porta di sola lettura non sicura.

2. Esegui il deployment del manifest:

   kubectl create -f read-only-port-metrics.yaml
   

3. Controlla i log DaemonSet:

   kubectl logs --namespace=node-metrics-printer-namespace \
       --all-containers --prefix \
       --selector=app=node-metrics-printer
   

   Se l'output contiene risultati che contengono la stringa server_type=readonly, un'applicazione utilizza la porta di sola lettura non sicura.

Controllare l'utilizzo delle porte in modalità Standard

Esegui il comando seguente su almeno un nodo in ogni pool di nodi del tuo cluster:

kubectl get --raw /api/v1/nodes/NODE_NAME/proxy/metrics | grep http_requests_total | grep readonly

Sostituisci NODE_NAME con il nome del nodo.

Se i carichi di lavoro sul nodo utilizzano una porta kubelet non sicura di sola lettura, l'output contiene voci con la stringa server_type="readonly" come nell'esempio seguente:

kubelet_http_requests_total{long_running="false",method="GET",path="healthz",server_type="readonly"} 3
kubelet_http_requests_total{long_running="false",method="GET",path="metrics",server_type="readonly"} 2549
kubelet_http_requests_total{long_running="false",method="GET",path="metrics/probes",server_type="readonly"} 2546
kubelet_http_requests_total{long_running="false",method="GET",path="other",server_type="readonly"} 2
kubelet_http_requests_total{long_running="false",method="GET",path="pods",server_type="readonly"} 1
kubelet_http_requests_total{long_running="false",method="GET",path="stats",server_type="readonly"} 2549

Se l'output è vuoto, nessuna applicazione sul nodo utilizza la porta di sola lettura non sicura.

Esegui la migrazione da una porta kubelet non sicura di sola lettura

In genere, la migrazione di un'applicazione alla porta sicura prevede i seguenti passaggi:

1. Aggiorna gli URL o gli endpoint che fanno riferimento alla porta di sola lettura non sicura per utilizzare invece la porta sicura di sola lettura. Ad esempio, modifica http://203.0.113.104:10255 in http://203.0.113.104:10250.

2. Imposta il certificato dell'autorità di certificazione (CA) del client HTTP sul certificato CA del cluster. Per trovare il certificato, esegui questo comando:

   gcloud container clusters describe CLUSTER_NAME \
       --location=LOCATION \
       --format="value(masterAuth.clusterCaCertificate)"
   

   Sostituisci quanto segue:

   • CLUSTER_NAME: il nome del tuo cluster.
   • LOCATION: la località del cluster.

La porta autenticata 10250 richiede che tu conceda i ruoli RBAC appropriati al soggetto per accedere a risorse specifiche. Per maggiori dettagli, nella documentazione di Kubernetes, vedi Autorizzazione kubelet.

Se il tuo carico di lavoro utilizza l'endpoint /pods sulla porta non sicura di sola lettura kubelet, devi concedere l'autorizzazione RBAC nodes/proxy per accedere all'endpoint sulla porta kubelet sicura. nodes/proxy è un'autorizzazione potente che non puoi concedere nei cluster GKE Autopilot e che non dovresti concedere nei cluster GKE Standard. Utilizza invece l'API Kubernetes con un fieldSelector come nome del nodo.

Se utilizzi applicazioni di terze parti che dipendono da una porta di sola lettura kubelet non sicura, contatta il fornitore dell'applicazione per istruzioni su come eseguire la migrazione alla porta sicura 10250.

Esempio di migrazione

Considera un pod che esegue query sulle metriche dalla porta non sicura di sola lettura kubelet.

apiVersion: v1
kind: Pod
metadata:
  name: kubelet-readonly-example
spec:
  restartPolicy: Never
  containers:
  - name: kubelet-readonly-example
    image: us-docker.pkg.dev/cloud-builders/ga/v1/curl:latest
    command:
      - curl
      - http://$(NODE_ADDRESS):10255/metrics
    env:
    - name: NODE_ADDRESS
      valueFrom:
        fieldRef:
          fieldPath: status.hostIP

Questa applicazione fa quanto segue:

• Utilizza l'account di servizio default nello spazio dei nomi default
• Esegue il comando curl sull'endpoint /metrics sul nodo.

Per aggiornare questo pod in modo che utilizzi la porta sicura 10250, segui questi passaggi:

1. Crea un ClusterRole con accesso per recuperare le metriche dei nodi:

   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRole
   metadata:
     name: curl-authenticated-role
   rules:
   - apiGroups:
     - ""
     resources:
     - nodes/metrics
     verbs:
     - get
   

2. Associa il ClusterRole all'identità dell'applicazione:

   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRoleBinding
   metadata:
     name: curl-authenticated-role-binding
   roleRef:
     apiGroup: rbac.authorization.k8s.io
     kind: ClusterRole
     name: curl-authenticated-role
   subjects:
   - kind: ServiceAccount
     name: default
     namespace: default
   

3. Aggiorna il comando curl per utilizzare l'endpoint della porta sicura con le intestazioni di autorizzazione corrispondenti:

   apiVersion: v1
   kind: Pod
   metadata:
     name: kubelet-authenticated-example
   spec:
     restartPolicy: Never
     containers:
     - name: kubelet-readonly-example
       image: us-docker.pkg.dev/cloud-builders/ga/v1/curl:latest
       env:
       - name: NODE_ADDRESS
         valueFrom:
           fieldRef:
             fieldPath: status.hostIP
       command:
       - sh
       - -c
       - 'curl -s --cacert /var/run/secrets/kubernetes.io/serviceaccount/ca.crt -H "Authorization:
         Bearer $(cat /var/run/secrets/kubernetes.io/serviceaccount/token)" https://${NODE_ADDRESS}:10250/metrics'
   

Modifica le regole firewall VPC

Se aggiorni i carichi di lavoro in modo che utilizzino la porta 10250, crea regole firewall in modo che i pod nel cluster possano raggiungere la porta negli intervalli di indirizzi IP dei nodi. Le regole firewall dovrebbero fare quanto segue:

• Consenti il traffico in entrata verso la porta TCP 10250 negli intervalli di indirizzi IP del tuo nodo dagli intervalli di indirizzi IP del pod interni
• Nega il traffico in entrata verso la porta TCP 10250 negli intervalli di indirizzi IP del tuo nodo dalla rete internet pubblica.

Attenzione: non modificare le regole firewall predefinite create da GKE nei tuoi cluster. Crea nuove regole per la porta sicura. La modifica delle regole predefinite potrebbe causare comportamenti imprevisti nei carichi di lavoro.

Puoi utilizzare le seguenti regole firewall GKE predefinite come modello per i parametri da specificare nelle nuove regole.

• gke-[cluster-name]-[cluster-hash]-inkubelet
• gke-[cluster-name]-[cluster-hash]-exkubelet

Disabilita la porta di sola lettura non sicura sui cluster Autopilot

Puoi disabilitare la porta di sola lettura kubelet non sicura per i cluster Autopilot nuovi ed esistenti.

Disabilita la porta di sola lettura non sicura sui nuovi cluster Autopilot

Per disabilitare la porta di sola lettura kubelet non sicura quando crei un nuovo cluster Autopilot, utilizza il flag --no-autoprovisioning-enable-insecure-kubelet-readonly-port, come nel seguente comando:

gcloud container clusters create-auto CLUSTER_NAME \
    --location=LOCATION \
    --no-autoprovisioning-enable-insecure-kubelet-readonly-port

Sostituisci quanto segue:

• CLUSTER_NAME: il nome del nuovo cluster Autopilot.
• LOCATION: la località del nuovo cluster Autopilot.

Disabilita la porta di sola lettura non sicura sui cluster Autopilot esistenti

Per disabilitare la porta non sicura di sola lettura kubelet su un cluster Autopilot esistente, utilizza il flag --no-autoprovisioning-enable-insecure-kubelet-readonly-port, come nel comando seguente. Tutti i nodi nuovi ed esistenti nel cluster non utilizzano più la porta.

Attenzione: questo comando avvia un aggiornamento in sequenza di tutti i nodi nel tuo cluster, che potrebbe causare interruzioni dei carichi di lavoro in esecuzione.

gcloud container clusters update CLUSTER_NAME \
    --location=LOCATION \
    --no-autoprovisioning-enable-insecure-kubelet-readonly-port

Sostituisci quanto segue:

• CLUSTER_NAME: il nome del cluster esistente.
• LOCATION: la località del cluster esistente.

Disabilita la porta di sola lettura non sicura sui cluster standard

Puoi disabilitare la porta kubelet non sicura di sola lettura per interi cluster Standard o per singoli pool di nodi. Ti consigliamo di disabilitare la porta per l'intero cluster.

Se utilizzi il provisioning automatico dei nodi, i pool di nodi di cui è stato eseguito il provisioning automatico ereditano l'impostazione della porta specificata a livello di cluster. Facoltativamente, puoi specificare un'impostazione diversa per i pool di nodi di cui è stato eseguito il provisioning automatico, ma ti consigliamo di disabilitare la porta in tutti i nodi del cluster.

Puoi anche utilizzare un file di configurazione del sistema dei nodi per disabilitare in modo dichiarativo la porta di sola lettura kubelet non sicura. Se utilizzi questo file, non puoi utilizzare i comandi nelle sezioni seguenti per controllare l'impostazione kubelet.

Disabilita la porta di sola lettura non sicura sui nuovi cluster Standard

Per disabilitare la porta kubelet non sicura di sola lettura su un nuovo cluster Standard, utilizza il flag --no-enable-insecure-kubelet-readonly-port come nel seguente comando:

gcloud container clusters create CLUSTER_NAME \
    --location=LOCATION \
    --no-enable-insecure-kubelet-readonly-port

Sostituisci quanto segue:

• CLUSTER_NAME: il nome del nuovo cluster standard.
• LOCATION: la località del nuovo cluster Standard.

Facoltativamente, puoi aggiungere il flag --no-autoprovisioning-enable-insure-kubelet-readonly-port per controllare separatamente l'impostazione di provisioning automatico dei nodi, ma sconsigliamo questo approccio. Questo flag avvia un aggiornamento in sequenza dei pool di nodi di cui è stato eseguito il provisioning automatico, che potrebbe causare interruzioni dei carichi di lavoro in esecuzione.

Disabilita la porta di sola lettura non sicura sui cluster standard esistenti

Per disabilitare la porta kubelet non sicura di sola lettura su un cluster standard esistente, utilizza il flag --no-enable-insecure-kubelet-readonly-port come nel comando seguente. Eventuali nuovi pool di nodi non utilizzeranno la porta non sicura. GKE non aggiorna automaticamente i pool di nodi esistenti.

gcloud container clusters update CLUSTER_NAME \
    --location=LOCATION \
    --no-enable-insecure-kubelet-readonly-port

Sostituisci quanto segue:

• CLUSTER_NAME: il nome del cluster Standard esistente.
• LOCATION: la località del cluster Standard esistente.

Disabilita la porta di sola lettura non sicura sui pool di nodi standard

Ti consigliamo di configurare in tutti i casi l'impostazione della porta di sola lettura a livello di cluster. Se hai disabilitato la porta di sola lettura su un cluster esistente in cui erano già in esecuzione dei pool di nodi, utilizza il comando seguente per disabilitare la porta su quei pool di nodi.

gcloud container node-pools update NODE_POOL_NAME \
    --cluster=CLUSTER_NAME \
    --location=LOCATION \
    --no-enable-insecure-kubelet-readonly-port

Sostituisci quanto segue:

• NODE_POOL_NAME: il nome del tuo pool di nodi.
• CLUSTER_NAME: il nome del cluster.
• LOCATION: la località del cluster.

Verifica che la porta sia disabilitata

Per verificare che la porta di sola lettura kubelet non sicura sia disabilitata, descrivi la risorsa GKE.

Controlla lo stato delle porte nei cluster Autopilot

Esegui questo comando:

gcloud container clusters describe CLUSTER_NAME \
    --location=LOCATION \
    --flatten=nodePoolAutoConfig \
    --format="value(nodeKubeletConfig)"

Sostituisci quanto segue:

• CLUSTER_NAME: il nome del tuo cluster Autopilot.
• LOCATION: la località del cluster Autopilot.

Se la porta è disabilitata, l'output è il seguente:

insecureKubeletReadonlyPortEnabled: false

Controlla lo stato delle porte nei cluster Standard

Lo stato della porta è disponibile nel campo nodePoolDefaults.nodeConfigDefaults.nodeKubeletConfig quando descrivi il cluster utilizzando l'API GKE.

Nei cluster standard, vedrai anche un campo nodeConfig che imposta un valore per lo stato della porta di sola lettura kubelet. Il campo nodeConfig è deprecato e si applica solo al pool di nodi predefinito che GKE crea quando crei un nuovo cluster in modalità Standard. Lo stato della porta nel campo nodeConfig deprecato non si applica ad altri pool di nodi nel cluster.

Esegui questo comando:

gcloud container clusters describe CLUSTER_NAME \
    --location=LOCATION \
    --flatten=nodePoolDefaults.nodeConfigDefaults \
    --format="value(nodeKubeletConfig)"

Sostituisci quanto segue:

• CLUSTER_NAME: il nome del cluster standard.
• LOCATION: la località del cluster standard.

Se la porta è disabilitata, l'output è il seguente:

insecureKubeletReadonlyPortEnabled: false

Controlla lo stato delle porte nei pool di nodi Standard

Esegui questo comando:

gcloud container node-pools describe NODE_POOL_NAME \
    --cluster= CLUSTER_NAME \
    --location=LOCATION \
    --flatten=config \
    --format="value(kubeletConfig)"

Sostituisci quanto segue:

• NODE_POOL_NAME: il nome del tuo pool di nodi.
• CLUSTER_NAME: il nome del cluster.
• LOCATION: la località del cluster.

Se la porta è disabilitata, l'output è il seguente:

insecureKubeletReadonlyPortEnabled: false