Fala pessoal! Neste post trago mais um tutorial sobre uma ferramenta muito útil e versátil no Linux, que é o comando lshw (List Hardware). Trata-se de um utilitário que permite exibir informações detalhadas sobre o hardware de um computador que esteja rodando um sistema Linux qualquer.

Esse comando mostra especificações de componentes como CPU, memória, armazenamento, dispositivos de rede, entre muitos outros.

Vejamos como ele funciona e exemplos de uso.

O que é o lshw?

Sucintamente, o lshw é uma ferramenta de linha de comandos que fornece uma descrição detalhada do hardware instalado em um sistema Linux.

Instalação do lshw

Geralmente a ferramenta vem instalada nas diversas distribuições Linux, mas eventualmente ela pode não estar disponível por padrão. Se for necessário instalá-la, execute um dos comandos a seguir, dependendo de sua distro:

$ sudo apt install lshw # Distribuições baseadas em Debian/Ubuntu
$ sudo yum install lshw # Distribuições baseadas em Red Hat/CentOS

Observação Para exibir informações completas sobre o sistema, recomenda-se executar a ferramenta com privilégios de superusuário (sudo).

Sintaxe básica do lshw

$ lshw [opções]

Opções comuns:

• -short: Mostra um resumo compacto das informações.
• -C <classe>: Exibe apenas informações sobre uma classe de hardware (ex.: processor, disk). Ver abaixo as classes disponíveis.
• -quiet: Suprime mensagens de erro.
• -json: Produz saída em formato JSON (se suportado).
• -xml: Produz saída em formato XML.

Classes de hardware disponíveis

O lshw organiza o hardware em classes. Algumas classes comuns são:

• processor: Mostra informações sobre a CPU.
• memory: Detalhes da RAM e cache.
• disk: Informações sobre discos.
• network: Detalhes das interfaces de rede.
• display: Informações sobre a GPU.
• storage: Controladores de armazenamento.

Exemplos de uso do lshw

Vejamos alguns exemplos de uso do lshw para consultar informações sobre o hardware do computador.

Mostrar informações completas do hardware

$ sudo lshw

A execução do lshw sem nenhuma opção produz uma saída com informações sobre CPU, memória, armazenamento, placas de rede, etc.

Saída típica:

description: Laptop
product: Inspiron 15 (Inspiron 3543)
vendor: Dell Inc.
width: 64 bits
capabilities: smbios-2.8 dmi-2.8 smp vsyscall32

Dica: Use o lshw combinado com ferramentas como o paginador less para facilitar a navegação na saída apresentada, como segue:

$ sudo lshw | less

Mostrar informações resumidas

Usamos a opção -short para exibir uma saída mais compacta:

$ sudo lshw -short

Saída típica:

H/W path Device Class Description
====================================================
/0 system Inspiron 3543
/0/0 memory 64KiB BIOS
/0/4 processor Intel(R) Core(TM) i5-5200U
/0/5 memory 8GiB System Memory
/0/5/0 memory 4GiB SODIMM DDR3
/0/5/1 memory 4GiB SODIMM DDR3

Mostrar informações específicas

Podemos filtrar informações para exibir apenas um tipo específico de hardware, como CPU, Rede ou Memória, entre outros.

1. Filtrar por CPU:

$ sudo lshw -C processor

Saída:

*-cpu
description: CPU
product: Intel(R) Core(TM) i5-5200U CPU @ 2.20GHz
vendor: Intel Corp.
physical id: 4
clock: 2200MHz

2. Filtrar por Memória:

$ sudo lshw -C memory

Saída:

*-memory
description: System Memory
size: 8GiB

3. Filtrar por Rede:

$ sudo lshw -C network

Saída:

*-network
description: Wireless interface
product: Wireless 7265
vendor: Intel Corporation
logical name: wlan0
capabilities: ethernet physical wireless

4. Filtrar por discos:

$ sudo lshw -C disk

Saída:

*-disk
description: ATA Disk
product: ST1000LM024 HN-M
size: 931GiB

Salvar a saída em um arquivo

Para analisar as informações posteriormente, é possível salvar a saída gerada pelo comando em um arquivo de texto simples:

1. Salvar a saída completa:

$ sudo lshw > hardware_info.txt

Assim, o conteúdo gerado pelo lshw será salvo no arquivo de nome hardware_info.txt (claro que você pode dar o nome que quiser ao arquivo!)

2. Saída resumida:

$ sudo lshw -short > hardware_summary.txt

Exibir saída em formato XML ou JSON

Também é possível exibir a saída gerado em um formato de intercâmbio de dados, como XML ou JSON, que pode alimentar outras aplicações ou scripts.

1. Formato XML:

$ sudo lshw -xml

Essa opção é útil para integrar informações em sistemas ou relatórios automatizados.

2. Formato JSON (depende da versão do lshw):

$ sudo lshw -json

Conclusão

O comando lshw é uma ferramenta simples e versátil usada para listar informações detalhadas sobre o hardware de um sistema Linux. Ele é bastante útil para ajudar a efetuar diagnósticos de problemas, criar inventário de hardware e realizar verificações de compatibilidade.

Para uso rápido e básico, a opção -short fornece uma visão geral rápida, enquanto as opções mais específicas ajudam a detalhar componentes individuais como CPU, memória, ou rede.

Colabore com a Bóson Treinamentos

Ajude o canal adquirindo meus cursos na Udemy:

• Bancos de Dados com MySQL Básico: https://bit.ly/35QdWE4
• Lógica de Programação com Português Estruturado: https://bit.ly/3QKPn22
• Programação em Python do Zero: https://bit.ly/python-boson

Adquira também livros e outros itens na loja da Bóson Treinamentos na Amazon e ajude o canal a se manter e crescer: https://www.amazon.com.br/shop/bosontreinamentos

O post Obter informações sobre hardware da máquina com comando lshw no Linux apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste tutorial veremos como realizar a instalação do popular navegador Google Chrome no sistema operacional Linux Mint e similares, por meio de comandos do terminal.

Por padrão, o Mint traz como navegador pré-instalado o Mozilla Firefox, mas não traz o Chrome, e caso você queira ou precise utilizar essa opção de navegador, deve instalá-la manualmente no sistema

Vamos aos passos para realizar a instalação do Chrome no Linux.

Atualizar o sistema

Antes de iniciar, vamos atualizar a lista de repositórios e os pacotes do sistema, para garantir que todas as versões dos pacotes instalados sejam as mais recentes:

$ sudo apt update && sudo apt upgrade

Dependendo da quantidade de pacotes a atualizar o sistema pode levar algum tempo até finalizar todo o processo. Apenas aguarde.

Desta forma também diminuimos a chance de ocorrer algum problema de compatibilidade entre pacotes ao instalar o Chrome.

Pacotes necessários

Vamos também instalar alguns pacotes que serão necessários para arealizar a instalação do Chrome, como o pacote curl. Pode ser que você já tenha esses pacotes instalados no sistema, mas por via das dúvidas executamos o comando a seguir para instalá-los:

$ sudo apt install software-properties-common apt-transport-https ca-certificates curl -y

Esses pacotes tem as seguintes funções no sistema:

• software-properties-common: Fornece ferramentas para gerenciar repositórios de software no Linux, como add-apt-repository.
• apt-transport-https: Habilita o uso de HTTPS como protocolo para repositórios no apt.
• ca-certificates: Fornece certificados SSL/TLS confiáveis para conexões seguras.
• curl: Ferramenta para transferir dados de ou para servidores usando vários protocolos (HTTP, HTTPS, FTP, etc.).

Chave GPG e Repositório APT do Chrome

O próximo passo na instalação do Google Chrome no Linux é importar a chave GPG para assinatura digital dos pacotes, e configurar o repositório APT do navegador. Faremos isso em dois passos:

1. Importar chave GPG

Para a chave de criptografia GPG do Chrome execute o comando a seguir:

$ curl -fSsL https://dl.google.com/linux/linux_signing_key.pub | sudo gpg --dearmor | sudo tee /usr/share/keyrings/google-chrome.gpg >> /dev/null

Neste comando, a instrução curl -fSsL baixa conteúdo da URL passada usando as seguintes opções:

-f: Retorna erro em caso de falha HTTP.
-S: Mostra mensagens de erro detalhadas.
-s: Suprime saída do progresso.
-L: Segue redirecionamentos.

