Se você já usou o sistema operacional Linux, provavelmente deve ter se deparado com sua linha de comandos, geralmente empregada para a realização de tarefas administrativas como instalação de pacotes, atualização de drivers e execução de ferramentas de manutenção, entre outras.

Essa linha de comandos é, normalmente, executada em um terminal, que pode rodar em um console diretamente ou ser emulado.

Como? Esses termos não significam a mesma coisa?

Na prática, não. Quando falamos em Linux e outros sistemas operacionais baseados em Unix, os termos Terminal, Console, Shell e Linha de Comandos são frequentemente utilizados para descrever aspectos distintos da interação do usuário com o sistema. Apesar de parecerem semelhantes, cada um desempenha um papel específico e está relacionado a diferentes níveis de interface e funcionalidade.

Neste artigo explico de forma sucinta o que é cada um desses termos, e suas diferenças.

Terminal

Quando falamos em Terminal estamos nos referindo, em sua essência, à interface que permite ao usuário interagir com o sistema por meio de entrada e saída de comandos de texto. Historicamente, o terminal era um dispositivo físico, como os antigos teletypes (TTY, em português Teletipos), que conectavam usuários a computadores remotos, permitindo a execução de comandos e a recepção de respostas. Hoje, em sistemas modernos como o Linux, o terminal é normalmente um software que emula essa funcionalidade em uma interface gráfica chamado de emulador de terminal.

Teletipo Teletype Corporation ASR-33.
Imagem: Wikimedia Commons

Softwares como GNOME Terminal, Konsole, ou xterm são exemplos de emuladores de terminal que permitem ao usuário acessar o sistema por meio de texto. Portanto, o terminal é a janela ou ambiente onde os usuários digitam comandos e observam os resultados, funcionando como uma ponte de comunicação com o sistema.

Tela de um emulador de terminais rodando em um sistema Linux Mint.

Console

Já o Console originalmente referia-se ao terminal físico diretamente conectado ao computador, sendo um monitor e teclado dedicados para administrar o sistema. Com o tempo, o termo evoluiu para incluir consoles virtuais, que permitem múltiplas sessões de trabalho em modo de texto em um sistema Linux. Acessíveis por teclas de atalho (como Ctrl+Alt+F1 até F6), esses consoles são comumente usados em situações em que a interface gráfica não está disponível ou não é necessária, como em servidores ou durante o processo de boot.

O console oferece uma interface de baixo nível, proporcionando acesso direto ao sistema em modo de texto.

Shell

O Shell é o programa que interpreta os comandos digitados no terminal ou console e os executa. Ele serve como uma interface entre o usuário e o sistema operacional, processando os comandos e retornando resultados. No Linux, existem diversos tipos de shells, sendo o mais comum o Bash (Bourne Again Shell), amplamente utilizado por sua versatilidade e capacidade de processamento de comandos complexos e scripts. Outros exemplos incluem o Zsh (Z Shell), conhecido por suas funções avançadas de automação, e o Fish (Friendly Interactive Shell), que oferece uma interface mais amigável e interativa. Independentemente do tipo de shell, sua função é sempre interpretar e executar os comandos fornecidos pelo usuário.

O shell é normalmente programável, podendo ser usado para escrever scripts (sequências automatizadas de comandos), por exemplo usando linguagem Shell Scripting.

Linha de Comandos

Uma Linha de Comandos, por sua vez, é uma interface onde os comandos são efetivamente inseridos e executados. Ela é a área ativa dentro de um terminal ou console onde o shell está operando. A linha de comandos é o ambiente textual que permite interação direta com o sistema, sem a necessidade de interfaces gráficas. Nela, o usuário pode inserir comandos simples, como listar arquivos ou pastas com o comando ls, ou comandos complexos que envolvem pipelines, redirecionamentos, filtros e automação de tarefas.

Em outras palavras, a linha de comandos é onde o usuário “conversa” com o shell, enviando instruções e recebendo saídas em texto. Também conhecida pela sigla CLI – Command Line Interface.

Resumo

Em resumo, temos que:

• Terminal é o ambiente (físico ou emulado) onde o usuário interage com o sistema por meio de texto. Emuladores de terminal são programas gráficos usados para essa interação.
• Console se refere ao terminal físico ou a consoles virtuais em modo texto, onde o usuário pode interagir diretamente com o sistema, sem uma interface gráfica.
• Shell é o intérprete de comandos, o programa que interpreta e executa os comandos inseridos no terminal ou console. Ele processa a entrada do usuário e retorna saídas e resultados..
• Linha de Comandos é a interface onde o usuário insere comandos diretamente. É a área dentro do terminal ou console onde o shell está ativo e processa comandos.

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 Qual a diferença entre Terminal, Console, Shell e Linha de Comandos no Linux? apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

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.

