Otimização de Desempenho RHEL: Guia Completo com Tuned, Nice e Renice

Introdução

Neste laboratório, você aprenderá como otimizar o desempenho do sistema RHEL usando tuned e gerenciar as prioridades dos processos com nice e renice. Você começará verificando a instalação do tuned e listando os perfis disponíveis, em seguida, observará como a alteração dos perfis tuned impacta os parâmetros do sistema.

O laboratório irá guiá-lo através do início e monitoramento de processos intensivos em CPU, seguido pelo ajuste de suas prioridades usando nice e renice para entender seu efeito na alocação de recursos. Finalmente, você aprenderá como limpar os processos em execução, garantindo uma compreensão completa da otimização de desempenho no RHEL.

Este é um Lab Guiado, que fornece instruções passo a passo para ajudá-lo a aprender e praticar. Siga as instruções cuidadosamente para completar cada etapa e ganhar experiência prática. Dados históricos mostram que este é um laboratório de nível iniciante com uma taxa de conclusão de 91%. Recebeu uma taxa de avaliações positivas de 99% dos estudantes.

Verificar o Status do Tuned e Listar Perfis Disponíveis

Nesta etapa, você aprenderá como verificar o status do daemon tuned e listar os perfis de ajuste disponíveis no seu sistema RHEL. tuned é um daemon de ajuste de sistema adaptável dinâmico que ajusta as configurações do sistema para otimizar o desempenho para cargas de trabalho específicas. Ele usa perfis de ajuste para aplicar um conjunto de configurações em todo o sistema.

Verifique se o daemon tuned está em execução.
Neste ambiente de contêiner, verificaremos se o daemon tuned está em execução procurando seu processo. Também podemos verificar sua funcionalidade verificando se ele responde a comandos.

Primeiro, verifique se o processo tuned está em execução:
```
pgrep tuned
```
Se tuned estiver em execução, este comando retornará seu ID de Processo (PID). Se nenhum PID for retornado, você pode iniciar o daemon manualmente:
```
sudo /usr/sbin/tuned &
```
Em seguida, verifique se está em execução:
```
pgrep tuned
```
Você deve ver uma saída semelhante a:
```
739
```
(Observação: O valor do PID na sua saída irá variar.)

Adicionalmente, você pode verificar se tuned é funcional verificando se ele responde a consultas de status:
```
sudo tuned-adm active
```
Isso deve retornar o perfil atualmente ativo sem erros.

Liste os perfis de ajuste disponíveis e identifique o perfil ativo.
O comando tuned-adm list exibe todos os perfis de ajuste disponíveis e destaca o perfil atualmente ativo.

sudo tuned-adm list

Você será solicitado a inserir sua senha. Observe o Current active profile na saída.

Available profiles:
- accelerator-performance     - Throughput performance based tuning with disabled higher latency STOP states
- aws                         - Optimize for aws ec2 instances
- balanced                    - General non-specialized tuned profile
- balanced-battery            - Balanced profile biased towards power savings changes for battery
- desktop                     - Optimize for the desktop use-case
- hpc-compute                 - Optimize for HPC compute workloads
- intel-sst                   - Configure for Intel Speed Select Base Frequency
- latency-performance         - Optimize for deterministic performance at the cost of increased power consumption
- network-latency             - Optimize for deterministic performance at the cost of increased power consumption, focused on low latency network performance
- network-throughput          - Optimize for streaming network throughput, generally only necessary on older CPUs or 40G+ networks
- optimize-serial-console     - Optimize for serial console use.
- powersave                   - Optimize for low power consumption
- throughput-performance      - Broadly applicable tuning that provides excellent performance across a variety of common server workloads
- virtual-guest               - Optimize for running inside a virtual guest
- virtual-host                - Optimize for running KVM guests
Current active profile: virtual-guest

Revise a configuração do perfil virtual-guest.
O perfil virtual-guest é frequentemente o padrão para máquinas virtuais. Você pode inspecionar seu arquivo de configuração para entender quais configurações ele aplica.

cat /usr/lib/tuned/virtual-guest/tuned.conf

Este comando mostra a configuração tuned para o perfil virtual-guest, incluindo os parâmetros que ele herda de outros perfis.

#
## tuned configuration
#

[main]
summary=Optimize for running inside a virtual guest
include=throughput-performance

[vm]
## If a workload mostly uses anonymous memory and it hits this limit, the entire
## working set is buffered for I/O, and any more write buffering would require
## swapping, so it's time to throttle writes until I/O can catch up.  Workloads
## that mostly use file mappings may be able to use even higher values.
#
## The generator of dirty data starts writeback at this percentage (system default
## is 20%)
dirty_ratio = 30

[sysctl]
## Filesystem I/O is usually much more efficient than swapping, so try to keep
## swapping low.  It's usually safe to go even lower than this on systems with
## server-grade storage.
vm.swappiness = 30

