Como soluciono problemas de alta utilização da CPU no meu cluster do Amazon OpenSearch Service?

8 minuto de leitura

Meus nós de dados estão mostrando alto uso da CPU no meu cluster do Amazon OpenSearch Service.

Breve descrição

É uma prática recomendada manter a utilização da CPU para garantir que o OpenSearch Service tenha recursos suficientes para realizar suas tarefas. Um cluster com performance consistente com alta utilização da CPU pode degradar a performance do cluster. Quando seu cluster está sobrecarregado, o OpenSearch Service para de responder, resultando em uma solicitação de tempo limite.

Para solucionar problemas de alta utilização da CPU no seu cluster, considere as seguintes abordagens:

Use a API de hot threads de nós.
Verifique a operação de gravação ou o grupo de threads da API em massa.
Verifique o grupo de threads de pesquisa.
Verifique o grupo de threads de mesclagem do Apache Lucene.
Verifique a pressão da memória da JVM.
Revise sua estratégia de fragmentação.
Otimize suas consultas.

Resolução

Usar a API de hot threads de nós

Se houver picos constantes de CPU no seu cluster do OpenSearch Service, use a API de hot threads de nós. A API de hot threads de nós atua como um gerenciador de tarefas, mostrando o detalhamento de todos os encadeamentos que consomem muitos recursos que estão sendo executados no seu cluster.

Exemplo de saída da API de hot threads de nós:

GET _nodes/hot_threads

100.0% (131ms out of 500ms) cpu usage by thread 'opensearch[xxx][search][T#62]'
10/10 snapshots sharing following 10
elements sun.misc.Unsafe.park(Native Method)
java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
java.util.concurrent.LinkedTransferQueue.awaitMatch(LinkedTransferQueue.java:737)

java.util.concurrent.LinkedTransferQueue.xfer(LinkedTransferQueue.java:647)

java.util.concurrent.LinkedTransferQueue.take(LinkedTransferQueue.java:1269)

org.opensearch.common.util.concurrent.SizeBlockingQueue.take(SizeBlockingQueue.java:162)

java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1067)

java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1127)

java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
java.lang.Thread.run(Thread.java:745)

Observação: a saída de hot threads de nós lista as informações de cada nó. A duração da saída depende de quantos nós estão em execução no cluster do OpenSearch Service.

Além disso, use a API de nós cat para ver a análise atual da utilização de recursos. Você pode restringir o subconjunto de nós com a maior utilização da CPU com o seguinte comando:

GET _cat/nodes?v&s=cpu:desc

A última coluna na sua saída exibe o nome do nó. Para mais informações, consulte a API de nós cat no site do Elasticsearch.

Em seguida, passe o nome do nó relevante para sua API de hot threads:

GET _nodes/<node-name>/hot_threads

Para mais informações, consulte a API de hot threads no site do Elasticsearch.

Exemplo de saída de hot threads de nós:

<percentage> of cpu usage by thread 'opensearch[<nodeName>][<thread-name>]'

O nome do thread indica quais processos do OpenSearch Service estão consumindo muita CPU.

Para mais informações, consulte a API de hot threads de nós no site do Elasticsearch.

Verificar a operação de gravação ou o grupo de threads da API em massa

Um erro 429 no OpenSearch Service pode indicar que seu cluster está lidando com muitas solicitações de indexação em massa. Quando há picos constantes de CPU no seu cluster, o OpenSearch Service rejeita as solicitações de indexação em massa.

O grupo de threads de gravação lida com solicitações de indexação, que incluem operações de API em massa. Para confirmar se seu cluster está lidando com muitas solicitações de indexação em massa, verifique a métrica IndexingRate no Amazon CloudWatch.

Se o seu cluster estiver lidando com muitas solicitações de indexação em massa, considere as seguintes abordagens:

Reduza o número de solicitações em massa em seu cluster.
Reduza o tamanho de cada solicitação em massa, para que seus nós possam processá-la com mais eficiência.
Se o Logstash for usado para enviar dados ao cluster do OpenSearch Service, reduza o tamanho do lote ou o número de trabalhadores.
Se a taxa de ingestão do seu cluster diminuir, escale-o (na horizontal ou vertical). Para ampliar seu cluster, aumente o número de nós e o tipo de instância para que o OpenSearch Service possa processar as solicitações recebidas.

Para mais informações, consulte API em massa no site do Elasticsearch.

Verificar o grupo de threads de pesquisa

Um grupo de threads de pesquisa que consome muita CPU indica que as consultas de pesquisa estão sobrecarregando seu cluster do OpenSearch Service. Seu cluster pode ser sobrecarregado por uma única consulta de longa duração. Um aumento nas consultas realizadas pelo seu cluster também pode afetar seu grupo de threads de pesquisa.

Para verificar se uma única consulta está aumentando o uso da CPU, use a API gerenciamento de tarefa. Por exemplo:

GET _tasks?actions=*search&detailed

A API de gerenciamento de tarefas obtém todas as consultas de pesquisa ativas em execução no seu cluster. Para mais informações, consulte a API de gerenciamento de tarefas no site do Elasticsearch.

Observação: a saída só inclui o campo de descrição se houver uma tarefa de pesquisa listada pela API de gerenciamento de tarefas.

Exemplos de resultado:

{
    "nodes": {
        "U4M_p_x2Rg6YqLujeInPOw": {
            "name": "U4M_p_x",
            "roles": [
                "data",
                "ingest"
            ],
            "tasks": {
                "U4M_p_x2Rg6YqLujeInPOw:53506997": {
                    "node": "U4M_p_x2Rg6YqLujeInPOw",
                    "id": 53506997,
                    "type": "transport",
                    "action": "indices:data/read/search",
                    "description": """indices[*], types[], search_type[QUERY_THEN_FETCH], source[{"size":10000,"query":{"match_all":{"boost":1.0}}}]""",
                    "start_time_in_millis": 1541423217801,
                    "running_time_in_nanos": 1549433628,
                    "cancellable": true,
                    "headers": {}
                }
            }
        }
    }
}

Verifique o campo de descrição para identificar qual consulta é executada. O campo running_time_in_nanos indica a quantidade de tempo em que uma consulta está sendo executada. Para diminuir o uso da CPU, cancele a consulta de pesquisa que está consumindo muita CPU. A API de gerenciamento de tarefas também oferece suporte a uma chamada _cancel.

Observação: certifique-se de registrar o ID da tarefa da sua saída para cancelar uma tarefa específica. Neste exemplo, o ID da tarefa é "U4M_p_x2Rg6YqLujeInPOw:53506997".

Exemplo de chamada POST de gerenciamento de tarefas:

POST _tasks/U4M_p_x2Rg6YqLujeInPOw:53506997/_cancel

A chamada POST de gerenciamento de tarefas marca a tarefa como "cancelada", liberando todos os recursos dependentes da AWS. Se você tiver várias consultas em execução no seu cluster, use a chamada POST para cancelar as consultas uma por vez. Cancele cada consulta até que seu cluster retorne ao estado normal. Também é uma prática recomendada definir um valor de tempo limite no corpo da consulta para evitar altos picos de CPU. Para mais informações, consulte Parâmetros de pesquisa do corpo da solicitação no site do Elasticsearch. Para verificar se o número de consultas ativas diminuiu, verifique a métrica SearchRate no Amazon CloudWatch.

Observação: cancelar todas as consultas de pesquisa ativas ao mesmo tempo em seu cluster do OpenSearch Service pode causar erros no lado da aplicação cliente.

Para mais informações, consulte Grupos de tópicos no site do Elasticsearch.

Verificar o grupo de threads de mesclagem do Apache Lucene

O OpenSearch Service usa o Apache Lucene para indexar e pesquisar documentos no seu cluster. O Apache Lucene executa operações de mesclagem para reduzir o número efetivo de segmentos necessários para cada fragmento e para remover quaisquer documentos excluídos. Esse processo é executado sempre que novos segmentos são criados em um fragmento.

Se você observar uma operação de thread de mesclagem do Apache Lucene afetando o uso da CPU, aumente a configuração refresh_interval dos índices de cluster do OpenSearch Service. O aumento na configuração refresh_interval retarda a criação de segmentos do seu cluster.

Observação: um cluster que está migrando índices para o armazenamento UltraWarm pode aumentar a utilização da CPU. Uma migração UltraWarm geralmente envolve uma operação de API de mesclagem forçada, que pode consumir muita CPU.

Para verificar as migrações UltraWarm, use o seguinte comando:

GET _ultrawarm/migration/_status?v

Para mais informações, consulte Mesclagem no site do Elasticsearch.

Verificar a pressão da memória da JVM

Analise a porcentagem de pressão de memória da JVM do heap Java em um nó de cluster. Se a pressão de memória da JVM atingir 75%, o Amazon OpenSearch Service acionará o coletor de lixo Concurrent Mark Sweep (CMS). Se a pressão de memória da JVM atingir 100%, a JVM do OpenSearch Service será configurada para encerramento e, eventualmente, será reiniciada em OutOfMemory (OOM).

No log de exemplo a seguir, a JVM está dentro da faixa recomendada, mas o cluster é afetado pela coleta de resíduos de longa duração:

[2022-06-28T10:08:12,066][WARN ][o.o.m.j.JvmGcMonitorService]
[515f8f06f23327e6df3aad7b2863bb1f] [gc][6447732] overhead, spent [9.3s]
collecting in the last [10.2s]

Para mais informações, consulte Como solucionar problemas de alta pressão de memória da JVM no meu cluster do Amazon OpenSearch Service?

Revisar sua estratégia de fragmentação

Dependendo do tamanho do cluster, sua performance pode diminuir com muitos fragmentos. É uma prática recomendada não ter mais de 25 fragmentos por GiB de pilha Java.

Por padrão, o Amazon OpenSearch Service tem uma estratégia de fragmentação de 5:1, em que cada índice é dividido em cinco fragmentos principais. Em cada índice, cada fragmento primário também tem sua própria réplica. O OpenSearch Service atribui automaticamente fragmentos primários e fragmentos de réplica a nós de dados separados e garante que haja um backup em caso de falha.

Para mais informações, consulte Como rebalancear a distribuição desigual de fragmentos no meu cluster do Amazon OpenSearch Service?

Otimizar suas consultas

Agregações pesadas, consultas de curingas (especialmente curingas principais) e consultas regex podem ser computacionalmente caras e causar picos na utilização da CPU. Pesquisar registros lentos e indexar logs lentos pode ajudar você a diagnosticar consultas caras e problemáticas.

Para mais informações, consulte Monitorar logs do OpenSearch com o Amazon CloudWatch Logs.