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.

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.

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 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.

Em Shell Scripting, os laços de repetição são estruturas que permitem executar uma série de comandos várias vezes. Os loops ajudam a automatizar tarefas repetitivas, iterando sobre listas, variáveis, comandos e arquivos. O Bash oferece algumas estruturas de repetição essenciais: for, while, e until.

Vamos explorar cada uma, com exemplos práticos e exercícios ao final.

O laço for em shell scripting

O laço for é usado para percorrer uma lista de itens, como um conjunto de números, strings ou até mesmo arquivos. Ele executa o conjunto de comandos uma vez para cada item na lista.

Sintaxe básica do laço for

for item in lista; do
   Comandos a serem executados
done

Exemplo 1: Laço for simples

Esse exemplo exibe uma mensagem para cada nome da lista.

#!/bin/bash
for nome in Fábio Marcos Bruno Robson; do
  echo "Olá, $nome!"
done

Saída:

Olá, Fábio!
Olá, Marcos!
Olá, Bruno!
Olá Robson!

Exemplo 2: Laço for com intervalo de números

Podemos definir um intervalo de números e iterar sobre ele:

#!/bin/bash
for i in {1..5}; do
echo "$i"
done

Saída:

1
2
3
4
5

Exemplo 3: Loop for sobre arquivos em um diretório

Este exemplo percorre todos os arquivos .txt em um diretório e exibe o nome de cada arquivo.

#!/bin/bash
for arquivo in *.txt; do
echo "Encontrado arquivo: $arquivo"
done

O laço while em shell scripting

O laço while repete os comandos definidos em seu corpo enquanto uma condição testada for verdadeira. Ele é útil quando a quantidade de iterações não é definida e depende de uma condição.

Sintaxe básica do while

while [ condição ]; do
    Comandos a serem executados
done

Vejamos alguns exemplos do loop while em scripts do shell.

Exemplo 1: Loop while simples

Exibir no terminal a sequência de números de 1 a 5:

#!/bin/bash
contador=1
while [ $contador -le 5 ]; do
  echo "$contador"
  contador=$((contador + 1))
done

Saída:

1
2
3
4
5

Exemplo 2: Ler valores do terminal de forma sequencial.

O script a seguir solicita que o usuário digite um número no terminal. Ele repete a solicitação até que o usuário entre com o valor 0, momento em que o loop termina.

#!/bin/bash
# Inicializar com um valor diferente de 0 para entrar no loop
numero=-1
while [ $numero -ne 0 ]; do
  read -p "Digite um número (0 para sair): " numero
  echo "Você digitou: $numero"
done
echo "Fim do laço. Você digitou 0."

O laço until em shell scripting

O laço until é semelhante ao laço while, mas ele repete os comandos enquanto uma condição for falsa, e para a execução quando a condição se torna verdadeira.

Sintaxe básica do until

until [ condição ]; do
    Comandos a serem executados
done

Vejamos alguns exemplos.

Exemplo 1: Loop until simples

Este exemplo incrementa um contador até que ele atinja 5:

#!/bin/bash
contador=1
until [ $contador -gt 5 ]; do
  echo "$contador"
  contador=$((contador + 1))
done
echo "Sequência terminada."

Saída:

1
2
3
4
5
Sequência terminada.

Comandos de controle de loop

Existem comandos de controle que podem ser usados para manipular o comportamento de um loop:

• break: Sai do loop imediatamente.
• continue: Pula a iteração atual e vai para a próxima.

Vejamos como usá-los em scripts.

Exemplo: Uso de break

Este exemplo usa break para sair do loop se o contador atingir 3.

#!/bin/bash
for i in {1..5}; do
  if [ $i -eq 3 ]; then
    echo "Saindo do loop no número $i"
    break
  fi
  echo "Número: $i"
done

Saída:

Número: 1
Número: 2
Saindo do loop no número 3

Exemplo: Uso de continue

Este exemplo usa continue para pular a exibição do número 3.

#!/bin/bash
for i in {1..5}; do
  if [ $i -eq 3 ]; then
    continue
  fi
  echo "Número: $i"
done

Saída:

Número: 1
Número: 2
Número: 4
Número: 5

Excelente. Vamos propor agora alguns exercícios para você treinar o uso de laços de repetição em Shell Scripting. Resoluções sugeridas se encontram logo após a lista de exercícios.

Exercícios práticos com laços de repetição