Já a instrução gpg –dearmor converte o arquivo de chave pública GPG de texto (ASCII) para um formato binário (.gpg), usado em sistemas como repositórios.

E, finalmente, a instrução tee /usr/share/keyrings/google-chrome.gpg  >> /dev/null redireciona a saída para o arquivo google-chrome.gpg e descarta a saída no terminal (dispositivo /dev/null), para evitar exibição de informações desnecessária no terminal.

2. Configurar repositório do Chrome

Para configurar o repositório do Chrome execute o comando a seguir:

$ echo 'deb [arch=amd64 signed-by=/usr/share/keyrings/google-chrome.gpg] http://dl.google.com/linux/chrome/deb/ stable main' | sudo tee /etc/apt/sources.list.d/google-chrome.list

Opcionalmente, podemos conferir a configuração do repositório:

$ less /etc/apt/sources.list.d/google-chrome.list

Na sequência, atualizamos a lista de repositórios do APT novamente:

$ sudo apt update

Instalação do pacote do Google Chrome

Finalmente, realizamos a instalação do pacote do Google Chrome no Linux com o comando a seguir:

$ sudo apt install google-chrome-stable

Basta aguardar enquanto o download do navegador Chrome é realizado e os pacotes instalados.

Testar o Google Chrome

Para abrir o navegador após a instalação, podemos executar o comando a seguir no terminal:

$ google-chrome-stable

Ou simplesmente clicar no atalho que foi criado automaticamente na GUI em Menu → Internet → Google Chrome.

Ao abrir o Chrome pela primeira vez, uma caixa de diálogo lhe perguntará se você quer tornar o Google Chrome o navegador padrão do sistema, e se você deseja permitir o envio automático de estatísticas de uso e bugs da aplicação para os desenvolvedores. Escolha o que melhor lhe aprouver, e clique em OK para continuar.

Na sequência, você pode optar por se logar na sua conta do Google ou não:

E, finalmente, clique em “Entendi” na tela de aviso de privacidade dos anúncios do Chrome para começar a usar o navegador:

É isso aí! Instalação do Google Chrome no Linux Mint realizada com sucesso!

Remover o Google Chrome do Linux

Se, por algum motivo, você quiser desinstalar o Google Chrome do Linux, execute o seguinte comando no terminal:

$ sudo apt remove google-chrome-stable --purge

Você também pode remover o repositório APT que foi configurado anteriormente:

$ sudo rm /etc/apt/sources.list.d/google-chrome.list

Conclusão

Neste tutorial vimos como efetuar a instalação do navegador Google Chrome no Linux, uma tarefa simples que envolve a execução de alguns comandos no terminal do sistema. Nos próximos tutoriais vamos aprender a instalar outras opções de browsers no Linux, como os navegadores Vivaldi, Bravo e o Tor Browser, entre outros.

Colabore com a Bóson Treinamentos

Ajude o canal adquirindo meus cursos na Udemy:

• Bancos de Dados com MySQL Básico: https://bit.ly/35QdWE4
• Lógica de Programação com Português Estruturado: https://bit.ly/3QKPn22
• Programação em Python do Zero: https://bit.ly/python-boson

Adquira também livros e outros itens na loja da Bóson Treinamentos na Amazon e ajude o canal a se manter e crescer: https://www.amazon.com.br/shop/bosontreinamentos

O post Como instalar o Google Chrome no Linux Mint e similares apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste tutorial apresento uma ferramenta para Linux bastante útil e simples de usar: o utilitário inxi.

O inxi é um script de linha de comandos escrito em linguagem Perl por Harald Hope que fornece informações sobre o sistema Linux (como informações de hardware da máquina). Trata-se de um fork (projeto derivado) do utilitário infobash, o qual por sua vez foi desenvolvido por Michiel de Boer (locsmif).

A página oficial do projeto na Internet é https://smxi.org/docs/inxi.htm.

Geralmente essa ferramenta já está disponível no sistema, mas se por acaso sua distribuição não a trouxer instalada por padrão, basta usar o gerenciador de pacotes adequado para obtê-la, com segue:

Instalação do inxi

Para Debian, Ubuntu, Linux Mint e similares:

$ sudo apt install inxi

No Fedora e distribuições baseadas em RHEL8:

$ sudo dnf install -y inxi

O inxi é um comando?

Tecnicamente, o inxi é um script, ou seja, um arquivo que contém código escruito em uma linguagem de programação (no caso, o Perl) que o shell interpreta e e executa como se fosse um comando binário. Para todos os efeitos, o usamos como um comando comum. Podemos descobrir a localização do script no sistema usando o comando whereis:

$ whereis inxi

No geral, o inxi está localizado no caminho /usr/bin/inxi (pode estar em outro lugar em seu sistema).

Podemos ver que se trata de um script executável:

$ ls -l /usr/bin/inxi

Saída:

-rwxr-xr-x 1 root root 1065851 fev 25 2022 /usr/bin/inxi

E, como se trata de um script, é possível ler (ou até mesmo alterar) seu conteúdo usando um editor de textos ou um comando como o less:

$ less /usr/bin/inxi

O código exibido estará na linguagem Perl, que é muito usada na construção de scripts e ferramentas de linha de comando, por exemplo, para monitoramento ou automação de sistemas Linux.

Como usar o inxi

Vejamos alguns exemplos de como usar o comando inxi no Linux.

Obter uma visão básica resumida do sistema

$ inxi

Neste exemplo foram retornadas informações sobre a CPU, Kernel do sistema, Memória RAM, Storage (dispositivos de armazenamento), processos em execução na máquina, shell usado (Bash) e a versão do inxi instalada.

Gerar um relatório que pode ser salvo encaminhado a saída para um arquivo

$ inxi > sistema.txt

Informações mais detalhadas

Para obter informações mais detalhadas do sistema, usamos a opção -b:

$ inxi -b

Para obter apenas informações sobre dispositivos de áudio:

$ inxi -A

Informações sobre a bateria (se estiver em um notebook, por exemplo):

$ inxi -B

Obter informações especificamente sobre as CPUs dos sistema:

$ inxi -C

Informações sobre discos rígidos:

$ inxi -D

Subsistema gráfico da máquina:

$ inxi -G

Essa opção inclui informações sobre o adaptador gráfico (placa de vídeo), display e drivers de vídeo, entre outras.

Informações sobre interfaces de rede:

$ inxi -i

Essa opção retorna os nomes dos dispositivos de rede presentes, endereços IPv4 e IPv6, e informações sobre os drivers das placas de rede instaladas.

Informações básicas sobre processos em execução e memória:

$ inxi -I

Apenas memória RAM básica:

$ inxi -m

Para outros detalhes sobre a RAM, é necessário possuir privilégios de admin:

$ sudo inxi -m

Informações de rede mais resumidas

$ inxi -n

Nesse caso não são exibidos os endereços IP das interfaces de rede, mas são mostrados os endereços físicos (endereços MAC).

Ver os repositórios em uso no sistema:

$ inxi -r

Informações (bem) básicas sobre o sistema:

$ inxi -S

Mostrar recursos do sistema (padrão top 5 processos):

$ inxi -t

Mostrar recursos do sistema: 15 top processos

$ inxi -t cm15

Informações sobre o tempo

Além das opções de informações sobre o hardware e processos do sistema, o inxi também permite, como “bônus”, obter os dados do tempo – no caso referente ao clima, não execução de processos. Esses dados são obtidos a partir da API do OpenWeatherMap.org.

Para tal usamos a opção -W seguida do nome de uma cidade e de um país, separados por uma vírgula. Se um dos nomes possuir espaços, use o sinal de + em seu lugar. Por exemplo:

$ inxi -W Sao+Paulo,Brasil

Saída obtida:

Essa opção também aceita como parâmetros código postal (válido somente para EUA e RU) e um par latitude,longitude do local.

Em versões mais recentes de algumas distribuições, deve-se usar a opção -w (minúscula) – consultar as páginas de manual para ter certeza de qual opção usar.

Conclusão

Neste artigo foi apresentada uma ferramenta bastante útil e bem simples de usar para verificação de informações variadas do sistema no Linux, o script inxi. Esta ferramenta possui diversas outras opções de uso, como por exemplo consulta a dispositivos Bluetooth, discos ópticos, dispositivos USB, partições e dispositivos RAID, além de diversos tipos de filtros aplicáveis às sapidas geradas.

Consulte o manual do inxi ($ man inxi) para ver todas as opções disponíveis.

