Usando o Bash Shell no Ubuntu 20.04

Uma parte importante de aprender a trabalhar com o Ubuntu, e as distribuições Linux em geral, envolve ganhar proficiência em trabalhar no ambiente shell. Enquanto os ambientes desktop gráficos como o GNOME incluídos com Linux fornecem uma interface amigável para o sistema operacional, na prática o ambiente shell fornece muito mais capacidades, flexibilidade e automação do que se pode conseguir usando ferramentas desktop gráficas. O ambiente shell também fornece um meio de interagir com o sistema operacional quando um ambiente desktop não está disponível; uma ocorrência comum quando se trabalha com um sistema operacional baseado em servidor como o Ubuntu ou um sistema danificado que não inicializará totalmente.

O objetivo deste capítulo, portanto, é fornecer uma visão geral do ambiente shell padrão no Ubuntu (especificamente o Bash shell).

1.1 O que é um Shell?

O shell é um ambiente interpretador de comandos interativo dentro do qual os comandos podem ser digitados em um prompt ou inseridos em um arquivo na forma de um script e executados. As origens da shell podem ser rastreadas até os primeiros dias do sistema operacional UNIX. De fato, nos primeiros dias do Linux antes da introdução dos desktops gráficos a shell era a única maneira de um usuário interagir com o sistema operacional.

Uma variedade de ambientes shell foi desenvolvida ao longo dos anos. A primeira shell amplamente utilizada foi a Bourne shell, escrita por Stephen Bourne no Bell Labs.

Já outra criação inicial foi a shell C que compartilhou algumas similaridades de sintaxe com a Linguagem de Programação C e introduziu melhorias de usabilidade, como edição de linha de comando e histórico.

A shell Korn (desenvolvida por David Korn no Bell Labs) é baseada em funcionalidades fornecidas tanto pela shell Bourne como pela shell C.

A shell padrão no Ubuntu é a shell Bash (abreviação para Bourne Again SHell). Esta shell, que começou a vida como uma versão de código aberto da shell Bourne, foi desenvolvida para o Projecto GNU por Brian Fox e é baseada em funcionalidades fornecidas tanto pela shell Bourne como pela C shell.

1.2 Obtendo Acesso ao Shell

De dentro do ambiente desktop GNOME, o prompt shell pode ser acessado de uma janela de Terminal selecionando a opção Activities na barra superior, digitando Terminal na barra de busca e clicando no ícone Terminal.

Quando se entra remotamente em um servidor Ubuntu, por exemplo usando SSH, o usuário também é apresentado com um prompt shell. Detalhes sobre como acessar um servidor remoto usando SSH serão cobertos no capítulo intitulado “Configurando Autenticação baseada em chaves SSH no Ubuntu”. Ao iniciar um sistema baseado em servidor no qual um ambiente de desktop não foi instalado, a shell é inserida imediatamente após o usuário completar o procedimento de login no terminal do console físico ou sessão de login remoto.

1.3 Inserindo Comandos no prompt de comando da shell

Comandos são inseridos no prompt de comando da shell simplesmente digitando o comando e pressionando a tecla Enter. Enquanto alguns comandos executam tarefas silenciosamente, a maioria irá mostrar alguma forma de saída antes de retornar ao prompt. Por exemplo, o comando ls pode ser usado para exibir os arquivos e diretórios no diretório de trabalho atual:

$ ls

Desktop Documents Downloads Music Pictures Public Templates Videos

Os comandos disponíveis ou são incorporados na própria shell, ou residem no sistema de arquivos físicos. A localização no sistema de arquivos de um comando pode ser identificada usando o comando qual. Por exemplo, para descobrir onde o executável ls reside no sistema de ficheiros:

$ which ls alias ls='ls --color=auto' /usr/bin/ls

Claramente o comando ls reside no directório /usr/bin. Note também que está configurado um alias, um tópico que será abordado mais adiante neste capítulo. Usando o comando para localizar o caminho para os comandos que estão embutidos na shell resultará em uma mensagem indicando que o executável não pode ser encontrado. Por exemplo, tentar encontrar a localização do comando history (que está realmente compilado na shell em vez de existir como executável no sistema de ficheiros) resultará numa saída semelhante à seguinte:

$ which history/usr/bin/which: no history in (/home/demo/.local/bin:/home/demo/bin:/usr/share/Modules/bin:/usr/local/bin:/usr/bin:/usr/local/sbin:/usr/sbin)

1.4 Obter Informação sobre um Comando

Muitos dos comandos disponíveis na shell do Linux podem parecer crípticos para começar. Para descobrir informações detalhadas sobre o que um comando faz e como usá-lo, use o comando man especificando o nome do comando como um argumento. Por exemplo, para aprender mais sobre o comando pwd:

$ man pwd

Quando o comando acima for executado, uma descrição detalhada do comando pwd será exibida. Muitos comandos também fornecerão informações adicionais quando executados com a opção de linha de comando -help:

$ wc --help

1.5 Bash Command-line Editing

Early shell environments não forneceram nenhuma forma de capacidade de edição de linha. Isto significou que se você detectou um erro no início de uma linha de comando longa que você estava digitando, você teve que apagar todos os seguintes caracteres, corrigir o erro e então digitar novamente o resto do comando. Felizmente o Bash fornece uma grande variedade de opções de edição de linha de comando, conforme descrito na tabela a seguir:

Tabela 9-1

1.6 Trabalhando com o Histórico da Shell

Além dos recursos de edição de linha de comando, a shell Bash também fornece suporte ao histórico da linha de comando. Uma lista de comandos executados anteriormente pode ser visualizada usando o comando histórico:

$ history1ps2ls3ls –l /4ls5man pwd6man apropos

Além disso, Ctrl-p (ou seta para cima) e Ctrl-n (ou seta para baixo) podem ser usados para rolar para frente e para trás através de comandos inseridos anteriormente. Quando o comando desejado do histórico for exibido, pressione a tecla Enter para executá-lo.

Outra opção é digitar o caractere ‘! seguido pelos primeiros caracteres do comando a ser repetido seguido pela tecla Enter.

1.7 Atalho de nome de arquivo

Muitos comandos shell tomam um ou mais nomes de arquivo como argumentos. Por exemplo, para exibir o conteúdo de um arquivo de texto chamado list.txt, o comando cat seria usado da seguinte forma:

$ cat list.txt

Similiarmente, o conteúdo de múltiplos arquivos de texto poderia ser exibido especificando todos os nomes de arquivos como argumentos:

$ cat list.txt list2.txt list3.txt list4.txt

Em vez de digitar cada nome, a correspondência de padrões pode ser usada para especificar todos os arquivos com nomes que correspondam a certos critérios. Por exemplo, o caractere curinga ‘*’ pode ser usado para simplificar o exemplo acima:

$ cat *.txt

O comando acima irá exibir o conteúdo de todos os arquivos que terminam com uma extensão .txt. Isto pode ser ainda mais restrito a qualquer nome de arquivo que comece com lista e termine em .txt:

$ cat list*.txt

As combinações de caracteres isolados podem ser especificadas usando o caractere ‘?’:

$ cat list?.txt

1.8 Nome do arquivo e conclusão do caminho

Realizar do que digitando um nome de arquivo inteiro ou caminho, ou usando a combinação de padrões para reduzir a quantidade de digitação, a shell fornece o recurso de conclusão do nome do arquivo. Para utilizar a conclusão de nome de ficheiro, basta introduzir os primeiros caracteres do nome do ficheiro ou caminho e depois premir duas vezes a tecla Esc. A shell irá então completar o nome do arquivo para você com o primeiro arquivo ou nome do caminho no diretório que corresponde aos caracteres que você digitou. Para obter uma lista de possíveis correspondências, pressione Esc = após inserir os primeiros caracteres.

1.9 Redirecionamento de Entrada e Saída

Como mencionado anteriormente, muitos comandos da shell emitem informação quando executados. Por defeito esta saída vai para um ficheiro de dispositivo chamado stdout que é essencialmente a janela de terminal ou consola em que a shell está a correr. Inversamente, a shell recebe informação de um ficheiro de dispositivo chamado stdin, que por omissão é o teclado.

A saída de um comando pode ser redireccionada de stdout para um ficheiro físico no sistema de ficheiros usando o caracter ‘>’. Por exemplo, para redirecionar a saída de um comando ls para um arquivo chamado files.txt, o seguinte comando seria necessário:

$ ls *.txt > files.txt