Verifique se o parâmetro vm.dirty_background_ratio é aplicado.
O perfil virtual-guest inclui throughput-performance. Vamos verificar um parâmetro que throughput-performance normalmente define, como vm.dirty_background_ratio. Este parâmetro controla quando o sistema começa a escrever páginas sujas no disco em segundo plano.
```
sysctl vm.dirty_background_ratio
```
A saída mostrará o valor atual deste parâmetro do kernel.
```
vm.dirty_background_ratio = 10
```

Alterar o Perfil Tuned e Observar as Mudanças nos Parâmetros do Sistema

Nesta etapa, você aprenderá como alterar o perfil tuned ativo e observar os efeitos imediatos nos parâmetros do sistema. A alteração de um perfil tuned permite que você aplique rapidamente um conjunto de otimizações de desempenho adaptadas para diferentes cargas de trabalho, como tarefas intensivas em throughput ou economia de energia.

Altere o perfil de ajuste ativo atual para throughput-performance.
O perfil throughput-performance é projetado para sistemas que exigem alto throughput, muitas vezes sacrificando um pouco de latência. Ele normalmente otimiza para I/O de disco e desempenho de rede. Use o comando tuned-adm profile para alternar os perfis.
```
sudo tuned-adm profile throughput-performance
```
Você será solicitado a inserir sua senha.
```
$ sudo tuned-adm profile throughput-performance
[sudo] password for user:
```
Confirme o novo perfil ativo.
Após alterar o perfil, é uma boa prática verificar se o novo perfil está realmente ativo. Você pode fazer isso usando tuned-adm active.
```
sudo tuned-adm active
```
A saída agora deve mostrar throughput-performance como o perfil ativo.
```
Current active profile: throughput-performance
```
Verifique se os parâmetros vm.dirty_ratio e vm.swappiness foram alterados.
O perfil throughput-performance modifica os parâmetros do kernel relacionados ao gerenciamento de memória, como vm.dirty_ratio e vm.swappiness. Embora o perfil virtual-guest herde de throughput-performance, a troca direta para o perfil throughput-performance aplica os valores base sem as modificações específicas do virtual-guest.
- vm.dirty_ratio: Este parâmetro define a porcentagem máxima da memória do sistema que pode ser preenchida com páginas sujas (páginas que foram modificadas, mas ainda não foram escritas no disco) antes que o sistema comece a escrevê-las no disco. Um valor mais alto pode melhorar o throughput, permitindo que mais dados sejam armazenados em buffer na memória.
- vm.swappiness: Este parâmetro controla com que agressividade o kernel troca a memória anônima (dados do aplicativo) da RAM para o espaço de swap. Um valor mais baixo significa que o kernel tentará manter mais dados do aplicativo na RAM, o que geralmente é melhor para o desempenho.
Vamos verificar seus valores atuais usando sysctl.
```
sysctl vm.dirty_ratio
sysctl vm.swappiness
```
Você deve observar que os valores foram alterados das configurações do perfil virtual-guest (dirty_ratio = 30, vm.swappiness = 30) para os valores base do perfil throughput-performance:
```
vm.dirty_ratio = 40
vm.swappiness = 10
```
(Observação: Esses valores refletem as otimizações base de throughput-performance sem as modificações específicas do virtual-guest.)

Iniciar e Monitorar Processos Intensivos em CPU no RHEL

Nesta etapa, você aprenderá como iniciar processos intensivos em CPU e monitorar o uso de seus recursos. Isso é crucial para entender como os processos consomem recursos do sistema e como identificar gargalos. Usaremos o comando sha1sum /dev/zero, que calcula continuamente a soma de verificação SHA1 de um fluxo infinito de zeros, consumindo efetivamente ciclos de CPU.

Importante: Este exercício usa comandos que executam somas de verificação infinitas em um arquivo de dispositivo, consumindo intencionalmente recursos significativos da CPU. Você deve encerrar todos os processos do exercício antes de sair deste exercício ou passar para o próximo laboratório.

