Desativar a porta somente leitura do kubelet em clusters do GKE

Autopilot Standard

---

Nesta página, mostramos como desativar a porta somente leitura do kubelet não segura em clusters do Google Kubernetes Engine (GKE) para reduzir o risco de acesso não autorizado ao kubelet e como migrar aplicativos para uma porta mais segura.

Em clusters do Kubernetes, incluindo o GKE, o processo kubelet do kubelet em execução nos nós exibe uma API somente leitura usando a porta não segura 10255. O Kubernetes não realiza nenhuma verificação de autenticação ou autorização nessa porta. O kubelet serve aos mesmos endpoints na porta 10250 mais segura e autenticada.

Desative a porta somente leitura do kubelet e mude todas as cargas de trabalho que usam a 10255 para usar a 10250, que é mais segura.

Antes de começar

Antes de começar, verifique se você realizou as tarefas a seguir:

• Ativar a API Google Kubernetes Engine.
Ativar a API Google Kubernetes Engine
• Se você quiser usar a Google Cloud CLI para essa tarefa, instale e, em seguida, inicialize a CLI gcloud. Se você instalou a CLI gcloud anteriormente, instale a versão mais recente executando gcloud components update.
  Observação: para instalações atuais da CLI gcloud, defina as propriedades compute/region e compute/zone. Ao definir locais padrão, é possível evitar erros na CLI gcloud, como: One of [--zone, --region] must be supplied: Please specify location.

Requisitos

• Só é possível desativar a porta somente leitura do kubelet não segura no GKE versão 1.26.4-gke.500 ou mais recente.

Verificar o uso de portas não seguras e migrar aplicativos

Antes de desativar a porta somente leitura não segura, migre todos os aplicativos em execução que usam a porta para a porta somente leitura mais segura. As cargas de trabalho que podem precisar de migração incluem pipelines de métricas personalizadas e cargas de trabalho que acessam endpoints do kubelet.

• Para cargas de trabalho que precisam acessar as informações fornecidas pela API kubelet no nó, como métricas, use a porta 10250.
• Para cargas de trabalho que recebem informações do Kubernetes usando a API kubelet no nó, como listar pods no nó, use a API Kubernetes.

Verificar se os aplicativos usam a porta somente leitura do kubelet não segura

Esta seção mostra como verificar o uso de portas não seguras no cluster.

Verificar o uso da porta no modo Autopilot

Para verificar o uso da porta em um cluster do Autopilot, verifique se há no mínimo uma carga de trabalho que não seja um DaemonSet em execução no cluster. Se você realizar as etapas a seguir em um cluster do Autopilot vazio, os resultados poderão ser inválidos.

1. Salve o seguinte manifesto como 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
   

   Esse manifesto faz o seguinte:

   1. Cria um namespace e configura papéis do RBAC para permitir a leitura de métricas de nó.
   2. Implanta um DaemonSet que verifica as métricas do kubelet para a porta somente leitura não segura.

2. Implante o manifesto:

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

3. Verifique os registros do DaemonSet:

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

   Se a saída tiver resultados que contêm a string server_type=readonly, um aplicativo está usando a porta somente leitura não segura.

Verificar o uso da porta no modo padrão

Execute o comando a seguir em pelo menos um nó em cada pool de nós no cluster:

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

Substitua NODE_NAME pelo nome do nó.

Se as cargas de trabalho no nó usarem a porta somente leitura do kubelet não segura, a saída terá entradas com a string server_type="readonly", como no exemplo abaixo:

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 a saída estiver vazia, nenhum aplicativo nesse nó usará a porta somente leitura não segura.

Migrar da porta somente leitura do kubelet não segura

Normalmente, a migração de um aplicativo para a porta segura envolve as seguintes etapas:

1. Atualize URLs ou endpoints que se referem à porta somente leitura não segura para usar a porta somente leitura segura. Por exemplo, altere http://203.0.113.104:10255 para http://203.0.113.104:10250.

