# Os comandos Linux mais importantes Como a maioria dos sistemas operacionais modernos, o Linux oferece um **terminal**, que pode ser usado para controlar todo o sistema, por meio de **comandos** (*prompts*). Basicamente, todas as configurações possíveis por [interface gráfica do usuário (GUI)](https://www.ionos.com/digitalguide/websites/web-development/what-is-a-gui/) podem ser igualmente executadas pelo terminal. Conheça os comandos de terminal mais importantes do Linux, entenda suas funções e aprenda a aplicá-los.
Comando Descrição
sudo Executa programas com direitos de superusuário
ls Lista o conteúdo do diretório
cd Navega pela árvore de diretórios
touch Cria novo arquivo
mkdir Cria novo diretório
rm Deleta arquivo
rmdir Deleta diretório
mv Move arquivo ou diretório
cp Copia arquivo ou diretório
pwd Mostra a posição de um diretório na árvore de diretórios
zip Converte arquivos em arquivos zip
unzip Extrai arquivos de arquivos zip
ln Cria link simbólico
cat Combina o conteúdo de arquivos
grep Busca arquivos de texto
diff Encontra diferenças entre arquivos de texto
cmp Alinha arquivos a nível de bytes
tar Cria e descompacta arquivos tar
echo Apresenta cadeia de resultados na especificação padrão
clear Limpa o terminal
ssh Conecta a outro computador por *secure shell*
wget Baixa arquivo diretamente da internet
ping Mede a latência pelo servidor
ftp, sftp Transfere arquivos por (S)FTP
ip Consulta e configura interfaces de rede
apt/pacman/yum Baixa e gerencia pacotes de software
netstat Exibe status da interface de rede
traceroute Rastreia pacotes de dados
route Exibe e edita tabelas de roteamento IP
dig Solicita informações do DNS
mount/unmount Integra arquivos de sistema
dd Copia arquivos, partições e transmissores de dados com o bit exato
chmod Gerencia direitos de acesso
chown Gerencia direitos de propriedade
adduser Adiciona e modifica contas de usuários
passwd Cria e edita senhas de usuários
groupadd Cria grupos de usuários
chattr Gerencia atributos de arquivos
lsattr Exibe atributos de arquivos
chgrp Gerencia membros de grupos de arquivos e diretórios
man Acessa o manual do usuário
shutdown, reboot Desliga/reinicia o sistema
top Panorama dinâmico de processos
lscpu Exibe informações do processador
lshw Exibe informações do hardware
kill Para e finaliza processos por PID
killall Para e finaliza processos pelo nome
nice Define a prioridade de processos
pgrep Identifica PID por termos de busca
ps Exibe lista de todos os processos em execução
### Comando Linux sudo O [comando Linux `sudo`](https://www.ionos.com/digitalguide/server/configuration/linux-sudo-command/ "Comando Linux sudo") (*substitute user do*) é capaz de acessar programas e executá-los com direitos de outros usuários. Para tanto, você precisará digitar uma senha: a senha do usuário que está tentando acessar. Caso nenhum usuário seja especificado, o superusuário *root* será definido. ```bash sudo -u USUÁRIO PROGRAMA ``` ### Comando Linux ls O [comando Linux `ls`](https://www.ionos.com/digitalguide/server/configuration/linux-ls-command/ "Comando Linux ls") (*list*) é usado para exibir todo o conteúdo de um diretório, ou seja, os nomes de todos os arquivos e pastas que o compõem. Esta é a sintaxe do comando `ls`: ```bash ls [ARGUMENTOS] DIRETÓRIO ``` Se o comando for acionado sem que um diretório seja especificado, ele listará o conteúdo do diretório atual. Argumentos adicionais permitem configurar as informações a serem exibidas, e de que forma. ### Comando Linux cd O [comando Linux `cd` ](https://www.ionos.com/digitalguide/server/configuration/linux-cd-command/ "Comando Linux cd") (*change directory*) é usado para navegar na árvore de diretórios. Esta é a sintaxe do comando `cd`: ```bash cd [ARGUMENTOS] DIRETÓRIO ``` Se nenhum diretório de destino for especificado, o comando acessará automaticamente o diretório *home* do usuário. Já ao adicionar um traço (-) após `cd`, este retornará ao diretório anterior. ### Comando Linux touch O [comando Linux `touch`](https://www.ionos.com/digitalguide/server/configuration/linux-touch-command/) tem a função de modificar registros de data e hora de acessos, e de alterações de arquivos. Ao ser usado com um arquivo não existente, este o criará automaticamente. O comando também serve, portanto, para criar arquivos vazios. Um comando `touch` deve ter a seguinte estrutura: ```bash touch [ARGUMENTOS] ARQUIVO ``` Para acessar registros de um arquivo em uma data específica, adicione `-t` ao comando, seguido da data desejada, no formato `[YY]MMDDhhmm[.ss]`, como mostra o exemplo: ```bash touch -t 1703231037 arquivo.txt ``` Acima, requeremos os registros acesso e as alterações feitas em 23 de março de 2017, às 10:37. Restrinja o acesso à alteração ou ao registro de data e hora utilizando `-a` e `-m`. Ao ser executado sem o suplemento `-t`, o comando exibirá o registro de data e hora atual. ### Comando Linux mkdir O [comando Linux `mkdir`](https://www.ionos.com/digitalguide/server/configuration/linux-mkdir-command/ "Comando Linux mkdir") (*make directory*) permite a criação de novos diretórios. Use a seguinte sintaxe para criar um novo diretório no diretório local: ```bash mkdir [ARGUMENTOS] NOME DO DIRETÓRIO ``` Caso você queira criar um diretório em outro local do sistema, deverá especificar seu caminho (absoluto ou relativo). ### Comando Linux rm O [comando Linux `rm`](https://www.ionos.com/digitalguide/server/configuration/linux-rm-command/) (*remove*) exclui permanentemente diretórios e arquivos inteiros. Assim é a sua estrutura: ```bash rm [ARGUMENTOS] ARQUIVO/DIRETÓRIO ``` Caso você queira excluir todos os subdiretórios contidos em um diretório, adicione a `rm` o argumento `-R` (*--recursive*). ### Comando Linux rmdir Se você quiser excluir um diretório específico, deve usar o comando `rmdir` (*remove directory*), que tem a seguinte sintaxe: ```bash rmdir [ARGUMENTOS] DIRETÓRIO ``` Diretórios vazios só podem ser excluídos por `rmdir`. Já para excluir um diretório juntamente com todos os seus subdiretórios e arquivos, você deve usar `rm` acrescido de `-r`. Nossos artigos especializados exploram, em mais detalhes, [como excluir arquivos no Linux](https://www.ionos.com/digitalguide/server/configuration/deleting-files-in-linux/ "Excluir arquivo no Linux") e [como excluir diretórios no Linux](https://www.ionos.com/digitalguide/server/configuration/delete-a-linux-directory/ "Excluir diretório no Linux"). ### Comando Linux mv O [comando Linux `mv`](https://www.ionos.com/digitalguide/server/configuration/linux-mv-command/ "Comando Linux mv") (*move*) move arquivos ou diretórios, excluindo o original. Se for usado dentro do mesmo diretório, o `mv` simplesmente renomeia o arquivo especificado. Execute o comando da seguinte forma: ```bash mv [ARGUMENTOS] ORIGEM DESTINO ``` ### Comando Linux cp O [comando Linux `cp`](https://www.ionos.com/digitalguide/server/configuration/linux-cp-command/ "Comando Linux cp") (*copy*) tem a função de copiar arquivos e diretórios. A sintaxe básica do comando é a seguinte: ```bash cp [ARGUMENTOS] ORIGEM DESTINO ``` ORIGEM aponta o elemento a ser copiado, já DESTINO define o local onde a cópia deve ser armazenada. Se você especificar um arquivo já existente como arquivo de destino, o conteúdo dele será substituído pelo do arquivo de origem. Há também a opção de se criar um novo arquivo, de nome a ser escolhido, como arquivo de destino. ### Comando Linux pwd Use o [comando Linux `pwd`](https://www.ionos.com/digitalguide/server/configuration/linux-pwd-command/ "Comando Linux pwd") (*print working directory*) para exibir o nome do diretório de trabalho atual. Para tanto, utilize a seguinte sintaxe: ```bash pwd [ARGUMENTOS] ``` ### Comando Linux zip Use o comando `zip` para compactar arquivos em um arquivo zip. Esta é a sintaxe do comando: ```bash zip DESTINO ARQUIVOS ``` DESTINO diz respeito ao nome ou caminho do arquivo zip a ser criado. Já ARQUIVOS são os arquivos propriamente ditos, ou caminhos de arquivos, a serem compactados (estes devem ser separados por espaços). ### Comando Linux unzip Utilize o comando `unzip` para extrair arquivos de um arquivo zip. Para tanto, digite: ```bash unzip ARQUIVO.zip -d DESTINO ``` ARQUIVO faz referência ao arquivo zip de onde os arquivos devem ser extraídos. Opcionalmente, utilize o argumento `-d` DESTINO para especificar o diretório onde os arquivos extraídos devem ser armazenados. De outra forma, os arquivos serão armazenados no diretório atual. ### Comando Linux ln O [comando Linux `ln`](https://www.ionos.com/digitalguide/server/configuration/linux-ln-command/ "Comando Linux ln") (*link*) cria um atalho para um arquivo ou diretório, para que ele possa ser acessado por meio de outro caminho. A sintaxe do comando deve conter, pelo menos, o caminho para o arquivo de origem: ```bash ln [ARGUMENTOS] caminho/para/arquivo ``` Nosso exemplo cria um atalho para o diretório de trabalho atual, de mesmo nome. Também é possível adicionar o caminho de destino do atalho, assim como nomeá-lo: ```bash ln [ARGUMENTOS] caminho/para/arquivo caminho/para/atalho ``` ### Comando Linux cat O [comando Linux `cat`](https://www.ionos.com/digitalguide/server/configuration/linux-cat-command/) (*concatenate*) foi desenvolvido para combinar o conteúdo de arquivos. Ele pode ser usado como um gerenciador de páginas, pois exibe o conteúdo dos arquivos no terminal. Para ler um arquivo e enviá-lo para `stdout` (a saída padrão), utilize a seguinte sintaxe: ```bash cat ARGUMENTOS ARQUIVOS ``` Separe arquivos adicionando um espaço entre eles. ```bash cat ARGUMENTOS ARQUIVO1 ARQUIVO2 ``` ### Comando Linux grep Com o [comando Linux `grep`](https://www.ionos.com/digitalguide/server/configuration/linux-grep-command/ "Comando Linux grep") é possível realizar pesquisas em arquivos de texto. Qualquer cadeia de caracteres ou de palavras pode ser usada como chave de busca. Esta é a sintaxe do comando `grep`: ```bash grep [ARGUMENTOS] CHAVE DE BUSCA [ARQUIVO(S)] ``` Se `grep` encontrar uma cadeia que corresponde à chave de busca, o terminal retornará o número da linha e o nome do arquivo correspondente. Em geral, o comando `grep` realiza buscas em todos os arquivos do diretório atual. Contudo, o argumento `-r` expande a pesquisa para os subdiretórios. ### Comando Linux diff O comando `diff` tem a função de comparar dois arquivos. Você também pode utilizá-lo para descobrir se dois diretórios contêm os mesmos arquivos. Para executar `diff`, digite a seguinte sequência no terminal: ```bash diff [ARGUMENTOS] ARQUIVO1 ARQUIVO2 ``` ### Comando Linux cmp O comando `cmp` faz parte do pacote `diff` e é usado para comparar o conteúdo de arquivos. Ao contrário do `diff`, o `cmp` realiza comparações a nível de byte, sendo, portanto, particularmente adequado a arquivos binários. Esta é sua sintaxe: ```bash cmp [ARGUMENTOS] ARQUIVO1 ARQUIVO2 ``` Se o `cmp` encontrar divergências entre os arquivos, o terminal retornará o número do byte e da linha da primeira divergência. ### Comando Linux tar O comando `tar` grava arquivos e diretórios, em sequência, em um arquivo tar, para que possam ser utilizados como cópia de segurança, se necessário. Ao contrário do que ocorre com arquivos zip, comuns no Windows, arquivos tar mantém direitos de usuários, mesmo após a descompactação. Esta é a sintaxe do comando: ```bash tar [ARGUMENTOS] ARQUIVOS ``` Caso você queira criar um novo arquivo, utilize `tar` juntamente com `-c` (*criar novo arquivo*) e `-f` (salvar arquivo em determinado arquivo ou lê-lo). Saiba mais sobre [backups tar e como criá-los no Linux](https://www.ionos.com/digitalguide/server/tools/tar-backup-how-to-create-an-archive-with-linux/ "Como criar backups tar no Linux") acessando nosso artigo especializado. ### Comando Linux echo Use o [comando Linux `echo`](https://www.ionos.com/digitalguide/server/configuration/linux-echo-command/) para gerar cadeias de caracteres, linha por linha, na saída padrão (geralmente, no terminal). A base do comando é a seguinte: ```bash echo [ARGUMENTOS] CADEIA DE CARACTERES ``` ### Comando Linux clear Use o comando `clear` para limpar o conteúdo do terminal. ```bash clear ``` Ao executar este comando, seu terminal retornará limpo, ou seja, sem qualquer entrada aparente. Porém, todas continuarão podendo ser acessadas, caso você role para cima. Também é possível limpar o terminal pressionando o atalho \[Ctrl\] + \[L\]. ### Comando Linux ssh Com `ssh` é possível conectar o seu computador a um computador externo, por meio de um protocolo SSH. Assim, você conseguirá acessar o terminal deste outro computador. Esta é a sintaxe do comando `ssh`: ```bash ssh USUÁRIO@HOSTNAME ``` USUÁRIO e HOSTNAME, neste contexto, dizem respeito, respectivamente, ao nome do usuário para o qual você deseja fazer login e ao endereço do computador externo. ### Comando Linux wget O [comando Linux `wget`](https://www.ionos.com/digitalguide/server/configuration/linux-wget-command/ "Comando Linux wget") pode ser usado para baixar arquivos da internet. Esta é sua estrutura: ```bash wget [ARGUMENTO] LINK ``` Em LINK, adicione o URL onde o arquivo desejado pode ser encontrado. Utilize o argumento `-c`, caso você queira dar prosseguimento a um download anteriormente interrompido. ### Comando Linux ping Use o [comando Linux `ping`](https://www.ionos.com/digitalguide/server/configuration/linux-ping-command/ "Comando Linux ping") para testar a acessibilidade de outros computadores em uma rede. Ele é baseado na seguinte sintaxe: ```bash ping [ARGUMENTOS] DESTINO ``` Juntamente com o tempo de ida e volta (RTT) — que é o intervalo de tempo entre o envio do pacote de dados e o recebimento de uma resposta — o `ping` exibe o endereço IP do sistema de destino no terminal. Use argumentos opcionais para determinar após quantos pacotes ou segundos o `ping` deve ser encerrado. ### Comandos Linux ftp e sftp Ambos os comandos, `ftp` e `sftp`, possibilitam trocas de arquivos entre o sistema local e outro computador da rede. Use o protocolo [FTP (*File Transfer Protocol*)](https://www.ionos.com/digitalguide/server/know-how/file-transfer-protocol/ "FTP: File Transfer Protocol") de acordo com a sintaxe abaixo, para estabelecer uma conexão com o servidor FTP do computador de destino: ```bash ftp [ARGUMENTOS] [HOST[PORTA]] ``` O endereçamento de uma conexão FTP pode ser feito por *hostname* ou endereço IP, já a especificação do número da porta é opcional. Faça uso do comando `ftp` somente em redes confiáveis, por se tratar de um protocolo pouco seguro. Já o [SFTP (*SSH File Transfer Protocol*)](https://www.ionos.com/digitalguide/server/know-how/sftp-ssh-file-transfer-protocol/ "SFTP: SSH File Transfer Protocol") realiza transferências criptografadas, por utilizar [*secure shell* (SSH)](https://www.ionos.com/pt-br/digitalguide/servidor/ferramentas/o-que-e-ssh-protocolo-ssh/) em seus métodos de autenticação. Aprenda a usar [chaves SSH nas suas conexões](https://www.ionos.com/pt-br/digitalguide/servidor/seguranca/como-usar-ssh-keys-em-conexoes-em-rede/), com o nosso artigo especializado. ### Comando Linux ip O comando Linux `ip` faz parte da coleção de *prompts* `iproute2`, que solicita e configura interfaces de rede pelo terminal. Esta é a sintaxe básica do `ip`: ```bash ip [ARGUMENTOS] OBJETO [COMANDO[ARGUMENTO]] ``` A ação a ser executada por `ip` deve ser definida por objetos, subcomandos e pelos argumentos correspondentes. São vários os objetos suportados pelo comando, como `address` (endereço IP), `link` (interface de rede), `route` (entrada para a tabela de roteamento) e `tunnel`. A estes devem ser adicionados subcomandos, como `add`, `change`, `del`, `list` e `show`. Digamos que você queira acessar o endereço IP de uma interface de rede qualquer (*eth0*). Neste caso, combine o comando `ip` com o objeto `address`, o subcomando `show` e o argumento `dev eth0`: ```bash ip address show dev eth0 ``` Aprenda, em detalhes, como [exibir um endereço IP no Linux](https://www.ionos.com/digitalguide/hosting/technical-matters/get-linux-ip-address/). ### Comandos Linux apt, pacman e yum Toda distribuição Linux oferece um ***packet manager*** (gerenciador de pacotes), com o qual você pode baixar e gerenciar pacotes de software. São essas as sintaxes para a instalação de aplicativos: ```bash apt install [PACOTE] # Distribuições baseadas em Debian, como Ubuntu pacman -S [PACOTE] # Distribuições baseadas em Arch yum install [PACOTE] # Distribuições baseadas em Red Hat ``` PACOTE diz respeito ao nome do pacote ou do programa a ser instalado. Na maioria das vezes, você só conseguirá executar comandos de instalação em combinação com `sudo`, ou seja, com permissões *root*. Observe que a sintaxe desses comandos Linux pode variar um pouco, a depender da distribuição utilizada, uma vez que cada gerenciador de pacotes possui comandos próprios para remoção, atualização de lista, e atualização de programas instalados. No Ubuntu, estes são os comandos: ```bash apt remove [PACOTE] # remover pacote apt update # atualizar lista de pacotes apt upgrade # atualizar pacotes ``` ### Comando Linux netstat O comando Linux `netstat` tem a função de consultar o status de interfaces de rede. A sintaxe base do comando é a seguinte: ```bash netstat [ARGUMENTOS] ``` Digite `netstat` sem especificar o argumento para exibir todos os *sockets* abertos no terminal. Use os seguintes argumentos para a exibição da tabela de roteamento (`-r`), das estatísticas de interface (`-i`), das conexões mascaradas (`-M`) e das mensagens de link de rede (`-N`). Acesse nosso artigo especializado para aprender mais sobre [netstat](https://www.ionos.com/digitalguide/server/tools/introduction-to-netstat/ "Introdução a netstat"). ### Comando Linux traceroute Para rastrear a rota de transporte de um pacote de dados IP entre o seu sistema e um computador de destino, faça uso do [comando Linux `traceroute`](https://www.ionos.com/digitalguide/server/tools/traceroute-your-digital-pathfinder-for-data-packages/ "Traceroute: Rastreie seus pacotes de dados"). Aqui está sua sintaxe: ```bash traceroute [ARGUMENTOS] HOSTNAME ``` Com `traceroute`, você pode identificar por quais roteadores e nós um pacote de IP passou, quando à caminho do computador de destino. Isto serve, por exemplo, para investigar a causa de um atraso. ### Comando Linux route Com o comando Linux `route`, você solicita e edita a tabela de roteamento IP do núcleo. Esta é sua sintaxe: ```bash route [ARGUMENTOS] [add|del] [-net|-host] DESTINO ``` Use o comando sem argumentos para exibir a tabela de roteamento do núcleo completa: ```bash route ``` Se você quiser definir uma rota para uma rede, adicione à sintaxe o subcomando `add`. ```bash route add -net 10.0.0.0 ``` ### Comando Linux dig O comando Linux `dig` é uma ferramenta de pesquisa que pode ser usada para solicitar informações sobre o servidor DNS. Geralmente, o comando é executado para se descobrir o endereço IP e outras informações do sistema de nomes de domínios de um determinado domínio. Observe sua estrutura: ```bash dig [@SERVIDOR] [DOMÍNIO] [TIPO] ``` SERVIDOR faz referência ao servidor DNS que deve ser pesquisado para a obtenção das informações desejadas. Caso nenhum servidor seja especificado, o comando obterá informações do DNS padrão, presente no arquivo `/etc/resolv.conf`. DOMÍNIO diz respeito ao nome de domínio a ser pesquisado para obtenção das informações do DNS. TIPO especifica o tipo de consulta: ANY (todas as entradas), A (registro IPv4 de um host) ou AAAA (registro IPv6 de um host). O tipo de solicitação padrão é sempre A. ### Comandos Linux mount e unmount Use o comando Linux `mount` para integrar um sistema de arquivos à estrutura de diretórios do sistema operacional, por meio da árvore de diretórios. A sintaxe base do `mount` é a seguinte: ```bash mount [ARGUMENTOS] DISPOSITIVO MOUNTPOINT ``` DISPOSITIVO nada mais é que o caminho até o arquivo do dispositivo de armazenamento que você deseja montar como partição. MOUNTPOINT é o local, na estrutura de diretórios do sistema operacional, onde a partição deve ser montada. Via de regra, o ponto de montagem deve ser especificado por um caminho absoluto. ```bash mount /dev/sdd /media/usb ``` Neste exemplo, o dispositivo `sdd` será montado no diretório `/media/usb`. ### Comando Linux dd O comando Linux `dd` realiza um processo de cópia, no qual dados de um arquivo de entrada (`if`) são lidos bit a bit e gravados em um arquivo de saída (`of`). Execute este comando digitando a seguinte sequência no terminal: ```bash dd if=ORIGEM of=DESTINO [ARGUMENTOS] ``` Como origem e destino, especifique arquivos individuais, partições inteiras (por exemplo, `/dev/sda1`) ou um dispositivo de armazenamento completo (por exemplo, `/dev/sda`). ```bash dd if=/dev/sda5 of=/dev/sdb1 ``` ### Comando Linux chmod O comando Linux `chmod` (*change mode*) é usado para atribuir direitos em sistemas de arquivos do tipo Unix (*ext2, ext3, ext4, reiser, xfs*). Estas são possíveis sintaxes para o comando `chmod`: ```bash chmod [ARGUMENTOS] MODO ARQUIVO ``` e ```bash chmod [ARGUMENTOS] MODO DIRETÓRIO ``` Em MODO, adicione a máscara de direitos aplicável. Aprenda a criar um sistema como este e no que prestar atenção durante o processo, no nosso tutorial sobre [direitos de acesso com `chmod`](https://www.ionos.com/digitalguide/server/know-how/allocating-directory-rights-with-chmod/ "Atribuir direitos de acesso com chmod"). Com a ajuda do argumento `-R`, expanda os direitos a subpastas e a arquivos contidos em um diretório. ### Comando Linux chown O [comando Linux `chown`](https://www.ionos.com/digitalguide/server/configuration/linux-chown-command/ "Comando Linux chown") (*change owner*) permite modificar permissões de proprietário. Entre as sintaxes possíveis estão: ```bash chown [ARGUMENTOS] [USUÁRIO][:[GRUPO]] ARQUIVO ``` e ```bash chown [ARGUMENTOS] [USUÁRIO][:[GRUPO]] DIRETÓRIO ``` Para definir direitos de proprietário para um usuário ou grupo, existem quatro combinações possíveis. Proprietário e grupos são configurados de acordo com a entrada: ```bash chown [ARGUMENTOS] nome_proprietário:nome_grupo arquivo.txt ``` ```bash # O grupo é redefinido de acordo com a entrada e o usuário permanece inalterado: chown [ARGUMENTOS] :nome_grupo arquivo.txt # O administrador é redefinido de acordo com a entrada e o grupo permanece inalterado: chown [ARGUMENTOS] nome_proprietário arquivo.txt # O usuário é redefinido de acordo com a entrada e o grupo é definido como padrão para o usuário conectado: chown [ARGUMENTOS] nome_proprietário: arquivo.txt # Alterações são estendidas a subdiretórios com a ajuda do ARGUMENTO `-R`. ``` ### Comando Linux adduser A forma mais simples de se criar uma conta de usuário no Linux é utilizando o comando `adduser`: um script Perl baseado no [comando Linux `useradd`](https://www.ionos.com/digitalguide/server/configuration/linux-useradd-command/ "Comando Linux useradd"). Ambos executam as mesmas funções, mas `adduser` é mais fácil de usar. Contudo, ele requer privilégios *root*. Esta é sua sintaxe: ```bash adduser [ARGUMENTOS] USUÁRIO ``` Use `adduser` sem argumentos para criar um ID de usuário automaticamente, um diretório inicial e um grupo de usuários com o mesmo nome, além de uma nova conta. ```bash adduser test ``` Ao comando se seguirá uma caixa de diálogo interativa, em que será possível definir senha e outras informações de usuário (nome real, telefone, localização do escritório e outros). ### Comando Linux passwd Use o [comando Linux `passwd`](https://www.ionos.com/digitalguide/server/configuration/linux-passwd-command/ "Comando Linux passwd") para alterar a senha de um usuário, ou definir/alterar intervalos de verificação. O comando é baseado na seguinte sintaxe: ```bash passwd [ARGUMENTOS] USUÁRIO ``` Caso você queira alterar a senha de outro usuário, precisará de permissões *root*. Use o comando `passwd` sem nome de usuário para alterar sua própria senha. Se você quiser bloquear a senha, use `passwd` em conjunto com o argumento `-l` (*--lock*). Outros argumentos possíveis são: definir validade de uma senha `(-x)`, avisos `(-w)`, e intervalos de verificação `(-i)`. ### Comando Linux groupadd O comando Linux `groupadd` é usado para criar grupos de usuários. Utilize `groupadd` com permissões *root*, como mostra o esquema abaixo: ```bash sudo groupadd [ARGUMENTOS] GRUPOS ``` Cada grupo recém-criado conterá um ID de grupo próprio (GID), sendo IDs de grupo entre 0 e 99 reservados a grupos de sistema. Se você quiser definir o GID de um novo grupo de usuários para si mesmo, digite o comando `groupadd` com o argumento `-g` (*GID*). Para criar um grupo de sistema, utilize `-r` (*root*). ### Comando Linux chattr O comando Linux `chattr` (*change attribute*) permite a visualização de arquivos e de diretórios com atributos. Use `chattr` com a seguinte sintaxe, para definir um atributo: ```bash chattr [ARGUMENTOS] +ATRIBUTO ARQUIVO ``` Substitua o sinal de mais pelo sinal de menos para remover atributos. Por exemplo, utilize o atributo `-i` para impedir alterações (exclusões ou modificações) em um arquivo ou diretório. Para conhecer outros atributos e argumentos compatíveis, consulte o manual do comando `chattr`. ### Comando Linux lsattr Se você quer visualizar os atributos definidos para um arquivo ou diretório, use o comando `lsattr` (*listar atributos*), como mostra a sintaxe abaixo: ```bash lsattr [ARGUMENTOS] ARQUIVO/DIRETÓRIO ``` ### Comando Linux chgrp O comando Linux `chgrp` (*change group*) tem a função de gerenciar permissões de grupos para arquivos e diretórios. Para usar `chgrp` em um arquivo ou diretório específico, você deverá ter permissões *root* e pertencer ao grupo. Estas são as sintaxes do comando: ```bash chgrp [ARGUMENTOS] GRUPO ARQUIVO ``` e ```bash chgrp [ARGUMENTOS] GRUPO DIRETÓRIO ``` Adicione o argumento `-R` para abranger subpastas e arquivos contidos no diretório. ### Comando Linux man O comando Linux `man` exibe páginas do manual de instruções (*man-pages*) da sua distribuição Linux, diretamente no terminal. Assim é sua sintaxe: ```bash man [ARGUMENTO] TEMA ``` Manuais Linux são divididos em 10 áreas temáticas: comandos de usuário, chamadas de sistema, funções da linguagem de programação C, formatos de arquivos, arquivos de configuração, jogos, diversos, comandos de administração de sistema, funções principais, novos comandos. ### Comando Linux shutdown O [comando Linux `shutdown`](https://ionos.com/digitalguide/server/configuration/linux-shutdown-command/) pode ser usado por usuários *root* para desligar o sistema. Esta é sua sintaxe: ```bash shutdown [ARGUMENTOS] [TEMPO] [MENSAGEM] ``` Também é possível programar desligamentos com a definição de um horário. Para isso, adicione à estrutura do comando uma entrada de hora (`hh:mm`) ou uma contagem regressiva (`+m`). Com esta configuração ativada, os demais usuários do sistema serão avisados antes do desligamento. Personalize uma mensagem, caso deseje. Use o comando `shutdown` com o argumento `-r` para reinicializar o sistema após o desligamento. ### Comando Linux top O comando Linux `top` exibe um panorama de todos os processos em execução. Para executá-lo, faça uso da seguinte estrutura: ```bash top [ARGUMENTOS] ``` Escolha como informações sobre processos serão exibidas, utilizando argumentos ou atalhos do teclado: - \[P\] = Ordena a exibição de acordo com a carga da CPU - \[M\] = Ordena a exibição de acordo com requisitos de armazenamento - \[N\] = Ordena a exibição numericamente, por PID - \[A\] = Ordena a exibição por antiguidade - \[T\] = Ordena a exibição por tempo - \[U USERNAME ou UID\] = Filtra a exibição por usuário Use o atalho de teclado \[H\] para acessar a página de ajuda e \[Q\] para fechar o panorama de processos. ### Comando Linux lscpu Faça uso do comando `lscpu` (*list cpu*) para ter acesso a informações sobre a arquitetura da CPU, no terminal. Utilize, para tanto, a seguinte estrutura: ```bash lscpu [ARGUMENTOS] ``` Para encontrar os argumentos compatíveis com o comando, consulte o manual do seu sistema operacional. ### Comando Linux lshw O comando Linux `lshw` (*list hardware*) exibe informações no terminal, sobre componentes de hardware. Use `lshw` com a seguinte sintaxe: ```bash lshw [ARGUMENTOS] ``` O comando suporta diversos argumentos, que podem ser usados para configurar o formato de saída (`-html`, `-xml`, `-short`, `-businfo`) e a emissão de informações (digite `-sanitize`, por exemplo, para ocultar informações confidenciais). ### Comando Linux kill O comando Linux `kill` interrompe ou finaliza processos. Ele segue o seguinte padrão, composto do sinal desejado e do ID do processo correspondente: ```bash kill [ARGUMENTOS] [-SINAL] PID ``` Os sinais mais comuns são: 1. `TERM`: Padrão para encerrar um processo 2. `KILL`: Força o término de um processo (por meio do sistema) 3. `STOP`: Interrompe um processo 4. `CONT`: Continua um processo previamente interrompido ### Comando Linux killall Use o [comando Linux `killall`](https://www.ionos.com/digitalguide/server/configuration/linux-killall-command/ "Comando Linux killall") em combinação com um termo de pesquisa específico, para encerrar apenas processos com nomes coincidentes (os primeiros 15 caracteres serão usados para fazer a correspondência). ```bash killall [ARGUMENTOS] [-SINAL] [PROCESSO NOME] ``` O argumento `-e` (*--exact*) permite que a correspondência seja estendida a todos os caracteres do nome do processo. ### Comando Linux nice Ao início de um processo realizado em etapas, o comando Linux `nice` indica um valor (entre -20 e +19) que corresponde à distribuição do poder de computação do sistema. Estes intervalos, de -20 a +19, correspondem aos níveis de prioridade do Linux, que variam de 100 a 139. Assim sendo, processos com valor `nice` -20 têm prioridade mais alta do que processos com valor `nice` 19. Sozinha, a sintaxe é a seguinte: ```bash nice [ARGUMENTOS] [COMANDO] ``` Caso não haja especificação adicional, todos os processos serão iniciados com o valor `nice` 0. Use o argumento `-n` para definir a prioridade de um processo. Prioridades negativas só podem ser atribuídas com permissões *root*. ### Comando Linux pgrep O comando Linux `pgrep` compara a lista de processos em execução com um termo de busca, gerando os respectivos PIDs, caso encontre correspondências. A sintaxe é a seguinte: ```bash pgrep [ARGUMENTOS] TERMO DE BUSCA ``` Por padrão, o `pgrep` gera PIDs para todos os processos que contêm o termo de busca. Para limitar a busca a correspondências exatas, use o comando com o argumento `-x`. Para obter o PID ao invés de somente o nome do processo, utilize `pgrep` com o argumento `-l`. Assim como `grep`, `pgrep` também suporta termos de busca baseados em expressões regulares. ### Comando Linux ps O [comando Linux `ps`](https://www.ionos.com/digitalguide/server/configuration/linux-ps-command/ "Comando Linux ps") exibe lista de todos os processos em execução no terminal. ```bash ps [ARGUMENTOS] ``` Se você deseja obter informações mais detalhadas, use `ps` combinado a `-f` (detalhada) ou a `-F` (muito detalhada). Para conhecer argumentos adicionais, consulte o manual do seu sistema operacional. ## Outros comandos Linux ### Comandos Linux básicos Na categoria de comandos básicos, você encontrará os principais comandos para **controlar o terminal**, como para limpar a visibilidade, recuperar entradas anteriores ou encerrar uma sessão. **1. exit**O comando `exit` encerra a sessão e fecha o terminal. ```bash exit ``` Para executar a mesma ação, você também pode utilizar o atalho de teclado \[Ctrl\] + \[D\]. **2. help** Use o comando `help` para receber uma lista com todos os comandos de terminal internos. Digite `help` em combinação com um outro comando para obter uma breve descrição de suas funções. ```bash help COMANDO ``` **3. history** O bash salva, no histórico, os últimos 500 comandos inseridos no terminal. Ele funciona como assistente de entradas, permitindo que usuários examinem a lista de comandos anteriores por meio das sentas do teclado, e os execute novamente, se necessário. Pesquise no histórico utilizando palavras-chave, depois de pressionar o atalho \[Ctrl\] + \[R\]. Você também pode visualizar lista completa e numerada de comandos executados no terminal. Para isso, digite `history` sem utilizar nenhum argumento. ```bash history ``` Se você quiser filtrar resultados, combine `history` com o comando `grep` (consultar argumentos de busca) e com um termo de busca, adicionando um [Linux pipe](https://www.ionos.com/digitalguide/server/configuration/linux-pipes/) à estrutura. ```bash history | grep TERMO DE BUSCA ``` ### Comandos Linux de ajuda Se você não souber agir em uma situação específica, não se desespere. O Linux disponibiliza **páginas de ajuda e documentações** no terminal, como o *Unix man-pages* e o *GNU info pages*. Elas contêm instruções detalhadas sobre: terminal, chamadas de sistema, arquivos de configuração, formatos de arquivo e funções principais. Use o [comando Linux `whatis`](https://www.ionos.com/digitalguide/server/configuration/linux-whatis-command/ "Comando Linux whatis") combinado ao `apropos`, para não somente acessar páginas de ajuda no terminal, mas pesquisar, dentro destas páginas, por palavras-chave. **1. apropos** Use `apropos` para pesquisar por títulos e descrições dentro dos manuais do seu sistema operacional, utilizando palavras-chave: ```bash apropos [ARGUMENTOS] TERMO DE BUSCA ``` O comando oferece suporte a diferentes argumentos. Use `-e` para limitar a pesquisa a correspondências exatas, ou curingas (como `-w '*TERMO DE BUSCA`) e [expressões regulares](https://www.ionos.com/digitalguide/websites/website-creation/regular-expression-tutorial/ "Tutorial de expressões regulares") (como `-r`). **2. info** Com o comando Linux `info`, você obterá todas as páginas de informação do GNU sobre um tema específico. Na maioria dos casos, estas páginas são as mesmas acessadas pelo comando `man`. Contudo, ao executar o comando `info`, ao invés de receber as instruções pelo terminal, você ganhará acesso a links contendo instruções, para serem acessados pelo navegador. O formato facilita a leitura. A estrutura do comando pode ser observada abaixo: ```bash info [ARGUMENTOS] TEMA ``` Ao utilizar `info` sem delimitar o tema da pesquisa, você receberá um link que o levará para a página de informação principal do GNU. **3. pinfo** O comando Linux `pinfo` é uma variação do `info`. A diferença é que `pinfo` abre o navegador de linha de comando Lynx, exibindo lá links para páginas de informação. A sintaxe é a mesma: ```bash pinfo [ARGUMENTOS] TEMA ``` **4. whatis** O comando Linux `whatis` pode ser usado para pesquisar palavras-chave em páginas de manuais. Digite termos de busca comuns para encontrar correspondências exatas no manual do seu sistema operacional. Ao encontrar o termo procurado, o `whatis` retorna com uma breve descrição no terminal. ```bash whatis [ARGUMENTOS] TERMO DE BUSCA ``` Você também pode reservar espaços usando `whatis -w '\*TERMO DE BUSCA'`, assim como adicionar expressões regulares, com `-r`. ### Comandos Linux de diretórios Você pode usar comandos Linux de diretórios para criá-los, exclui-los ou gerenciá-los, diretamente pelo terminal, bem como para navegar pela árvore de diretórios. Os comandos mais importantes para diretórios são: `cd`, `ls`, `mkdir` e `rmdir`, já explorados por este tutorial. Outros *prompts* comumente utilizados estão listados abaixo: **1. chroot** O comando `chroot` (*change root*) serve para executar uma ação em um diretório *root* diferente daquele que está sendo utilizado no momento. Use `chroot` para isolar programas críticos do restante do [sistema de arquivos](https://www.ionos.com/digitalguide/server/know-how/file-systems/ "Sistemas de arquivo"). Para executar este comando, você deverá ter privilégios *root*, conforme mostra a estrutura abaixo: ```bash chroot DIRETÓRIO COMANDO ``` **2. mkdirhier** Com `mkdirhier`, você consegue criar hierarquias de diretórios inteiras, com uma única linha de comando: ```bash mkdirhier [ARGUMENTOS] /home/usuário/diretório1/diretório2/diretório3 ``` Se `diretório1` e `diretório2` já existirem, o comando `mkdirhier` criará apenas o `diretório3`. Caso nenhum deles exista, todos os três diretórios serão criados. **3. tree** Enquanto `ls` lista apenas o conteúdo de um diretório, o comando `tree` exibe toda a hierarquia de diretórios recursivamente, como estrutura de árvore. Utilize-o com a seguinte sintaxe: ```bash tree [ARGUMENTOS] [DIRETÓRIO] ``` ### Comandos Linux de arquivos Os comandos Linux apresentados nesta seção permitem que você execute ações em arquivos, a partir do terminal. Os comandos básicos `cp`, `mv` e `rm`, copiam, movem, renomeiam ou excluem arquivos do seu sistema. Fora estes, é importante conhecer: **1. basename** Ao adicionar um caminho de arquivo ao comando `basename`, ele retornará o nome do arquivo sem indicar o caminho padrão. Observe a sintaxe abaixo: ```bash basename [ARGUMENTOS] caminho/para/arquivo [SUFIXO] ``` Expanda este comando adicionando argumentos a ele. **2. comm** Use o comando `comm` para comparar, linha por linha, arquivos ordenados (por exemplo, por `sort`). Execute-o inserindo a seguinte sintaxe no terminal: ```bash comm [ARGUMENTOS] ARQUIVO1 ARQUIVO2 ``` O comando suporta três argumentos: - `-1`: Suprime linhas exclusivas do `ARQUIVO1` - `-2`: Suprime linhas exclusivas do `ARQUIVO2` - `-3`: Suprime todas as linhas contidas em ambos os arquivos **3. cut** O comando Linux `cut` extrai (corta) o conteúdo de um arquivo, a partir de uma linha de texto de um arquivo (por exemplo, arquivos de registro ou CSV). Observe a sintaxe: ```bash cut [ARGUMENTOS] ARQUIVO ``` A posição exata da seção a ser extraída pode ser definida por `-b` (posição de byte), `-c` (posição de caractere), `-d` (delimitador) ou `-f` (campo). **4. dirname** O comando `dirname` é a contrapartida do comando `basename`. Ele extrai parte do caminho de um arquivo e o exibe no terminal, sem conter o nome do arquivo. A sintaxe de `dirname` é: ```bash dirname [ARGUMENTOS] caminho/para/arquivo ``` **5. file** Com o comando `file`, você solicita informações sobre o tipo de um arquivo, como mostra a sintaxe base: ```bash file [ARGUMENTO] ARQUIVO ``` **6. lsof** O [comando Linux `lsof`](https://www.ionos.com/digitalguide/server/configuration/linux-lsof/ "Comando Linux lsof") (*list open files*) ocupa-se em fornecer informações sobre arquivos abertos no terminal, classificando-os por PID (ID do processo). Para executá-lo, utilize a sintaxe: ```bash lsof [ARGUMENTOS] ``` Sistemas Unix como o Linux adotam a política “tudo é um arquivo”, por isso, a lista gerada pelo comando `lsof` costuma ser extensa. Utilize argumentos para limitar os resultados. **7. md5sum** O comando `md5sum` ajuda a calcular e checar somas de verificações MD5 em arquivos. **8. paste** Parecido com `cat`, o comando `paste` também permite a saída de conteúdos de arquivos pelo *output* padrão. Entretanto, enquanto `cat` somente combina conteúdos, `paste` une coluna com coluna. Sua sintaxe básica é a seguinte: ```bash paste [ARGUMENTOS] ARQUIVO1 ARQUIVO2… ``` Você pode personalizar o separador de `paste`, adicionando à estrutura dele o argumento `-d`. Apesar de tabulações serem usadas como separadores padrão, um segundo modo pode ser ativado pelo argumento `-s` (*serial*). Ele faz com que todas as linhas do primeiro arquivo de entrada sejam transferidas para a primeira linha do arquivo de saída. Já os dados de todos os outros arquivos de entrada seguem em linhas de saída diferentes. Assim, cada linha da saída contém o conteúdo de apenas um arquivo de entrada. **9. rename** O comando Linux `rename` permite renomear arquivos e diretórios com a ajuda de expressões regulares (*regex*). Ao contrário de `mv`, `rename` é adequado para operar arquivos em que nomes devem ser parcialmente ou totalmente ajustados. Esta é sua sintaxe: ```bash rename [ARGUMENTOS] 'EXPRESSÕES REGULARES' ARQUIVO ``` EXPRESSÕES REGULARES devem ser substituídas de acordo com a seguinte estrutura: ```bash S/TERMO DE BUSCA/SUBSTITUTO/MODIFICADOR ``` **10. shred** O comando `shred` exclui arquivos, com segurança, pelo terminal. Os elementos apontados são sobrescritos durante o processo de exclusão, não sendo possível a restauração. A sintaxe do comando é a seguinte: ```bash shred [ARGUMENTOS] ARQUIVO ``` **11. sort** Use o comando `sort` para ordenar listas de arquivos e resultados do terminal numericamente, alfabeticamente ou por linha. A sintaxe de `sort` é a seguinte: ```bash sort [ARGUMENTOS] ARQUIVO ``` Personalize o método de ordenação com o uso de argumentos. Por exemplo, por número (`-n`), aleatoriamente (`-R`) ou inversamente (`-r`). **12. split** O comando Linux `split` é usado para dividir arquivos. A sintaxe é a seguinte: ```bash split [ARGUMENTOS] [ENTRADA [PREFIXO]] ``` ENTRADA corresponde ao arquivo a ser dividido e PREFIXO atua nos nomes dos arquivos participantes, seguindo o padrão abaixo: ```bash PREFIXOaa, PREFIXOab, PREFIXOac … ``` Caso nenhum prefixo seja definido, `split` usará o prefixo padrão `x`. Adicione o argumento `-b` (*bytes*) para especificar o tamanho dos arquivos parciais. Ele também pode ser especificado por kilobytes (k) e megabytes (m). ```bash split -b 95m arquivo.tgz arquivo-dividido.tgz. ``` **13. stat** O comando `stat` (*status*) gera carimbos de data e hora de acesso, assim como carimbos de alterações, nos arquivos e diretórios selecionados. Esta é a sintaxe do comando: ```bash stat [ARGUMENTOS] ARQUIVO ``` O formato de saída pode ser personalizado com o uso de argumentos. **14. uniq** O comando `uniq` é normalmente utilizado em combinação com `sort`, para limpar arquivos ordenados, oriundos de linhas duplicadas. No exemplo abaixo, `sort` é vinculado por pipe (`|`) ao comando `uniq` para, primeiramente, ordenar um arquivo e, em seguida, recriá-lo sem as linhas duplicadas. ```bash sort arquivo.txt | uniq ``` ### Comandos Linux de pesquisa O Linux disponibiliza inúmeros comando de pesquisa para serem usados diretamente no terminal. **1. find** Com `find`, você consegue [pesquisar dentro de um arquivo Linux](https://www.ionos.com/digitalguide/server/configuration/linux-find-command/ "Comando Linux find"). Para tanto, utilize a seguinte sintaxe: ```bash find [ARGUMENTOS] [DIRETÓRIO] [BUSCA_CONDICIONAL] [AÇÕES] ``` Insira, em DIRETÓRIO, o diretório onde a pesquisa deve ser realizada. Ela também se expandirá aos subdiretórios. Caso nenhum diretório seja especificado, o `find` buscará dentro do diretório de trabalho atual. Argumentos permitem que você defina critérios de busca e ações a serem executadas. A ação padrão é `-print`. Ela determina que todos os resultados de busca sejam emitidos na saída padrão (geralmente, no terminal). Outros argumentos possibilitam filtragem pelo nome do arquivo, por tamanho, por hora de acesso etc. Encontre todos os argumentos possíveis no manual correspondente. **2. locate** O comando `locate` também busca arquivos pelo terminal. Ao contrário de `find`, contudo, ele realiza buscas num banco de dados especialmente criado e atualizado regularmente. O comando `locate` é capaz de emitir resultados muito mais rapidamente que o `find`. Para pesquisar um arquivo específico em um banco de dados, faça uso da seguinte estrutura: ```bash locate TERMO DE BUSCA ``` Aqui, TERMO DE BUSCA suporta metacaracteres e espaços reservados (`*`). Coloque-os entre aspas para impedir o terminal de interpretá-los. **3. tre-agrep** O comando Linux `tre-agrep` também é usado para pesquisar cadeias de caracteres em arquivos de texto, a partir de um termo de busca. Mas, ao contrário de `grep`, `tre-agrep` não exibe somente correspondências exatas, mas também resultados parecidos, que podem conter, por exemplo, alguma letra errada ou ausente. Este comando é baseado na biblioteca TRE, tornando-a disponível ao terminal. Sua sintaxe corresponde à do comando `grep`: ```bash tre-agrep [ARGUMENTOS] TERMO DE BUSCA ARQUIVO(S) ``` Adicionando argumentos à estrutura, você define a tolerância a divergências. No nosso exemplo, toleramos uma única divergência. ```bash tre-agrep -1 'Linux' test .txt ``` **4. updatedb** O comando de busca `locate` só funciona corretamente se o arquivo `/var/lib/locatedb` for regularmente atualizado. É aí que o comando `updatedb` entra, por possibilitar a atualização manual deste banco de dados. Você precisa de permissões *root* para executá-lo: ```bash updatedb ``` **5. whereis** Com o comando `whereis`, você é capaz de localizar o código binário, o código-fonte ou os arquivos de manual do programa especificado. A sintaxe do comando é a seguinte: ```bash whereis [ARGUMENTOS] PROGRAMA ``` Utilize argumentos para limitar a pesquisa a determinados tipos de arquivos e diretórios. **6. which** Se você quiser identificar os arquivos binários de um programa, use o comando `which` com a seguinte sintaxe: ```bash which [ARGUMENTOS] PROGRAMA ``` Por padrão, o comando `which` exibe logo o primeiro arquivo que encontrar. Use o argumento `-a` para que todos os arquivos que atendam aos critérios de busca sejam mostrados. ### Comandos Linux de informações sobre usuários Alguns comandos Linux garantem acesso a **informações detalhadas sobre usuários registrados no sistema**, assim como a grupos e seus respectivos processos. **1. finger** O comando `finger` serve para acessar informações de usuário. Combine-o com o nome do usuário desejado: ```bash finger [ARGUMENTOS] [USUÁRIO] ``` Ao digitar somente `finger`, sem especificar um nome de usuário, o terminal retornará informações sobre a sua própria conta. **2. groups** O comando `groups` lista participações em grupos de uma conta de usuário específica. Use `groups` sem especificar um nome de usuário para obter a lista de todos os grupos da sua própria conta. Assim é a sintaxe de `groups`: ```bash groups [ARGUMENTOS] [USUÁRIO] ``` **3. id** O comando Linux `id` retorna IDs dos usuários e grupos especificados. Caso você queira obter seus próprios IDs, basta executar o comando sem especificar um nome de usuário. ```bash id [ARGUMENTOS] [USUÁRIO] ``` Limite o intervalo de saída fazendo uso de argumentos. **4. last** Use o comando `last`, com o padrão mostrado abaixo, para receber lista com todos os usuários que se conectaram recentemente ao sistema, incluindo horários de login e logout. ```bash last [ARGUMENTOS] [USUÁRIO] ``` As informações a serem exibidas serão obtidas do arquivo `wtmp`, em `/var/log/wtmp`. Para solicitar informações sobre apenas uma determinada conta, digite o comando, seguido do nome de usuário desejado. **5. w** O comando `w` gera lista de todos os usuários registrados, e também inclui todos os processos por eles executados. Use `w` em combinação com um nome de usuário para obter informações somente sobre este usuário: ```bash w [ARGUMENTOS] [USUÁRIO] ``` Tanto o intervalo quanto o formato da saída podem ser personalizados com o uso de argumentos. **6. who** O comando `who` apresenta informações detalhadas sobre usuários registrados no sistema. Esta é sua sintaxe: ```bash who [ARUGUMENTOS] [ORIGEM] ``` Por padrão, `who` exibe dados sobre usuários atualmente registrados, já que baseia-se no arquivo `/var/run/utmp`. Você tem a opção de especificar outros arquivos como fonte de informação. **7. whoami** Use o comando `whoami` para obter dados sobre o seu usuário. ```bash whoami [ARGUMENTOS] ``` ### Comandos Linux para gerenciar usuários Comandos Linux permitem que você crie, exclua e gerencie usuários e grupos diretamente pelo terminal. Reunimos, abaixo, os **principais comandos para gerenciar usuários no Linux**, assim como comandos para acessar direitos de outros usuários, com o **superusuário *root***. **1. chfn** O comando `chfn` (*change finger*) possibilita a personalização de informações sobre a conta de um usuário, adicionando a ela o nome real, a localização do escritório e o número do telefone, seja este particular ou comercial. A sintaxe é a seguinte: ```bash chfn [ARGUMENTOS "NOVA INFORMAÇÃO"] [USUÁRIO] ``` A NOVA INFORMAÇÃO deve ser adicionada juntamente com o respectivo argumento: `-f` para nome real, `-r` para localização do escritório, `-w` para telefone comercial e `-h` para telefone particular. **2. chsh** O comando Linux `chsh` (*change shell*) altera o *shell* de login do usuário especificado. Para tanto, utilize a seguinte estrutura: ```bash chsh [ARGUMENTOS] USUÁRIO ``` Também é possível utilizar o argumento `-s` em conjunto com o comando `chsh` para alterar o *shell* de login de uma conta. **3. deluser** O comando `deluser` exclui todas as entradas da conta de usuário especificada, dos arquivos de contas do sistema. Para executar `deluser`, você precisa de permissões *root* e da seguinte sintaxe: ```bash deluser [ARGUMENTOS] USUÁRIO ``` Se você também quiser excluir todos os arquivos do diretório inicial do usuário, use `deluser` juntamente com `--remove-home`. Se quiser excluir todos os arquivos do usuário do sistema, combine o comando a `--remove-all-files`. **4. delgroup** O comando `delgroup` (*delete group*) exclui um grupo de usuários existente. Para executar o comando, você precisa de permissões *root*. A sintaxe de `delgroup` é: ```bash delgroup [ARGUMENTOS] GRUPO ``` **5. groupmod** Nomes e IDs de grupos de usuários (GID) existentes podem ser modificados pelo comando `groupmod`. Ele necessita de permissões *root*e possui a seguinte sintaxe: ```bash groupmod ARGUMENTOS GROUP ``` Use `groupmod` com `-g` para personalizar o GID. Com o argumento `-n`, sobrescreva o nome do grupo. **6. newgrp** O comando `newgrp` (*new group*) permite que usuários registrados alterem o ID do grupo atual, sem a necessidade de realizarem logout seguido de login. Esta é a estrutura do comando: ```bash newgrp [-] [GRUPO] ``` Se o comando `newgrp` for usado com o parâmetro opcional \[`-`\], a alteração causará uma reinicialização do ambiente de usuário, que exigirá novo login. Se você executar `newgrp` sem especificar um grupo, aquele que estiver especificado em `/etc/passwd` será modificado. **7. su** O comando `su` possibilita alterações temporárias de usuários, permitido que ações sejam executadas com direitos de outros usuários. Ao contrário de `sudo`, `su` não é um comando direto, e sim uma mudança de identidade. Ao invés de solicitar a senha do usuário de origem, a senha do usuário de destino é exigida. Esta é sua sintaxe: ```bash su [ARGUMENTOS] [USUÁRIO] ``` Ao utilizar este comando sem especificar o usuário, *root* será o usuário de destino. **8. usermod** O comando `usermod` permite que contas de usuários anteriormente criadas possam ser editadas. Use `usermod` com permissões *root* e a seguinte sintaxe: ```bash usermod [ARGUMENTOS] USUÁRIO ``` As modificações devem ser feitas com a ajuda de argumentos. Para alterar o nome de usuário, por exemplo, adicione à estrutura `-l NOVO NOME`. Para mais opções, acesse a página de manual correspondente. ### Comandos Linux de sistema Nesta categoria, você conhecerá comandos Linux para controlar seu sistema. Utilize-os para reiniciar e desligar o sistema pelo terminal, assim como para configurar um *timer*, se desejar. **1. logger** Use `logger` com a seguinte estrutura: ```bash logger "MENSAGEM" ``` Localize o registro no sistema em `/var/log/syslog`. **2. reboot** O comando `reboot` reinicia o sistema. Para tanto, ele deve ser executado com permissões *root*. ```bash reboot [ARGUMENTOS] ``` **3. rtcwake** O comando `rtcwake` possibilita que você determine quando seu sistema deve ligar e desligar, automaticamente, com a ajuda de um *timer*. Esta é a sintaxe do comando: ```bash rtcwake [ARGUMENTOS] [MODO] [TEMPO] ``` Determine como o sistema deve ser desligado (`-m MODE`), e em que momento (`-s TEMPO EM SEGUNDOS`). Também existe a opção de ligar o sistema em um horário definido por (`-t UNIXTIME`). ### Comandos Linux de informações sobre o sistema Comandos desta categoria permitem que você obtenha **informações e relatórios** sobre o status do seu sistema, para ter uma ideia geral do seu funcionamento. **1. date** O comando `date` exibe a data e a hora configuradas no sistema. ```bash date [ARGUMENTOS] [FORMATO] ``` Caso você deseje trabalhar com tempos específicos para o contexto de programação (veja `rtcwake`), faça essa configuração adicionando ao comando `date` o argumento `-d 'DATE'`. Vários formatos podem ser configurados para a exibição de informações sobre data e hora. **2. df** Use o comando `df` (*disk free*) de acordo com a estrutura abaixo: ```bash df [ARGUMENTOS] [ARQUIVO] ``` Adicione um arquivo específico ao comando, para o sistema especificar apenas o espaço livre da partição onde ele está localizado. Caso você não o faça, o espaço livre no disco rígido das partições montadas será exibido. O argumento `-l` (*local*) restringe o `df` ao sistema de arquivos local, e também permite a personalização do formato de exibição. **3. dmesg** O comando `dmesg` (*display message*) exibe informações sobre o buffer circular no terminal, permitindo a identificação e localização de falhas de driver e hardware. Ele tem a seguinte sintaxe: ```bash dmesg [ARGUMENTOS] ``` Por conter todas as mensagens da rotina de inicialização do sistema, o resultado do comando é longo. A depender do nível de detalhes que você deseja obter, utilize `dmesg` em combinação com os argumentos `more`, `less` e `tail`. **4. free** O comando `free` fornece informações sobre o uso da memória. Esta é sua sintaxe: ```bash free [ARGUMENTOS] ``` O comando lhe retornará dois resultados: `Mem` e `Swap`. Adicione `-h` a `free` para que o uso da memória seja exibido em formato legível por humanos. **5. hostname** Use `hostname` para ter acesso aos nomes DNS do sistema. Este é o padrão do comando: ```bash hostname [ARGUMENTOS] ``` **6. uname** O comando Linux `uname` (*unix name*) tem a função de exibir informações sobre o núcleo do sistema. Utilize variados argumentos para filtrar resultados e obter somente as informações que você deseja. Encontre estes argumentos no respectivo manual. ```bash uname [ARGUMENTOS] ``` **7. uptime** Se você quiser saber há quanto tempo seu sistema está em execução desde a última reinicialização, digite o comando `uptime` no terminal: ```bash uptime ``` **8. vmstat** Com a ajuda da ferramenta de monitoramento `vmstat`, você pode acessar informações sobre memória virtual, procedimentos de leitura e gravação no disco, e atividade da CPU. Execute `vmstat` de acordo com a seguinte sintaxe, para gerar valores desde a última inicialização do sistema: ```bash vmstat [ARGUMENTOS] ``` O `vmstat` também oferece um modo de monitoramento contínuo, que acessa os valores do sistema sempre que solicitado, em um intervalo de tempo definido em segundos. ```bash vmstat [ARGUMENTOS] [INTERVALO [REPETIÇÕES]] ``` ### Comandos Linux de informações sobre hardware Comandos Linux desta categoria fornecem **informações detalhadas sobre os componentes de hardware** do seu sistema. **1. lspci** Use o comando `lspci` (*list pci*) para obter informações, em detalhes, sobre dispositivos PCI. Este é o padrão a ser seguido: ```bash lspci [ARGUMENTOS] ``` Para conhecer os argumentos que podem ser combinados a este comando, consulte o manual do seu sistema operacional. **2. lsusb** Use `lsusb` (*list usb*) para obter informações detalhadas, no terminal, sobre dispositivos USB conectados. ```bash lsusb [OPTIONS] ``` Para conhecer os argumentos que podem ser combinados a este comando, consulte o manual do seu sistema operacional. ### Comandos Linux para gerenciar processos No Linux, qualquer programa em execução é classificado como um processo. Os comandos Linux listados nesta seção permitem que você **supervisione todos os processos em execução no seu sistema**, com facilidade, pelo terminal. Alguns também possibilitam o gerenciamento e o controle de processos, de acordo com a sua vontade. **1. chrt** O comando Linux `chrt` encarrega-se de controlar, em tempo real, a prioridade de cada processo, permitindo ajustes dos processos em execução, pelo terminal. Utilize-o com a seguinte sintaxe: ```bash chrt [ARGUMENTOS] [PRIORIDADE] PID/COMANDO [ARGUMENTO] ``` Também é possível utilizar `chrt` sem especificar uma prioridade. Complemente-o com o argumento `-p` para identificar atributos, em tempo real, dos processos especificados. O comando também permite que processos em execução ou recém-iniciados sejam agendados e regulados, com a ajuda de argumentos. Para descobri-los, consulte o manual do seu sistema. **2. ionice** O comando Linux `ionice` é usado para modificar a prioridade de processos que utilizam a interface de entrada e saída (E/S). Esta é a sintaxe do comando: ```bash ionice [ARGUMENTOS] COMANDO ``` Para conseguir executar o `ionice`, você precisa de permissões *root*. O comando faz distinção entre três classes de agendamento, que devem ser especificadas pelo argumento `-c class`. Os valores, 1, 2 e 3, correspondem a: - 1 = Tempo real: A ação E/S é executada imediatamente - 2 = Melhor esforço: A ação E/S é executada o mais rápido possível - 3 = Inativo: A ação E/S só é executada quando nenhum outro processo ocupar a E/S **3. nohup** Normalmente, todos os processos executados por um usuário são encerrados, automaticamente, assim que o terminal é fechado (`exit`). Contudo, o [comando Linux `nohup`](https://www.ionos.com/digitalguide/server/configuration/linux-nohup-command/ "Comando Linux `nohup`") (*no hangup*) desassocia o comando especificado da sessão corrente, para que ele continue a ser executado mesmo após o logout. ```bash nohup COMANDO ``` **4. pidof** O comando Linux `pidof` gera números de identificação de processos (PIDs) para todos os programas em execução. Gere PIDs usando `pidof` da seguinte maneira: ```bash pidof [ARGUMENTOS] PROGRAMA ``` Caso você necessite gerar um ID somente para o primeiro processo, digite `pidof` em combinação com o argumento `-s` (*single shot*). **5. pidkill** Assim como `kill`, o comando `pkill` também envia um sinal ao processo especificado. No entanto, este não utiliza o PID para encontrar o processo, e sim o termo de busca correspondente ao nome do processo em execução — também é possível localizar o processo por expressão regular. O comando `pkill` encaminha o sinal padrão `TERM` quando nenhum outro sinal é definido. Esta é sua sintaxe: ```bash pkill [ARGUMENTOS] [-SINAL] [TERMO DE BUSCA] ``` Argumentos podem ser adicionados à expressão para limitar a atuação do comando a processos de um usuário específico (`-U UID`), a subprocessos de um processo pai (`-P PID`), ou aos processos mais novos (`-n`) ou mais antigos (`-o`). **6. pstree** Use o comando Linux `pstree` para que todos os processos em execução sejam exibidos em estrutura de árvore. A sintaxe geral do comando é a seguinte: ```bash pstree [ARGUMENTOS] ``` Personalize o formato e o intervalo dos resultados utilizando argumentos. **7. renice** O comando `renice` permite personalizar a prioridade de um processo em execução. Esta é sua sintaxe: ```bash renice PRIORIDADE [ARGUMENTOS] ``` **8. sleep** O [comando Linux `sleep`](https://www.ionos.com/digitalguide/server/configuration/linux-sleep-command/ "Comando Linux sleep") interrompe a sessão atual do terminal por um período determinado de tempo. A estrutura de `sleep` é a seguinte: ```bash sleep NÚMERO[SUFIXO] ``` Digite `sleep` sem sufixo para que o número especificado seja interpretado em segundos (s). Também interrompa a sessão do terminal por minutos (m), horas (h) ou dias (d). **9. taskset** O comando Linux `taskset` pode ser usado para controlar processos de modo avançado, quando sistemas com vários processadores estão sendo utilizados. Ele pode, por exemplo, atribuir processos e comandos a processadores específicos. Para fazer uso do `taskset`, você deverá ter permissões *root*. Esta é sua estrutura: ```bash taskset [ARGUMENTOS] MÁSCARA COMANDO taskset [ARGUMENTOS] -p PID ``` A atribuição de um processo ou comando a um processador é feita por máscaras de bits hexadecimais. Como atribuições por máscaras de bits não são tão intuitivas, o `taskset` costuma ser usado em conjunto com o argumento `-c` (*--cpu-list*), que atribui correspondentes numéricos a processadores (por exemplo, 0, 5, 7, 9-11). ### Comandos Linux de paginação Quer obter um panorama sobre o conteúdo de um arquivo extenso? Comandos Linux de paginação lhe permitem selecionar seções de arquivos para que sejam exibidas pelo terminal, podendo assim serem percorridas de modo interativo. **1. head** O [comando Linux `head`](https://www.ionos.com/digitalguide/server/configuration/linux-head-command/ "Comando Linux head") tem a função de gerar a primeira parte de um arquivo. Esta é sua sintaxe: ```bash head [ARGUMENTOS] ARQUIVO ``` Combine o comando com `-n NÚMERO DE LINHAS` para especificar a quantidade de linhas a serem exibidas, a começar do início. **2. less** O comando `less` exibe o conteúdo de um arquivo de texto diretamente no terminal. A estrutura pode ser encontrada abaixo: ```bash less [ARGUMENTOS] ARQUIVO ``` Ao acessar um documento pelo terminal, você poderá interagir ativamente com ele, percorrendo-o, selecionando-o ou buscando por trechos utilizando palavras-chave. Encerre o modo de leitura interativo com o atalho de teclado \[Q\]. Descubra outras teclas de controle no manual do seu sistema operacional. **3. tail** Enquanto `head` exibe as primeiras 10 linhas do arquivo por você determinado, o [comando Linux `tail`](https://www.ionos.com/digitalguide/server/configuration/linux-tail-command/) exibe as últimas 10. Ambos utilizam o mesmo padrão, portanto consulte `head` para conhecê-lo. ### Comandos Linux de edição No Linux, você não precisa instalar um software de processamento de texto para personalizar arquivos de configuração, editar trechos de códigos ou fazer pequenas anotações. Acesse **editores de texto** pelo terminal, para trabalhar com documentos escritos. Abaixo, indicamos três interessantes programas: **1. Emacs** Emacs é um editor de texto multiplataforma, que pode ser expandido conforme desejado, por interface de programação. Por padrão, o programa também oferece uma interface gráfica de usuário, mas pode ser aberto pelo terminal, se combinado ao argumento `--no-window-system`: ```bash emacs --no-window-system ``` Acesse tutoriais sobre o Emacs utilizando o atalho de teclado \[CTRL\] + \[H\], \[T\]. **2. Nano** Nano é um editor de texto baseado em terminal. Apesar de oferecer menos recursos que editores similares (como o Vim), ele é especialmente fácil de usar. Utilize esta sintaxe para acessar o programa: ```bash nano [ARGUMENTOS] ARQUIVOS ``` Com o Nano, você consegue abrir arquivos de texto no terminal, que podem ser editados. Ao utilizar a sintaxe do programa sem especificar o arquivo a ser aberto, o terminal criará um novo arquivo de texto e o armazenará no diretório especificado. **3. Vim** Vim (*Vi Improved*) é derivado do editor de texto Vi e se destaca por suas várias extensões, como realce de sintaxe, abrangente sistema de ajuda, scripts nativos, preenchimento automático de códigos e seleção visual de textos. Este programa de código aberto oferece vários modos de edição de arquivos de texto puro, e pode ser usado tanto no terminal quanto por uma aplicação, que conta com interface gráfica de usuário própria (*GVim*). Este editor é utilizado, principalmente, para a edição de códigos-fonte. Caso você inicie o Vim pelo terminal, terá de operá-lo pelo teclado. Utilize a seguinte sintaxe para chegar ao programa: ```bash vim [ARGUMENTOS] ARQUIVO ``` O argumento para Vim `vimtutor` fornece extensa introdução ao editor, também no terminal. Acesse nosso artigo especializado no [editor Linux Vim](https://www.ionos.com/digitalguide/server/tools/linux-editor-effective-code-editing-with-vim/ "Vim: Editor de códigos para Linux") para mais informações sobre instalação e modos de operação do programa. ### Comandos Linux para gerenciar rede Você também pode **gerenciar sua rede** com facilidade, pelo terminal do Linux. Entre as possibilidades estão testar conexão, solicitar informações DNS, configurar interface e enviar arquivos para outros computadores na rede. Os principais comandos do tipo estão listados abaixo. **1. arp** O comando `arp` permite que você acesse e manipule o cache [ARP](https://www.ionos.com/digitalguide/server/know-how/what-is-arp-address-resolution-in-networks/ "O que ARP: Resolução de endereços em redes") do seu sistema operacional. Use `arp` sem adicionar argumentos a ele para ter acesso ao conteúdo da tabela ARP. ```bash arp [ARGUMENTO] ``` Alternativamente, limite a exibição dos resultados com argumentos, ou crie e delete entradas: - `-a HOSTNAME` = Limita resultados para [*hostnames*](https://www.ionos.com/digitalguide/hosting/technical-matters/hostname/ "Hostname") específicos. - `-s HOSTNAME MAC_ADDRESS` = Cria entrada ARP com *hostname* e endereço MAC especificados - `-d HOSTNAME` = Exclui entrada ARP **2. iw** O comando Linux `iw` é usado para a configurar interfaces WLAN, funcionando como alternativa ao `iwconfig`. Execute-o utilizando uma sintaxe semelhante à do comando `ip`: ```bash iw [ARGUMENTOS] OBJETO [COMANDO] ``` Estes são os argumentos possíveis: - dev NOME\_INTERFACE = Interface de rede - phy NOME\_DISPOSITIVO = Dispositivo WLAN (por nome) - phy#ÍNDICE\_DISPOSITIVO = Dispositivo WLAN (por índice) - reg = Agente regulador para configurar definições regionais e de país Você pode encontrar mais detalhes sobre os comandos listados no manual do seu sistema operacional. **3. nslookup** Assim como `dig`, o comando `nslookup` também é aplicado à resolução de nomes, sendo este disponível em dois modos: interativo e não interativo. Para usar o `nslookup` no modo não interativo, execute o comando combinando-o com um *hostname* ou endereço IP. ```bash nslookup [ARGUMENTOS] [HOST/IP] ``` Para iniciar o modo interativo, digite `nslookup` no terminal sem adicionar qualquer outra informação. Em seguida, insira *hostnames* ou endereços IP para vizualizar os *hostnames* ou endereços IP associados. Contudo, como este comando está **oficialmente desatualizado**, recomendamos que você opte pelo comando `dig` sempre que possível. **4. rsync** O comando Linux `rsync` sincroniza arquivos localmente ou em rede. Para tanto, ele compara o tamanho e o tempo de modificação dos mesmos. Esta é sua sintaxe: ```bash rsync [ARGUMENTOS] FONTE(S) DESTINO ``` O comando costuma ser executado em conjunto com o argumento `-a`, que garante que todos os subdiretórios e links simbólicos sejam copiados, e que todos os direitos de usuário sejam efetivados. **5. scp** Com o [comando Linux `scp`](https://www.ionos.com/digitalguide/server/configuration/linux-scp-command/ "Comando Linux scp") (*secure copy*) você tem mais um modo de transferir dados em rede, de maneira segura, diretamente pelo terminal. O comando copia dados de um computador em outro, utilizando o protocolo de rede SSH. Parecido com o comando `cp`, `scp` abrange todo o sistema, se utilizado de acordo com a sintaxe: ```bash scp [ARGUMENTOS] ARQUIVO [[USUÁRIO@]host_remoto:]CAMINHO ``` Se você especificar o caminho que leva ao computador remoto, este deverá ser prescedido pelo nome do usuário e pelo *hostname*. Já arquivos locais devem ser endereçados por caminhos relativos ou absolutos. Observe o exemplo: ```bash scp/home/max/images/image.jpg max@exemplo.com:/home/max/archive ``` Argumentos permitem que você configure o modo de transferência e as opções de criptografia. **6. tty** O comando `tty` retorna nomes de arquivos, no terminal, definidos como entradas padrão. A sintaxe é esta: ```bash tty [ARGUMENTOS] ``` ### Comandos Linux para comprimir e compactar No Linux, arquivos podem ser comprimidos e compactados com as mais diferentes tecnologias. Contudo, é importante saber que **nem todo arquivo comprimido é compactado**. Portanto, para compactar arquivos, você deve utilizar o comando `tar`. Combine-o a outros comandos, como `gzip`, `bzip2` e `xz`, para realizar compactações juntamente com compressões. **1. gzip** O `gzip` permite que você comprima e descomprima arquivos com facilidade, pelo terminal. Utilize, para tanto, a seguinte sintaxe: ```bash gzip [ARGUMENTOS] ARQUIVO(S) ``` Por padrão, o comando `gzip` deleta o arquivo original durante o processo de compressão. Para evitar a exclusão, use o argumento `-k`. Este comando pode seja usado em múltiplos arquivos ao mesmo tempo, em caso de necessidade. Cada um dos arquivos comprimidos é convertido ao formato *.gz*. Caso você deseje agrupar vários arquivos em um único arquivo compactado, combine `gzip` e `tar`. Para descomprimir, combine `gzip` e `-d`. **2. bzip2** O comando `bzip2` é similar ao `gzip`. Contudo, apesar de utilizar a mesma sintaxe do primeiro, esse executa um processo de compressão baseado em três estágios, o que permite uma redução ainda maior do tamanho dos arquivos. Ao serem comprimidos por este comando, arquivos recebem a extensão *.bz2*. Aqui está sua estrutura: ```bash bzip2 [ARGUMENTOS] ARQUIVO(S) ``` O comando `bzip2` também pode ser executado conjuntamente com `tar`. A descompressão é feita da mesma forma que a executada por `gzip`, com a ajuda do argumento `-d`. **3. xz** O comando Linux `xz` comprime arquivos, convertendo-os em arquivos de terminação *.xz*. A sintaxe é similar à dos outros que executam esta função: ```bash xz [ARGUMENTOS] ARQUIVO(S) ``` Para descomprimir arquivos *.xz*, utilize o comando combinado ao argumento `d`. Também é possível descompactar arquivos executando o comando `unxz`. Assim como arquivos *.gz* e *.bz2*, arquivos *.xz* não são compactados, mas somente comprimidos. Para agrupar vários arquivos *.xz* em um único arquivo compactado, utilize o comando em conjunto com `tar`. **4. cpio** O programa de compactação `cpio` (*copy in copy out*) permite a gravação de dados em um arquivo compactado (*.cpio*), assim como a extração. ### Comandos Linux para gerenciar partições Se você quiser acessar um sistema de arquivos em outra partição do Linux, deverá integrá-lo à estrutura de diretórios do seu sistema operacional primeiro — processo que recebe o nome de montar partições, e que também pode ser feito por interface gráfica de usuário. Com os comandos `lsblk`, `blkid` e `mount`, também é possível solicitar informações sobre dispositivos de armazenamento em bloco, assim como montá-los ou desmontá-los, se necessário. **1. lsblk** Use o comando Linux `lsblk` (*list block devices*) para exibir, como estrutura de árvore, todos os dispositivos de armazenamento em bloco e partições conectados, mesmo que não estejam diretamente envolvidos. Utilize a seguinte sintaxe: ```bash lsblk [ARGUMENTOS] ``` Modifique, individualmente, os resultados apresentados e a lista de atributos, fazendo uso do argumento `-o` (*--output*). Assim, você obterá acesso a informações adicionais, como ao número de identificação (UUID), ao sistema de arquivos (FSTYPE) e ao estado (STATE). Quando configurados no modo padrão, dispositivos de armazenamento vazios são ignorados. Caso você deseje incluí-los entre os resultados, combine `lsblk` e `-a` (*--all*). Para solicitar informações sobre um único dispositivo específico, digite `lsblk` com a seguinte sintaxe: ```bash lsblk [ARGUMENTOS] DISPOSITIVO ``` **2. blkid** Assim como `lsblk`, `blkid` também expõe informações sobre os dispositivos de armazenamento em bloco conectados. Use `blkid` com a seguinte sintaxe, para ter acesso ao número de identificação (`UUID`) e ao tipo de sistema de arquivos (`TYPE`) de cada um deles. ```bash blkid [ARGUMENTOS] ``` Para que o resultado seja apresentado em forma de tabela, adicione à expressão o argumento `-o`, seguido de `list`. Também é possível limitar o `blkid` a um dispositivo específico: ```bash blkid [ARGUMENTOS] DISPOSITIVO ``` ### Comandos Linux diversos Apresentamos, na lista abaixo, importantes comandos Linux, de variadas categorias que não se encaixam nas anteriores. **1. alias** Geralmente, usuários interagem com o terminal de um sistema operacional por meio da **digitação de comandos**. Estes, correspondem à ação desejada, que deve ser executada. O [comando Linux `alias`](https://www.ionos.com/digitalguide/server/configuration/linux-alias-command/ "Comando Linux alias") permite que você customize os comandos que mais utiliza, personalizando seus nomes. Aqui está sua sintaxe: ```bash alias NOME_PERSONALIZADO= 'COMANDO' ``` Substitua o espaço reservado a COMANDO por qualquer comando padrão, inclusive com argumentos. A ação o vinculará ao NOME\_PERSONALIZADO inserido. **2. at** Execute o comando `at`, com a seguinte sintaxe, para executar um comando com controle de tempo. ```bash at TEMPO ``` Em seguida, digite o comando a ser controlado e encerre o modo interativo, por meio do atalho de teclado \[CTRL\] + \[D\]. **3. cal** Use `cal` para visualizar um calendário no terminal. A estrutura está indicada abaixo: ```bash cal [ARGUMENTOS] [[MÊS] ANO] ``` **4. pr** Faça uso do comando Linux `pr` para preparar arquivos de texto para impressão, como mostra a sintaxe: ```bash pr [ARGUMENTOS] ARQUIVO ``` Na configuração padrão, `pr` gera um cabeçalho de página contendo o nome do arquivo, a data corrente e o número da página. **5. script** O comando `script` permite o registro de uma sessão do terminal, que será salva em um arquivo `typescript`. Caso outra seção já esteja salva no `typescript`, esta será sobrescrita. A gravação se iniciará automaticamente, assim que o comando for executado pelo terminal. ```bash script ``` Use a o atalho de teclado \[CTRL\] + \[D\] para encerrar a gravação. Se você quiser salvar a gravação em outro arquivo que não no `typescript`, use `script` em combinação com um nome ou caminho de arquivo. **6. seq** Faça uso do comando Linux `seq` para que o terminal gere uma série numérica padrão. Para tanto, defina o valor inicial, o valor final e um incremento (opcional). ```bash seq [ARGUMENTOS] VALOR_INICIAL INCREMENTO VALOR_FINAL ``` **7. tasksel** O comando `tasksel` ajuda a instalar aplicações padrão (servidores de e-mail, servidores DNS, servidores OpenSSH, servidores LAMP e outros). Com ele, você consegue automatizar a instalação dos pacotes e programas que precisa, e organizar as tarefas na ordem certa. Ao digitar `tasksel` e `--list-tasks`, você gerará uma lista com todas as aplicações padrão disponíveis. ```bash tasksel --list-tasks ``` Para ter acesso a mais informações sobre um aplicativo padrão da lista, combine `tasksel`, `--task-desc` e a tarefa correspondente. Para obter uma lista com todos os pacotes que pertencem à tarefa “mail-server”, por exemplo, use o comando `tasksel` com o argumento `--task-packages`. Para instalar todos os pacotes de um aplicativo padrão, faça uso do subcomando `install`, mas este requer permissões *root*. **8. tee** O [comando Linux `tee`](https://www.ionos.com/digitalguide/server/configuration/linux-tee-command/ "Comando Linux tee") duplica a saída de um programa: uma saída funciona como padrão e a outra é gravada no arquivo especificado por `tee`. ```bash tee [ARGUMENTOS] ARQUIVO ``` O comando é normalmente usado em combinação com o operador de redirecionamento pipe (`|`): ```bash ls | tee exemplo.txt ``` **9. time** Faça uso do comando Linux `time`, seguido da seguinte sintaxe, para identificar o tempo de execução dos comandos que você iniciou no terminal. ```bash time [ARGUMENTOS] COMANDO [ARGUMENTOS] ``` **10. tr** Digite `tr` no terminal para excluir um conjunto de caracteres específico ou substituí-lo por outro. O comando `tr` tem a capacidade de ler fluxos de dados com entradas padrão (por exemplo, um arquivo) e de gravá-los, na saída padrão, conforme a modificação executada. Se um conjunto de caracteres tiver de ser substituído por outro, adicione estes dois argumentos: ```bash tr ARGUMENTO CONJUNTO_CARACTERES1 CONJUNTO_CARACTERES2 ``` O segundo argumento (CONJUNTO\_CARACTERES2) substituirá o primeiro (CONJUNTO\_CARACTERES1). Para deletar uma sequência de caracteres, combine `tr` ao argumento `-d` e digite o conjunto a ser excluído. ```bash tr -d CONJUNTO_CARACTERES ``` Esse comando é geralmente utilizado em combinação com operadores de redirecionamento (< e >) para a realização de modificações nos arquivos. ```bash tr 'a-z' 'A-Z' < exemplo1.txt > exemplo2.txt ``` Ao ser usado, `tr` lê o conteúdo do arquivo `exemplo1.txt`, substitui as letras minúsculas de *a* a *z* pelas maiúsculas e salva o resultado no arquivo `exemplo2.txt`. **11. wall** O comando `wall` envia uma mensagem a todos os usuários registrados no sistema. Execute-o com a seguinte sintaxe: ```bash wall ``` Após pressionar \[Enter\] para executar o comando, digite a mensagem que gostaria de transmitir. Ao final, pressione \[Enter\] mais uma vez e conclua o envio com o atalho de teclado \[CTRL\] + \[D\]. Todos os usuários registrados no sistema receberão sua mensagem, enviada pelo terminal. Importante destacar que, para que estes possam receber comunicações pelo terminal, você deverá concedê-los acesso a elas, fazendo uso do comando `mesg`: Para enviar o conteúdo do arquivo a todos os usuários registrados, use `wall` em combinação com um redirecionamento de entrada e o respectivo nome do arquivo: ```bash wall < ARQUIVO ``` **12. watch** O comando Linux `watch` permite a configuração de um comando a ser executado em intervalos regulares de tempo. Utilize a seguinte sintaxe: ```bash watch [ARGUMENTOS] COMANDO ``` O intervalo de tempo para a execução deve ser dado em segundos, com a utilização do argumento `-n SECONDS`. Para encerrar o `watch`, utilize o atalho de teclado \[CTRL\] + \[C\]. **13. wc** O [comando Linux `wc`](https://www.ionos.com/digitalguide/server/configuration/linux-wc-command/ "Comando Linux wc") (*word count*) mostra o número de linhas, palavras, letras, caracteres e/ou bytes de um arquivo de texto. Solicite estas informações com a sintaxe: ```bash wc [ARGUMENTOS] ARQUIVO ``` Se `wc` for utilizado sem argumentos, o resultado corresponderá ao padrão `LINHAS PALAVRAS CARACTERES ARQUIVO`. Para filtrar resultados, utilize os seguintes argumentos: `-l` (linhas), `-c` (bytes), `-m` (caracteres), `-L` (comprimento da linha mais longa) e `-w` (palavras). **14. xargs** O [comando Linux `xargs`](https://www.ionos.com/digitalguide/server/configuration/linux-xargs-command/ "Comando Linux xargs") permite que você transfira o resultado de um comando anterior a um novo comando, como argumento. Via de regra, ele é combinado a um pipe (`|`), que funciona como operador de desvio. Esta é a sintaxe do `xargs`: ```bash COMANDO1| xargs [ARGUMENTOS] COMANDO2 ``` O comando pode ser usado em combinação com `find`, por exemplo. Abaixo, `find` identifica todos os arquivos no diretório atual que se encaixam no termo de busca `*.tmp` e exibe seus nomes no formato padrão. Então, os arquivos com o nome `xargs` são aceitos e repassados como argumentos ao comando `rm`. ```bash find . -NOME '*.tmp' | xargs rm ``` A lista de comandos Linux apresentada aqui não tem qualquer pretensão de ser completa, mas certamente inclui os comandos mais básicos do Linux e apresenta exemplos de aplicação no trabalho diário com sistemas operacionais Unix. Para descrições detalhadas e completas sobre comandos Linux, consulte o manual do seu sistema operacional. Acesse, também, páginas de ajuda e documentações no [Linux man-pages project](https://www.kernel.org/doc/man-pages/ "Linux man-pages, projeto de Michael Kerrisk"), elaborado por Michael Kerrisk. This is a markdown version of: [https://www.ionos.com/pt-br/digitalguide/servidor/configuracao/comandos-linux-para-usar-no-terminal/](https://www.ionos.com/pt-br/digitalguide/servidor/configuracao/comandos-linux-para-usar-no-terminal/) for AI/LLM consumption.