1. Crie um script que exiba uma contagem regressiva de 10 a 1 usando um loop for.
2. Use um loop while para somar os números de 1 a 100 e exibir o resultado total.
3. Escreva um script que use o loop for para percorrer arquivos .txt em um diretório e exiba o nome de cada arquivo encontrado.
4. Use um loop until para solicitar uma senha até que o usuário digite a senha correta (“1234”).
5. Crie um loop for que percorra os números de 1 a 10, pulando o número 5 e saindo do loop quando chegar ao número 8.

Resolução dos exercícios

Exercício 1

#!/bin/bash
for i in {10..1}; do
  echo "Contagem regressiva: $i"
done

Exercício 2

#!/bin/bash
soma=0
contador=1
while [ $contador -le 100 ]; do
  soma=$((soma + contador))
  contador=$((contador + 1))
done
echo "A soma de 1 a 100 é: $soma"

Exercício 3

#!/bin/bash
for arquivo in *.txt; do
  echo "Arquivo encontrado: $arquivo"
done

Exercício 4

#!/bin/bash
senha=""
until [ "$senha" == "1234" ]; do
  read -sp "Digite a senha: " senha
  echo
done
echo "Senha correta!"

#Exercício 5: Usar break e continue em um loop

#!/bin/bash
for i in {1..10}; do
  if [ $i -eq 5 ]; then
    continue
  fi
  if [ $i -eq 8 ]; then
    break
  fi
  echo "Número: $i"
done

Conclusão

Os laços de repetição em Shell Scripting permitem criar fluxos de trabalho eficientes para manipular dados, arquivos e outros elementos de forma automatizada.

Aprender a usar for, while e until com comandos de controle como break e continue aumenta a flexibilidade e o controle que temos sobre o código, permitindo resolver problemas de forma mais simples e eficiente.

O post Como usar laços de repetição em Shell Scripting apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

O comando echo no Linux é uma ferramenta utilizada para exibir mensagens, variáveis e resultados do processamento de scripts diretamente no terminal. Ele é muito empregado em scripts, mas também pode ser usado interativamente para imprimir texto e informações no console.

Neste tutorial, vamos explorar o comando echo e seus principais usos com vários exemplos, incluindo algumas de suas opções mais úteis.

Sintaxe básica do comando echo

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

echo [opções] [texto]

O comando echo exibe o texto ou o valor das variáveis passadas como argumento diretamente no terminal. Vejamos alguns exemplos agora.

Exemplos básicos de uso do echo

1. Exibir uma mensagem simples

echo "Bóson Treinamentos!"

Esse comando exibe a mensagem “Bóson Treinamentos!” no terminal.

2. Exibir texto com variáveis

O echo pode exibir valores armazenados em variáveis. Para isso, basta utilizar o caractere $ antes do nome da variável, como no exemplo a seguir:

nome="Isaac Newton"
echo "Bem-vindo, $nome!"

Saída:

Bem-vindo, Isaac Newton!

Principais opções do comando echo

O echo oferece algumas opções bastante úteis que permitem personalizar a saída:

• -n: Evita a quebra de linha no final da saída.
• -e: Permite o uso de caracteres de escape (como \n para nova linha, \t para tabulação).
• -E: Desativa o uso de caracteres de escape (geralmente já é o comportamento padrão).
• –version: Mostra informações sobre a versão do comando e sai

Vejamos alguns exemplos de uso do comando echo com essas opções.

Exemplos com as opções do echo

Exemplo 1: Usar -n para evitar a quebra de linha

Por padrão, echo adiciona uma nova linha ao final da saída. Com -n, essa quebra de linha é removida.

echo -n "Esta linha não termina com uma quebra de linha."
echo " Próxima linha será exibida na mesma linha."

Saída:

Esta linha não termina com uma quebra de linha. Próxima linha será exibida na mesma linha.

Ou ainda:

echo -n "Esta linha não termina com uma quebra de linha" && echo "Próxima linha será exibida na mesma linha"

Exemplo 2: Usar a opção -e para caracteres de escape

A opção -e permite adicionar caracteres especiais na saída. Alguns dos mais comuns são:

• \n: Nova linha
• \t: Tabulação
• \\: Barra invertida literal

Por exemplo:

echo -e "Linha 1\nLinha 2"

Saída:

Linha 1
Linha 2

Outro exemplo:

echo -e "Coluna 1\tColuna 2"

Saída:

Coluna 1    Coluna 2

Exemplo 3: Exibir aspas e caracteres especiais