2. Defina o certificado de autoridade de certificação (CA) do cliente HTTP como o certificado de CA do cluster. Para encontrar esse certificado, execute o seguinte comando:

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

   Substitua:

   • CLUSTER_NAME: o nome do cluster.
   • LOCATION: o local do cluster.

A porta autenticada 10250 exige que você conceda papéis RBAC adequados ao sujeito para acessar os recursos específicos. Para mais detalhes, consulte a documentação do Kubernetes em autorização do kubelet.

Se a carga de trabalho usar o endpoint /pods na porta somente leitura do kubelet não segura, será necessário conceder a permissão RBAC nodes/proxy para acessar o endpoint na porta segura do kubelet. nodes/proxy é uma permissão poderosa que não pode ser concedida em clusters do GKE Autopilot e não deve ser concedida em clusters do GKE Standard. Use a API Kubernetes com um fieldSelector para o nome do nó.

Se usar aplicativos de terceiros que dependem da porta somente leitura do kubelet não segura, consulte o fornecedor do aplicativo para saber como migrar para a porta segura 10250.

Exemplo de migração

Considere um pod que consulta métricas da porta somente leitura do kubelet não segura.

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

Este aplicativo faz o seguinte:

• Usa a conta de serviço default no namespace default
• Executa o comando curl no endpoint /metrics do nó.

Para atualizar esse pod para usar a porta segura 10250, siga estas etapas:

1. Crie um ClusterRole com acesso para receber as métricas do nó:

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

2. Vincule o ClusterRole à identidade do aplicativo:

   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. Atualize o comando curl para usar o endpoint de porta seguro com os cabeçalhos de autorização correspondentes:

   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'
   

Modificar regras de firewall da VPC

Se você atualizar os workloads para usar a porta 10250, crie regras de firewall para que os pods no cluster possam acessar a porta nos intervalos de endereços IP do nó. As regras do firewall precisam fazer o seguinte:

• Permitir o tráfego de entrada na porta TCP 10250 nos intervalos de endereços IP do nó dos intervalos de endereços IP internos do pod
• Negar o tráfego de entrada para a porta TCP 10250 nos intervalos de endereço IP do nó da Internet pública.

Atenção: não modifique as regras de firewall padrão que o GKE cria nos clusters. Crie novas regras para a porta segura. Modificar as regras padrão pode resultar em um comportamento inesperado nas cargas de trabalho.

É possível usar as regras de firewall padrão do GKE a seguir como modelo para os parâmetros a serem especificados nas novas regras:

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

Desativar a porta somente leitura não segura em clusters do Autopilot

É possível desativar a porta somente leitura do kubelet não segura para clusters novos e atualizados do Autopilot.

Desativar a porta somente leitura não segura em novos clusters do Autopilot

Para desativar a porta somente leitura do kubelet não segura ao criar um novo cluster do Autopilot, use a flag --no-autoprovisioning-enable-insecure-kubelet-readonly-port, como no seguinte comando:

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

Substitua:

• CLUSTER_NAME: o nome do novo cluster de Autopilot.
• LOCATION: o nome do novo cluster de Autopilot.

Desativar a porta somente leitura não segura em clusters do Autopilot atuais

Para desativar a porta somente leitura do kubelet não segura em um cluster do Autopilot, use a flag --no-autoprovisioning-enable-insecure-kubelet-readonly-port, como no seguinte comando: Todos os nós novos e existentes no cluster param de usar a porta.

Cuidado: esse comando inicia uma atualização gradual de todos os nós do cluster, o que pode causar interrupções nas cargas de trabalho em execução.

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

Substitua:

• CLUSTER_NAME: o nome do cluster atual.
• LOCATION: o local do cluster atual.

Desativar a porta somente leitura não segura em clusters padrão

