Disattivare la porta di sola lettura di kubelet nei cluster GKE

Autopilot Standard

---

Questa pagina mostra come disattivare la porta di sola lettura non sicura di kubelet nei cluster Google Kubernetes Engine (GKE) per ridurre il rischio di accesso non autorizzato a kubelet e come eseguire la migrazione delle applicazioni a una porta più sicura.

Nei cluster Kubernetes, tra cui GKE, il processo kubelet in esecuzione sui nodi gestisce un'API di sola lettura utilizzando la porta non sicura 10255. Kubernetes non esegue controlli di autenticazione o autorizzazione su questa porta. Il kubelet gestisce gli stessi endpoint sulla rete porta 10250.

Disattiva la porta di sola lettura di kubelet e imposta tutti i carichi di lavoro che utilizzano la porta10255 in modo che utilizzino la porta più sicura 10250.

Prima di iniziare

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

• Attiva l'API Google Kubernetes Engine.
Attiva l'API Google Kubernetes Engine
• Se vuoi utilizzare Google Cloud CLI per questa attività, install e poi inizializzare con gcloud CLI. Se hai già installato gcloud CLI, scarica 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 le posizioni predefinite, puoi evitare errori in gcloud CLI come il seguente: One of [--zone, --region] must be supplied: Please specify location.

Requisiti

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

Controlla se le porte sono utilizzate in modo non sicuro e esegui la migrazione delle applicazioni

Prima di disattivare la porta di sola lettura non sicura, esegui la migrazione di tutte le applicazioni in esecuzione che la utilizzano alla porta di sola lettura più sicura. Carichi di lavoro la migrazione potrebbe richiedere di includere pipeline di metriche personalizzate e carichi di lavoro che per accedere 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 utilizzando l'API kubelet sulla come un elenco di pod sul nodo, usa invece l'API Kubernetes.

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

Questa sezione mostra come verificare l'utilizzo di porte non sicure nel cluster.

Controllare 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 svolgi i passaggi che seguono 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
   

   Il file manifest esegue le seguenti operazioni:

   1. Crea uno spazio dei nomi e configura i ruoli RBAC per consentire la lettura delle metriche del nodo.
   2. Esegue il deployment di un DaemonSet che controlla le metriche di 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 contenenti la stringa server_type=readonly, un'applicazione sta usando una porta di sola lettura non sicura.

Controllare l'utilizzo delle porte in modalità standard

Esegui il seguente comando su almeno un nodo di ogni pool di nodi nel 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 la porta di sola lettura non sicura di kubelet, 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 su quel nodo utilizza la classe porta di sola lettura.

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 da utilizzare sulla porta sicura di sola lettura. Ad esempio, cambia 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 questo 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 posizione del cluster.

La porta autenticata 10250 richiede di concedere all'oggetto i ruoli RBAC appropriati per accedere alle risorse specifiche. Per maggiori dettagli, nella documentazione di Kubernetes, vedi Autorizzazione kubelet.

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

Se utilizzi applicazioni di terze parti che dipendono dalla porta di sola lettura non sicura di kubelet, rivolgiti al fornitore dell'applicazione per istruzioni sulla migrazione alla porta sicura 10250.

Esempio di migrazione

Considera un pod che esegue query sulle metriche dalla porta di sola lettura non sicura di 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 esegue le seguenti operazioni:

• 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 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'
   

Modificare 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 può raggiungere la porta negli intervalli di indirizzi IP del nodo. Il firewall regole dovrebbero fare quanto segue:

• Consenti il traffico in entrata verso la porta TCP 10250 negli intervalli di indirizzi IP del tuo nodo da intervalli di indirizzi IP del pod interni
• Rifiuta il traffico in entrata alla porta TCP 10250 sugli intervalli di indirizzi IP del tuo nodo provenienti dalla rete internet pubblica.

Attenzione: non modificare le regole firewall predefinite create da GKE nei tuoi cluster. Crea nuove regole per la porta sicura. Modifica del valore predefinito potrebbero causare comportamenti imprevisti nei carichi di lavoro.

Puoi utilizzare le seguenti opzioni 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

Disattivare la porta di sola lettura non sicura sui cluster Autopilot

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

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

Per disattivare la porta di sola lettura non sicura di kubelet quando crei un nuovo cluster Autopilot, utilizza il --no-autoprovisioning-enable-insecure-kubelet-readonly-port flag, 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 posizione del tuo nuovo Autopilot in un cluster Kubernetes.

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

Per disattivare la porta di sola lettura non sicura di kubelet in 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 smettono di utilizzare l'impostazione una porta.

Attenzione: questo comando avvia un aggiornamento graduale di tutti i nodi del 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 tuo esistente in un cluster Kubernetes.
• LOCATION: la posizione del tuo attuale in un cluster Kubernetes.

Disabilita la porta di sola lettura non sicura sui cluster standard

Puoi disabilitare la porta kubelet non sicura di sola lettura per l'intero standard o per singoli pool di nodi. Ti consigliamo di disattivare 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. In via facoltativa, un'impostazione diversa per i pool di nodi di cui è stato eseguito il provisioning automatico, ma consigliamo di disabilitare la porta in tutti i nodi del cluster.

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

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

Per disattivare la porta di sola lettura non sicura di kubelet in 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 posizione del nuovo standard in un cluster Kubernetes.

Se vuoi, 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 graduale 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

a disabilitare la porta di sola lettura kubelet non sicura su un modello Standard esistente usa il flag --no-enable-insecure-kubelet-readonly-port come nell'istanza . 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 tuo cluster standard esistente.
• LOCATION: la posizione del cluster standard esistente.

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

Ti consigliamo di impostare l'impostazione della porta di sola lettura a livello di cluster in tutti i casi. Se hai disabilitato la porta di sola lettura su un cluster esistente che già utilizza pool di nodi in esecuzione, utilizza il comando seguente per disabilitare la porta su questi 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 pool di nodi.
• CLUSTER_NAME: il nome del cluster.
• LOCATION: la posizione del cluster.

Verifica che la porta sia disabilitata

Per verificare che la porta di sola lettura kubelet non sicura sia disabilitata, descrivi 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 posizione 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 in nodePoolDefaults.nodeConfigDefaults.nodeKubeletConfig nel campo della descrizione del cluster utilizzando l'API GKE.

Nei cluster Standard, vedrai anche un campo nodeConfig che imposta un per lo stato della porta di sola lettura kubelet. Il campo nodeConfig è ritirato e si applica solo al pool di nodi predefinito creato da GKE quando crei un nuovo cluster in modalità standard. Lo stato del porta nel campo nodeConfig deprecato non si applica agli 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 tuo standard in un cluster Kubernetes.
• LOCATION: la posizione del tuo account in un cluster Kubernetes.

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

insecureKubeletReadonlyPortEnabled: false

Controllare lo stato della porta 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 pool di nodi.
• CLUSTER_NAME: il nome del cluster.
• LOCATION: la località del cluster.

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

insecureKubeletReadonlyPortEnabled: false