Conclusão do componente, files.txt conterá a lista de arquivos no diretório atual. Similarmente, o conteúdo de um arquivo pode ser alimentado em um comando no lugar do stdin. Por exemplo, para redirecionar o conteúdo de um arquivo como entrada para um comando:

$ wc –l < files.txt

O comando acima irá exibir o número de linhas contidas no arquivo files.txt.

É importante notar que o operador de redirecionamento ‘>’ cria um novo arquivo, ou truncata um arquivo existente quando usado. Para anexar a um arquivo existente, use o operador ‘>>’:

$ ls *.dat >> files.txt

Além da saída padrão, a shell também fornece saída de erro padrão usando stderr. Enquanto a saída de um comando é direcionada para stdout, quaisquer mensagens de erro geradas pelo comando são direcionadas para stderr. Isto significa que se stdout for direcionado para um arquivo, as mensagens de erro ainda aparecerão no terminal. Este é geralmente o comportamento desejado, embora stderr também possa ser redirecionada se desejado usando o operador ‘2>’:

$ ls dkjfnvkjdnf 2> errormsg

Ao completar o comando, um erro reportando o fato de que o arquivo chamado dkjfnvkjdnf não pôde ser encontrado estará contido no arquivo errormsg.

Both stderr e stdout podem ser redirecionados para o mesmo arquivo usando o operador:

$ ls /etc dkjfnvkjdnf &> alloutput

No final da execução, o arquivo alloutput conterá tanto uma listagem do conteúdo do diretório /etc, quanto a mensagem de erro associada à tentativa de listar um arquivo inexistente.

1.10 Trabalhando com Pipes no Bash Shell

Além do redirecionamento de E/S, o shell também permite que a saída de um comando seja piped diretamente como entrada para outro comando. Uma operação de pipe é alcançada colocando o caracter ‘|’ entre dois ou mais comandos em uma linha de comando. Por exemplo, para contar o número de processos em execução em um sistema, a saída do comando ps pode ser passada para o comando wc:

$ ps –ef | wc –l

Não há limite para o número de operações de pipe que podem ser realizadas em uma linha de comando. Por exemplo, para encontrar o número de linhas num ficheiro que contém o nome Smith:

$ cat namesfile | grep Smith | wc –l

1.11 Configurando Aliases

Como você ganha proficiência com o ambiente shell é provável que você se encontre frequentemente a emitir comandos com os mesmos argumentos. Por exemplo, você pode frequentemente usar o comando ls com as opções l e t:

$ ls –lt

Para reduzir a quantidade de digitação envolvida na emissão de um comando, é possível criar um alias que mapeie para o comando e os argumentos. Por exemplo, para criar um alias tal que digitando a letra l fará com que o comando ls -lt seja executado, a seguinte declaração seria usada:

$ alias l="ls –lt"

Entrar l no prompt de comando agora executará a declaração original.

1.12 Variáveis de ambiente

Variáveis de ambiente de Shell fornecem armazenamento temporário de dados e configurações. A própria shell configura um número de variáveis de ambiente que podem ser alteradas pelo usuário para modificar o comportamento da shell. Uma lista de variáveis atualmente definidas pode ser obtida usando o comando env:

$ envSSH_CONNECTION=192.168.0.19 61231 192.168.0.28 22MODULES_RUN_QUARANTINE=LD_LIBRARY_PATHLANG=en_US.UTF-8HISTCONTROL=ignoredupsHOSTNAME=demo-pc.ebookfrenzy.comXDG_SESSION_ID=15MODULES_CMD=/usr/share/Modules/libexec/modulecmd.tclUSER=demoENV=/usr/share/Modules/init/profile.shSELINUX_ROLE_REQUESTED=PWD=/home/demoHOME=/home/demoSSH_CLIENT=192.168.0.19 61231 22SELINUX_LEVEL_REQUESTED= ...

Talvez a variável de ambiente mais útil seja PATH. Isto define os diretórios nos quais a shell irá procurar por comandos inseridos no prompt de comando, e a ordem em que o fará. A variável de ambiente PATH para uma conta de usuário em um sistema Ubuntu recentemente instalado provavelmente será configurada da seguinte forma:

$ echo $PATH/home/demo/.local/bin:/home/demo/bin:/usr/share/Modules/bin:/usr/local/bin:/usr/ bin:/usr/local/sbin:/usr/sbin

