Faça a gestão dos limites de IDs de processos

Vista geral

Um limite de ID do processo (PID) é uma restrição de recursos do Kubernetes em nós e pods para evitar a criação excessiva de processos, o que pode afetar a estabilidade dos nós. O Apigee Hybrid suporta a funcionalidade do Kubernetes para definir limites de ID do processo. Este documento fornece instruções sobre como definir estes limites, com recomendações de valores para os serviços do Apigee em plataformas específicas.

Quando os utilizadores do Apigee hybrid gerem os seus próprios clusters, a definição de limites de PIDs no Kubernetes pode melhorar a estabilidade, a segurança e a gestão de recursos do sistema. Isto também é consistente com as práticas recomendadas do Kubernetes.

Definições dos limites de ID do processo

Os limites de ID do processo incluem limites de PID do nó e limites de PID do pod.

Os limites de PIDs dos nós incluem PIDs reservados para o Kube e PIDs reservados para o sistema. O número total de PIDs atribuíveis é o máximo do kernel menos os PIDs reservados para o kube menos os PIDs reservados para o sistema menos os PIDs do limite de despejo:

Limites máximos de IDs do kernel
    - Kube reserved
    - Reservado pelo sistema
    - Limite de despejo
= Atribuível
  • Limites máximos de ID do kernel: determinados pelo sistema operativo e pelas respetivas definições do kernel. Uma vez que o Apigee Hybrid é executado exclusivamente num kernel Linux, este guia aborda os limites baseados no Linux nos nós do Kubernetes. O número máximo de limites de ID de processo para um kernel Linux é 4194304.
  • Kube-reserved e system-reserved: para a reserva de recursos para Kubernetes ou daemons do sistema operativo.
  • Limite de despejo: o limite que indica pressão no nó. O nó é removido quando o limite é atingido. Consulte o artigo Despejo baseado no PID para ver mais detalhes.
  • Atribuível: o número de PIDs disponíveis. Consulte o artigo Kubernetes: Node Allocatable para mais informações. Kube-reserved e system-reserved podem ser configurados com as definições do limite de PID do nó.

O limite de PID do agrupamento pode ser configurado para o nó e partilhado entre todos os agrupamentos no nó.

Prepare-se para gerir os limites de IDs de processos

Estes procedimentos usam as seguintes variáveis de ambiente:

export PROJECT_ID=MY_PROJECT_ID
export CLUSTER_NAME=MY_CLUSTER_NAME
export LOCATION=MY_CLUSTER_LOCATION
export APIGEE_NAMESPACE=MY_APIGEE_NAMESPACE # Default: apigee

Valide o acesso

Antes de configurar o limite de IDs de processos, certifique-se de que tem acesso à edição de clusters do Kubernetes.

Os passos seguintes destinam-se a instalações no GKE. Para outras plataformas, consulte a documentação da sua plataforma.

  1. Verifique se tem roles/container.clusterAdmin na política de IAM: 
    gcloud projects get-iam-policy ${PROJECT_ID}  \
 --flatten="bindings[].members" \
 --format='table(bindings.role)' \
 --filter="bindings.members:your_account_email"
  2. Se não tiver o acesso, adicione a função à sua conta: 
    gcloud projects add-iam-policy-binding ${PROJECT_ID} \
 --member user:your_account_email \
 --role roles/container.clusterAdmin

Valide os limites de PIDs existentes

Verifique se o nó tem limites de PID existentes antes de configurar novos limites.

  1. Obtenha um nó do cluster para verificar os valores. Tem de verificar os nós dos conjuntos de nós apigee-data e apigee-runtime: 
    kubectl get nodes -n ${APIGEE_NAMESPACE}

    O resultado deve ser semelhante ao seguinte:

    NAME                                      STATUS   ROLES    AGE    VERSION
gke-my-hybrid-apigee-data-0a1b2c3d-efgh      Ready       2d8h   v1.31.5-gke.1169000
gke-my-hybrid-apigee-runtime-1b2c3d4e-fghi   Ready       2d8h   v1.31.5-gke.1169000
  2. Exporte o nome do nó a partir do resultado do passo anterior. Execute primeiro este passo seguinte para um nó apigee-data e, novamente, para um nó apigee-runtime:

    Código

    export NODE_NAME=MY_NODE_NAME

    Exemplo

    export NODE_NAME="gke-my-hybrid-apigee-data-0a1b2c3d-efgh"
  3. Verifique os limites de PID do node. Use os seguintes comandos para verificar os valores reservados. Se o valor for nulo, o valor não está configurado: 
    kubectl get --raw "/api/v1/nodes/${NODE_NAME}/proxy/configz" | jq '.kubeletconfig.kubeReserved'
