103.1 - Trabalhando na linha de comando
Este tópico aborda os comandos usado no shell, tudo o que você deve saber para operar o sistema, conhecendo seus comandos e funcionalidades.
A maneira usada para interagir com um servidor linux é através do prompt de comando do bash, o prompt possui 3 níveis de "permissões", que são: usuário root (super usuário), usuário comum e usuário comum mas com poderes de usuário root. Porque um usuário comum iria ter poderes de root?, porque quando você usa o comando sudo, você invoca o super usuário para realizar a tarefa para você, isso é usado quando se precisa de mais permissão para executar alguma tarefa.
A PS1 do shell exibe informações do nível de privilégio de seu usuário:
$ - Indica um usuário comum; # - Indica um super usuário (normalmente o root).
A PS1 pode ser editada, e pode omitir essa informação, mas uma PS1 padrão, sempre irá exibir o nível de permissão do seu usuário.
Sequência de comandos
A grande maioria das tarefas no shell depende da execução de mais de um comando, para isso, usamos AND lógico, OU lógico para fazer a execução de vários comandos consecutivos.
; - O ponto e vírgula executam tudo que vier depois dele, não importa se o comando anterior foi bem ou mal executado (pwd ; echo "O comando PWD funcionou" e arquivo ; echo "O comando arquivo não funcionou");
&& - AND lógico, só executa o comando, se o comando anterior funcionar (pwd && echo "funcionou"), outra forma de ver é 'executa 1 e executa 2';
|| - OU lógico, só executa o comando se o comando anterior não funcionou (arquivo || echo "Comando nao existe"), outra forma de visualizar é 'executa comando 1 ou executa comando 2'.
Variáveis de ambiente
Aspectos de ambiente do shell é definido e controlado através de variáveis. Uma variável é um espaço alocado na memória RAM que recebe um valor, e fica alocado lá por tempo determinado (chamado tempo de execução), toda variável tem um nome e um valor.
Locais - Variáveis disponíveis apenas para a sessão atual (cada shell é um novo processo (nova sessão));
Exportadas - Disponíveis para a sessão atual e subseções (seções filhas da sua sessão atual), em outras palavras, para processo atual e para subprocessos (processos filhos).
Criar variáveis
No linux, a criação de uma variável é bem simples, basta você dar um nome e um valor, como no exemplo abaixo:
linux:~/$ POSICAO="4.3"
linux:~/$ POSICAO='echo 4.3'
No segundo caso, já adicionei o echo ao valor da variável, então basta digitar $POSICAO e o comando echo irá mostrar o 4.3.
Para exibir o valor da variável usamos o comando echo, segue abaixo:
linux:~/$ echo "$POSICAO"
# Exibe o valor da variável;
linux:~/$ $POSICAO
# Nesse caso, como foi colocado um comando dentro da variável,
# esse comando será executado.
Exportar variáveis
Isso irá criar o que chamamos de variáveis exportadas, tornando a variável visível para subprocessos do seu shell.
Temos duas formas de exportar, uma é exportar declarando a variável e outra é exportar uma variável já criada, segue exemplo:
linux:~/$ export POSICAO="4.3"
# Exportando a variável enquanto cria-se ela;
linux:~/$ export POSICAO
# Exportando uma variável já existente.
SET ou ENV
Para ver as variáveis de ambiente, temos alguns comandos que podem ser usados, os mais conhecidos são env e set, esses comandos não tem apenas essa função.
SET = Server para definir ou ativar/desativar opções de shell.
ENV = É usado para exibir as variáveis de ambiente, também é usado para executar um utilitário ou comando em um ambiente customizado.
Obs.: Os comandos printenv e export sem argumentos também exibem as variáveis.
O comando env lista somente as variáveis "Globais", ou seja, as variáveis que foram exportadas, enquanto o comando set lista todas as variáveis.
Para exibir as variáveis digite no terminal env ou set.
Remover uma variável
linux:~/$ env -u VARIAVEL
# Remove a variável temporariamente;
linux:~/$ env -u VARIAVEL ./meu_script
# Remove temporariamente para execução de um script.
UNSET - Apagar variáveis de ambiente
Para apagarmos uma variável, usamos o comando unset, ele vem com dois argumentos, o -f que remove uma função e o -v que remove uma variável, não sendo obrigatório a escolha do -v para remover uma variável.
As variáveis só existem enquanto o Shell existir, para torná-las "imortais", elas devem ser colocadas em arquivos como /etc/profile, /etc/bash.bashrc ou nos arquivos .bashrc ou .profile de sua HOME.
/etc/profile - Contém dados que serão carregados para todos os usuários, esse arquivo é executado sempre que um shell de login do bash é carregado, como ao fazer login no console ou através do ssh, também é carregado quando fazemos login pela interface gráfica.
/etc/environment - É usado para definir variáveis para programas que geralmente não são iniciados a partir de um shell, aqui temos a definição da PATH.
linux:~/$ unset POSICAO
# A variável foi removida, mas se ela estiver sendo declarada em algum lugar, ao abrir um
# novo shell, essa mesma variável volta a existir.
Algumas variáveis importantes do sistema
| Nome | Descrição |
|---|---|
| PATH | Armazena a localização de diretórios que contém executáveis, a PATH é definida no arquivo /etc/environment; |
| PS1 | Forma como o Shell irá aparecer (NOME@HOST-NAME:~$ ); |
| PS2 | Mesma coisa do PS1, mas ela entra em ação quando um comando tem mais de uma linha, por padrão o caractere é >; |
| HOME | Mostra o diretório do usuário atual; |
| LOGNAME | Nome do usuário logado atualmente; |
| USER | Nome do usuário logado atualmente, variável padrão para sistemas BSD; |
| SHELL | Mostra o Shell em uso; |
| HISTFILE | Arquivo que irá conter os históricos do que for digitado no terminal (padrão é .bash_history); |
| HISTFILESIZE | Quantidade máxima de comando que serão gravados no arquivo; |
| HISTSIZE | Quantidade máxima de comando que serão gravados na memória; |
| HOSTTYPE | Exibe a arquitetura do sistema. |
Algumas variáveis embutidas no bash atuam como comandos e retornam um valor que são bem úteis em scripts, são elas:
| Variável | Descrição |
|---|---|
| $# | Armazena o número de argumentos da linha de comando que foram passados para o programa shell. |
| $0 | Armazena a primeira palavra do comando inserido (o nome do programa shell). |
| $* | Armazena todos os argumentos que foram inseridos no linha de comando ($1 $2 ...). |
| $@ | Armazena todos os argumentos que foram inseridos na linha de comando, citada individualmente ("$1" "$2" ...). |
| $_ | Último argumento do último comando executado. |
| $! | PID do último processo executado e background; |
| $$ | PID do shell atual; |
| $? | Retorna 0 se o último comando foi bem-sucedido, caso seja diferente de 0 ele não foi. |
ECHO
Exibe na tela o que for digitado na frente do comando, exemplo:
linux:~/$ echo "isso aparecerá"
isso aparecerá
Esse comando é bem útil em scripts e é usado para verificar o que tem dentro de uma variável, exemplo:
linux:~/$ echo "$SHELL"
/bin/bash
# Nesse caso, o echo está exibindo o valor da variável SHELL.
TYPE
Verifica se o comando é interno do shell ou é um comando externo.
Interno: Está embutido dentro do shell; Externo: Foi instalado no Linux, não faz parte do shell;
# Opções
-a = Mostra o caminho.
-t = Mostra o tipo de arquivo.
Exemplo:
linux:~/$ type echo
echo é um comando interno do shell
# Isso significa que o comando é interno do Shell.
Outra saída que você pode ter é: echo is a shell builtin, que também significa que é um comando interno do Shell.
linux:~/$ type tar
tar é /bin/tar
# Nesse caso, o comando tar, é um comando externo do Shell.
Ao usar o mesmo programa algumas vezes, esse programa entra em cache, para ser carregado mais rápido, usando o tar como exemplo, recebemos o resultado: tar está hasheado (/bin/tar) ou tar is hashed (/bin/tar), significando que o programa está em Hashe será carregado mais rápido, podemos ver isso com o comando hash.
hash
hits command
1 /usr/bin/lsblk
2 /usr/bin/locate
1 /usr/bin/chmod
1 /usr/bin/vim
5 /usr/bin/locale
11 /usr/bin/sudo
2 /usr/bin/mv
5 /usr/bin/whereis
2 /usr/bin/ln
1 /usr/bin/man
2 /usr/bin/less
12 /usr/bin/ls
7 /usr/bin/find
1 /usr/bin/updatedb
# Podemos usar o parametro -d para remover um binário do cache:
$ hash -d lsblk
$ hash
hits command
2 /usr/bin/locate
1 /usr/bin/chmod
1 /usr/bin/vim
5 /usr/bin/locale
11 /usr/bin/sudo
2 /usr/bin/mv
5 /usr/bin/whereis
2 /usr/bin/ln
1 /usr/bin/man
2 /usr/bin/less
12 /usr/bin/ls
7 /usr/bin/find
Testando as opções:
# Verificando o tipo de arquivo que é o tar:
$ type -t tar
file
# Verificando o tipo de arquivo que é o comando hash:
$ type -t hash
builtin
# Verificando o tipo de arquivo que é o comando cp:
$ type -t cp
file
# Verificando o local do binário mais a informação se é builtin ou não:
$ type -a rm
rm is /usr/bin/rm
$ type -a hash
hash is a shell builtin
hash is /usr/bin/hash
$ type -a echo
echo is a shell builtin
echo is /usr/bin/echo
Curiosidade A nomeclatura é hashed porque o comando hash verifica no banco de dados db.h, quantas vezes um programa foi usado, caso esse programa não seja interno do bash, ele ficará em cache para que sua execução seja mais rápida.
# Exemplo do comando hash (mostrando aplicações em cache):
linux:~/$ hash
hits command
3 /usr/bin/tar
UNAME
Exibe informações do sistema, como: nome, versão do kernel, arquitetura entre outros.
Opções:
-a, --all Exibe todas as informações
-s, --kernel-name Exibe o nome do kernel
-n, --nodename Exibe o nome do host do nó da rede (Nome do PC)
-r, --kernel-release Exibe o kernel release (Versão do kernel de distribuição)
-v, --kernel-version Exibe a versão do kernel
-m, --machine Exibe o nome do hardware da máquina
-p, --processor Exibe o tipo de processador
-i, --hardware-platform Exibe a plataforma de hardware
-o, --operating-system Exibe o sistema operacional.
Usando o -a:
# Exibindo tudo:
linux:~/$ uname -a
Linux wcscpy 4.4.0-151-generic #178-Ubuntu SMP Tue Jun 11 08:30:22 UTC 2019 x86_64 x86_64 x86_64 GNU/Linux'
# Exibindo o nome do kernel:
linux:~/$ uname -s
Linux
# Exibindo a versão de lançamento do kernel (RELEASE) de um Kernel compilado:
linux:~/$ uname -r
5.14.8-001-maddogs
# Exibindo a versão de um kernel compilado:
linux:~/$ uname -v
\#2 SMP Mon Oct 11 17:37:40 UTC 2021
# Exibindo o tipo de processador:
linux:~/$ uname -p
x86_64
#### Exibindo informações de um raspberry pi
# Exibindo tudo:
linux:~/$ uname -a
Linux raspberrypi 5.4.51-v7l+ #1327 SMP Thu Jul 23 11:04:39 BST 2020 armv7l GNU/Linux
# Exibindo o nome do kernel:
linux:~/$ uname -s
Linux
# Exibindo a versão de lançamento do kernel:
linux:~/$ uname -r
5.4.51-v7l+
# Exibindo a versao do kernel:
linux:~/$ uname -v
\#1327 SMP Thu Jul 23 11:04:39 BST 2020
# Exibindo o tipo de processador:
linux:~/$ uname -p
unknown
ALIAS
O alias funciona como um "apelido" para comandos, um único alias pode executar uma sequência indeterminada de comandos.
Declarando um Alias
# Formato de declaração de alias:
alias NOME='AÇÃO'
# Criando um alias chamado google, que vai pingar para o google.
linux:~/$ alias google='ping www.google.com.br'
Agora basta digitar google no terminal e vai começar a pingar para o endereço do google.
Remover um Alias
# Removendo o alias chamado google:
linux:~/$ unalias google
Deixar o alias permanente
Para criar o alias e deixar ele permanente, você deve criar ele no seu ~/.bashrc, mas o mais correto é criar o arquivo ~/.bash_aliases, isso inclusive e avisado no arquivo ~/.bashrc.
QUOTING
É usado para remoção do significado especial de determinados caracteres ou palavras no shell. Para isso, podemos usar um encapsulamento entre aspas ou apóstrofos, tendo diferença no uso de cada um deles.
O encapsulamento pode ser utilizado para desabilitar a interpretação de caracteres especiais, impedindo que palavras especiais sejam reconhecidas como tais.
Em regra, temos dois métodos de encapsulamento e um de escape, sendo: encapsulamento simples, encapsulamento duplo e caractere de escape.
Caractere de Escape
Usamos a barra invertida \ como um caractere de escape do Bash. Ele atua preservando o valor literal do próximo caractere (aquele que está logo depois da barra invertida). Aqui só temos uma pequena exceção que o uso da barra invertida para quebra de linha, mais conhecido como newline.
Como funciona o newline (Por favor, digite cada caractere para não haver erros):
linux:~/$ echo "teste de quebra \
> de linha"
teste de quebra de linha
Usando o comando echo, adicionamos uma barra invertida e damos um enter, o newline é tratado como uma continuação da linha, isso porque, a barra invertida escapa o "enter", impedindo que o Shell interprete ele.
Encapsulamento simples
Para isso, usamos o apóstrofos (aspas simples como é mais comumente conhecido). O uso do encapsulamento é mais usado, pois, ao usar ele, se mantém o valor literal de tudo que está dentro do encapsulamento.
Não se deve usar um encapsulamento precedido de uma barra invertida echo '\$SHELL'(O próprio encapsulamento simples anula o poder do que estiver dentro dele, nesse caso, a barra invertida é somente uma barra invertida). Cuidado com esse método, pois, ele impede a interpretação total do que estiver dentro dele, por exemplo:
linux:~/$ echo '$SHELL'
$SHELL
Como funciona o Encapsulamento Simples:
Crie uma variável conforme abaixo (Por favor, digite cada caractere para não haver erros):
linux:~/$ var='ola
> oi
> hello'
Digite o comando abaixo:
linux:~/$ echo '$var'
$var
Observe que ele manteve o valor literal de todo conteúdo que estava dentro do encapsulamento, o mesmo acontece se, ao invés de usar o encapsulamento, você usar o caractere de escape (barra invertida \).
Se for usado barra invertida dentro do encapsulamento, a barra invertida será apenas uma barra invertida e não um caractere de escape, pois o encapsulamento irá manter o valor literal da barra, que neste caso é apenas ser uma barra invertida.
linux:~/$ echo 'ola \
> oie'
ola \
oie
Encapsulamento Duplo
Esse encapsulamento funciona exatamente igual ao encapsulamento simples, porém, ele mantém o valor especial do cifrão $, da crase ´ e da barra invertida \.
Isso significa que se você encapsular o cifrão, a crase ou a barra invertida dentro de aspas duplas, esses caracteres serão caracteres especiais dentro do encapsulamento.
linux:~/$ echo "$USER"
joao
# Observe que o encapsulamento duplo mantém o valor do cifrão.
Bash_history - Histórico de comandos
O comando history exibe um histórico dos comandos digitados no terminal, o histórico fica “dividido”, uma cópia do histórico fica no arquivo .bash_history e outra cópia fica na memória (Em cache).
Se você digitar history -c o comando history não vai exibir nada, porque o -c apaga o histórico que está na memória, se após isso você digitar history -r tudo o que estiver no '.bash_history' será enviado para a memória.
Obs.: Cuidado ao digitar history -c, o sistema não descarrega o que está na memória (histórico em cache) automaticamente no arquivo '.bash_history', para que isso ocorra, digite history -a e tudo o que estiver na memória irá ser jogado no arquivo.
Caso queira digitar comandos sem que fique gravado no 'history' você pode usar set +o history ou dar um espaço antes do comando, isso faz com que o comando não seja enviado para memória e para o arquivo ~/.bash_history.
Executando um comando direto do history
!! - Executa o último comando digitado;
!NUM* - Executa o comando cujo número você escolheu;
!texto - Executa o último comando que começa com o texto;
!?texto - Executa o último comando que tenha o termo texto;
PATH
A PATH é definida no arquivo '/etc/environment', ela serve para buscar executáveis em diretórios que estejam definidos nela, tornando possível a execução de qualquer executável apenas com o nome dele, não importando sua localização na árvore de diretórios.
Definir caminhos
Temos que tomar cuidado ao definir algum caminho na PATH, principalmente se colocarmos isso em algum arquivo como .bashrc ou .profile.
Para definir um novo diretório dentro da PATH use o exemplo abaixo:
linux:~/$ PATH=$PATH:/mnt
# Use sempre o caminho absoluto, quando for adicionar algum diretório na PATH.
WHICH
O comando which exibe a localização de binários, o que isso quer dizer?
Ele usa o PATH para procurar onde está o programa (Esse programa é mais conhecido como Binário).
Exemplo:
linux:~/$ which tar
/bin/tar
O comando which é semelhante ao comando whereis porém, o comando which só exibe o binário.
WHEREIS
Seu uso é semelhante ao comando which, porém, ao invés de retornar apenas o binário, ele retorna tudo o que está vinculado a esse programa, como a página man, bibliotecas entre outras coisas.
Exemplo:
linux:~/$ whereis tar
tar: /usr/lib/tar /bin/tar /usr/share/man/man1/tar.1.gz
APROPOS
Busca as seções de manual do termo que foi digitado.
linux:~/$ apropos security
apparmor.d (5) - syntax of security profiles for AppArmor.
chcon (1) - change file security context
hardening-check (1) - check binaries for security hardening features
nmap (1) - Network exploration tool and security / port scanner
ntfs-3g.secaudit (8) - NTFS Security Data Auditing
pam_selinux (8) - PAM module to set the default security context
perlsec (1) - Perl security
runcon (1) - run command with specified security context
security (2) - unimplemented system calls
subdomain.conf (5) - configuration file for fine-tuning the behavior of the...
sudoers (5) - default sudo security policy plugin
unattended-upgrade (8) - automatic installation of security (and other) upgrades
Xsecurity (7) - X display access control
MAN
Abre o manual do programa solicitado.
Seções do Comando MAN
Ao digitar o man para algum binário, é apresentado um número entre parenteses, esse número identifica um tipo de seção, dentre 9 tipos que esse binário se adequa.
Tipos de seções:
1 - Binários comuns (Disponíveis ao usuário);
2 - Chamadas do Sistema (Rotinas do sistemas Unix e C);
3 - Bibliotecas;
4 - Dispositivos (Arquivos especiais como dispositivos em */dev*);
5 - Arquivos de configuração;
6 - Jogos;
7 - Miscelânea (Diversos);
8 - Binários do Root (Procedimentos administrativos como daemons);
9 - Rotinas do kernel.
Exemplo:
# Vendo os tipos de seções existentes para o
# passwd.
linux:~/$ whatis passwd
passwd (5) - arquivo de senhas
passwd (1) - change user password
passwd (1ssl) - compute password hashes
# Listando a 5° seção do passwd.
linux:~/$ man 5 passwd
# Listando a seção 1ssl do passwd.
linux:~/$ man 1ssl passwd
Por padrão, os arquivos de manuais ficam armazenados em /usr/man/ e /usr/share/man/, dentro dessas pastas o manual deve ficar dentro de sua respectiva seção, outros locais podem ser especificados, para isso usamos a variável MANPATH, que fica localizada no arquivo /usr/lib/man.conf ou /etc/man.conf.
linux:~/$ man sed
Podemos usar a opção -L para especificar a lingua a ser usada.
linux:~/$ man -L en sed
linux:~/$ man -L pt_BR sed
# Você deve ter o manual nas pastas da linguagem escolhida, caso não tenha,
# será retornado o manual em inglês (en).
## Algumas linguagens (Utiliza-se o código das línguas ou código de idiomas):
# pt = Português de Portugual
# pt_BR = Portguês do Brasil
# en = Inglês
# nl = Holandês
# hr = Croata
# cs = Checa
# gl = Galego
# fr = Francês
# es = Espanhol
# da = Dinamarquês
# de = Alemão