É possível desativar a porta somente leitura do kubelet não segura para clusters padrão inteiros ou para pools de nós individuais. Recomendamos desativar a porta para todo o cluster.

Se você usar o provisionamento automático de nós, os pools de nós provisionados automaticamente herdarão a configuração de porta especificada no nível do cluster. Você pode especificar uma configuração diferente para pools de nós provisionados automaticamente, mas recomendamos desativar a porta em todos os nós do cluster.

Também é possível usar um arquivo de configuração do sistema de nó para desativar de forma declarativa a porta somente leitura do kubelet não segura. Se você usar esse arquivo, não poderá usar os comandos nas seções a seguir para controlar a configuração do kubelet.

Desativar a porta somente leitura não segura em novos clusters padrão

Para desativar a porta somente leitura do kubelet não segura em um novo cluster padrão, use a flag --no-enable-insecure-kubelet-readonly-port, como no comando abaixo:

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

Substitua:

• CLUSTER_NAME: o nome do novo cluster padrão.
• LOCATION: o nome do novo cluster padrão.

Você pode adicionar a flag --no-autoprovisioning-enable-insure-kubelet-readonly-port para controlar separadamente a configuração de provisionamento automático de nós, mas não recomendamos essa abordagem. Essa flag inicia uma atualização gradual dos pools de nós provisionados automaticamente, o que pode causar interrupções nas cargas de trabalho em execução.

Desativar a porta somente leitura não segura em clusters padrão atuais

Para desativar a porta somente leitura do kubelet não segura em um cluster padrão atual, use a flag --no-enable-insecure-kubelet-readonly-port, como no comando abaixo. Os novos pools de nós não vão usar a porta não segura. O GKE não atualiza os pools de nós automaticamente.

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

Substitua:

• CLUSTER_NAME: o nome do cluster padrão atual.
• LOCATION: o local do cluster padrão atual.

Desativar a porta somente leitura não segura em pools de nós padrão

Recomendamos definir a configuração da porta somente leitura no nível do cluster em todos os casos. Se você desativou a porta somente leitura em um cluster que já tinha pools de nós em execução, use o comando a seguir para desativar a porta nesses pools de nós.

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

Substitua:

• NODE_POOL_NAME: o nome do pool de nós.
• CLUSTER_NAME: o nome do cluster.
• LOCATION: o local do cluster.

Verificar se a porta está desativada

Para verificar se a porta somente leitura do kubelet não segura está desativada, descreva o recurso do GKE.

Verificar o status da porta em clusters do Autopilot

Execute este comando:

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

Substitua:

• CLUSTER_NAME: o nome do cluster do Autopilot.
• LOCATION: o local do cluster do Autopilot.

Se a porta estiver desativada, a saída será a seguinte:

insecureKubeletReadonlyPortEnabled: false

Verificar o status da porta em clusters padrão

O status da porta está disponível no campo nodePoolDefaults.nodeConfigDefaults.nodeKubeletConfig ao descrever o cluster usando a API GKE.

Em clusters padrão, também há um campo nodeConfig que define um valor para o status da porta somente leitura do kubelet. O campo nodeConfig foi descontinuado e se aplica apenas ao pool de nós padrão criado pelo GKE quando você cria um novo cluster no modo Padrão. O status da porta no campo nodeConfig descontinuado não se aplica a outros pools de nós no cluster.

Execute este comando:

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

Substitua:

• CLUSTER_NAME: o nome do cluster padrão.
• LOCATION: o local do cluster padrão.

Se a porta estiver desativada, a saída será a seguinte:

insecureKubeletReadonlyPortEnabled: false

Verificar o status da porta em pools de nós padrão

Execute este comando:

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

Substitua:

• NODE_POOL_NAME: o nome do pool de nós.
• CLUSTER_NAME: o nome do cluster.
• LOCATION: O local do cluster.

Se a porta estiver desativada, a saída será a seguinte:

insecureKubeletReadonlyPortEnabled: false