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

Por que usar o htop?

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

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

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

Instalação do htop

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

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

Como usar o htop

Para iniciar o htop, basta executar:

$ sudo htop

Interface do htop

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

1 – Cabeçalho

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

Aqui temos:

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

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

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

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

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

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

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

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

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

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

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

2 – Lista de processos

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

As colunas são:

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

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

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

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

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

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

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

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

%CPU: Porcentagem de uso de CPU pelo processo.

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

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

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

3 – Rodapé

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

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

Vejamos alguns exemplos de uso do htop agora.

Exemplos práticos

1 – Listar todos os processos:

$ sudo htop

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

2 – Ordenar processos pelo uso de memória:

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

3 – Exibir processos em formato de árvore

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

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

4 – Buscar um processo específico

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

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

5 – Matar (kill) um processo

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

6 – Filtrar processos

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

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

Exercícios: Comando htop

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

Resolução dos exercícios

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

   $ sudo htop

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

   Pressione F5.

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

   Pressione F6 e escolha %MEM.

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

   Pressione F3 e digite htop.

5. Matar um processo específico:

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

Conclusão

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

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

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

O que é o comando top?

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

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

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

Sintaxe do top

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

top [opções]

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

Interface do top

1. Cabeçalho do sistema

Informações gerais sobre o estado do sistema.

Saída típica:

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

Aqui temos:

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

2. Resumo dos recursos do sistema

Saída típica:

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

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

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

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

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

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

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

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

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

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

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

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

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

3. Lista de processos

Saída típica:

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

Onde:

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

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

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

Quanto menor o valor, maior a prioridade.

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

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

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

Principais comandos interativos no top

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

Vejamos agora alguns exemplos do uso de top no Linux.

Exemplos do comando top

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

$ sudo top

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

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

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

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

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

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

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

$ top -u fabio

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

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

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

Exercícios: comando top

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

Resolução dos exercícios

1. Liste os 5 processos que mais consomem CPU

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

2. Finalize um processo de baixa prioridade

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

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

Execute o comando:

$ sudo top -u $USER

4. Altere o niceness de um processo

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

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

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

Conclusão

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

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

Até mais!

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

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

Sintaxe básica do ps

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

$ ps [opções]

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

Opções comuns do comando ps

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

1. ps (sem opções)

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

$ ps

Saída típica:

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

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

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

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

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

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

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

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

2. ps -e ou ps -A

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

$ ps -e

Saída típica:

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

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

3. ps -f

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

$ ps -f

Saída típica:

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

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

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

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

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

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

4. ps aux

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

$ ps aux

Saída típica:

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

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

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

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

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

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

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

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

5. ps -u [usuário]

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

$ ps -u root

6. ps -p [PID]

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

$ ps -p 1234

7. ps –forest

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

$ ps --forest

8. ps -eo

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

$ ps -eo pid,cmd

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

Exemplos do comando ps

Exemplo 1: Encontrar um processo pelo nome

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

$ ps aux | grep bash

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

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

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

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

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

Conclusão

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

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

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

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.

A expressão Globbing (“Englobamento”) no Linux se refere ao uso de metacaracteres para realizar correspondências de padrões de nomes de arquivos e diretórios. Essa técnica é amplamente utilizada para facilitar o trabalho com grupos de arquivos em vez de manipular cada um individualmente.

Em um shell Linux (como o Bash), o globbing permite que expressões como *, ? e [] sejam interpretadas pelo shell para encontrar arquivos e diretórios com base em um padrão específico.

Principais Metacaracteres Usados no Globbing

Os principais metacaracteres (caracteres-curinga) usados para englobamento incluem os seguintes:

1. Asterisco (*)

Corresponde a qualquer sequência de caracteres (incluindo nenhum caractere). Ele é útil quando se quer selecionar todos os arquivos de uma pasta ou aqueles que seguem um padrão específico.

Exemplo:

$ ls *.txt

Esse comando lista todos os arquivos com a extensão .txt no diretório atual.

2. Interrogação (?)

Corresponde a exatamente um caractere. É utilizado quando se precisa de uma correspondência para um arquivo com um caractere específico em uma posição fixa.

Exemplo:

$ ls arquivo?.txt

corresponde a arquivo1.txt, arquivoA.txt, etc., mas não a arquivoAB.txt.

3. Colchetes ([])

Definem um conjunto de caracteres permitidos em uma posição específica. É útil para corresponder a um caractere entre várias opções.

Exemplo:

$ ls arquivo[12].txt

corresponde a arquivo1.txt e arquivo2.txt, mas não a arquivo3.txt.

4. Hífens dentro de colchetes ([a-z])

Definem intervalos de caracteres. Isso permite correspondências com qualquer caractere dentro do intervalo especificado.

Exemplo:

$ ls arquivo[a-c].txt

corresponde a arquivoa.txt, arquivob.txt, e arquivoc.txt.

5. Exclamação ou Circunflexo ([!abc] ou [^abc])

Excluem caracteres específicos de uma correspondência.

Exemplo:

$ ls arquivo[!0-9].txt

corresponde a arquivos como arquivob.txt, mas não a arquivo3.txt.

Como o globbing funciona

O shell expande esses padrões de globbing antes de executar o comando. Por exemplo, ao digitar ls *.txt, o shell transforma *.txt em uma lista de arquivos que terminam em .txt e executa o comando ls com essa lista como argumento.

Existe diferença entre globbing e expressões regulares?

Embora ambos sejam usados para correspondência de padrões, globbing e expressões regulares não são a mesma coisa. Globbing é mais simples e focado em padrões de nomes de arquivos, enquanto as expressões regulares são mais poderosas e complexas, sendo usadas para correspondência de padrões em textos de maneira geral.

Conclusão

O globbing simplifica o gerenciamento de arquivos no Linux, permitindo operações em lote com apenas alguns caracteres. Conhecer globbing é bastante importante para todos que trabalham em linha de comando pois facilita operações como listar, mover e excluir grupos de arquivos com rapidez e eficiência.

O post O que é Globbing no Linux apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.