O comando sleep, no Linux, é empregado para pausar um processo por um período de tempo especificado na forma de um ou mais argumentos passados a ele. Esse tempo pode ser especificado em segundos (padrão), minutos, horas ou dias.

Sintaxe

$ sleep numero [opções|unidades]...

Onde numero é um valor inteiro positivo, seguido por uma unidade de tempo opcional. Se a unidade de tempo não for especificada, será assumida como sendo tempo em segundos, por padrão.

As unidades aceitas pelo sleep são as seguintes:

• s: segundos
• m: minutos
• h: horas
• d: dias

É possível passar mais de um valor de tempo ao comando, e nesse caso os valores são somados automaticamente para resultar no valor da temporização final.

No lugar de numero também é possível usar a palavra inf, que significa pausa infinita.

As únicas opções disponíveis para o sleep são –help (para ajuda do comando) e –version (consultar versão).

Para que usamos exatamente o comando sleep?

O comando sleep pode ser usado em diversas tarefas em um sistema Linux, tais como:

• Sincronização de processos, permitindo inserir atrasos entre comandos ou processos, garantindo a execução sequencial correta.
• Economia de recursos ao usar scripts ou loops, sendo possível reduzir o uso de CPU ao aguardar antes de novas tentativas ou verificações.
• Automação de tarefas repetitivas em intervalos de tempo em scripts.

Entre outras.

Exemplos do comando sleep

Pausar por 10 segundos:

$ sleep 10

Pausar por 5 minutos:

$ sleep 5m

Pausar por 1 minuto e 30 segundos:

$ sleep 1m 30s

Pausar infinitamente:

$ sleep inf

Pausar por 300 milissegundos:

$ sleep 300e-3

Neste exemplo, 300e-3 significa 300 x 10-3, ou seja, 300/1000 = 300ms

Gerenciamento de tarefas em sequência

Podemos criar um script que execute tarefas em sequência, mas com intervalos temporais definidos:

#!/bin/bash
./processo1.sh
sleep 30 # Aguarda 30 segundos antes de iniciar o próximo processo.
./processo2.sh

Repetição com intervalo de tempo em loops

Também podemos usar o sleep para inserir pausas em scripts que realizem repetição de tarefas:

while true; do
  echo "Verificando servidor..."
  sleep 10 # Aguarda 10 segundos antes de repetir.
done

Conclusão

O comando sleep, como visto, é uma ferramenta simples, porém bastante útil no Linux, especialmente quando usado em scripts e para automação de processos.

Com ele podemos temporizar execuções, economizar recursos e sincronizar processos em sistemas e aplicações.

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 Pausar processos com temporização com o comando sleep no Linux apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

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

O Tor é uma ferramenta muito importante para os usuários que priorizam segurança e anonimato na Internet. O que ele faz é rotear seu tráfego web por meio da rede Tor, que consiste em milhares de servidores mantidos por voluntários ao redor do globo, criptografando os dados durante todo o processo.

Assim, suas atividades na Web permanecem anônimas e seguras.

A página oficial do projeto Tor é https://www.torproject.org/.

Por padrão, o Mint traz como navegador instalado apenas o Mozilla Firefox, mas não traz o Tor Browser, e se você precisar utilizar essa opção de navegador (por segurança, por exemplo), deve instalá-lo manualmente no sistema.

Vamos aos passos para realizar a instalação do navegador Tor 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 que necessitam de atualização, o sistema pode levar algum tempo até finalizar todo o processo. Apenas aguarde.

Assim também evitamos que ocorra algum problema de compatibilidade entre pacotes ao instalar o Tor.

Métodos de Instalação

O Tor pode ser instalado de mais de uma forma distinta. Neste tutorial veremos primeiramente como instalar o Tor baixando o navegador a partir do website oficial, o que garante que tenhamos a versão mais atualizada do software para a instalação.

Uma outra forma de instalar o navegador é usando o comando flatpak e um repositório flathub.

Baixar o pacote de instalação do Tor

Para baixar o pacote de instalação mais atual do Tor, executamos o seguinte comando no terminal:

$ wget https://dist.torproject.org/torbrowser/14.0.3/tor-browser-linux-x86_64-14.0.3.tar.xz

Neste caso estamos fazendo download da versão 14.0.3 do Tor. Pode ser que haja uma versão mais recente disponível, e para verificar visite a página https://www.torproject.org/download/.

Caso haja uma versão mais recente, apenas mude seu número no comando antes de executá-lo.

Extrair o arquivo

O instalador do Tor baixado é um arquivo compactado com extensão .xz. Devemos descompactá-lo antes de poder rodar a instalação. Podemos fazer isso com o comando tar, como segue (mude o número da versão para a que você tiver baixado):