Determine o número de núcleos de CPU em seu sistema.
Entender o número de núcleos de CPU ajuda você a decidir quantos processos intensivos em CPU executar para utilizar totalmente o sistema. Você pode encontrar esta informação em /proc/cpuinfo.
```
grep -c '^processor' /proc/cpuinfo
```
Este comando conta o número de linhas que começam com processor, que corresponde ao número de núcleos de CPU lógicos (ou processadores virtuais).
```
2
```
(Observação: Sua saída pode mostrar um número diferente de núcleos, dependendo da configuração do sistema.)
Inicie duas instâncias do comando sha1sum /dev/zero & para cada núcleo de CPU.
Para simular um sistema com alta carga, iniciaremos várias instâncias de sha1sum /dev/zero &. O & no final do comando executa o processo em segundo plano, permitindo que você continue usando o terminal. Por exemplo, se você tiver 2 núcleos de CPU, iniciaria 4 instâncias (2 instâncias/núcleo * 2 núcleos).
```
for i in $(seq 1 $(grep -c '^processor' /proc/cpuinfo | awk '{print $1 * 2}')); do sha1sum /dev/zero & done
```
Este comando calcula dinamicamente o número de processos a serem iniciados com base na contagem de núcleos da sua CPU.
```
[1] 1234
[2] 1235
[3] 1236
[4] 1237
```
(Observação: Os valores de PID na sua saída variarão do exemplo.)
Verifique se os trabalhos em segundo plano estão em execução.
O comando jobs lista todos os processos atualmente em execução em segundo plano da sua sessão de shell.
```
jobs
```
Você deve ver uma lista dos processos sha1sum que acabou de iniciar.
```
[1]   Running                 sha1sum /dev/zero &
[2]   Running                 sha1sum /dev/zero &
[3]   Running                 sha1sum /dev/zero &
[4]-  Running                 sha1sum /dev/zero &
```
Use os comandos ps e pgrep para exibir a porcentagem de uso da CPU para cada processo sha1sum.
O comando ps relata um instantâneo dos processos atuais. Vamos combiná-lo com pgrep para filtrar os processos sha1sum.
- ps -o pid,pcpu,nice,comm: Isso especifica o formato de saída: ID do Processo (pid), porcentagem de uso da CPU (pcpu), valor nice (nice) e nome do comando (comm).
- $(pgrep sha1sum): Esta substituição de comando encontra os PIDs de todos os processos chamados sha1sum e os passa como argumentos para ps.
```
ps -o pid,pcpu,nice,comm $(pgrep sha1sum)
```
Você deve ver cada processo sha1sum consumindo uma porcentagem significativa da CPU.
```
    PID %CPU  NI COMMAND
   5248 48.8   0 sha1sum
   5249 48.7   0 sha1sum
   5250 48.8   0 sha1sum
   5251 48.8   0 sha1sum
```
(Observação: Os valores de %CPU podem flutuar, mas devem ser altos, indicando uso intenso da CPU. A coluna NI mostra o valor nice.)
Encerre todos os processos sha1sum em execução e verifique se nenhum restou.
É crucial limpar esses processos intensivos em CPU antes de prosseguir. O comando pkill encerra processos com base em seus nomes.
```
pkill sha1sum
```
Agora, verifique se nenhum trabalho sha1sum está em execução em segundo plano.
```
jobs
```
A saída deve estar vazia ou indicar que todos os trabalhos foram encerrados.
```
[1]   Terminated              sha1sum /dev/zero
[2]   Terminated              sha1sum /dev/zero
[3]   Terminated              sha1sum /dev/zero
[4]-  Terminated              sha1sum /dev/zero
```
(Observação: Você pode ver mensagens "Terminated", o que é esperado, pois os processos estão sendo interrompidos.)

Ajustar a Prioridade de Processos com nice e renice no RHEL

Nesta etapa, você aprenderá como influenciar a prioridade de agendamento de processos usando os comandos nice e renice. O valor nice (também conhecido como niceness) de um processo indica sua prioridade para o agendador Linux. Um valor nice mais baixo (mais negativo) significa maior prioridade, enquanto um valor nice mais alto (mais positivo) significa menor prioridade. A faixa para valores nice é tipicamente de -20 (maior prioridade) a 19 (menor prioridade), com 0 sendo o padrão.

Inicie várias instâncias de sha1sum /dev/zero & e, em seguida, inicie uma instância adicional com um nível nice de 10.
Iniciaremos vários processos sha1sum para simular um sistema ocupado. Em seguida, iniciaremos um com uma prioridade deliberadamente mais baixa (valor nice mais alto) para observar o efeito.

Primeiro, inicie três instâncias regulares (ajuste com base na contagem de núcleos da sua CPU, se desejar, mas pelo menos tantas quanto processadores virtuais para criar contenção):
```
for i in {1..3}; do sha1sum /dev/zero & done
```
Em seguida, inicie a quarta instância com um nível nice de 10. Este processo terá uma prioridade mais baixa em comparação com os outros.
```
nice -n 10 sha1sum /dev/zero &
```
Você verá uma saída semelhante a esta, indicando os PIDs dos processos em segundo plano:
```
[1] 5443
[2] 5444
[3] 5445
[4] 5446
```
(Observação: Os valores de PID na sua saída variarão.)
Use os comandos ps e pgrep para exibir o PID, a porcentagem de uso da CPU, o valor nice e o nome do executável para cada processo.
Observe as colunas %CPU e NI. A instância com o valor nice de 10 deve exibir uma porcentagem de uso da CPU menor do que as outras instâncias, pois o agendador lhe dá menos tempo de CPU.
```
ps -o pid,pcpu,nice,comm $(pgrep sha1sum)
```
Procure o processo com o valor NI de 10. Seu %CPU deve ser visivelmente menor do que os outros.
```
    PID %CPU  NI COMMAND
   5443 56.8   0 sha1sum
   5444 58.0   0 sha1sum
   5445 56.5   0 sha1sum
   5446  6.7  10 sha1sum
```
(Observação: Os valores exatos de %CPU variarão com base na carga do sistema e na contagem de núcleos, mas o processo com nice 10 deve ter uma participação menor.)
Use o comando sudo renice para alterar o nível nice de um dos processos regulares para 5.
O comando renice permite que você altere o valor nice de um processo já em execução. Demonstraremos isso alterando um dos processos regulares (valor nice 0) para um valor nice de 5.

