Este livro está organizado segundo o programa de conteúdos oficiais para a certificação LPIC-1. Dessa forma, o candidato encontrará exatamente os temas que são abordados no exame de certificação, na profundidade que é exigida para a prova. A organização dos tópicos foi alterada para que você consiga avançar nos estudos da forma mais tranquila possível.

Iniciaremos nosso estudo com a linha de comando do Linux. Este passo é importante, para que você se familiarize com o Shell, aprendendo o básico sobre comandos de navegação de arquivos, redirecionamento de saída de comando, busca de arquivos e edição de texto através da linha de comando.

Descrição do tópico:

• Como trabalhar na linha de comando (4)
• Aplicar filtros a textos e arquivos (3)
• Gerenciamento básico de arquivos (4)
• Fluxo, PIPES e redirecionamentos (4)
• Criar, modificar e encerrar processos (4)
• Pesquisar arquivos de texto com expressões regulares (2)
• Edição básica de arquivos usando o VI (3)

O número que está entre parenteses é o “peso” do tópico na prova; que nada mais é do que a quantidade questões que vão estar no exame.

103.1 - Como trabalhar na linha de comando

O Shell é uma interface entre o kernel Linux e o o usuário, uma camada interativa onde você digita comandos. Além disto, o Shell é um ambiente de programação. Nele, criamos programas, que normalmente chamamos de Shell Scripts.

Existem diversas versões de Shell, sendo os mais conhecidos: Ksh, Sh, Bash, Fish e Dash.

O exame de certificação cobra apenas conhecimento no Bash, que é o padrão de Shell nas distribuições de Linux mais populares, como Ubuntu, Debian, Red Hat, Suse, Fedora, Centos e Linux Mint.

Como saber qual Shell estou utilizando?

Como este livro tem como pré-requisito um conhecimento básico de Linux, vou presumir que você esteja com seu sistema operacional Linux instalado e funcionando. Se estiver no ambiente gráfico, você pode abrir um terminal de comando pelo seu menu iniciar, ou abrir o ambiente modo-texto, com as teclas: <ctrl + alt + f2>.

No ambiente de linha de comando, vamos iniciar nosso aprendizado com o comando echo. Este comando é comum em linguagens de programação e seu objetivo é imprimir na tela o resultado de algo que você venha a digitar. Por exemplo:

$ echo "Linux Ubuntu"
Linux Ubuntu

Não digite o sinal de cifrão $, ele representa que meu Shell está aberto com um usuário comum. Em alguns casos, teremos que executar os comandos como um usuário administrador, neste caso o símbolo será # o sustenido. Para alterar de um usuário comum para o usuário administrador, também conhecido como root, executamos o comando:

$ su root

Será necessária a sua senha de administrador. Se você usa Ubuntu Linux ou outra distribuição que não tem o usuário root disponível por padrão, execute o comando:

$ sudo passwd root

Informe a senha do seu usuário e depois informe uma senha para o seu usuário root, que agora estará disponível. Como usuário root, vamos descobrir qual Shell estamos utilizando em nosso sistema. Para isto, vou verificar a variável de sistema chamada SHELL que mantém esta informação. O comando é:

# echo $SHELL
/bin/bash

Observe que a saída foi: /bin/bash o que significa que estamos com o Shell correto para prosseguirmos nossos estudos. Se você não estiver executando o bash como padrão, é só chamá-lo, executando:

# bash

Mas, afinal, o que é um comando?

Um comando pode ser um programa externo (instalado no Linux) ou um comando interno (do próprio Shell). Verificamos esta informação com um comando chamado type, exemplo:

# type echo
echo is a shell builtin

Outro exemplo:

# type tar
tar is /bin/tar

Observa a saída do primeiro comando que executamos, type echo. Ela informa que o comando echo é um “shell builtin” ou seja, um comando interno do Shell. Já para o segundo comando que digitamos, type tar, o resultado é um caminho para o comando executável do utilitário tar, o que significa que o tar é um comando externo.

Como o Shell sabe localizar um comando externo?

São tantos comandos no universo Linux, como o Shell sabe como encontrar e executá-los sempre que você os digita na linha de comando? A resposta é simples:

Existe uma variável do Shell que guarda o caminho dos executáveis, chamada PATH. Você pode verificar o seu conteúdo executando:

# echo $PATH
/usr/local/bin;/usr/bin;/bin;/usr/sbin;/sbin

Observe que, na saída do comando, é exibida uma série de diretórios. Estes diretórios são os que armazenam os binários, que são comandos executáveis do Linux. Assim sendo, quando você chama um comando, seu sistema o procura em cada um destes diretórios e, quando o encontra, ele é executado.