kubectl get --raw "/api/v1/nodes/${NODE_NAME}/proxy/configz" | jq '.kubeletconfig.systemReserved'
kubectl get --raw "/api/v1/nodes/${NODE_NAME}/proxy/configz" | jq '.kubeletconfig.evictionHard'
  4. Verifique o limite de PID do pod. Use o seguinte comando para verificar o limite de PID do pod existente. Se o valor devolvido for -1 ou estiver vazio, o limite não é definido: 
    kubectl get --raw "/api/v1/nodes/${NODE_NAME}/proxy/configz" | jq '.kubeletconfig.podPidsLimit'

Faça a gestão dos limites de ID do processo

Faça a gestão dos limites de PID do nó

Para instalações no GKE, os recursos de infraestrutura dos nós do Kubernetes são geridos internamente e não precisa de os configurar. Pode ver a capacidade atual e os recursos alocáveis seguindo as instruções em Recursos alocáveis de nós na documentação do Google Kubernetes Engine.

Para plataformas não GKE, consulte a documentação do Kubernetes correspondente para a plataforma. Se o cluster/nó for gerido pelo utilizador (em oposição a totalmente gerido), o limite de PID reservado para o kube e o limite de PID reservado para o sistema podem ser configurados com o Kubelet. Consulte os limites de PID dos nós na documentação do Kubernetes.

Ferramentas

Este procedimento usa o Kubelet para gerir o limite de ID do processo. O Kubelet é o agente que é executado em pods e contentores, e garante que estão a ser executados de acordo com o respetivo PodSpec. Se precisar de instalar o Kubelet, siga as instruções na documentação do Kubernetes: Instalar o kubeadm, o kubelet e o kubectl.

Procedimento

  1. Crie um ficheiro de configuração do Kubelet denominado kubelet-config.yaml. 
    apiVersion: kubelet.config.k8s.io/v1beta1
kind: KubeletConfiguration
kubeReserved:
 pid: PID_VALUE # Example: 1000

    Veja mais informações sobre as configurações: Kube Reserved na documentação do Kubernetes.

  2. Aplique a configuração do Kubelet: 
    kubelet --config PATH_TO_KUBELET_CONFIG_YAML

Faça a gestão dos limites de PID do pod

Escolher o limite

Se o limite de PIDs estiver definido para um valor demasiado baixo, pode impedir o arranque de um pod. Se for definido um valor demasiado elevado, pode não detetar comportamentos incorretos dos recursos. Ao selecionar o limite adequado, é importante considerar o comportamento anterior do nó e quaisquer requisitos específicos do serviço.

O GKE tem um intervalo obrigatório para o valor: [1024, 4194304]. Nas plataformas do GKE, pode ver o estado das suas contas de serviço do Kubernetes no Google Cloud console Explorador de métricas. Selecione as métricas Kubernetes Node - PID usage e aplique filtros. Estas métricas mostram a utilização recente de IDs de processos e podem ser consultadas quando escolher um limite de PID.

Explorador de métricas

Em plataformas não GKE, podem estar disponíveis diferentes opções de monitorização. Consulte a documentação do Kubernetes da plataforma correspondente para verificar as métricas.

Processe os requisitos de ID para pods do Apigee

O Apigee Hybrid usa 2 conjuntos de nós, apigee-data e apigee-runtime. Uma vez que alguns dos componentes do Apigee são implementados em ambos os conjuntos de nós, o limite de PID do pod deve ser o mesmo para os dois conjuntos de nós. O limite de PIDs do agrupamento também deve ser superior ao número máximo de PIDs necessários em todos os agrupamentos do Apigee. O limite de PID do pod do Apigee necessário é de 1000, que está abaixo do número mínimo necessário para plataformas GKE.

Algumas plataformas aplicam um requisito de valor mínimo para o número do limite de PIDs do pod. Nesse caso, é selecionado o requisito de valor mínimo.

Plataforma Limite mínimo de PID do agrupamento
GKE no Google Cloud 1024
GKE no AWS 1024
GKE no Azure 1024
Google Distributed Cloud (apenas software) no VMware 1024
Google Distributed Cloud (apenas software) em bare metal 1024
EKS 1000
AKS 1000
OpenShift 1000
Rancher Kubernetes Engine (RKE) 1000

