Disabilita la porta di sola lettura kubelet nei cluster GKE

Autopilot . . Standard

---

Questa pagina mostra come disabilitare la porta di sola lettura kubelet non sicura dei cluster Google Kubernetes Engine (GKE) per ridurre il rischio di accessi non autorizzati il kubelet e come migrare le 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 alcun controllo di autenticazione o autorizzazione su questo una porta. Il kubelet gestisce gli stessi endpoint sulla rete porta 10250.

Disabilita la porta di sola lettura kubelet e cambia qualsiasi carico di lavoro che la utilizza 10255 per utilizzare la porta più sicura 10250.

Prima di iniziare

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

• Attiva l'API Google Kubernetes Engine.
Abilita l'API Google Kubernetes Engine .
• Se vuoi utilizzare Google Cloud CLI per questa attività, install e poi initialize con gcloud CLI. Se hai già installato gcloud CLI, scarica la versione più recente eseguendo gcloud components update.
  Nota: per gcloud CLI esistente di installazione, assicurati di impostare compute/region e compute/zone proprietà. Se imposti località predefinite, puoi evitare errori in gcloud CLI come i seguenti: One of [--zone, --region] must be supplied: Please specify location.

Requisiti

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

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 di qualsiasi le applicazioni che la utilizzano per accedere alla porta di sola lettura, più sicura. Carichi di lavoro che la migrazione potrebbe richiedere di includere pipeline di metriche personalizzate e carichi di lavoro 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 tramite l'API kubelet in come un elenco dei 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 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 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 il nodo di lettura metrics.
   2. Esegue il deployment di un DaemonSet che controlla le metriche kubelet per una 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 comando seguente su almeno un nodo in ogni pool di nodi nella 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 in 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 sulla porta sicura comporta quanto segue 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. Per 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 su 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 località del cluster.

La porta autenticata 10250 richiede la concessione dell'RBAC appropriato ruoli al soggetto per accedere a 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 la l'API Kubernetes con un fieldSelector per il nome del nodo.

Se usi applicazioni di terze parti che dipendono da un kubelet non sicuro porta di sola lettura, rivolgiti al fornitore dell'applicazione per avere istruzioni sulla migrazione alla porta 10250 protetta.

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 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 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 verso la porta TCP 10250 negli intervalli di indirizzi IP del tuo nodo da nella 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

Disabilita la porta di sola lettura non sicura sui cluster Autopilot

Puoi disabilitare la porta di sola lettura kubelet non sicura per le porte nuove ed esistenti Autopilot.

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

a disabilitare la porta di sola lettura kubelet non sicura quando crei un nuovo Autopilot, utilizza --no-autoprovisioning-enable-insecure-kubelet-readonly-port, come nella 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 tuo nuovo Autopilot in un cluster Kubernetes.
• LOCATION: la posizione del tuo nuovo Autopilot in un cluster Kubernetes.

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

a disabilitare la porta non sicura di sola lettura kubelet su un Autopilot esistente utilizza --no-autoprovisioning-enable-insecure-kubelet-readonly-port, come nella . Tutti i nodi nuovi ed esistenti nel cluster non utilizzano più la classe una porta.

Attenzione: questo comando avvia un aggiornamento in sequenza di tutti i nodi nel cluster, causando interruzioni nell'esecuzione dei carichi di lavoro.

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 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. 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 file di configurazione del sistema dei nodi per disabilitare in modo dichiarativo la porta di sola lettura kubelet non sicura. Se utilizzi questo , non puoi utilizzare i comandi nelle sezioni seguenti per controllare dell'impostazione kubelet.

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

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

Se vuoi, puoi aggiungere --no-autoprovisioning-enable-insure-kubelet-readonly-port flag da separare controllare 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, 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 dello standard esistente in un cluster Kubernetes.
• LOCATION: la posizione dello standard esistente in un cluster Kubernetes.

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

Ti consigliamo di configurare l'impostazione della porta di sola lettura a livello di cluster in tutti d'uso diversi. 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 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 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 della modalità Autopilot in un cluster Kubernetes.
• LOCATION: la posizione della modalità Autopilot in un cluster Kubernetes.

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

insecureKubeletReadonlyPortEnabled: false

Controlla lo stato delle porte nei cluster Standard

Lo stato della porta è disponibile in campo nodePoolDefaults.nodeConfigDefaults.nodeKubeletConfig quando descrivi 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 è deprecato e si applica solo al pool di nodi predefinito che 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

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