Para saber mais sobre a ferramenta inxi no Linux, assista ao vídeo a seguir da Bóson Treinamentos em Tecnologia:

Colabore com a Bóson Treinamentos

Ajude o canal adquirindo meus cursos na Udemy:

• Bancos de Dados com MySQL Básico: https://bit.ly/35QdWE4
• Lógica de Programação com Português Estruturado: https://bit.ly/3QKPn22
• Programação em Python do Zero: https://bit.ly/python-boson

Adquira também livros e outros itens na loja da Bóson Treinamentos na Amazon e ajude o canal a se manter e crescer: https://www.amazon.com.br/shop/bosontreinamentos

O post Utilitário inxi – Obter informações sobre o sistema no Linux apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

O comando free é usado no Linux para exibir informações sobre o uso de memória do sistema. Ele fornece uma visão geral da memória física (RAM) e da memória swap, incluindo o total disponível, usado, e livre.

Essa ferramenta é bastante útil para monitorar o desempenho do sistema e identificar possíveis gargalos relacionados ao uso de memória, e os dados retornados por ela são coletados por meio da análise do arquivo especial /proc/meminfo.

Sintaxe básica do free

$ free [opções]

Se nós simplesmente executarmos o comando free sem usar nenhuma opção, será exibido um resumo das informações de memória. Vejamos um exemplo básico:

$ free

Saída típica:

      total    usada   livre  compart. buff/cache disponível
Mem:  16389832 4051232 807360 58464    11931240   11854436
Swap: 2097148  1200    2095948

As principais colunas exibidas na saída do comando free são:

• total: O total de memória RAM ou swap disponível (instalada) no sistema (obtida do arquivo /proc/meminfo).
• usada: A memória que está em uso atualmente (total – (livre + buffers + cache)).
• livre: Memória que está completamente livre e não está sendo utilizada.
• compart.: Memória usada por programas compartilhados (normalmente em ambientes gráficos).
• buff/cache: Memória usada para buffers e caches do sistema. Essa memória pode ser reutilizada por aplicativos se necessário.
• disponível: Memória efetivamente disponível para novos processos, considerando que parte da memória usada em cache pode ser liberada.

E as linhas principais:

• Mem.: Dados sobre a memória RAM física.
• Swap: Dados sobre a memória swap (área de troca no disco).

Opções comuns do comando free

Algumas das opções mais usadas juntamente com o comando free incluem:

-h: Exibe os valores em formato legível para humanos (valores em Ki, Mi, Gi, Ti, Pi).

$ free -h

Saída típica:

      total usada livre compart. buff/cache disponível
Mem:  15Gi  3.8Gi 789Mi    57Mi  11Gi       11Gi
Swap: 2.0Gi 1.2Mi 2.0Gi

-b, -k, -m, -g: Permitem exibir os valores em bytes, kibibytes (Ki), mebibytes (Mi) ou gibibytes (Gi), respectivamente. Por exemplo, para exibir os resultados em MiB:

$ free -m

Saída:

      total usada livre compart. buff/cache disponível
Mem:  16389 4051  807   58       11931      11854
Swap: 2047  1     2046

–tebi, –pebi: Exibir os valores em tebibytes (Ti) e pebibytes (Pi), respectivamente.

–kilo, –mega, –giga, –tera, –peta: Mostrar os valores em bytes, kilobytes, megabytes, gigabytes, terabytes ou petabytes, respectivamente.

–si: Usa kilo, mega, giga, tera, peta (potências de 10) em vez de kibi, mebi, tebi, pebi, que são potências de 2.

-t: Exibe uma linha de total acumulado de memória RAM e swap (arquivo de troca).

$ free -t

Saída:

       total usada livre compart. buff/cache disponível
Mem:   16389 4051  807   58       11931      11854
Swap:  2047  1     2046
Total: 18436 4052  2853

-s <intervalo>: Atualiza as informações de memória a cada intervalo especificado (em segundos).

$ free -s 2

Saída:

      total usada livre compart. buff/cache disponível
Mem:  16389 4051  807   58       11931      11854
Swap: 2047  1     2046

A saída será atualizada a cada 2 segundos. Para interromper, pressionamos Ctrl+C.

-c <n>: Repete a saída gerada n vezes e depois para.

$ free -s 2 -c 3

Saída: A mesma do exemplo anterior., porém agora são exibidas 3 atualizações com intervalo de 2 segundos entre elas.

Conclusão

O comando free é uma ferramenta simples porém bastante útil para consultar e monitorar o uso de memória no Linux. Com ele podemos visualizar rapidamente informações sobre memória RAM, swap, buffers e caches do sistema.

Como vimos, também é possível personalizar a saída para diferentes unidades (como SI ou unidades binárias) ou ainda monitorar a memória em tempo real, usando as várias opções disponíveis para o comando.

Para saber mais sobre as unidades de informação usadas em sistemas computacionais, como o que é um Kibibyte ou a diferença entre Megabyte e Mebibyte, assista ao vídeo a seguir da Bóson Treinamentos:

O post Exibir informações sobre uso da memória com comando free no Linux apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Os comandos nice e renice são usados para ajustar a prioridade de processos no Linux. Isso é especialmente útil para gerenciar o uso de CPU em sistemas onde múltiplos processos competem por recursos, ajudando a garantir que processos mais importantes tenham prioridade maior.

O que são nice e renice?

Comando nice

Define a prioridade de um processo no momento em que ele é iniciado. O “nível de niceness” (valor de nice) indica o quão “agradável” o processo será em relação aos outros:

• Valores altos tornam o processo menos prioritário.
• Valores baixos tornam o processo mais prioritário.

Comando renice

O comando renice permite alterar a prioridade de processos que já estão em execução.

Sintaxe básica

nice:

$ nice -n <valor> comando

renice:

$ renice <valor> -p <PID>

Intervalo de valores de nice

Os valores de “niceness” podem variar de -20 a 19:

• -20: Maior prioridade.
• 0: Prioridade padrão (valor padrão para a maioria dos processos).
• 19: Menor prioridade.

Processos com valores de nice menores recebem mais tempo de CPU em relação a processos com valores maiores – ou seja, tem maior prioridade.

Como verificar a prioridade de um processo?

Podemos usar os comandos ps, top ou htop para verificar o valor de nice de processos:

1. Com ps:

   $ ps -eo pid,ni,cmd

   A coluna NI mostra o valor de nice.

2. Com top:

   $ top

   Localize a coluna NI para ver os valores de nice.

3. Com htop:

   O htop também exibe a coluna de nice de forma interativa.

Exemplos do comando nice

Exemplo 1: Executar um processo com prioridade baixa

$ nice -n 10 tar -czf backup.tar.gz /home/fabio

Este comando cria um arquivo backup.tar.gz, mas com prioridade menor (nice = 10), consumindo assim menos recursos do sistema caso o processo demore (por exemplo, se a pasta tiver milhares de arquivos).

Exemplo 2: Executar um processo com prioridade alta (menos “agradável”)

Para usar valores de nice menores que 0, é necessário ser superusuário:

$ sudo nice -n -5 dd if=/dev/zero of=/dev/null

Neste exemplo, o comando copia um fluxo infinito de bytes zero (/dev/zero) para o “buraco negro” (/dev/null). Ele é executado com prioridade -5, o que significa que receberá mais tempo de CPU em relação a processos com prioridades padrão ou mais baixas.

Execute o comando em um terminal, e abra outra aba ou terminal para verificar o processo em execução. Use os comandos top ou htop para visualizar o processo gerado pelo comando dd, e perceba o valor de nice (coluna NI) que o processo está usando – no caso, será -5.

Para encerrar o dd. pressione Ctrl+C na aba onde ele está em execução.

Obs.:
/dev/zero: dispositivo especial do sistema que fornece um fluxo infinito de bytes zero.
/dev/null: dispositivo especial do sistema que descarta tudo que é escrito nele (“buraco negro”).

Exemplos do comando renice

Exemplo 1: Alterar a prioridade de um processo em execução

1. Execute novamente o comando do exemplo anterior encontre o PID do processo (usando outra aba do terminal):

   $ sudo nice -n -5 dd if=/dev/zero of=/dev/null 
   $ ps aux | grep dd

2. Verifique sua prioridade atual e a altere, por exemplo para 10:

   $ top
   $ renice 10 -p <PID retornado anteriormente> 
   $ top

   Desta forma, o valor de nice do processo será alterado para 10, tornando o processo menos prioritário.