Mas e quando o comando não está no PATH?

Quando você digita um comando que não está em um dos diretórios referenciados na variável PATH, ele não será executado. Mas existem duas soluções para este caso: você pode executar o comando de dentro do seu diretório atual, ou adicioná-lo a algum diretório referenciado na variável PATH.

Digamos que você tem um programa de nome sbrobols dentro do diretório /home/juliano/ que é um diretório não referenciado na variável PATH. Para executá-lo, você primeiro deve acessar este diretório:

$ cd /home/juliano

Em seguida, executá-lo com algumas das opções possíveis:

$ bash sbrobols

Ou

$ ./sbrobols

Se você desejar executar este programa, sem acessar seu diretório, deverá digitar o caminho completo:

$ /home/juliano/sbrobols

Variáveis de ambiente - local e global

Assim que você inicia o Shell, várias variáveis do seu sistema são carregadas automaticamente. Como o Shell é também um ambiente de programação, você pode declarar suas próprias variáveis. Para isso, coloque o nome da variável e o seu valor, por exemplo:

# LINUX="Eu uso Debian"

Para ver o valor da variável, digite:

# echo $LINUX
Eu uso Debian

Quando declaramos a variável do modo que realizei neste exemplo, ela fica disponível apenas no seu Shell atual. Isso significa que, se você abrir um novo terminal de comandos, ela não vai existir, porque esta variável que declaramos é uma variável local.

Para que esta variável funcione também em outros terminais de comando, ela deve ser do tipo global. O comando que transforma uma variável local em global é o export, então realizamos:

# export LINUX

É possível já criar a variável como global, neste caso é só usar o export à frente do nome da variável no ato da criação:

# export LINUX="Eu uso Debian e Ubuntu"

Sendo assim, esta variável de nome LINUX vai estar disponível em qualquer terminal de comandos do seu sistema.

Ver todas as variáveis

Para visualizar todas as variáveis disponiveis em nosso sistema operacional Linux, inclusive as que criamos, usamos o comando set. Exemplo:

# set

Como se trata de muitas variáveis, a saída do comando será grande. Você pode subir a tela do terminal com as teclas <shift> + <Page Up> e descer com <shift> + <Page Down>. Outra forma, mais eficaz, é usar um comando paginador de tela. Este comando lhe permite descer a tela com as setas direcionais. O comando padrão para paginar tela é o less, execute-o assim:

# set | less

Observe que o resultado da saída do comando será em partes, o que facilita sua leitura.

Ver apenas as variáveis globais

Diferente do comando setque mostra todas as variáveis do sistema operacional, o comando env vai oferecer como saída apenas as variáveis globais. Ou seja, variáveis criadas com o comando export. Lembre-se de paginar a saída com o auxílio do comando less:

# env |less

Como remover uma variável

Antes de eu mencionar o comando de remoção de variável, fica um alerta: “Não remova as variáveis do sistema”. Algumas são necessárias para o funcionamento correto das aplicações e do próprio Shell. Utilize este comando para remover suas próprias variáveis.

O comando é unset mais o nome da variável:

# unset LINUX

Nesse exemplo, removi a variável LINUX, que tinha criado no exemplo de declaração de variáveis.

Comandos de modo sequencial

O mais interessante de se trabalhar com a linha de comando Linux é a possibilidades de otimizarmos nossas tarefas. Para isso, podemos deixar uma lista de comandos para o sistema realizar enquando degustamos um saboroso cafezinho.

Vou dar um pequeno exemplo de três comandos que eu desejo que sejam executados em sequência: clear, que limpa a tela, date, que mostra a data e a hora, e o comando ls, que vai mostrar o conteúdo do meu diretório atual. Segue:

# clear; date; ls

Nesse exemplo, os três comandos serão executados. Esta sequência usando ponto e virgula não possui condição, ou seja, caso o comando falhe ou não, o próximo é executado normalmente.

Os próximos exemplos de comandos em sequência já possuem uma condição. Se você desejar que o segundo comando só seja executado se o primeiro tiver sucesso, faça:

# ls /tmp/qualquercoisa.txt && echo $SHELL

Se você não possuir o arquivo /tmp/qualquercoisa.txt, sua sequência de comandos será finalizada e o Shell retornará para a entrada padrão. Outra condição seria usando o || (dois pipes). Neste caso, o segundo comando só é executado quando o primeiro retorna com erro.

Exemplo:

# ls /tmp/qualquercoisa.txt || echo $SHELL

Como eu não tenho o arquivo /tmp/qualquercoisa.txt somente o comando echo $SHELL será executado.

Navegar pelos comandos - histórico