Outra variável útil é HOME, que especifica o diretório home do usuário atual. Se, por exemplo, você quiser que a shell também procure por comandos no diretório de scripts localizado no seu diretório home, você modificaria a variável PATH da seguinte forma:

$ export PATH=$PATH:$HOME/scripts

O valor atual de uma variável de ambiente existente pode ser exibido usando o comando echo:

$ echo $PATH

Você pode criar suas próprias variáveis de ambiente usando o comando export. Por exemplo:

$ export DATAPATH=/data/files

Um truque útil para atribuir a saída de um comando a uma variável de ambiente envolve a utilização de aspas (`) em torno do comando. Por exemplo, para atribuir a data e hora atual a uma variável de ambiente chamada NOW:

$ export NOW=`date`$ echo $NOWTue Apr 2 13:48:40 EDT 2020

Se houver uma variável de ambiente ou alias que você precise configurar cada vez que entrar no ambiente shell, elas podem ser adicionadas a um arquivo no seu diretório home chamado .bashrc. Por exemplo, o seguinte arquivo .bashrc é configurado para configurar a variável de ambiente DATAPATH e um alias:

# .bashrc # Source global definitionsif ; then . /etc/bashrcfi # User specific environmentPATH="$HOME/.local/bin:$HOME/bin:$PATH"export PATH # Uncomment the following line if you don't like systemctl's auto-paging feature:# export SYSTEMD_PAGER= # User specific aliases and functionsexport DATAPATH=/data/filesalias l="ls -lt"

1.13 Escrevendo Shell Scripts

Até agora temos focado exclusivamente na natureza interativa da shell Bash. Por interactivo entendemos a introdução manual de comandos no prompt um a um e a sua execução. Na verdade, isto é apenas uma pequena parte do que a shell é capaz de fazer. Provavelmente um dos aspectos mais poderosos da shell envolve a capacidade de criar scripts shell. Os scripts shell são essencialmente ficheiros de texto contendo sequências de comandos que podem ser executados dentro do ambiente shell para executar tarefas. Além da capacidade de executar comandos, a shell fornece muitas das construções de programação como para e faz loops e se declarações que você pode razoavelmente esperar encontrar em uma linguagem de scripting.

Felizmente, uma visão detalhada da shell scripting está além do escopo deste capítulo. Existem, no entanto, muitos livros e recursos web dedicados ao shell scripting que fazem muito mais justiça ao assunto do que alguma vez poderíamos esperar alcançar aqui. Nesta secção, portanto, estaremos apenas a fornecer um gosto muito pequeno de shell scripting.

O primeiro passo na criação de um script shell é criar um ficheiro (para os propósitos deste exemplo vamos dar-lhe um nome simples.sh) e adicionar o seguinte como primeira linha:

#!/bin/sh

O #! é chamado de “shebang” e é uma sequência especial de caracteres indicando que o caminho para o interpretador necessário para executar o script é o próximo item da linha (neste caso o executável sh localizado em /bin). Isto poderia igualmente ser, por exemplo, /bin/csh ou /bin/ksh se qualquer um deles fosse o interpretador que você queria usar.

O próximo passo é escrever um script simples:

#!/bin/shfor i in *do echo $idone

Tudo o que este script faz é iterar através de todos os arquivos no diretório atual e exibir o nome de cada arquivo. Isto pode ser executado passando o nome do script como argumento para sh:

$ sh simple.sh

Para tornar o arquivo executável (negando assim a necessidade de passá-lo para o comando sh) o comando chmod pode ser usado:

$ chmod +x simple.sh

Após o bit de execução ter sido definido nas permissões do arquivo, ele pode ser executado diretamente. Por exemplo:

$ ./simple.sh

1.14 Resumo

Neste capítulo do Ubuntu Essentials fizemos um breve tour pelo ambiente do Bash shell. No mundo dos ambientes desktop gráficos é fácil esquecer que a verdadeira potência e flexibilidade de um sistema operacional muitas vezes só pode ser utilizada descendo abaixo da interface amigável do desktop e usando um ambiente shell. Além disso, a familiaridade com a shell é uma necessidade quando é necessário administrar e manter sistemas baseados em servidor que não têm o desktop instalado ou quando se tenta reparar um sistema que está danificado ao ponto de o desktop ou a interface Cockpit não ser mais lançada.