Exemplo 2: Alterar a prioridade de todos os processos de um usuário

$ sudo renice -n 10 -u fabio

Com este comando todos os processos do usuário fabio terão sua prioridade ajustada para 10.

A seguir temos alguns exercícios para você treinar mais o emprego dos comandos nice e renice para alterar prioridades de execução de processos no Linux.

Exercícios práticos

1. Execute um comando simples, como sleep, com um valor de nice igual a 15.
2. Use renice para alterar a prioridade do processo sleep em execução.
3. Liste todos os processos em execução e encontre os valores de nice associados a eles.
4. Crie um script que execute três comandos simultaneamente com diferentes valores de nice e os compare com ps.
5. Altere a prioridade de todos os processos de um usuário específico, por exemplo o usuário mariana,  para um valor de nice igual a 12.

Resolução dos exercícios

1. Execute o comando sleep com nice igual a 15

$ nice -n 15 sleep 100

Este comando executa o sleep com prioridade baixa.

2. Use renice para alterar a prioridade de um processo

1. Encontre o PID do processo (use outra aba ou janela de terminal):

   $ ps aux | grep sleep

2. Altere sua prioridade:

   $ sudo renice 5 -p <PID>

3. Liste todos os processos e seus valores de nice

$ ps -eo pid,ni,cmd

4. Criar um script para comparar diferentes valores de nice

#!/bin/bash

echo "Iniciar processos com diferentes prioridades..."
nice -n 0 dd if=/dev/zero of=/dev/null &
nice -n 10 dd if=/dev/zero of=/dev/null &
nice -n 19 dd if=/dev/zero of=/dev/null &
ps -eo pid,ni,cmd | grep dd

Salve o arquivo como teste_nice.sh, e o torne executável:

$ chmod +x teste_nice.sh

Execute o script para testar:

./teste_nice.sh

Para encerrar os processos no terminal podemos executar o comando kill -9 seguido do pid de cada um:

$ kill -9 <pid>

5. Altere a prioridade de todos os processos de um usuário qualquer

sudo renice -n 12 -u mariana

Conclusão

Os comandos nice e renice são ferramentas importantes para ajustar a prioridade de processos no Linux, permitindo que possamos controlar como os recursos da CPU são alocados.

Isso é especialmente útil em servidores e ambientes com carga alta, onde a gestão adequada de processos pode melhorar o desempenho do sistema. 

O post Ajustar a prioridade de processos no Linux com nice e renice apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

O comando dmesg (display message) é usado para exibir as mensagens do kernel ring buffer, que registra eventos do kernel, incluindo inicialização do sistema, detecção de hardware, mensagens de drivers, erros e outros eventos importantes.

As mensagens retornadas pelo dmesg são bastante úteis para depurar problemas de hardware, drivers e inicialização do sistema.

O que é o kernel ring buffer?

O kernel ring buffer é uma área de memória no kernel do Linux usada para armazenar mensagens e eventos gerados pelo próprio kernel, podendo ser usado para monitorar o funcionamento interno do kernel e depurar problemas relacionados ao sistema.

Essas mensagens incluem informações sobre:

• Detecção e configuração de hardware.
• Mensagens de drivers de dispositivos.
• Relatórios de erros ou alertas.
• Logs do processo de inicialização.
• Mensagens de depuração.

É importante notar que o kernel ring buffer é uma área de memória volátil. Isso significa que as mensagens armazenadas nele não são gravadas em disco e serão perdidas após reinicializações, a menos que sejam salvas por serviços de logging como o syslog ou o journald.

Vamos estudar agora o funcionamento do comando dmesg, começando pela sua sintaxe.

Sintaxe básica do comando dmesg

$ dmesg [opções]

Quando executado sem opções, o dmesg exibe todas as mensagens do kernel em ordem cronológica.

Estrutura da saída do dmesg

A saída típica da execução do comando dmesg é composta por mensagens como estas:

[ 0.000000] Linux version 5.15.0-50-generic (buildd@lcy02-amd64) ...
[ 0.002000] ACPI: RSDP 0x000000007FEE0000 000024 (v02 INTEL )
[ 0.002050] ACPI: XSDT 0x000000007FEE0100 000074 (v01 INTEL D945GCLF 00000001 INTL 20091013)
[ 0.012345] PCI: Using configuration type 1 for IO mapping

Nesta saída podemos identificar dois componentes da saída, um em cada coluna:

1. Marcador de tempo ([ 0.000000]): Tempo desde a inicialização do sistema (em segundos e frações).
2. Mensagem do kernel: Detalhes sobre eventos do sistema, como detecção de hardware ou inicialização de drivers.

Vejamos agora algumas das principais opções disponíveis no dmesg.

Principais opções do dmesg

-H ou –human

Exibe o tempo em formato legível para humanos, com rolagem de paginação.

$ dmesg -H

Saída do comando dmesg -H no Linux

-T, –ctime

Converte os marcadores de tempo (timestamps) para formato de data e hora. 

-l ou –level: Permite filtrar as mensagens por nível de prioridade, recebendo um dos seguintes valores como argumento:

• emerg: Emergência.
• alert: Alerta.
• crit: Crítico.
• err: Erro.
  warn: Aviso.
• notice: Notificação.
• info: Informações gerais.
• debug: Mensagens de depuração.

Exemplo: Exibir apenas erros:

$ dmesg -l err

Saída do comando dmesg -l err no Linux

–since <tempo>

A opção –since permite exibir as mensagens do kernel desde um momento específico. Por exemplo, se quisermos verificar as mensagens nos últimos dois minutos:

$ dmesg --since "2 minutes ago"

A opção –since aceita vários formatos de tempo, desde datas completas até intervalos relativos. Alguns dos formatos mais comuns aceitos são os seguintes:

Data completa no formato: AAAA-MM-DD HH:MM:SS. Exemplo:

$ dmesg --since "2024-11-01 14:30:00"

Somente a hora no formato HH:MM:SS. Exemplo:

$ dmesg --since "14:30:00"

Somente datas, no formato AAAA-MM-DD. Exemplo:

$ dmesg --since "2024-11-01"

Intervalos relativos, com expressões como <n> seconds ago, <n> minutes ago, <n> hours ago, <n> days ago, etc.. Exemplo:

dmesg --since "5 minutes ago"

Combinação de data e hora relativas, no formato yesterday, today, ou now, com modificadores. Exemplo:

dmesg --since "yesterday 18:00"

Além dessas, existem outras opções de formatos que podem ser consultadas nas páginas de manual do dmesg.

–follow

Exibir as mensagens que estão sendo geradas em tempo real. No exemplo abaixo, inserimos um DVD no drive da máquina após executar o dmesg com essa opção, e visualizamos a mídia sendo reconhecida:

Comando dmesg –follow capturando a inserção de um DVD no drive da máquina. Note a detecção do sistema de arquivos ISO 9660 (para mídia de disco óptico).

Para interromper, pressionamos Ctrl+C no teclado.

–facility

A opção facility nos permite filtrar as mensagens por subsistema, como hardware ou drivers.

O que são subsistemas no Linux?

Um subsistema é uma parte específica do sistema operacional que lida com um conjunto particular de funcionalidades ou responsabilidades. Cada subsistema gera mensagens relacionadas a seus eventos, operações ou erros, que são registradas no kernel ring buffer.

Os valores possíveis para a opção –facility são os seguintes:

• auth: Mensagens relacionadas a autenticação de usuários ou sistemas.
  Inclui eventos de login/logout.
• authpriv: Mensagens de autenticação que incluem informações confidenciais (por exemplo, IPs ou falhas de login).
• cron: Logs relacionados a tarefas agendadas (ex.: cron, at).
• daemon: Mensagens provenientes de daemons (processos em segundo plano).
• kern: Mensagens do kernel.
  Inclui logs de inicialização, detecção de hardware e eventos de drivers.
• lpr: Logs relacionados a serviços de impressão.
• mail: Logs de serviços de e-mail (ex.: Postfix, Sendmail).
• news: Logs de serviços relacionados a distribuição de notícias (geralmente obsoletos).
• syslog: Logs gerados pelo próprio sistema de logging (syslogd ou equivalente).
• user: Logs relacionados a aplicativos de usuários.
• uucp: Logs do sistema UUCP (Unix-to-Unix Copy Protocol), geralmente obsoletos.
• **local0 a local7: Categorias personalizáveis para mensagens de aplicativos ou subsistemas definidos pelo administrador.