$ tar -xvJf tor-browser-linux-x86_64-14.0.3.tar.xz

O conteúdo do arquivo será extraído para um diretório de nome tor-browser no local atual.

Diretório de instalação do Tor

Provavelmente você baixou e extraiu o conteúdo do pacote em seu diretório pessoal de Downloads. Porém, este não é um local adequado para armazenar os programas que baixamos e instalamos da Internet. Vamos mover a pasta descompactada do Tor para um local mais conveniente, como por exemplo o diretório /opt (ou outro de sua preferência):

$ sudo mv tor-browser /opt/

O diretório /opt é adequado para armazenar aplicativos de terceiros no sistema. Note que precisamos de privilégios de administrador (sudo) para realizar essa operação. Outro diretório comumente usado é o /usr/local/share/.

Entre no diretório logo a seguir:

$ cd /opt/tor-browser

Agora, vamos registrar o Tor como uma aplicação Desktop no sistema:

$ ./start-tor-browser.desktop --register-app

A opção –register-app informa ao sistema para registrar o aplicativo Tor Browser no ambiente de desktop.
Isso também cria atalhos no menu do sistema e integra o navegador como uma aplicação padrão.

Assim, o Tor Browser será configurado no sistema para ser acessado diretamente por meio do menu de aplicativos, sem a necessidade de navegar até o diretório e executar manualmente o arquivo.

Executar o Navegador Tor

Para abrir o navegador Tor basta acessar o atalho criado no menu do sistema, como segue:

Menu → Internet → Tor

Testar o Tor

Para abrir o navegador após a instalação, clique no atalho que foi criado automaticamente na GUI em Menu → Internet → Tor Browser.

Ao abrir o Tor pela primeira vez, você terá as opções de configurar uma conexão ou conectar à rede Tor , respectivamente nos botões “Configure a Conexão…” e “Conectar”.

A opção Conectar é a ideal para navegação em geral, e te conecta à rede do Tor usando configurações padrão.

Já a opção Configure a Conexão… é importante para locais com acesso restrito à Internet, como lugares onde há censura, ou ainda quando o usuário precisa de alguma configuração avançada de conexão, como servidores proxy e pontes Tor.

No geral, clicar na opção Conectar já é o suficiente para começar a usar o navegador Tor. Dependendo do local onde você está e da rede ao qual está se conectando, essa conexão pode levar até cerca de 60 segundos para ocorrer.

Quando o processo de conexão finalizar, você será redirecionado para a página padrão do Tor. Por padrão, o navegador usa o mecanismo de busca DuckDuckGo.

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

Remover o Tor do Linux

Caso você queira desinstalar o Tor do Linux, execute o seguinte comando no terminal:

$ sudo rm -r /opt/tor-browser

O comando apaga o diretório dos arquivos do Tor por completo.

Também devemos excluir o atalho da interface gráfica que foi criado ao registrar a aplicação. Para tal, executamos o comando a seguir:

$ sudo rm ~/.local/share/applications/start-tor-browser.desktop

Instalação usando Flatpak e Flathub

O Flatpak é um sistema de distribuição de aplicativos para Linux que permite aos desenvolvedores empacotar e distribuir software de forma independente da distribuição Linux utilizada pelo usuário. Ele cria um ambiente isolado (sandbox) para cada aplicativo, incluindo todas as suas dependências, o que garante que o software funcione de maneira consistente em diferentes sistemas.

Já o Flathub é um repositório central para os aplicativos distribuídos no formato Flatpak. Ele permite que os usuários instalem, atualizem e gerenciem aplicativos de forma universal, independente da distro usada.

Vamos habilitar o Flathub no Linux (geralmente está por padrão) rodando o seguinte comando:

$ sudo flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo

Após habilitar o Flathub, procedemos à instalação do Tor executando o comando a seguir:

$ flatpak install flathub org.torproject.torbrowser-launcher/x86_64/stable -y

Os pacotes necessários serão automaticamente baixados e instalados no sistema.

Remover Tor instalado via Flatpak

Para desinstalar o navegador Tor que foi instalado usando o Flaspak, basta rodar o comando a seguir:

$ flatpak remove --delete-data org.torproject.torbrowser-launcher/x86_64/stable -y

Conclusão

Neste tutorial vimos como efetuar a instalação do navegador Tor no Linux, de forma bastante simples, que envolve o download do instalador e o uso de alguns comandos no terminal do sistema. Nos próximos tutoriais veremos como instalar outros navegadores no Linux, como os navegadores Google Chrome, Vivaldi e o Bravo, entre outros.

Enquanto isso, aproveite para assistir a um vídeo tutorial de instalação do navegador Tor no Linux, caso prefira esse formato de aprendizado:

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 navegador Tor no Linux Mint e similares 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.