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.

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.

O utilitário tar no Linux é uma ferramenta extremamente útil e amplamente utilizada para empacotamento / arquivamento e compressão de arquivos e diretórios. A palavra “tar” vem de “Tape Archive“, pois historicamente o comando foi desenvolvido para fazer backups em fitas magnéticas.

O tar permite agrupar vários arquivos em um único arquivo, conhecido como arquivo tar ou tarball, que pode ser comprimido para economizar espaço.

Neste tutorial veremos como usar o comando tar para empacotar e comprimir arquivos e diretórios no Linux.

Sintaxe Básica do Comando tar

A sintaxe básica do comando tar é:

tar [opções] arquivo.tar [arquivos/diretórios]

Algumas das opções mais comuns incluem:

• -c : Cria um novo arquivo tar.
• -x : Extrai os arquivos de um arquivo tar.
• -t : Lista o conteúdo de um arquivo tar.
• -v : Mostra o processo detalhado (verbose) enquanto o comando é executado.
• -f : Especifica o nome do arquivo tar.
• -z : Compacta o arquivo com gzip (.tar.gz).
• -j : Compacta o arquivo com bzip2 (.tar.bz2).
• -J : Compacta o arquivo com xz (.tar.xz).

Como criar arquivos Tar

Para criar um arquivo tar, usamos a opção -c combinada com a opção -f para especificar o nome do arquivo. Vejamos alguns exemplos.

Exemplo 1: Criar um arquivo empacotado tar de nome vim.tar com o conteúdo do diretório /etc/vim

$ tar -cvf vim.tar /etc/vim/

Esse comando, portanto, cria um arquivo chamado vim.tar com o conteúdo do diretório /etc/vim/.

Exemplo 2: Criar um Arquivo tar Compactado com gzip

Vamos criar agora um arquivo empacotado semelhante ao exemplo anterior, porém compactando-o com o utilitário gzip. Para tal, basta acrescentar a opção -z ao comando (e não esqueça de acrescentar a extensão .gz ao arquivo): 

tar -czvf vim.tar.gz /etc/vim/

Aqui, o arquivo vim.tar.gz é criado e compactado com gzip. Podemos comparar os arquivos criados para ver seus respectivos tamanhos:

$ ls -l vim*

Exemplo 3: Criar um arquivo tar compactado com a ferramenta bzip2

(Não esqueça de alterar a extensão para .bz2).

$ tar -cjvf vim.tar.bz2 /etc/vim/

Este comando cria um arquivo .tar.bz2, usando bzip2. Verificamos os tamanhos dos arquivos criados para comparação na sequência:

$ ls -l vim*

Como extrair arquivos tar

Para extrair arquivos, usa-se a opção -x, e normalmente -v para ver o progresso.

Exemplo 1: Extrair o arquivo tar vim.tar

$ tar -xvf vim.tar
$ ls

Com esse comando extraímos o conteúdo de vim.tar no diretório atual.

Exemplo 2: Extrair um Arquivo tar compactado com gzip

$ tar -xzvf vim.tar.gz

Aqui, o conteúdo de vim.tar.gz é extraído e descompactado no diretório atual.

Exemplo 3: Extrair um arquivo tar para um diretório específico

Vamos extrair o conteúdo do pacote vim.tar para dentro do diretório Documentos do usuário atual:

$ tar -xvf vim.tar -C ~/Documentos/
$ ls ~/Documentos

Com esse comando o conteúdo do arquivo vim.tar será extraído para o diretório especificado.

Exemplo 4: Extrair um arquivo específico de um pacote tar

Podemos também extrair um ou mais arquivos específicos de um pacote tar, sem no entanto extrair o conteúdo completo do pacote. Para tal usamos a opção –extract como segue:

$ tar -vf arquivo.tar --extract arquivo1 arquivo2 ...

Exemplo: Suponha um arquivo backup.tar que contenha diversos arquivos, entre eles um arquivo de nome ls.txt. Para extrair apenas esse arquivo no diretório atual executamos:

$ tar -vf backup.tar --extract ls.txt

Como listar o conteúdo de um arquivo tar

O que há dentro do arquivo tar criado? A opção -t permite ver o conteúdo de um arquivo tar sem extraí-lo.

$ tar -tvf vim.tar

Esse comando exibe uma lista de arquivos e diretórios dentro de vim.tar.

Como adicionar mais arquivos a um arquivo tar existente

O tar também permite adicionar mais arquivos a um arquivo tar existente usando a opção -r. Vamos adicionar o arquivo pwd.dat ao arquivo vim criado anteriormente, e depois visualizar seu conteúdo atualizado:

$ pwd > pwd.dat
$ tar -rvf vim.tar pwd.dat
$ tar -tvf vim.tar

Como remover arquivos de um arquivo tar

Para excluir arquivos de dentro de um pacote tar criado, podemos usar a opção –delete seguida do nome do arquivo ou arquivos a excluir. Por exemplo, vamos remover o arquivo pwd.dat de dentro de vim.tar:

$ tar -vf vim.tar --delete pwd.dat
$ tar -tvf vim.tar

É isso aí! Vimos vários exemplos de uso do tar, e agora vamos fazer mais alguns exercícios de reforço para fixar o aprendizado da ferramenta.

Exercícios com resolução

A seguir temos alguns exercícios para treinarmos o uso do comando tar no Linux.

Exercício 1: Criar um arquivo tar com dois diretórios e compactá-lo com gzip

Instrução: Use o comando tar para criar um arquivo chamado backup.tar.gz que inclua os diretórios /home/fabio/Documentos e /home/fabio/Imagens, compactando-o com gzip.

Solução:

tar -czvf backup.tar.gz /home/fabio/Documentos /home/fabio/Imagens

Esse comando cria um arquivo chamado backup.tar.gz contendo ambos os diretórios. Com o comando ls podemos ver o arquivo criado no diretório atual:

$ ls -l

Exercício 2: Extrair um Arquivo tar para um diretório específico

Instrução: Extraia o conteúdo do arquivo backup.tar.gz para o diretório /tmp/backup.

Solução:

$ mkdir /tmp/backup
$ tar -xzvf backup.tar.gz -C /tmp/backup/
$ tree /tmp/backup

Exercício 3: Listar o conteúdo de um arquivo compactado sem extraí-lo

Devemos listar todos os arquivos e diretórios dentro de backup.tar.gz sem extrair o arquivo.

Solução:

$ tar -tzvf backup.tar.gz

Exercício 4: Adicionar um arquivo de texto a um arquivo tar existente

Instrução: Adicione o arquivo /home/fabio/ls.txt ao arquivo backup.tar e depois visualize o conteúdo do arquivo tar.

Lembre-se de criar o arquivo sem compactação .tar antes, pois não é possível atualizar o conteúdo de arquivos compactados. Suponha também que você já esteja no diretório do usuário, por exemplo /home/fabio/.

Solução:

ls > ls.txt
tar -cvf backup.tar ./Documentos ./Imagens
tar -rvf backup.tar /home/fabio/ls.txt
tar -tvf backup.tar.gz

Conclusão

O tar é uma ferramenta essencial para manipulação de arquivos no Linux, permitindo arquivar e compactar grandes volumes de dados. Ele é amplamente utilizado para backup, transferência e armazenamento de dados em uma estrutura organizada e eficiente, e por conta disso é essencial prender a usar essa ferramenta de forma adequada.

O post Arquivar e comprimir arquivos com comando tar no Linux apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

O comando grep no Linux é uma ferramenta bastante interessante e muito útil para realizar pesquisa de texto em arquivos e na saída de outros comandos. Seu nome vem de “Global Regular Expression Print“, pois ele permite buscar padrões usando expressões regulares.

Trata-se de uma ferramenta extremamente versátil e pode ser utilizado para localizar linhas específicas em arquivos, realizar pesquisas avançadas e filtrar dados com precisão.

Neste artigo veremos como usar o grep para realizar busca em textos de forma simplificada.