Para exibir aspas duplas ou outros caracteres especiais, podemos usar a barra invertida \ para escape:

echo "\"Esse é um texto entre aspas\""

Saída:

"Esse é um texto entre aspas"

Usos comuns do echo

1. Exibir o conteúdo de variáveis de ambiente

Variáveis de ambiente, como $HOME, $USER e $PATH, contêm informações importantes sobre o sistema e o usuário atual. O echo é útil para acessar e mostrar esses valores rapidamente.

echo "Usuário atual: $USER"
echo "Diretório pessoal: $HOME"
echo "Caminho de busca: $PATH"

Saída:

Usuário atual: nome_do_usuário
Diretório pessoal: /home/nome_do_usuário
Caminho de busca: /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

2. Exibir o resultado de comandos embutidos

O echo pode ser usado para exibir o resultado de outros comandos usando a sintaxe de substituição $(COMANDO):

echo "Data atual: $(date)"
echo "Diretório atual: $(pwd)"

Saída:

Data atual: Mon Oct 25 10:30:00 UTC 2024
Diretório atual: /home/nome_do_usuário

3. Escrever em um arquivo com echo

O echo também pode ser usado para escrever conteúdo em arquivos. Para isso, simplesmente usamos o operador de redirecionamento >:

echo "Texto de exemplo" > exemplo.txt

Esse comando cria o arquivo exemplo.txt (ou o sobrescreve se ele já existir) e insere “Texto de exemplo” nele.

Para adicionar ao final do arquivo sem sobrescrevê-lo, usamos >>:

echo "Outra linha" >> exemplo.txt

4. Usar o echo para criar quebras de linha e tabulações

Quando queremos formatar a saída do terminal com espaços e quebras de linha, o echo com com a opção -e facilita essa tarefa. Podemos criar mensagens organizadas, como em tabelas simples:

echo -e "Produto\tQuantidade\tPreço"
echo -e "Caneta\t10\t\t1.50"
echo -e "Caderno\t5\t\t4.00"

Saída:

Produto Quantidade Preço
Caneta  10         $1.50
Caderno 5          $4.00

Conclusão

O comando echo é uma ferramenta bastante usada para exibir informações no terminal e manipular texto. Com suas opções, ele permite criar saídas formatadas, armazenar dados em arquivos e acessar variáveis do sistema.

Esses recursos são úteis tanto no uso interativo quanto em scripts, permitindo uma comunicação clara e personalizada no terminal.

O post Como exibir mensagens com o comando echo no terminal do Linux apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Os comandos more e less no Linux são usados para visualizar o conteúdo de arquivos de texto no terminal, especialmente arquivos grandes. Ambos exibem o conteúdo de maneira paginada, permitindo uma leitura mais controlada, mas o less oferece funcionalidades mais avançadas, o que o torna mais útil em várias situações.

Comando more

O comando more permite visualizar arquivos paginados, de modo que é possível ver o conteúdo em uma tela por vez e avançar conforme necessário. Ele é útil para leitura rápida, embora tenha algumas limitações em relação ao less.

Uma observação importante: é possível que sua distribuição não tenha o comando more instalado por padrão, pois o comando less o substitui com vantagens. Se for o caso, e você quiser realmente utilizar esse comando, o instale com o gerenciador de pacotes de sua distribuição.

Sintaxe do more

$ more [arquivo]

Navegação no more

Para navegar dentro do comando less podemos os seguintes atalhos de teclado:

• Espaço: Avança uma página.
• Enter: Avança uma linha.
• q: Sai do modo more.

Exemplos de uso do comando more

Vejamos alguns exemplos de uso do comando more no Linux:

1. Visualizar um Arquivo com more

$ more /etc/passwd

Este comando exibe o conteúdo do arquivo /etc/passwd em uma tela de cada vez.

2. Usar more com cat e Redirecionamento

É possível combinar more com cat para exibir a saída paginada de um comando que gera muito conteúdo:

$ cat arquivo.txt | more

Comando less

O comando less é semelhante ao more, porém bem mais versátil. Ele permite rolar para cima e para baixo, realizar buscas, e sair sem exibir o conteúdo completo do arquivo.

Por isso, o less é bastante utilizado para ler arquivos longos e fazer consultas rápidas, pois permite mainter mais controle sobre a navegação e a filtragem de dados.

Sintaxe do less

$ less [arquivo]

Navegação Básica no less

Podemos navegar dentro do comando less usando os seguintes atalhos de teclado (entre outros):