Primeiro, identifique o PID de um dos processos sha1sum que tem um valor nice de 0 na saída do comando ps anterior. Vamos usar o primeiro do exemplo acima (PID 5443).
```
sudo renice -n 5 <PID_of_regular_process>
```
Substitua <PID_of_regular_process> pelo PID real que você identificou. Por exemplo:
```
sudo renice -n 5 5443
```
Você deve ver a saída confirmando a alteração da prioridade:
```
5443 (process ID) old priority 0, new priority 5
```
Repita os comandos ps e pgrep para exibir a porcentagem da CPU e o nível nice.
Observe a mudança no uso da CPU para o processo cujo valor nice você modificou. O processo com valor nice 5 agora deve ter um uso de CPU ligeiramente menor em comparação com os processos com valor nice 0, mas maior do que o processo com valor nice 10.
```
ps -o pid,pcpu,nice,comm $(pgrep sha1sum)
```
Você deve ver que o valor NI para o processo modificado agora é 5, e seu uso da CPU reflete seu novo nível de prioridade.
```
    PID %CPU  NI COMMAND
   5443 55.4   5 sha1sum
   5444 67.2   0 sha1sum
   5445 67.1   0 sha1sum
   5446  7.5  10 sha1sum
```
(Observação: Os valores exatos de %CPU variarão, mas você deve observar que os processos com valores nice mais baixos (maior prioridade) recebem mais tempo de CPU.)

Limpar Processos em Execução

Nesta etapa final, você garantirá que todos os processos em segundo plano iniciados durante o laboratório sejam devidamente encerrados. Esta é uma etapa crítica de limpeza para evitar o consumo não intencional de recursos e garantir que o ambiente do laboratório seja redefinido para uso futuro.

Use o comando pkill para encerrar todos os processos em execução com o padrão de nome sha1sum.
O comando pkill é uma maneira eficiente de enviar um sinal (por padrão, SIGTERM) para processos com base em seus nomes. Isso interromperá todos os processos sha1sum que você iniciou nas etapas anteriores.
```
pkill sha1sum
```
Você pode ver mensagens indicando que os processos foram encerrados.
```
[3]-  Terminated              sha1sum /dev/zero
[2]-  Terminated              sha1sum /dev/zero
[4]+  Terminated              nice -n 10 sha1sum /dev/zero
[1]+  Terminated              sha1sum /dev/zero
```
Verifique se nenhum processo sha1sum ainda está em execução.
Você pode usar pgrep para verificar se algum processo sha1sum ainda está ativo. Se pgrep não retornar nenhuma saída, significa que nenhum processo desse tipo está em execução.
```
pgrep sha1sum
```
Este comando não deve retornar nenhuma saída, indicando que todos os processos sha1sum foram encerrados com sucesso.
```
$ pgrep sha1sum
$
```

Resumo

Neste laboratório, aprendemos como gerenciar e utilizar o tuned para otimização do desempenho do sistema no RHEL. Começamos verificando a instalação e o status do serviço tuned e listando os perfis de ajuste disponíveis, entendendo que o tuned adapta dinamicamente as configurações do sistema para cargas de trabalho específicas usando esses perfis. Em seguida, praticamos o login em um ambiente servera simulado via SSH como o usuário labex e confirmamos a instalação do pacote tuned usando dnf list tuned.

O laboratório nos guiou ainda pela alteração dos perfis tuned para observar seu impacto nos parâmetros do sistema, demonstrando como diferentes perfis podem alterar o comportamento do sistema. Também ganhamos experiência prática em iniciar e monitorar processos intensivos em CPU, o que é crucial para identificar gargalos de desempenho. Por fim, aprendemos a ajustar as prioridades dos processos usando os comandos nice e renice para gerenciar a alocação de recursos de forma eficaz e concluímos limpando os processos em execução para restaurar o sistema ao seu estado inicial.

Otimizar o Desempenho do Sistema no RHEL