Dentro do seu prompt de comandos, você poderá navegar pelos últimos comandos digitados, usando as teclas direcionais para cima e para baixo. Outra opção é através do comando history, que mantém um histórico dos comandos digitados. Exemplo:

# history
1 uname -a
2 echo "Linux"
3 clear
4 pwd

Observe na saída do comando history o número da linha. Com este número, você poderá executar diretamente um comando usando uma exclamação mais o número da linha, por exemplo:

# !3

Se observar na saída do meu comando history, a linha três corresponde ao comando clear, isto significa que este é o comando que será executado.

Para executar o último comando digitado em seu terminal, digite:

# !!

Limpar arquivo de histórico

Se você deseja limpar seu histórico de comandos, utilize o comando:

history -C

Os comandos do history ficam armazenados em um arquivo, e para localizar este arquivo execute:

$ echo $HISTFILE
HISTFILE=/home/juliano/.bash_history

A variável HISTFILE informa o local deste arquivo. Você poderá visualizá-lo com o comando cat, por exemplo:

$ cat /home/juliano/.bash_history

Você também poderá remover este arquivo, para garantir mais segurança na exclusão do seu histórico de comandos:

$ rm /home/juliano/.bash_history

Obter ajuda

Praticamente todos os comandos têm um manual de referência, que pode ser acessado pelo comando man. Por exemplo:

$ man ls

Alguns comandos, além da página completa de manual, possuem um guia de referência, que pode ser acessado com a sintaxe -- help exemplo:

$ ls --help

A página de manual é sempre bem detalhada, com exemplos e referências externas com mais informações, já o guia de referência, é simples, com uma definição básica do comando.

Os comandos whatis e apropos

Muitas vezes, você deseja obter uma descrição sobre o que certo comando faz. Para isso, utilize o comando whatis, como em:

$ whatis tar
tar (1)              - The GNU version of the tar archiving utility

Neste exemplo, estou perguntando o que faz o comando tar e o sistema me informa que ele é um utilitário de arquivamento. Por outro lado, você pode desejar saber quais comandos exibem alguma informação do sistema, ou seja, buscar comandos pela descrição. Nesses casos, utilize o apropos:

$ apropos information

O retorno será uma lista de comandos que tenham em suas descrições a string “information”. Já que estamos citando informação do sistema, um excelente comando para visualizarmos a nossa versão do Kernel Linux e a arquitetura do nosso sistema operacional é o comando uname, exemplo:

$ uname -r

Neste caso, a saída será a versão do seu kernel Linux. Para ter uma saída mais completa, mostrando também a arquitetura do sistema, use o comando:

$ uname -a

Apelidos de comandos

Um apelido é um nome que você cria para facilitar a entrada de um comando. Você pode ver todos os apelidos disponíveis usando o comando alias:

$ alias
alias alert='notify-send --urgency=low -i "$([ $? = 0 ] && echo terminal || echo error)" "$(history|tail -n1|sed -e '\''s/^\s*[0-9]\+\s*//;s/[;&|]\s*alert$//'\'')"'
alias egrep='egrep --color=auto'
alias fgrep='fgrep --color=auto'
alias grep='grep --color=auto'
alias l='ls -CF'
alias la='ls -A'
alias ll='ls -alF'
alias ls='ls --color=auto'

No meu caso, quando digito ls, na verdade, ele vai executar: ls --color=auto como está nessa saída. Você pode criar no seu Shell atual um apelido usando o alias, por exemplo:

$ alias lt=´ls /tmp´

Agora, sempre que digitar o comando lt que acabei de criar, será executado na verdade o comando ls /tmp.

Conclusão do capítulo

A grande dica para este capítulo é: “Faça atividades sobre tudo que aprendeu até aqui, isso reforçará a informação no seu cérebro”. Não adianta você passar horas na teoria e não praticar o que se aprende. Já vi muita gente lendo livros técnicos como este no ônibus, ou no metrô, e isso não é eficaz. O essencial é você lê-lo à frente do seu computador, e neste momento, fazer uma pausa na leitura e executar todos os comandos, não uma, mas diversas vezes. Algo que sempre funciona comigo é criar perguntas sobre o que leio. Algo do tipo: “Preciso criar um apelido de comando para listar o diretório /etc, como devo proceder?”. Isso vai exigir que você pense no que leu para formular a pergunta e depois, pensar na resposta.

O exame LPIC-1 poderá realizar até quatro perguntas sobre este tópico. Mas não se preocupe, as questões são multipla escolha, o que já facilita bastante. Pratique e você vai se sair muito bem.

Commits

• 18/06/2020 - 12:51 - Upload da publicação.