Procedimento

Os procedimentos de gestão dos limites de PID de pods são diferentes para plataformas GKE e não GKE.

Plataforma do GKE

A plataforma GKE que suporta a atualização do limite de PID inclui:

O limite de PID do pod é controlado pelas configurações do sistema de nós. O GKE tem um intervalo obrigatório para o valor: [1024, 4194304]. Para mais informações, consulte o artigo NodeKubeletConfig.

  1. Crie uma configuração do sistema de nós denominada node-config.yaml com o limite de PID de pods designado com o seguinte conteúdo: 
    kubeletConfig:
 podPidsLimit: POD_PID_VALUE # Example: 1024
  2. Aplique a configuração aos conjuntos de nós apigee-data e apigee-runtime do Apigee. Quando aplica a configuração, o nó inicia a implementação com uma das estratégias de atualização de nós sem tempo de inatividade. 
    gcloud container OPTIONAL_HOST_PLATFORM node-pools update NODE_POOL_NAME \
   --cluster CLUSTER_NAME \
   --region CLUSTER_LOCATION \
   --system-config-from-file=node-config.yaml \
   --project PROJECT_ID

Plataformas não GKE

Para plataformas não pertencentes ao GKE, o limite de PID do pod é controlado pelo Kubelet. O limite é definido pelo campo podPidsLimit no ficheiro de configuração do Kubelet.

  1. Crie um ficheiro de configuração do Kubelet denominado kubelet-config.yaml com o seguinte conteúdo: 
    apiVersion: kubelet.config.k8s.io/v1beta1
kind: KubeletConfiguration
podPidsLimit: POD_PID_VALUE # Example: 1024
  2. Aplique a configuração. A definição de podPidsLimit requer o reinício do nó afetado, o que pode causar tempo de inatividade: 
    kubelet --config PATH_TO_KUBELET_CONFIG_YAML
  3. Valide a configuração. Consulte o artigo Verifique os limites de PIDs existentes para obter instruções.

Os comandos de configuração dos limites de PID dos pods e as recomendações de ferramentas são diferentes em várias plataformas. Consulte a documentação das respetivas plataformas para ver comandos detalhados. Seguem-se alguns links de documentação de plataformas não GKE para referência. Tenha em atenção que estão sujeitos a alterações:

Plataforma Documentação
EKS Personalize nós geridos com modelos de lançamento
AKS Personalize a configuração dos nós para os node pools do Serviço Kubernetes do Azure (AKS)
OpenShift Riscos de definir limites de ID de processos mais elevados para pods do Red Hat OpenShift Service na AWS
Rancher Kubernetes Engine (RKE) Aceda a um cluster com o Kubectl e o kubeconfig

Resolução de problemas de limites de IDs de processos

O pod está bloqueado no estado Pending com um erro FailedScheduling

Quando o limite de PIDs do nó ou do pod despeja ou restringe o arranque de um pod, este fica bloqueado no estado Pending e falha com o erro FailedScheduling.

  1. Obtenha a coluna Node: 
    kubectl get pods -n ${APIGEE_NAMESPACE} ${POD_NAME} -o wide
  2. Verifique se existe uma condição PIDPressure: 
    kubectl describe node -n apigee ${NODE_NAME} | grep PIDPressure
  3. Em alternativa, verifique o ApigeeDeployment do pod correspondente. Obtenha o ApigeeDeployment do resultado que tem o mesmo prefixo que o agrupamento com erro. 
    kubectl get ApigeeDeployment -n ${APIGEE_NAMESPACE}
  4. Verifique se o registo recente Events tem mensagens de erro relacionadas com o PID: 
    kubectl describe ApigeeDeployment -n ${APIGEE_NAMESPACE} ${APIGEE_DEPLOYMENT_NAME}
  5. Se a causa for confirmada como o limite de PID, siga os passos em Gerir os limites de PID do nó para atualizar o limite de PID para um valor mais elevado.

O campo podPidsLimit é inválido.

Quando definir o limite para o GKE, se o podPidsLimit estiver acima do limite, é apresentada a seguinte mensagem de erro: 

ERROR: (gcloud.container.node-pools.update) ResponseError: code=400, message=Invalid podPidsLimit : value must be 1024 <= podPidsLimit <= 4194304.

Atualize o valor de podPidsLimit para dentro do intervalo necessário.