Sintaxe Básica do Comando grep

A sintaxe básica do grep é:

grep [opções] padrão arquivo

Os parâmetros mais comuns são:

• padrão: o texto ou expressão regular que será pesquisado.
• arquivo: o arquivo onde será realizada a busca (ou vários arquivos).

Exemplos de Uso do Comando grep

1. Buscar uma Palavra em um Arquivo

Para localizar uma palavra exata em um arquivo, basta especificar o termo e o arquivo. Vamos criar um arquivo de nome arquivo.txt e inserir algum conteúdo nele:

$ ls -l > arquivo.txt

E então buscar uma palavra dentro do arquivo, como a palavra “Documentos”:

$ grep "Documentos" arquivo.txt

Este comando exibe todas as linhas em arquivo.txt que contêm a palavra “Documentos”.

2. Pesquisa Insensível a Maiúsculas e Minúsculas

Para ignorar diferenças entre maiúsculas e minúsculas, usamos a opção -i:

$ grep -i "documentos" arquivo.txt

Este comando encontra “documentos”, “Documentos”, “DOCUMENTOS”, etc.

3. Contar Ocorrências de um Padrão

Para contar em quantas linhas um padrão ocorre em um arquivo, utilizamos a opção -c, Por exemplo, em quantas linhas a palavra “fabio” ocorre no arquivo.txt?

$ grep -c "fabio" arquivo.txt

Aqui, o grep mostra o número total de linhas contendo “fabio” no arquivo.

4. Exibir Números das Linhas

Para exibir o número das linhas onde o padrão é encontrado, usamos -n:

$ grep -n "fabio" arquivo.txt

Cada linha que contém a palavra “fabio” será exibida com seu número correspondente em arquivo.txt.

5. Buscar Recursivamente em Diretórios

A opção -r permite buscar em arquivos dentro de um diretório e seus subdiretórios:

$ grep -r "fabio" /home/fabio

Esse comando busca o termo “fabio” em todos os arquivos dentro do diretório /home/fabio.

Opcionalmente nesse caso, poderíamos usar o caracter curinga ~:

$ grep -r "fabio" ~

6. Buscar Linhas que Não Contêm um Padrão

Para encontrar linhas que não contêm o termo especificado, use a opção -v:

$ grep -v "4096" arquivo.txt

O comando acima exibe todas as linhas de arquivo.txt que não contêm a string “4096”.

7. Buscar com Expressões Regulares

O grep é muito poderoso com expressões regulares. Por exemplo, para localizar palavras que começam com “D” e terminam com “s”:

$ grep "\bD[a-z]*s\b" arquivo.txt

Esse comando localiza palavras como “Documentos” e “Downloads” em arquivo.txt.

8. Exibir Apenas o Nome do Arquivo

Para listar apenas os nomes dos arquivos onde o padrão foi encontrado, usamos -l:

$ grep -l "fabio" *.txt

Se o termo “fabio” for encontrado em um ou mais arquivos, apenas os nomes desses arquivos serão listados.

Opções Adicionais Úteis do grep

• -w: Busca palavras exatas. Por exemplo, grep -w “Do” arquivo.txt localiza apenas a palavra “Do” e não “Documentos” ou “Downloads”.
• -A n: Exibe n linhas após a linha encontrada. Por exemplo: grep -A 2 “Documentos” arquivo.txt encontra a palavra “Documentos” e mostra também as duas linhas seguintes a ela.
• -B n: Exibe n linhas antes da linha encontrada.
• -C n: Exibe n linhas antes e depois da linha encontrada.

Exercícios Práticos com Resolução

Vejamos agora alguns exercícios extras para treinarmos o uso do comando grep no Linux.

Para tal vamos criar um arquivo de nome “grep.txt” com o conteúdo das páginas de ajuda do próprio comando man, como segue:

$ man man > grep.txt

Exercício 1: Encontrar um Termo em um Arquivo

Instrução: Encontre todas as linhas que contêm a palavra “manual” no arquivo grep.txt.

Solução:

$ grep "manual" grep.txt

Exercício 2: Pesquisar Insensivelmente a Palavra “comandos” em um Arquivo

Instrução: Busque o termo “comandos” de forma insensível a maiúsculas em grep.txt.

Solução:

$ grep -i "comandos" grep.txt

Exercício 3: Contar Linhas que Contêm uma Palavra em um Arquivo

Instrução: Conte o número de linhas que contêm a palavra “página” no arquivo grep.txt.

Solução:

$ grep -c "página" grep.txt

Exercício 4: Buscar Recursivamente por um Padrão em um Diretório

Instrução: Busque o termo “my.cnf” em todos os arquivos dentro do diretório /etc/mysql/

Solução:

$ grep -r "my.cnf" /etc/mysql/

Exercício 5: Listar Apenas Nomes de Arquivos Contendo um Padrão

Instrução: Liste os nomes dos arquivos .conf em /etc que contêm a palavra “sudo”.

Solução:

$ grep -l "sudo" /etc/*.conf

Conclusão

Vimos neste tutorial a sintaxe e uso básico do comando grep no Linux, incluindo alguns exemplos de aplicação na linha de comandos e exercícios resolvidos. Trata-se de uma ferramenta muito útil para administradores de sistemas, usuários em geral e até mesmo programadores que utilizam o Linux em seu dia-a-dia.

Nos próximos artigos aprenderemos a usar outras ferramentas também muito úteis no Linux, como por exemplo os comandos sort, awk e find.

O post Buscar padrões em textos com comando grep no Linux apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

O comando type é usado para descobrir informações sobre um outro comando qualquer  no Linux. ELe mostra algumas informações básicas sobre um ou mais comandos informados como argumento no terminal.

Algumas das informações que podem ser visualizadas com o comando type incluem:

• Se ele é um alias (apelido)
• Se é built-in do shell (comando interno)
• Se é arquivo (programa executável)
• Se é uma palavra-chave (usada em scripts do shell, por exemplo)
• O caminho do comando

Entre outras.

Sintaxe

type [opções] comando(s)

Onde comando(s) é uma lista de comandos separados por espaços para os quais se deseja obter informações básicas.

Obter ajuda sobre o comando type

Para obter ajuda sobre este comando não empregados as tradicionais páginas de manual. Ao tentarmos ver a ajuda com o comando man, obteremos isso:

$ man type

Nenhuma entrada de manual para type

Se quisermos ver a ajuda do comando é necessário passar a palavra “type” como argumento do comando help:

$ help type

Exemplos

Vejamos alguns exemplos de uso do comando type.

1. Obter informação geral sobre um comando:

$ type ls
$ type cd
$ type type

ls está apelidada para `ls --color=auto'
cd é um comando interno do shell
type é um comando interno do shell

2. É possível obter informações sobre mais de um comando ao mesmo tempo:

$ type head tail
$ type while for if case

head é /usr/bin/head
tail é /usr/bin/tail
while é uma palavra-chave do shell
for é uma palavra-chave do shell
if é uma palavra-chave do shell
case é uma palavra-chave do shell

3. Para mostrar somente o tipo do comando usamos a opção -t

$ type -t ls
$ type -t cd
$ type -t mkdir

alias
builtin
file

4. Mostrar caminho absoluto do comando se ele for arquivo: opção -p (similar ao comando which)

$ type -p mkdir
$ type -p cal
$ type -p ip

/usr/bin/mkdir
/usr/bin/cal
/usr/bin/ip

5. Mostrar caminho do arquivo executado mesmo que o comando seja um apelido, comando interno ou função.

$ type -P pwd

/usr/bin/pwd

Aqui, a opção -p (p minúsculo) não retornaria nada, pois o comando pwd é um comando interno do sistema (bultin), mas a opção -P mostra o caminho do executável.

É isso aí! No próximo artigo vamos falar sobre outro comando muito importante para o gerenciamento de comandos no shell: o comando history.

Até!

O post Comando type – ver informações sobre outros comandos no Linux apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.