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
inizializzare
con gcloud CLI. Se hai già installato gcloud CLI, scarica la versione più recente
eseguendo
gcloud components update
.
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 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 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.
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:
- Crea uno spazio dei nomi e configura i ruoli RBAC per consentire il nodo di lettura metriche di valutazione.
- Esegue il deployment di un DaemonSet che controlla le metriche kubelet per una porta di sola lettura non sicura.
Esegui il deployment del manifest:
kubectl create -f read-only-port-metrics.yaml
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:
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
inhttp://203.0.113.104:10250
.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.
/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 nomidefault
- Esegue il comando
curl
sull'endpoint/metrics
sul nodo.
Per aggiornare questo pod in modo che utilizzi la porta sicura 10250
, segui questi passaggi:
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
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
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.
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.
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