Exemplo – exibir mensagens relacionadas ao kernel:

$ dmesg --facility=kern

Também é possível filtrar mais de um subsistema de uma vez, separando os valores por vírgulas. Por exemplo:

$ dmesg --facility=kern,syslog

Este comando exibe mensagens relacionadas ao kernel e a logs gerados pelo sistema de logging.

-C, –clear

A opção -C permite limpar o buffer de anel do kernel.

Além de usar essas e outras opções disponíveis com o dmesg, também podemos combinar a saída gerada por essa ferramenta com outros utilitário do sistema. Por exemplo, podemos filtrar as mensagens usando um filtro como o grep. Exemplo a seguir.

Filtrar as mensagens relacionadas a dispositivos USB

$ dmesg | grep usb

Filtrar mensagens relacionadas a USB com dmesg

A seguir temos alguns exercícios práticos para você treinar um pouco o uso do comando dmesg no Linux. Resoluções se encontram logo após os exercícios.

Exercícios práticos com dmesg

1. Use o dmesg para exibir apenas mensagens relacionadas a dispositivos de rede.
2. Identifique mensagens de aviso geradas pelo kernel.
3. Acompanhe as mensagens do kernel em tempo real e conecte/desconecte um dispositivo USB para verificar os logs.
4. Exiba todas as mensagens relacionadas ao subsistema de processos em segundo plano (daemon).
5. Crie um script que utilize o comando dmesg e interaja com o usuário para filtrar mensagens do kernel com base em uma palavra-chave fornecida.

Resolução dos exercícios

1. Exibir mensagens relacionadas a dispositivos de rede (‘net”)

$ dmesg | grep -i net

2. Identificar mensagens de aviso geradas pelo kernel

$ dmesg -l warn

3. Acompanhar mensagens do kernel em tempo real e verificar logs ao conectar um dispositivo USB

$ dmesg --follow

Conecte um dispositivo USB e veja as mensagens sendo geradas em tempo real.

#4. Exibir todas as mensagens relacionadas ao subsistema daemon

$ dmesg --facility=daemon

5. Script para filtrar mensagens com base em palavra-chave

a. Crie um script de nome verifica_palavras.sh com seu editor de textos preferido e o conteúdo a seguir:

#!/bin/bash
# Exibe uma mensagem inicial para o usuário
echo "Bem-vindo ao analisador de logs do kernel!"
echo "Este script permite filtrar mensagens do kernel baseadas em uma palavra-chave."
echo ""
# Solicita que o usuário insira uma palavra-chave para filtrar mensagens
read -p "Digite uma palavra-chave para buscar no log do kernel (ex.: usb, disk, error): " palavra
# Verifica se o usuário inseriu uma palavra-chave
if [ -z "$palavra" ]; then
  echo "Você não digitou nenhuma palavra-chave. Encerrando o script."
  exit 1
fi
# Usa o comando dmesg para filtrar mensagens que correspondem à palavra-chave
echo ""
echo "Buscando por mensagens do kernel contendo a palavra-chave '$keyword'..."
echo ""
dmesg | grep -i "$palavra"
# Verifica se o comando anterior encontrou resultados
if [ $? -ne 0 ]; then
  echo ""
  echo "Nenhuma mensagem do kernel encontrada para a palavra-chave '$palavra'."
else
  echo ""
  echo "Busca concluída."
fi
# Finaliza o script
echo "Obrigado por usar o analisador de logs do kernel!"
exit 0

b. Torne o script executável:

$ chmod +x verifica_palavras.sh

c. Execute o script para testar, fornecendo uma palavra chave como disk ou usb:

$ ./verifica_palavras.sh

Conclusão

O comando dmesg é uma ferramenta importante e bastante útil para monitorar eventos do sistema Linux em nível de kernel. Ele é usado para solucionar problemas de hardware, drivers e inicialização. Também permite que os administradores de sistemas analisem e depurem rapidamente os logs do kernel, de modo a solucionar problemas de forma eficiente e simplificada. 

O post Exibir mensagens do kernel ring buffer no Linux com comando dmesg apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

O htop é uma ferramenta interativa para monitoramento de processos no Linux. Ele oferece uma interface amigável que exibe informações detalhadas sobre processos, consumo de recursos como CPU e memória, e permite interagir com os processos de forma intuitiva.

Por que usar o htop?

O utilitário htop possui diversas vantagens em relação ao tradicional utilitário top, incluindo:

• Apresenta uma interface visual fácil de usar, com barras de uso de CPU e memória. É uma versão mais amigável do top.
• Possui mais recursos que o comando top, como por exemplo suporte a mouse e ordenação interativa.
• Permite gerenciar processos diretamente, como matar ou renomear processos.

A ferramenta htop está disponível para Linux, FreeBSD, NetBSD, OpenBSD, DragonFly BSD, MacOS e Solaris, e sua página de desenvolvimento oficial é https://htop.dev/.

Instalação do htop

Em algumas distribuições e sistemas, o htop não vem pré-instalado. Podemos usar os seguintes comandos para instalá-lo:

• Debian/Ubuntu: sudo apt install htop
• Fedora: sudo dnf install htop
• Arch Linux: sudo pacman -S htop
• macOS: brew install htop
• FreeBSD: sudo pkg install htop

Como usar o htop

Para iniciar o htop, basta executar:

$ sudo htop

Interface do htop

Ao iniciar, o htop exibe as informações divididas em três seções principais:

1 – Cabeçalho

Mostra o uso da CPU, memória, e swap com barras coloridas, além do número de tarefas, carga média do sistema e uptime. Exemplo:

Aqui temos:

CPU: Representa o uso das CPUs do sistema. Geralmente é exibido como barras de progresso para cada núcleo, mostrando:

• Uso do usuário (verde ou azul): Tempo gasto em processos de usuários.
• Uso do sistema (vermelho): Tempo gasto em tarefas do kernel.
• Ocioso (preto ou vazio): Tempo em que a CPU está inativa.

Mem: Refere-se ao uso da memória RAM do sistema. Exibe a memória total, usada, livre e buffers/cache.

Na figura acima temos que 1,05 GB de RAM estão sendo usados de um total de 3,02 GB.

Swp: Representa o uso da memória de swap. Mostra a memória total de swap, usada e livre.

Tasks: Exibe o número total de tarefas (processos) e o status delas. Inclui:

• Total de tarefas.
• Processos em execução.
• Processos em estado de espera.

No exemplo, existem 103 processos ativos, 294 threads e 1 processo em execução.

Load Average: Mostra a média de carga do sistema nos últimos 1, 5 e 15 minutos. Valores elevados indicam que muitos processos estão competindo por recursos.

Uptime: Indica o tempo total que o sistema está em execução desde a última inicialização. Geralmente exibido no formato dias:horas:minutos.

No exemplo, temos que o sistema está ativo há apenas 07 minutos e 30 segundos.

2 – Lista de processos

Exibe os processos em execução no sistema com diversas informações em várias colunas. Exemplo de saída:

As colunas são:

PID: Número de identificação do processo.

USER: Usuário que iniciou o processo (seu proprietário).

PR: Prioridade do processo. Quanto menor o valor, maior a prioridade

NI: Valor “nice” do processo, que afeta sua prioridade de execução.

VIRT: Quantidade de memória virtual usada pelo processo.

RES: Quantidade de memória RAM física usada pelo processo, em kilobytes.

SHR: Quantidade de memória compartilhada que o processo está usando.

S: Status do processo, como Em Execução, Parado, Zumbi, Dormindo, Rastreado, etc.)

%CPU: Porcentagem de uso de CPU pelo processo.

%MEM: Porcentagem de uso de memória RAM (física) pelo processo.

TIME+: Quanto tempo de processamento o processo já usou (cumulativo)

COMMAND: Nome do comando ou programa que iniciou o processo.

3 – Rodapé

Exibe as teclas de função disponíveis para interagir com os processos, como mostra o exemplo abaixo.

A tabela abaixo mostra as teclas de acesso do rodapé do utilitário htop, com a descrição sucinta de cada uma delas:

Vejamos alguns exemplos de uso do htop agora.

Exemplos práticos

1 – Listar todos os processos:

$ sudo htop

Observe os processos em execução, organizados pela utilização de CPU por padrão.

2 – Ordenar processos pelo uso de memória:

Pressione F6 e escolha %MEM na lista de colunas disponíveis.

3 – Exibir processos em formato de árvore

Pressione F5 para alternar para a exibição em formato de árvore

Isso ajuda a visualizar a hierarquia de processos (processos pai e filhos).

4 – Buscar um processo específico

Pressione F3 e digite o nome do processo (ex.: bash). 

Digite o nome ou parte do comando do processo que deseja localizar (ex.: “bash”).

5 – Matar (kill) um processo

Selecione o processo usando as setas e pressione F9.
Escolha o sinal para enviar (por padrão, SIGTERM).            

6 – Filtrar processos

1. Pressione a tecla F4.
2. Digite parte do nome ou comando do processo (por ex.: python).
3. O htop exibirá apenas processos que correspondem ao filtro.

Muito bom. Na sequência, liso alguns exercícios sobre o comando htop para você treinar um pouco mais seu uso. A resolução sugerida de cada um se encontra logo após a listagem.

Exercícios: Comando htop

1. Use o htop para listar todos os processos em execução e identifique o processo com maior uso de CPU.
2. Altere a visualização para o formato de árvore e identifique o processo pai do bash.
3. Ordene os processos pelo uso de memória e localize o processo que está consumindo mais memória.
4. Encontre o processo do htop em execução usando a função de busca.
5. Mate um processo específico, como o sleep, iniciado manualmente no terminal.

Resolução dos exercícios

1. Listar todos os processos e identificar o maior consumidor de CPU:

   $ sudo htop

2. Alterar para o formato de árvore e identificar o processo pai do bash:

   Pressione F5.

3. Ordenar por uso de memória e identificar o maior consumidor:

   Pressione F6 e escolha %MEM.

4. Encontrar o processo do htop em execução:

   Pressione F3 e digite htop.

5. Matar um processo específico:

   Inicie um processo de teste com sleep 300, localize-o no htop e pressione F9.

Conclusão

O htop é uma ferramenta avançada e interativa para monitoramento e gerenciamento de processos no Linux. Com uma interface fácil de usar e funcionalidades adicionais em relação ao top, ele é bastante útil para administradores de sistemas e usuários avançados. 

O post Monitoramento de processos no Linux com comando htop apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

O comando top no Linux é uma ferramenta empregada para monitorar o uso de recursos do sistema em tempo real, como CPU, memória, e processos. Ele é muito utilizado para identificar gargalos de desempenho e gerenciar processos.

O que é o comando top?

O utilitário top exibe informações dinâmicas sobre os processos em execução, incluindo:

• Percentual de uso da CPU.
• Consumo de memória.
• Estado dos processos (em execução, dormindo, etc.).
• Tempo de execução de processos.

Sua saída é atualizada automática e periodicamente, oferecendo assim uma visão instantânea e contínua do desempenho do sistema.

Sintaxe do top

A sintaxe básica do comando top é como segue:

top [opções]

Simplesmente executar top no terminal já exibe o painel de monitoramento em tempo real. Vejamos como interpretar a interface de saída do comando.

Interface do top

1. Cabeçalho do sistema

Informações gerais sobre o estado do sistema.

Saída típica:

top - 10:00:01 up 1 day, 5:30, 3 users, load average: 0.05, 0.10, 0.15

Aqui temos:

• Hora atual (10:00:01).
• Tempo desde o último boot (1 dia, 5:30).
• 3 Usuários logados (3 users).
• Load average: Média de carga da CPU nos últimos 1, 5 e 15 minutos.

2. Resumo dos recursos do sistema

Saída típica:

Tarefas: 125 total, 2 em exec, 123 dormindo, 0 parado, 0 zumbi
%Cpu(s): 3.0 us, 2.0 sy, 0.0 ni, 95.0 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
KiB Mem : 4048572 total, 2048572 used, 2000000 free, 512000 buffers
KiB Swap: 2097148 total, 104857 used, 1992291 free. 1024000 cached Mem

Vamos interpretar a saída desse comando de forma detalhada.

Linha 01: Tarefas (Informações sobre as tarefas/processos)

• 125 total: Número total de tarefas (processos) no sistema.
• 2 em exec: Quantidade de tarefas que estão em execução ativa no momento.
• 123 dormindo: Processos que estão aguardando eventos ou recursos para continuar.
• 0 parado: Nenhum processo está parado (suspenso manualmente).
• 0 zumbi: Não há processos zumbis. Um processo zumbi ocorre quando ele terminou a execução, mas o pai ainda não leu seu status.

Linha 02: %Cpu(s) (Utilização da CPU)

Os campos indicam como o tempo da CPU está sendo gasto:

• 3.0 us: Percentual de tempo gasto em processos de usuários (não relacionados ao kernel).
• 2.0 sy: Percentual de tempo gasto em processos do sistema (kernel).
• 0.0 ni: Percentual de tempo gasto em processos com prioridade alterada (nice).
• 95.0 id: Percentual de tempo em que a CPU está ociosa.
• 0.0 wa: Percentual de tempo em que a CPU está esperando por I/O (leitura ou gravação em disco, por exemplo).
• 0.0 hi: Percentual de tempo gasto atendendo interrupções de hardware.
• 0.0 si: Percentual de tempo gasto atendendo interrupções de software.
• 0.0 st: Percentual de tempo “roubado” por máquinas virtuais (caso esteja rodando em um hypervisor).

Linha 03: KiB Mem (Uso da Memória RAM)

• 4048572 total: Memória RAM total disponível no sistema (em KiB).
• 2048572 used: Quantidade de memória RAM usada no momento.
• 2000000 free: Memória RAM não utilizada no momento.
• 512000 buffers: Memória usada para buffers, que armazena temporariamente dados em trânsito para dispositivos como discos ou redes.

Linha 04: KiB Swap (Uso da memória Swap)

• 2097148 total: Tamanho total do espaço de swap configurado (em KiB).
• 104857 used: Quantidade de espaço de swap atualmente usada.
• 1992291 free: Espaço de swap não utilizado.
• 1024000 cached Mem: Parte da memória RAM usada para cache de páginas de disco. Essa memória é usada para acelerar operações e pode ser liberada pelo sistema, se necessário.

Muita informação não? Podemos resumir essa saída da seguinte forma:

• O sistema tem 125 processos ativos, com apenas 2 em execução e a maioria (123) aguardando recursos.
• A CPU está 95% ociosa, indicando pouca carga no sistema.
• Cerca de 2 GB de RAM estão em uso (de um total de 4 GB), e 2 GB estão livres.
• O espaço de swap está praticamente livre (apenas 104 MB usados de 2 GB).
• O sistema está usando 1 GB de memória para cache, o que melhora o desempenho geral ao evitar acessos frequentes ao disco.

3. Lista de processos

Saída típica:

 PID USER PR NI VIRT   RES   SHR  S %CPU %MEM   TIME+ COMMAND
1234 user 20 0  123456 5678  1024 R  5.0 0.1  0:01.23 python
2345 user 20 0  345678 12345 2048 S  3.0 0.3  0:10.45 chrome
[TRUNCADO]

Onde:

