Gerenciar limites de ID do processo

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Visão geral

Um limite de ID do processo (PID, na sigla em inglês) é 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 do nó. A Apigee híbrida oferece suporte ao recurso do Kubernetes para definir limites de ID de processo. Este documento fornece instruções sobre como definir esses limites, com recomendações de valores para serviços da Apigee em plataformas específicas.

Quando os usuários da Apigee híbrida gerenciam os próprios clusters, a definição de limites de PID no Kubernetes pode melhorar a estabilidade, a segurança e o gerenciamento de recursos do sistema. Isso também está de acordo com as práticas recomendadas do Kubernetes.

Definições de limites de ID do processo

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

Os limites de PID do nó incluem PIDs reservados pelo Kube e pelo sistema. O número total de PIDs alocáveis é o máximo do kernel menos os PIDs reservados pelo kube menos os PIDs reservados pelo sistema menos os PIDs do limite de expulsão:

• Limites máximos de ID do kernel: determinados pelo sistema operacional e pelas configurações do kernel. Como a Apigee híbrida é executada exclusivamente em um kernel Linux, este guia discute os limites baseados em Linus nos nós do Kubernetes. O número máximo de limites de ID de processo para um kernel do Linux é 4194304.
• Kube-reserved e system-reserved: para reserva de recursos para daemons do sistema do Kubernetes ou do SO.
• Limite de expulsão: o limite que indica a pressão no nó. O nó será removido quando o limite for atingido. Consulte Remoção baseada em PID para mais detalhes.
• Alocável: o número de PIDs disponíveis. Consulte Kubernetes: Node Allocatable para mais informações. As reservas do Kube e do sistema podem ser configuradas com as configurações de limite de PID do nó.

O limite de PID do pod pode ser configurado para o nó e compartilhado entre todos os pods no nó.

Prepare-se para gerenciar os limites de ID do processo

Esses 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

Verifique o acesso

Antes de configurar o limite de ID do processo, verifique se você tem acesso para editar clusters do Kubernetes.

As etapas a seguir são para instalações no GKE. Para outras plataformas, consulte a documentação da sua plataforma.

1. Verifique se você tem roles/container.clusterAdmin na política do IAM:

   gcloud projects get-iam-policy ${PROJECT_ID}  \
    --flatten="bindings[].members" \
    --format='table(bindings.role)' \
    --filter="bindings.members:your_account_email"
   

2. Se você não tiver o acesso, adicione o papel à sua conta:

   gcloud projects add-iam-policy-binding ${PROJECT_ID} \
    --member user:your_account_email \
    --role roles/container.clusterAdmin

Verificar os limites de PID atuais

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

1. Receba um nó do cluster para verificar os valores. Verifique os nós dos pools de nós apigee-data e apigee-runtime:

   kubectl get nodes -n ${APIGEE_NAMESPACE}
   

   A saída será parecida com esta:

   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ó da saída da etapa anterior. Execute a próxima etapa primeiro 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 nó. Use os comandos a seguir para verificar os valores reservados. Se o valor for nulo, ele não será 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 comando a seguir para verificar o limite de PID do pod. Se o valor retornado for -1 ou vazio, o limite não será definido:

   kubectl get --raw "/api/v1/nodes/${NODE_NAME}/proxy/configz" | jq '.kubeletconfig.podPidsLimit'
   

Gerenciar os limites de ID do processo

Gerenciar os limites de PID do nó

Para instalações no GKE, os recursos de infraestrutura dos nós do Kubernetes são gerenciados internamente, e você não precisa configurá-los. A capacidade atual e os recursos alocáveis podem ser visualizados em Recursos alocáveis do nó na documentação do Google Kubernetes Engine.

Para plataformas que não são do GKE, consulte a documentação do Kubernetes correspondente. Se o cluster/nó for gerenciado pelo usuário (em vez de totalmente gerenciado), o limite de PID reservado pelo kube e o limite de PID reservado pelo sistema poderão ser configurados com o Kubelet. Consulte Limites de PID do nó na documentação do Kubernetes.

Ferramentas

Este procedimento usa o Kubelet para gerenciar o limite de ID do processo. O Kubelet é o agente executado em pods e contêineres que garante que eles sejam executados de acordo com o PodSpec. Se você precisar instalar o Kubelet, siga as instruções na documentação do Kubernetes: Instalação do kubeadm, kubelet e kubectl.

Procedimento

1. Crie um arquivo de configuração do Kubelet chamado kubelet-config.yaml.

   apiVersion: kubelet.config.k8s.io/v1beta1
   kind: KubeletConfiguration
   kubeReserved:
    pid: PID_VALUE # Example: 1000
   

   Confira 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
   

Gerenciar os limites de PID do pod

Como escolher o limite

Se o limite de PID for definido muito baixo, isso pode impedir a inicialização de um pod. Se ele for definido muito alto, pode não detectar comportamentos incorretos dos recursos. Ao selecionar o limite adequado, é importante considerar o comportamento anterior do nó e os requisitos específicos do serviço.

O GKE tem um intervalo obrigatório para o valor: [1024, 4194304]. No GKE Platforms, é possível conferir o status das suas contas de serviço do Kubernetes no Google Cloud console Metrics Explorer. Selecione as métricas Nó do Kubernetes: uso do PID e aplique filtros. Essa métrica mostra o uso recente de IDs de processo e pode ser referenciada ao escolher um limite de PID.

Metrics Explorer

Em plataformas que não são do GKE, talvez haja opções de monitoramento diferentes. Consulte a documentação do Kubernetes da plataforma correspondente para conferir as métricas.

Requisitos de ID do processo para pods do Apigee

A Apigee híbrida usa dois pools de nós, apigee-data e apigee-runtime. Como alguns dos componentes da Apigee são implantados nos dois pools de nós, o limite de PID do pod é o mesmo para os dois pools. O limite de PID do pod também precisa ser maior que o número máximo de PIDs necessários em todos os pods do Apigee. O limite necessário de PID do pod do Apigee é 1.000, que é menor que o número mínimo necessário para plataformas do GKE.

Limite de PIDs de pods recomendado

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

Procedimento

Os procedimentos para gerenciar os limites de PID do pod são diferentes para o GKE e plataformas que não são do GKE.

Solução de problemas com os limites de ID do processo

Pod travado no status Pending com um erro FailedScheduling

Quando o limite de PIDs do nó ou do pod remove ou restringe a inicialização de um pod, ele fica preso no status Pending e falha com o erro FailedScheduling.

1. Acesse a coluna "Node":

   kubectl get pods -n ${APIGEE_NAMESPACE} ${POD_NAME} -o wide
   

2. Verifique se há uma condição PIDPressure:

   kubectl describe node -n apigee ${NODE_NAME} | grep PIDPressure
   

3. Você também pode verificar ApigeeDeployment do pod correspondente. Receba o ApigeeDeployment do resultado que tem o mesmo prefixo do pod com erro.

   kubectl get ApigeeDeployment -n ${APIGEE_NAMESPACE}
   

4. Verifique se o Events recente tem mensagens de erro relacionadas ao PID:

   kubectl describe ApigeeDeployment -n ${APIGEE_NAMESPACE} ${APIGEE_DEPLOYMENT_NAME}
   

5. Se a causa for confirmada como limite de PID, siga as etapas em Gerenciar os limites de PID do nó para atualizar o limite de PID para um valor maior.

podPidsLimit inválido

Ao definir o limite para o GKE, se o podPidsLimit estiver além do limite, o erro será solicitado:

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

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