• Espaço: Avança uma página.
• Seta para baixo ou Enter: Avança uma linha.
• Seta para cima: Retrocede uma linha.
• b: Retrocede uma página.
• q: Sai do less.

Funções Avançadas do less

O comando less também possui algumas funções mais “avançadas”, como busca de texto dentro do arquivo. Algumas dessas funções incluem:

• /texto: Procura por um termo no arquivo; pressione n para ir à próxima ocorrência.
• ?texto: Procura o termo na direção oposta (acima da posição atual).
• g: Vai diretamente para o início do arquivo.
• G: Vai diretamente para o final do arquivo.
• &texto: Filtra linhas com o termo especificado.

Vejamos agora alguns exemplos de uso do comando less.

Exemplos de Uso do less

1. Visualizar um Arquivo com less

$ less /etc/group

Esse comando abre o arquivo /etc/group e permite a navegação com rolagem e busca.

2. Buscar um Termo Específico

Para buscar uma palavra específica, usamos / seguido do termo desejado. Por exemplo, para encontrar “root” em /etc/passwd:

$ less /etc/passwd

Dentro do less, digite /root e pressione Enter. Pressione n para ir para a próxima ocorrência de “root”.

3. Ir para o Fim do Arquivo

Abra o arquivo lista-animais.txt e vá diretamente para o final do arquivo com G (maiúsculo):

$ less lista-animais.txt

Dentro do less, pressionamos o comando G para ir imediatamente ao fim do arquivo.

4. Filtrar Linhas

Para visualizar apenas linhas que contenham um termo específico, como “mamífero”, use o &:

$ less lista-animais.txt

No less, pressione &mamífero para exibir apenas linhas que contenham “mamífero”. Para voltar a exibir o texto completo, digite apenas & e depois Enter, sem digitar nenhum termo.

Exercícios Práticos

A seguir, temos uma lista de exercícios sobre os comandos more e less para você praticar:

1. Abrir o arquivo /etc/group com more e avançar uma linha de cada vez
   Navegue uma linha de cada vez usando o Enter até a metade do arquivo.
2. Buscar o termo “home” no arquivo /etc/passwd usando less
   Abra o arquivo /etc/passwd com less, busque por “home” e navegue pelas ocorrências com n.
3. Abrir arquivo.txt com less e ir diretamente para o final do arquivo
   Use o comando less para abrir arquivo.txt e pressione G para ir ao final do conteúdo.
4. Filtrar Linhas em lista-animais.txt para Exibir Apenas Aves
   Abra lista-animais.txt com less e exiba somente as linhas que contenham “ave” usando o &.

Resolução dos Exercícios

Exercício 1

Para abrir o arquivo /etc/group com more e avançar uma linha de cada vez:

$ more /etc/group

Pressione Enter para avançar linha por linha até alcançar a metade do arquivo.

Exercício 2

Para buscar o termo “home” no arquivo /etc/passwd usando less:

$ less /etc/passwd

Dentro do less, digite /home e pressione Enter. Pressione n para ir para a próxima ocorrência.

Exercício 3

Para abrir arquivo.txt com less e ir diretamente ao final:

$ less arquivo.txt

Dentro do less, pressione G maiúsculo para exibir o final do arquivo.

Exercício 4

Para filtrar e exibir apenas linhas que contenham “ave” em lista-animais.txt:

$ less lista-animais.txt

Dentro do less, pressione &ave e Enter para exibir apenas as linhas que contêm “ave”.

Conclusão

O less é uma ferramenta muito importante para leitura de arquivos no terminal do Linux, especialmente quando lidamos com grandes volumes de dados. Por conta de seus recursos de navegação e busca, ele nos traz controle e agilidade no terminal.

Já o more, embora mais simples, também é útil para leitura rápida de arquivos menores – lembrando que ele pode não estar disponível em todas as distribuições Linux.

O post Visualizar o conteúdo de arquivos com comandos more e less no Linux apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

O comando wc no Linux (abreviação de word count ou “contagem de palavras”) é utilizado para realizar a contagem do número de linhas, palavras e bytes de um ou mais arquivos. Este comando é bastante útil para obter informações sobre o tamanho de arquivos, especialmente em análises de texto ou processamento de logs.

Sintaxe do Comando wc

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

wc [opções] [arquivo(s)]

O comando possui algumas opções importantes, que veremos na próxima seção.

Opções Comuns do Comando wc

As principais opções do wc incluem:

• -l: Conta apenas o número de linhas.
• -w: Conta apenas o número de palavras.
• -c: Conta o número de bytes.
• -m: Conta o número de caracteres.
• -L: Exibe o comprimento da linha mais longa no arquivo.

Exemplos de Uso do Comando wc

Vejamos alguns exemplos de uso do comando wc para entender melhor seu funcionamento e aplicação.

Exemplo 1. Contar Linhas, Palavras e Bytes em um Arquivo

Para contar o número total de linhas, palavras e bytes em um arquivo, basta utilizar o comando wc seguido do nome do arquivo:

$ wc /etc/passwd

A saída mostrará três colunas: número de linhas, número de palavras e número de bytes. Como resultado, teremos algo como:

45 101 2784 /etc/passwd

Neste exemplo, a saída do comando indica que o arquivo possui 45 linhas, 101 palavras (incluindo números) e 2784 bytes no total.

Exemplo 2. Contar Apenas Linhas

Para contar somente o número de linhas em um arquivo, podemos usar a opção -l:

$ wc -l /etc/passwd

Exemplo 3. Contar Apenas Palavras

Se o interesse for apenas o número de palavras em um arquivo, a opção -w é a indicada:

$ wc -w lista-animais.txt

Exemplo 4. Contar Bytes ou Caracteres

Para obter o número de bytes em um arquivo, utilizamos a opção -c:

$ wc -c arquivo.txt

Caso o interesse seja contar o número de caracteres (diferente de bytes em arquivos de codificações diferentes), utilize -m:

$ wc -m arquivo.txt

Exemplo 5. Exibir o Comprimento da Linha Mais Longa

Para saber o comprimento da linha mais longa em um arquivo, utilizamos a opção -L:

$ wc -L lista-animais.txt

Essa opção é útil para identificar o tamanho de linhas e verificar o conteúdo mais extenso no arquivo.

Exemplo 6. Contar Linhas em Múltiplos Arquivos

É possível utilizar o wc em vários arquivos ao mesmo tempo. No exemplo a seguir, contamos as linhas nos arquivos arquivo.txt e lista-animais.txt:

$ wc -l arquivo.txt lista-animais.txt

A saída irá mostrar o número de linhas em cada arquivo e uma linha final com o total combinado.

Exercícios Práticos com o Comando wc

Vejamos agora uma lista de exercícios práticos para praticar um pouco mais o uso do comando wc no Linux. As resoluções de cada um estão logo após a lista.

1. Utilize o comando para exibir apenas o número de linhas no arquivo /etc/group
2. Exibir o total de palavras no arquivo lista-animais.txt
3. Qual o número total de caracteres (incluindo espaços e pontuação) no arquivo arquivo.txt?
4. Qual o comprimento da linha mais longa no arquivo /etc/passwd?
5. Exibir o número de linhas, palavras e bytes nos arquivos arquivo.txt e lista-animais.txt

Resolução dos Exercícios

A seguir temos a resolução de cada exercício:

Exercício 1

Para contar o número de linhas no arquivo /etc/group, utilizamos:

$ wc -l /etc/group

A saída irá mostrar algo como 25 /etc/group, onde 25 representa o número de linhas.

Exercício 2

Para contar o número de palavras em lista-animais.txt, executamos:

$ wc -w lista-animais.txt

Supondo que haja 20 palavras no arquivo, a saída será 20 lista-animais.txt.

Exercício 3

Para contar o número de caracteres em arquivo.txt, usamos:

$ wc -m arquivo.txt

A saída mostrará o total de caracteres presentes no arquivo.

Exercício 4

Para verificar o comprimento da linha mais longa no arquivo /etc/passwd, utilizamos:

$ wc -L /etc/passwd

A saída pode ser algo como 75 /etc/passwd, indicando que a linha mais longa tem 75 caracteres.

Exercício 5

Para exibir o número de linhas, palavras e bytes nos arquivos arquivo.txt e lista-animais.txt, use o comando:

$ wc arquivo.txt lista-animais.txt

A saída listará as contagens para cada arquivo e o total, algo como:

5 15 100 arquivo.txt
7 20 150 lista-animais.txt
12 35 250 total

Conclusão

O comando wc é útil para obter rapidamente informações sobre o tamanho e o conteúdo de arquivos no Linux. Ele é especialmente útil em scripts de automação, onde essas contagens podem servir como parâmetros de controle, além de auxiliar em operações de análise de texto e organização de dados em sistemas Linux.

O post Como contar linhas e palavras com comando wc no Linux apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.