• PID: ID do processo.
• USER: Usuário que iniciou o processo.
• PR: Prioridade do processo.
• NI: Valor do niceness (impacta a prioridade do processo).
• VIRT: Tamanho da memória virtual total do processo.
• RES: Memória física usada pelo processo.
• SHR: Memória compartilhada utilizada.
• S: Estado do processo (no caso, R = em execução e S = Dormindo.
• %CPU: Percentual de uso da CPU.
• %MEM: Percentual de uso da memória.
• TIME+: Tempo acumulado de CPU.
• COMMAND: Nome do comando/processo.

A coluna PR indica a prioridade atual do processo. Essa prioridade determina a ordem em que os processos são agendados para a CPU. Processos com valores de prioridade mais baixos recebem mais tempo de CPU.
A prioridade pode ser influenciada pelo valor NI (niceness), mostrado na coluna ao lado de PR.

A coluna NI indica o valor de “niceness” do processo. O “niceness” é usado para ajustar a prioridade de processos normais (não em tempo real). É um valor que pode ser configurado manualmente para indicar quão “agradável” (em inglês, “nice”) um processo é em relação ao consumo de CPU.

Quanto menor o valor, maior a prioridade.

Já a coluna VIRT indica o tamanho total da memória virtual utilizada pelo processo. Isso inclui:

• Memória física em uso.
• Memória swap em uso.
• Memória reservada que pode não estar sendo utilizada.
• Áreas de memória mapeadas (como bibliotecas e arquivos).

Vejamos agora alguns dos comandos interativos disponibilizados na interface do top.

Principais comandos interativos no top

Quando o top está em execução, podemos interagir com a interface usando os seguintes comandos de teclado:

Vejamos agora alguns exemplos do uso de top no Linux.

Exemplos do comando top

1. Executar o top e observar os processos em tempo real:

$ sudo top

2. Classificar processos pelo uso de memória (tecla M):

Após iniciar o top, pressionamos M para listar os processos com maior uso de memória.

3. Finalizar um processo específico (tecla k)

Após iniciar o top, pressionamos k e inserimos o PID do processo que desejamos finalizar.

4. Exibir o uso de cada núcleo de CPU separadamente (tecla 1)

Após iniciar o top, pressionamos 1 para ver o uso de cada núcleo.

5. Exibir apenas processos de um usuário específico, como o usuário fabio:

$ top -u fabio

6. Alterar a taxa de atualização do top (tecla d)

Pressionamos a tecla d e então inserimos o intervalo de atualização de tela desejado em segundos (por padrão, é 3 segundos).

A seguir temos alguns exercícios para você treinar um pouco mais o uso do comando top no Linux. A resolução sugerida de cada um se encontra após a listagem.

Exercícios: comando top

1. Liste os 5 processos que mais consomem CPU usando o top.
2. Finalize um processo de baixa prioridade usando o PID obtido no top.
3. Exiba apenas os processos pertencentes ao usuário atual.
4. Altere o niceness de um processo usando o top.
5. Ordenar os processos pelo tempo de execução acumulado.

Resolução dos exercícios

1. Liste os 5 processos que mais consomem CPU

Dentro do top, pressione P para ordenar pelo uso da CPU. Observe os 5 primeiros processos da lista.

2. Finalize um processo de baixa prioridade

1. No top, pressione k.
2. Insira o PID do processo que deseja finalizar.
3. Confirme pressionando Enter.

3. Exiba apenas os processos pertencentes ao usuário atual

Execute o comando:

$ sudo top -u $USER

4. Altere o niceness de um processo

1. No top, pressione r.
2. Insira o PID do processo.
3. Digite o novo valor de niceness (de -20 a 19, sendo -20 o mais prioritário).

5. Ordenar os processos pelo tempo de execução acumulado

No top, pressione a tecla T para ordenar os processos pelo tempo de execução.

Conclusão

O comando top é uma ferramenta bastante útil para monitorar o desempenho do sistema Linux em tempo real. Ele fornece informações detalhadas sobre os processos em execução, permitindo que os administradores de sistemas Linux identifiquem problemas e ajustem o uso de recursos de forma eficiente.

Nos próximos tutoriais veremos outras ferramentas também bastante úteis para esses propósitos, como o comando htop.

Até mais!

O post Monitorar uso de recursos do sistema com comando top no Linux apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

O comando ps (process status) é usado no Linux para exibir informações sobre os processos em execução no sistema. Ele é uma ferramenta bastante útil para monitoramento, análise e solução de problemas relacionados a processos no sistema operacional – por exemplo, processos travados ou que estão consumindo muito tempo de processamento da CPU.

Sintaxe básica do ps

A sintaxe básica do comando ps é a seguinte:

$ ps [opções]

Se não forem usadas opções, o comando ps exibe os processos pertencentes ao usuário que executou o comando no terminal atual. A seguir, vamos conhecer as principais opções disponíveis para o ps.

Opções comuns do comando ps

Vejamos algumas das opções mais comuns utilizadas em conjunto com o comando ps no Linux:

1. ps (sem opções)

Exibe uma lista dos processos em execução no terminal atual:

$ ps

Saída típica:

PID TTY TIME CMD
1234 pts/0 00:00:01 bash
2345 pts/0 00:00:00 ps

Nesta saída, temos quatro colunas que trazem as seguintes informações:

• PID: O ID do processo.
• TTY: Terminal associado ao processo.
• TIME: Tempo de CPU utilizado.
• CMD: Comando executado.

A coluna TTY (abreviação de “Teletype“), se refere a terminais físicos ou terminais de console usados para interagir com os sistemas de computadores.

O valor que aparece, pts, é uma abreviação de “pseudo-terminal slave“. Se refere a terminais virtuais criados dinamicamente quando abrimos terminais em emuladores gráficos, como o terminal do gnome (gnome-terminal), o xterm, ou ainda quando realizamos conexões remotas via SSH a um sistema Linux.

Ou seja, são terminais virtuais conectados ao sistema por meio de um programa que emula um terminal. Cada terminal virtual (isso inclui até mesmo abas em um emulador gráfico) recebe um código identificador como pts/0, pts/1, etc.

O valor tty aparece se estivermos usando um terminal físico ou console, ao passo que o valor pts aparece quando usamos um emulador de terminal gráfico ou nos conectamos via SSH.

Já a coluna TIME indica o tempo total acumulado que o processo usou a CPU desde o momento em que foi iniciado. Ela é apresentada no formato HH:MM e inclui o tempo gasto em execução ativa ou em funções do sistema.

2. ps -e ou ps -A

Lista todos os processos em execução no sistema. Exemplo:

$ ps -e

Saída típica:

  1 ? 00:00:05 systemd
  2 ? 00:00:00 kthreadd
434 ? 00:00:03 sshd
567 ? 00:00:01 cron

Com esta opção, alguns processos podem trazer o símbolo ? na coluna TTY, o que significa que o processo não está associado a nenhum terminal. Isso ocorre, por exemplo, com processos de sistema, da inicialização ou serviços em segundo plano (daemons), que não possuem interação direta com o usuário.

3. ps -f

Exibe informações detalhadas sobre os processos pertencente ao usuário:

$ ps -f

Saída típica:

UID  PID  PPID C STIME TTY   TIME     CMD
user 1234 1200 0 10:00 pts/0 00:00:01 bash
user 2345 1234 0 10:05 pts/0 00:00:00 ps -f

Além das quatro colunas exibidas no exemplo anterior, com esta opção também são exibidas as seguintes informações:

• UID: Nome do usuário que iniciou o processo.
• PPID: ID do processo pai.
• C: Utilização de CPU.
• STIME: Hora de início do processo.

A coluna C indica a prioridade relativa do processo em relação ao uso da CPU. Ou seja,representa a utilização de CPU como uma percentagem aproximada do tempo gasto pelo processo na execução de tarefas durante um intervalo curto (geralmente desde o último reinício do sistema).

Essa métrica é volátil, pois reflete apenas o comportamento recente do processo. É útil para identificar processos que estão consumindo muita CPU em tempo real.

Se a coluna C exibir o valor 0, significa que o processo não está utilizando significativamente a CPU no momento. Se exibir 1 ou um valor maior, significa que o processo está consumindo mais ciclos de CPU.

4. ps aux

Lista todos os processos com informações detalhadas, incluindo os processos que foram iniciados por outros usuários. Essa é uma das formas mais usadas do comando:

$ ps aux

Saída típica:

USER PID  %CPU %MEM VSZ    RSS  TTY   STAT START TIME COMMAND
user 1234  0.0  0.1 123456 2345 pts/0 S    10:00 0:01 bash
root    1  0.1  0.2 345678 5678 ?     Ss   09:50 0:05 init

Agora são exibidas também as seguintes informações:

• %CPU: Percentual de uso da CPU.
• %MEM: Percentual de uso da memória.
• VSZ: Tamanho virtual do processo (em KB).
• RSS: Memória física usada pelo processo.
• STAT: Estado do processo
• COMMAND: Comando que iniciou o processo.

A coluna STAT exibe o status de cada processo no sistema. Este status indica o estado atual do processo, ou seja, o que ele está fazendo ou aguardando naquele momento. Os principais status são:

• Em execução (R): O processo está ativo e sendo executado pela CPU.
• Dormindo (S) – Dormindo “interrompível”. O processo está em um estado de espera interrompível, ou seja, ele está inativo, mas pode ser despertado por eventos como entrada/saída (I/O).
• Dormindo em espera (D) – Dormindo “não interrompível”. O processo está em um estado de espera não interrompível, ou seja, ele está inativo, mas não pode ser imediatamente interrompido ou finalizado. Por exemplo, ele está aguardando diretamente uma interação de hardware, como com um disco rígido, e não pode ser interrompido até que a operação termine.
• Zumbi (Z): O processo foi finalizado, mas ainda está listado na tabela de processos porque seu processo pai ainda não leu o código de saída (não realizou a chamada wait() para coletar o status de término.)
• Parado (T): O processo está suspenso ou parado, geralmente devido a um sinal, como o SIGSTOP ou SIGTSTP (enviado pelo atalho Ctrl+Z no terminal). Geralmente ocorre quando o processo foi explicitamente suspenso pelo usuário ou pelo sistema.
• I (Idle): O processo está inativo e não consumindo recursos.
• < (Alta prioridade): O processo está sendo executado com uma prioridade mais alta que o normal.
• N (Baixa prioridade): O processo está sendo executado com uma prioridade mais baixa que o normal.

Também há alguns status adicionais exibidos nessa coluna:

• s (Processo líder): Indica que o processo é um líder de sessão, ou seja, o primeiro processo de uma sessão, como em uma nova sessão de terminal.
• l (Em thread de nível baixo): O processo está multithreaded (ou seja, utiliza várias threads). Este status aparece quando o processo está rodando em modo “nível baixo” (lightweight) com múltiplas threads. comum em processos que fazem uso intensivo de threads, como navegadores Web e a JVM.
• + (No grupo do terminal atual): Processo que está em execução no grupo de processos em primeiro plano no terminal atual (foreground group), como processos que estão diretamente associados ao terminal que estamos usando no momento.

Já a coluna VSZ (Virtual Size) indica o tamanho virtual do processo, que representa a quantidade total de memória virtual que o processo está utilizando, incluindo a memória usada pelo código e dados do processo, bibliotecas compartilhadas, memória alocada mas não necessariamente usada e memória mapeada. Essa coluna NÃO representa a memória RAM física usada pelo processo (que é o RSS, Residente Set Size).

5. ps -u [usuário]

Exibeir os processos pertencentes a um usuário específico:

$ ps -u root

6. ps -p [PID]

Exibir informações sobre um processo específico pelo seu PID (número de identificação do processo):

$ ps -p 1234

7. ps –forest

Mostrar a hierarquia dos processos (relação entre processos pai e filhos) do usuário atual:

$ ps --forest

8. ps -eo

Permite personalizar os campos a serem exibidos ao executar o ps. Por exemplo, para mostrar apenas o PID e o comando:

$ ps -eo pid,cmd

Vejamos mais alguns exemplos de uso do comando ps no terminal do Linux.

Exemplos do comando ps

Exemplo 1: Encontrar um processo pelo nome

Podemos usar o comando grep junto com o ps para encontrar processos específicos. Por exemplo, para exibir informações sobre o processo do bash:

$ ps aux | grep bash

Exemplo 2: Monitorar o uso de memória de todos os processos

$ ps -eo pid,comm,%mem --sort=-%mem

Este comando exibe o PID, o nome do comando e o uso de memória dos processos, ordenados do maior para o menor uso de memória.

Exemplo 3: Ver os 5 processos que estão consumindo mais CPU no sistema

$ ps -eo pid,comm,%cpu --sort=-%cpu | head -n 6

Conclusão

Neste tutorial vimos como usar o comando ps para descobrir informações sobre processos em um ambiente Linux, incluindo processos em execução, processos parados ou travados e outros.

Muitas outras ferramentas estão disponíveis para gerenciamento de processos no Linux, e vamos estudar mais algumas delas nos próximos tutoriais, como os utilitários top e htop, entre outras.

O post Comando ps – informações sobre processos em execução no Linux apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste artigo dou início a uma série de tutoriais sobre uma linguagem de programação muito interessante, por vários motivos que veremos a seguir, e que está em ascenção na atualidade: a linguagem Rust.

O Rust é uma linguagem de programação de sistemas, desenvolvida como um projeto pessoal pelo desenvolvedor Graydon Hoare (que também criou a linguagem Swift), que trabalhava na Mozilla Research, sendo posteriormente financiado pela empresa.

É uma linguagem que foi projetada para ser segura, rápida e com suporte a concorrência, combinando o controle de baixo nível existente em linguagens como C e C++ com recursos de alto nível, como gerenciamento de memória sem garbage collector, sistema de tipos forte e estático e abstrações de dados.

Logo da linguagem Rust de Programação

O site oficial da linguagem Rust é o rust-lang.org.

Linguagens de programação de sistemas são empregadas para criar software e plataformas de software, como sistemas operacionais, compiladores, motores de jogos, sistemas embarcados, etc.

Ou seja, são linguagens que efetuam uma forte interação com o hardware da máquina. Outros exemplos de linguagens de sistemas são as linguagens C e C++.

Características do Rust

Uma das principais características da linguagem Rust é sua ênfase na segurança e na prevenção de erros de programação comuns, como por exemplo acessos inválidos a memória, vazamentos de memória e condições de corrida em programas concorrentes.

Para isso, a linguagem inclui diversos recursos como verificação de limites de vetor em tempo de compilação, controle de mutabilidade de dados, gerenciamento de memória baseado em propriedade (ownership) e sistema de tipos avançado com  exclusão mútua.

Além disso, outra característica importante da linguagem Rust é seu desempenho, que pode ser comparado ao de linguagens de sistemas como linguagem C e C++.

Isso se deve em parte ao fato de Rust permitir programação de baixo nível, incluindo acesso direto a hardware, sem a sobrecarga de um garbage collector ou de outros recursos de linguagens de alto nível.

Sendo assim, podemos resumir algumas das características principais da linguagem Rust como sendo:

• Desempenho
  Essa linguagem não possui um coletor de lixo (Garbage Collector – GC) por padrão. Por conta disso, o desempenho em tempo de execução é bastante melhorado.
• Segurança de memória em tempo de compilação
  Softwares criados com Rust são protegidos contra problemas de memória, como ponteiros pendentes, estouros de buffer e vazamentos de memória.
• Aplicativos Multi-Thread
  As regras de propriedade e segurança de memória do Rust fornecem simultaneidade sem corridas de dados.
• Suporte para Web Assembly (WASM)
  O Web Assembly ajuda a executar algoritmos de computação altamente intensiva no navegador, em dispositivos embarcados ou em qualquer outro lugar. Ele é executado na velocidade do código nativo, para execução rápida e confiável.

Além disso, o Rust tem uma comunidade de desenvolvedores ativa e crescente, com muitas bibliotecas e ferramentas disponíveis para uma variedade de aplicações, incluindo automação de processos, jogos, computação científica e sistemas embarcados.

Quais são as aplicações da linguagem Rust?

A linguagem Rust é uma linguagem de programação de propósito geral que foi desenvolvida com o objetivo de fornecer segurança e alto desempenho em sistemas de software. Algumas das principais aplicações da linguagem Rust incluem:

• Sistemas Operacionais: a linguagem Rust é adequada para o desenvolvimento de sistemas operacionais devido à sua segurança e desempenho.
• Software de rede: a linguagem Rust é adequada para o desenvolvimento de software de rede devido à sua capacidade de lidar com operações de E/S de forma eficiente e segura.
• Software para sistemas embarcados: a linguagem Rust é adequada para o desenvolvimento de software de sistemas embarcados devido à sua capacidade de fornecer código de baixo nível com segurança e alto desempenho.
• Servidores web: a linguagem Rust é adequada para o desenvolvimento de servidores web devido à sua capacidade de lidar com grande quantidade de requisições simultâneas com eficiência e segurança.
• Jogos: a linguagem Rust é adequada para o desenvolvimento de aplicações de jogos devido à sua capacidade de fornecer alto desempenho e segurança no gerenciamento de memória.

Essas são algumas das principais aplicações da linguagem Rust. Com o seu crescimento e popularidade, novas aplicações e usos estão sendo desenvolvidos pela comunidade de programadores.

Parece excelente não? Mas como começar a programar em Rust?

No próximo tutorial mostrarei como instalar a linguagem e criar seu primeiro programa em Rust.

Referências

• Site oficial da linguagem Rust: https://www.rust-lang.org/
• Documentação oficial do Rust: https://doc.rust-lang.org/
• Rust by Example: https://doc.rust-lang.org/stable/rust-by-example/
• Rust Programming Language Book: https://doc.rust-lang.org/book/
• The Rust Programming Language Blog: https://blog.rust-lang.org/

O post O que é a linguagem Rust de programação apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.