Unix e Shell: automação com scripts e pipelines

Configuração e Consulta do Ambiente Shell - Introdução ao Shell Scripting

Apresentando o curso e realizando audiodescrição

Olá, bem-vindas e bem-vindos ao curso de introdução a Shell Scripting (criação de scripts para shell) da Alura. Este curso faz parte da carreira de DevOps (desenvolvimento e operações). Vamos entender como criar Shell Scripting e como desenvolver automatizações, especialmente em servidores Linux. Vamos nos aprofundar neste curso. Primeiro, vamos nos apresentar e realizar uma audiodescrição.

Audiodescrição: Somos Anny Isabel Macedo, também conhecida como Anya, uma pessoa branca que usa óculos, com cabelo de pontas lilases, mechas rosas e parte da raiz em castanho-escuro. Vestimos uma camiseta azul-marinho com a imagem da Torre Eiffel em um dos lados. Temos uma tatuagem no braço direito (à direita de quem assiste) com um personagem de anime. Ao fundo, há um Macintosh dos anos 80, e, do outro lado, uma cama em que um gato está dormindo.

Nesta apresentação, nosso LinkedIn é linkedin.com/in/retpolani e nosso e-mail é anny.retpolani.com. Somos pessoa engenheira de infraestrutura e programadora. Formamo-nos em Análise e Desenvolvimento de Sistemas pela FATEC da Zona Leste, em São Paulo. Somos uma pessoa trans e autista e cuidamos do gato Tux, que aparecerá em alguns momentos e que costuma dormir o dia todo.

Introduzindo shell scripting e sistemas operacionais

Vamos ao que interessa: vamos falar de Shell Scripting (criação de scripts para shell). Neste curso, vamos aprender os conceitos do shell, especificamente de Bash Shell Scripting (criação de scripts no Bash), uma habilidade extremamente importante para administração de servidores Linux e para carreiras baseadas em infraestrutura e em cloud (nuvem). É fundamental aprendermos isso porque permite criar automatizações em servidores Linux, além de pequenas automatizações para programas que mantemos ou para provisionamento de recursos na nuvem. Ter essa competência à mão é útil ao criar recursos e dar manutenção em serviços, especialmente em servidores Linux.

Antes de navegarmos pelo shell, vamos falar sobre sistemas operacionais. Esta seção é introdutória. Provavelmente conhecemos diversos exemplos de sistemas operacionais: Windows, macOS, iOS, Android, e muitas pessoas utilizam Linux tanto para uso pessoal quanto corporativo e para servidores. Mas o que são, de fato, os sistemas operacionais? Conhecemos exemplos, porém, muitas vezes, não sabemos exatamente o que são.

Computadores são, em essência, um conjunto de silício, placas, componentes metálicos e pulsos eletromagnéticos. Tudo isso é extremamente complexo e requer grande precisão. Esses pulsos seguem padrões específicos para codificação de mensagens, mas não precisamos nos preocupar com as complexidades do hardware. Utilizamos um sistema operacional, pois ele sabe se comunicar com essas complexidades e nos oferece uma interface. Essa interface permite invocarmos funcionalidades — por exemplo, chamarmos uma função — sem precisarmos entrar nos detalhes de como ela é implementada.

Além disso, sistemas operacionais gerenciam o compartilhamento de recursos entre programas. Esse processo é chamado de multiplexação, que determina como os programas terão tempo de execução. Podemos manter um programa executando por certo período, mas outros também precisam ser executados. É necessário alguém que saiba quanto tempo e quais recursos atribuir para cada programa. É isso que os sistemas operacionais fazem.

Contextualizando a história da computação e dos terminais

Nem sempre foi assim. Vamos apresentar uma breve história da computação — e, por breve, não vamos recuar até Ada Lovelace ou Alan Turing, embora sejam figuras extremamente importantes para a história da computação. Vamos abordar a época das grandes centrais de processamento, com computadores gigantescos.

Nessa época, a interface de uso eram cartões perfurados. No slide, vemos uma foto de um cartão perfurado da Bell: um cartão bege com uma linha laranja, contendo números de 0 a 9 e letras de A a Z. Pessoas programadoras perfuravam esses cartões; cada perfuração, ou padrão de perfurações, indicava uma instrução que a máquina executaria. As pessoas desenvolvedoras escreviam o código em cartões perfurados e os levavam a uma pessoa chamada “computadora” (um computador humano), que executava aquele código e trazia o resultado de volta para a pessoa programadora. Era uma dinâmica equivalente, em propósito, ao que fazemos hoje ao escrever um script em Python e executá-lo — com a diferença de que, naquela época, era necessário levar o material fisicamente para outra pessoa executar.

As máquinas eram gigantes. Há uma foto emblemática de um equipamento chamado PDP-7, um computador de grande porte, um verdadeiro mainframe (computador de grande porte). Na imagem, além da máquina enorme, há terminais semelhantes a máquinas de escrever. A pessoa sentava-se diante do teclado, digitava, e um rolo de papel imprimia tanto o que era digitado quanto a saída do programa. Essa foto também é marcante por registrar duas pessoas fundamentais para a história da computação: em pé, Dennis Ritchie, criador da linguagem C; sentado, Ken Thompson, criador do sistema operacional Unix. Estão diante desses terminais.

Qual era a ideia? O PDP-7 executava um sistema de time-sharing (compartilhamento de tempo), no qual várias pessoas podiam se conectar ao computador via terminal e executar processos em uma fila. Esses processos eram executados de acordo com o tempo de CPU alocado ou conforme a liberação da fila, pois a máquina executava um processo por vez.

O modelo de terminal é muito interessante e existe até hoje, embora não mais como máquinas de escrever. Com o passar do tempo, os sistemas de time-sharing continuaram a existir, e os mainframes também, mas os terminais se modernizaram e passaram a ter capacidade de vídeo. Um exemplo é o VT-100, um terminal de vídeo que hoje é peça de museu. Ele se conectava ao mainframe, como o PDP-7; podíamos digitar e ver a informação na tela, eliminando a necessidade de papel.

Esse desenho de desacoplar a interface humano-computador do sistema principal existe até hoje. Para exemplificar, temos um Mac, e aqui estamos usando o Terminal do macOS. Estamos executando ls /dev/ttys. Cada um desses dispositivos — esses arquivos ttys — representa um tipo de terminal. Em sistemas operacionais modernos, os terminais são essencialmente emuladores de terminal, simulando o comportamento dos terminais das décadas de 1960 e 1970. Inclusive, há exemplos de pessoas que conseguiram conectar uma distribuição Linux moderna a um terminal antigo que funcionava como máquina de escrever.

Para visualizar explicitamente esses dispositivos de terminal no sistema, utilizamos o comando abaixo no Terminal. Ele lista os arquivos do diretório /dev que representam diferentes terminais (pseudo-terminais):

ls /dev/ttys

Ao executar esse comando, vemos os diversos dispositivos ttys disponíveis. Cada entrada é tratada como um arquivo pelo Unix, reforçando a filosofia de que “tudo é um arquivo” — inclusive terminais. Isso ajuda a compreender como o shell interage com a interface de texto e como conexões e sessões são gerenciadas.

Explorando a origem do Unix e sua filosofia

Mencionamos o Unix. Vamos falar sobre Unix. O que é Unix? Temos aqui duas figuras que já apresentamos, as mesmas da imagem anterior.

Audiodescrição: A pessoa instrutora narra a aula a partir de slides; sua imagem não aparece em vídeo. O slide inicial exibe fotografias históricas de Ken Thompson e Dennis Ritchie, com legendas e detalhes de vestimenta; o ambiente é neutro, com foco no conteúdo projetado.

À esquerda, vemos Ken Thompson, um homem com pouca quantidade de cabelo, barba e óculos grandes, vestindo uma camiseta branca. À direita, vemos Dennis Ritchie, com o cabelo penteado para o lado, óculos escuros, barba e uma camiseta laranja com a inscrição "Bell Labs". O sistema operacional Unix (Unix) foi criado por essas duas pessoas, especialmente por Ken Thompson, que desejava realizar um experimento.

Ken Thompson trabalhava na Bell Labs (Bell Labs), uma subsidiária da AT&T (AT&T), uma das empresas que inventaram o telefone. Nessa empresa eram realizados muitos experimentos com telecomunicações, rádio, computadores e outros temas. Na década de 1960, Thompson queria conduzir um experimento para entender como os sistemas de arquivos funcionavam, trabalhando com cartões perfurados e fitas magnéticas, que eram os meios disponíveis à época. Durante esse processo, ele percebeu que estava construindo um sistema operacional de fato, com suporte a time-sharing (compartilhamento de tempo), no qual pessoas se conectavam e executavam comandos. Aos poucos, surgiram novas versões do Unix (Unix).

Dennis Ritchie criou a linguagem C para auxiliar no desenvolvimento dessas novas versões do Unix (Unix), porque, no início, tudo era implementado em assembly (linguagem de montagem) e linguagem de máquina. Ao introduzir uma linguagem de alto nível, tornou-se mais simples desenvolver para Unix (Unix). Além disso, para que programas pudessem se adaptar ao Unix (Unix), criou-se um padrão chamado POSIX (POSIX), que define uma interface comum para que programas sejam executados em qualquer versão do Unix (Unix), incluindo clones. Trata-se de uma especificação na qual quase todos os sistemas operacionais modernos se baseiam, o que traz um nível alto de compatibilidade, com diversas sutilezas interessantes.

O Unix (Unix) introduz uma filosofia bastante interessante e simples. A principal característica é que tudo é um arquivo. Assim, quando apresentamos um slide com terminais, cada terminal é um arquivo. Podemos acessá-lo como se fosse um arquivo. Entradas, saídas, processos, dispositivos e até mesmo sockets (soquetes), que são dispositivos de rede, podem ser lidos de diferentes maneiras, porém sempre como arquivos.

Outra característica do Unix (Unix) é que os programas são extremamente simples e fazem apenas uma tarefa, mas a executam muito bem. Cada programa do Unix (Unix) realiza uma tarefa específica com excelência. Isso permite composições: podemos encadear programas simples, colocando-os em sequência por meio de pipes (canais), criando soluções grandes e complexas.

Há uma questão importante: o Unix (Unix) era distribuído com seu código-fonte, mas pertence à Bell Labs (Bell Labs) e tem direitos autorais. Copiar esse código constitui violação de copyright (direitos autorais) e é crime. Mesmo assim, algumas empresas e universidades, como a Universidade de Berkeley, na Califórnia, utilizaram o código-fonte do Unix (Unix) como base para desenvolver uma variante chamada BSD (Berkeley Software Distribution). O BSD é um sistema operacional baseado em Unix (Unix) — não é o Unix (Unix) original, mas é muito similar e compatível com a especificação POSIX (POSIX). Atualmente, encontramos componentes BSD especialmente em computadores Mac (Mac), macOS (macOS), iOS (iOS) e em versões livres como o FreeBSD (FreeBSD), que não contêm código do Unix (Unix).

Outra vertente que surgiu nos anos 1980 veio de pessoas programadoras que criaram programas compatíveis com Unix (Unix) por meio da metodologia de desenvolvimento em clean room (sala limpa), ou seja, sem utilizar nenhum código do Unix (Unix), criando implementações compatíveis. Essa abordagem não infringe copyright (direitos autorais) e gera programas extremamente compatíveis, que funcionam da mesma forma que os do Unix (Unix), mas sem usar seu código. Essa distribuição livre é chamada GNU (GNU), acrônimo recursivo de GNU is not Unix (GNU não é Unix), algo bastante interessante. Se utilizarmos Mac (Mac), podemos baixar as ferramentas da GNU (GNU) sem problema. Neste curso, recomendamos utilizar as ferramentas da GNU (GNU), pois são o padrão. Entretanto, em computadores Mac (Mac), geralmente teremos BSD e ferramentas BSD; se utilizarmos outro sistema operacional como o FreeBSD (FreeBSD), ele será baseado em BSD.

Detalhando o shell e o fluxo de E/S

Chegou o momento de falar do shell (interpretador de comandos). O Shell é um programa que executa programas, isto é, um interpretador de comandos. Ele permite executar programas um a um e redirecionar o fluxo de texto, redirecionando entre arquivos e entre programas, além de criar pipelines (encadeamentos). Em outras palavras, colocamos pipes (canais) que passam conteúdo — como arquivos, texto, bytes — de um programa a outro. Existem muitos tipos de Shell, e comentaremos sobre alguns deles a seguir. Um Shell possui várias funcionalidades, e algo muito interessante é que cada programa do Shell, cada conjunto de comandos ou cada um dos nossos scripts (scripts) de Shell, seguem um padrão relativamente bem definido.

Tudo começa na entrada. Um programa recebe o input (entrada) pela entrada padrão. Pode ser texto, um arquivo ou o que digitamos no teclado. Esse será o input (entrada), recebido pela entrada padrão. Em seguida, ocorre o processamento: o programa processa a informação recebida até concluir a execução do comando. Então é gerada uma saída. A saída é enviada para a saída padrão — standard output (saída padrão) — quando não houve erro, e para a saída de erro — standard error (erro padrão) — quando ocorreu algum problema e é necessário informar qual foi. Enviamos para dois destinos diferentes porque isso facilita filtrar o que é saída normal e o que é erro.

Depois, temos os redirecionamentos. Podemos redirecionar o standard output (saída padrão) para o standard error (erro padrão), o standard error (erro padrão) para o standard output (saída padrão), descartar o standard error (erro padrão) ou realizar outras combinações. Por fim, entram os pipes (canais), que transferem informação de um programa para outro, encadeando a execução.

Apresentando tipos de shell e ferramentas do curso

Mencionaremos quatro tipos de Shell — não são os únicos; existem muitos:

• POSIX SH: é o shell mais básico e mais fiel ao padrão. É o mais compatível, pois praticamente todas as pessoas e sistemas o utilizam, mas não é tão poderoso quanto o Bash, por exemplo.
• BusyBox (BusyBox): é um shell minimalista, com foco forte em segurança. Ele disponibiliza apenas alguns programas pequenos, o que o torna leve e prático, porém com várias limitações. É útil em dispositivos embarcados, contêineres e ambientes nos quais não é necessário um conjunto amplo de ferramentas.
• Bash: é o shell mais utilizado, também conhecido como Bourne Again Shell (Shell Renascido Bourne). Possui plugins (extensões), built-ins (comandos internos) e ferramentas poderosas; é o que utilizaremos neste curso.
• ZSH: é extremamente personalizável e compatível com Bash. Se gostarmos de personalizar e ter um terminal com informações úteis no dia a dia, vale dedicar um tempo configurando o ZSH, instalando-o, alterando o shell padrão para ZSH e criando nossa própria configuração. É visualmente agradável; veremos o nosso funcionando.

Para este curso, os comandos que executaremos são comandos de Linux, GNU (GNU) e Bash. Como o ZSH é compatível, nós não faremos a troca do nosso lado, mas não há problema em utilizar ZSH; os scripts (scripts) sempre estarão baseados em Bash.

Encerramos esta aula. Por favor, deixe um comentário, avalie se gostou e siga-nos. Em caso de dúvidas, entre em contato ou converse pela plataforma da Alura; responderemos. Muito obrigado!

Configuração e Consulta do Ambiente Shell - Ambiente

Iniciando a configuração do ambiente

Agora que já conhecemos a história do Unix e do Shell (interpretador de comandos), precisamos configurar nosso ambiente.

Estamos utilizando macOS. No macOS, há um Terminal já instalado e, por padrão, ele utiliza o zsh. Instalamos o Oh My Zsh (Oh Meu Zsh), que é um sistema de configuração e personalização do Shell (interpretador de comandos). No entanto, não há necessidade de instalar o zsh para acompanhar o curso; deixamos apenas como recomendação, pois é muito personalizável.

No Mac, o Terminal já estará disponível. Geralmente acessamos o “Dock” (canto inferior da tela), abrimos a barra de aplicativos e buscamos por Terminal. Também é possível pressionar Command + Espaço para pesquisar por aplicativos e abrir o Terminal. Vamos manter esse Terminal aberto, embora não o utilizemos exatamente neste momento.

Instalando Homebrew e Visual Studio Code no macOS

Para quem usa Mac, utilizaremos o Homebrew. No site brew.sh há um pequeno script (roteiro) que podemos colar no Terminal para instalar esse gerenciador de pacotes, o Homebrew. Com ele, podemos instalar pacotes e será o que usaremos para instalar o Visual Studio Code (VS Code). É possível utilizar qualquer editor de texto preferido, como Vim, Emacs ou Sublime, mas neste curso usaremos o Visual Studio Code, porque já traz funcionalidades que ajudam bastante.

Para instalar o Homebrew a partir do site brew.sh, execute no Terminal:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Acessamos o site code.visualstudio.com, que indica a melhor forma de instalação para cada sistema. Há download (baixar) para macOS e também é possível usar o Homebrew para instalar o Visual Studio Code, o que preferimos. Além disso, é possível fazer download (baixar) para Windows, para pacotes Debian e RPM (Debian, Ubuntu, Fedora, Red Hat e SUSE) e para Mac, escolhendo a arquitetura correspondente (Intel ou Apple Silicon). Recomendamos habilitar a ferramenta de linha de comando, para podermos abrir o Visual Studio Code digitando code no Terminal.

Depois de habilitar a ferramenta de linha de comando do VS Code, você já consegue abrir o editor a partir da pasta atual:

code .

Preparando terminais no Linux e configurando o WSL no Windows

Se estivermos usando Linux, também haverá um Terminal já instalado. Em vez do zsh (como no macOS), teremos o bash por padrão. Ambos são compatíveis com o que faremos. Como dito anteriormente, não há problema em instalar zsh se preferirmos, mas o curso é focado em bash. Portanto, usar bash não trará problemas; será totalmente compatível. O zsh permite ter um prompt (linha de comando) com nome da pessoa usuária, hostname (nome do host), diretório e outras informações semelhantes. Isso também fica disponível se utilizarmos zsh, especialmente com o Oh My Zsh (Oh Meu Zsh), que amplia a personalização.

Para quem estiver usando Windows, consideremos Windows 11. Abrimos a busca, digitamos cmd e executamos o comando wsl --install. Em geral, o Windows habilita o WSL e depois solicita reiniciar o equipamento. Em seguida, reiniciamos o sistema. O Windows pode instalar por padrão uma distribuição (como Ubuntu). Se quisermos instalar outra distribuição de Linux, executamos wsl --list --online para listar as distribuições disponíveis e, em seguida, instalamos a desejada. Recomendamos Debian; para isso, executamos wsl --install -d Debian. Em um ambiente de máquina virtual, essa instalação pode falhar por limitações de virtualização aninhada (máquina virtual dentro de máquina virtual). Nessa situação, não conseguiremos avançar com todas as etapas diretamente no Windows.

No Windows 11, utilize os seguintes comandos no Prompt (ou PowerShell):

wsl --install

Para listar as distribuições Linux disponíveis:

wsl --list --online

E para instalar especificamente o Debian:

wsl --install -d "Debian"

Também será necessário instalar o Visual Studio Code em Windows, acessando a página de Downloads e escolhendo Windows. Reforçamos que é possível utilizar outro editor de texto, caso seja a preferência. Vamos encerrar a máquina virtual para economizar CPU.

Explorando emuladores de terminal e apresentando o ShellCheck

Existem outros emuladores de terminal que podemos usar. Em geral, utilizamos o terminal padrão do sistema. Em Linux, o terminal padrão já atende bem. Se quisermos algo mais personalizável, podemos usar o Kitty, um emulador de terminal bastante interessante, ou o Rio Terminal, que também é muito interessante, escrito em Rust, com diversos recursos. Outra ferramenta que instalaremos e utilizaremos é o ShellCheck; entraremos em detalhes em breve.

Depois de instalar o Visual Studio Code, o próximo passo é clonar o repositório que criamos, com vários dos módulos que vamos estudar, materiais que precisaremos e alguns READMEs com informações importantes.

Configurando engine de contêineres e clonando submódulos do repositório

Além disso, precisaremos de pelo menos um engine (mecanismo) de contêineres. Podemos instalar Docker no macOS. Normalmente usamos Colima; muitas pessoas usam Podman, e recomendamos fortemente o Podman tanto para Windows quanto para Mac. Se usarmos Podman, é ideal criar um alias mapeando docker para podman, pois a linha de comando é muito semelhante, mas os comandos que executaremos neste tutorial estarão escritos para Docker. Se preferirmos uma alternativa mais clássica, existe o Docker Engine, que é a opção tradicional. Contudo, o Docker Engine não pode ser utilizado em equipamentos corporativos sem a devida licença; é necessário ter cuidado com esse ponto.

Isso pode causar algum problema. Se estivermos no macOS, no diretório raiz do repositório, ao clonar o repositório, precisamos utilizar um parâmetro adicional de clonagem recursiva para baixar também repositórios que não fazem parte do repositório principal, como o do NGINX (NGINX), por exemplo. Isso será importante apenas para demonstrar algumas funcionalidades. Aqui está o endereço do repositório: github.com... github.com.kit.

Para clonar o repositório já trazendo os submódulos (por exemplo, para incluir o NGINX), execute:

git clone --recurse-submodules https://github.com/retospalane/shell-alura.git

Depois de clonar o repositório com a opção recursiva, abrimos o projeto no Visual Studio Code (Visual Studio Code).

Instalando ferramentas GNU via Homebrew com Brewfile

Se estivermos no macOS, depois de instalar o Homebrew (Homebrew), podemos executar o processo de instalação em lote do Homebrew para instalar todos os pacotes necessários. Alguns pacotes já existem no macOS, mas optamos por instalá-los novamente nas variantes da GNU (GNU), como o grep da GNU. Isso é interessante porque o macOS é baseado em BSD (BSD), e alguns utilitários seguem o padrão BSD, que nem sempre é compatível com o que precisamos. Nestas aulas, vamos nos concentrar nas ferramentas GNU, portanto, sempre baixaremos as versões GNU. Sempre que tivermos um módulo novo que exija mais pacotes, vamos atualizar o arquivo packages.txt, e então poderemos executar o mesmo procedimento para instalar os novos pacotes listados.

Como exemplo, um Brewfile pode listar os utilitários GNU e ferramentas que usaremos com frequência:

brew "gnu-sed"
brew "grep"
brew "lima"
brew "shellcheck"
brew "jq"

Com o Brewfile no diretório do projeto, instale tudo de uma vez:

brew bundle

Gerenciando máquinas virtuais com Lima no macOS

Se estivermos no macOS, teremos instalado o Lima, nosso virtualizador e hypervisor (hipervisor). O utilitário limactl cria e gerencia a máquina virtual. Ao iniciar a instância com o comando de inicialização do limactl e, em seguida, interagir com o ambiente via ferramenta do Lima, veremos uma máquina virtual executando Ubuntu. Isso é útil quando precisarmos, por exemplo, de comandos como systemctl, que não existem no macOS; nesse caso, executaremos esses comandos dentro da máquina virtual.

Para iniciar uma VM do Lima e checar o sistema dentro dela, utilize:

limactl start

Em seguida, para interagir com a VM padrão e verificar o kernel:

limactl shell default uname -a

E, quando necessário, executar comandos como systemctl dentro da VM:

limactl shell default systemctl

Se estivermos em alguma distribuição de Linux (Linux) ou se estivermos no Windows (Windows) utilizando o WSL (Subsistema do Windows para Linux), comandos como systemctl, journalctl, entre outros, funcionarão normalmente no ambiente Linux. No macOS é que precisamos recorrer ao Lima. Podemos escolher fazer o curso inteiro dentro do Lima ou realizar a maior parte no macOS e, em alguns momentos, acessar o ambiente do Lima, conforme preferirmos.

Instalando pacotes no Debian/Ubuntu e preparando o ShellCheck

No nosso Visual Studio Code (Visual Studio Code), após instalá-lo, já deixamos o Brewfile preparado com o ShellCheck. Em sistemas Debian ou Ubuntu, recomendamos, na raiz do projeto, atualizar a lista de repositórios com o gerenciador de pacotes e, em seguida, instalar os pacotes usando a opção de confirmação automática (-y) e a substituição de comando $(...) para ler o conteúdo do arquivo packages.txt. Isso instalará os pacotes listados nesse arquivo — por ora, ShellCheck e jq. Até o final do curso, incluiremos mais itens; esta etapa serve para instalar os pacotes e manter tudo configurado.

No Debian/Ubuntu, você pode fazer assim:

sudo apt update
sudo apt install -y $(cat packages.txt)

Praticando atalhos de terminal e controlando tarefas

Alguns atalhos úteis no terminal:

• Se estivermos executando algo e precisarmos interromper, podemos pressionar Ctrl+C.
• Se estivermos executando algo (como o comando tail) e precisarmos fazer outra coisa mantendo o processo em segundo plano, podemos pressionar Ctrl+Z para suspendê-lo.
• Ao digitarmos o comando jobs, veremos a lista de tarefas suspensas.
• Para continuar a tarefa suspensa, usamos fg.
• Se precisarmos encerrar a tarefa em primeiro plano, usamos Ctrl+C.
• Ctrl+C envia um sinal para finalizar o processo. Em alguns contextos, por exemplo, dentro de um shell interativo específico, Ctrl+C não encerra a sessão. Nesses casos, precisamos fazer logout da sessão ou enviar o fim de arquivo, usando Ctrl+D.
• O mesmo ocorre ao alternarmos de sh para bash: Ctrl+C não encerra o bash; precisamos sair com Ctrl+D.
• Esses atalhos se aplicam de forma geral em Windows, Linux e macOS.

Para acompanhar os exemplos acima no próprio terminal:

• Um processo longo de leitura contínua (para demonstrar Ctrl+Z, jobs e fg):

tail

• Listar tarefas em segundo plano/suspensas:

jobs

• Trazer a tarefa suspensa de volta para o primeiro plano:

fg

Habilitando a extensão ShellCheck no VS Code e recapitulando

No Visual Studio Code (Visual Studio Code), no lado esquerdo, há o painel com vários ícones. Devemos clicar no ícone de Extensões, buscar por “ShellCheck” e instalar a extensão. A extensão que vamos utilizar é a do autor Timon Wong. Confiamos nessa publicação e procedemos com a instalação. Com isso, o ShellCheck ficará disponível também no editor.

Recapitulando: instalamos o Bash e o ambiente Linux no Windows (via WSL), criamos uma máquina virtual no macOS, configuramos alguns itens no macOS, e deixamos o ShellCheck habilitado tanto no terminal quanto no Visual Studio Code (Visual Studio Code).

Verificando o Docker e inicializando o Colima

Verifiquemos se o Docker Engine (Docker Engine) está em execução. Podemos utilizar o comando de listagem de contêineres do Docker para conferir. Caso não apareça nada em execução no macOS, pode ser porque o Colima está desligado. Iniciamos o Colima para habilitar o Docker. Como mencionado, isso depende do que preferirmos utilizar: podemos usar Colima (como será o nosso caso), usar Podman, instalar o Docker Engine diretamente ou, se estivermos no Windows ou no macOS, utilizar o Docker Desktop (Docker Desktop). O importante é manter o Docker em execução e termos acesso para criar contêineres. Isso será fundamental para as próximas aulas.

Para checar os contêineres (e se o Docker está acessível):

docker ps -a

Se necessário, inicie o Colima para habilitar o backend do Docker no macOS:

colima start

Ao listar novamente os contêineres do Docker após iniciar o ambiente escolhido, veremos os nossos contêineres ativos.

docker ps -a

Instalando Golang e finalizando a preparação

Outro ponto importante de configuração inicial é instalar o Golang (Golang) para as primeiras aulas. No site go.dev, na seção Download, há distribuições para cada sistema: no Windows, o instalador MSI; no macOS, o instalador PKG; no Linux, o pacote tar.gz. A linguagem Go será importante para gerar alguns registros (logs) no nosso NGINX (NGINX), o que veremos em aulas futuras.

Ao listar novamente os contêineres do Docker após iniciar o ambiente escolhido, veremos os nossos contêineres ativos.

Na próxima aula, veremos como resolver dúvidas caso não estejamos presentes — ou seja, como utilizar o terminal para buscar e validar soluções por conta própria.

Até a próxima.

Configuração e Consulta do Ambiente Shell - Tirando dúvidas

Introduzindo a consulta e a documentação do shell

Já configuramos nosso ambiente. Agora, precisamos aprender como consultar o Shell (interpretador de comandos), que possui documentação disponível internamente.

Quando tivermos dúvidas sobre comandos ou não encontrarmos um comando, podemos acessar o site command-not-found.com, digitar o nome do comando e visualizar exatamente como instalá-lo, além de alguns exemplos de uso. Também podemos pesquisar no Google (buscador Google), no Shell GPT (GPT do interpretador de comandos) ou por outros meios como utilizar determinados comandos, pois às vezes isso pode ser um pouco difícil.

Usaremos com frequência a opção --help dos comandos. Por exemplo: curl --help. Alguns comandos oferecem o parâmetro --help, que apresenta rapidamente as opções de ajuda disponíveis. No entanto, nem sempre isso é suficiente.

Para ver o exemplo citado na prática, execute:

curl --help

Explorando o manual e a navegação no man

Para uma documentação mais completa, existe o programa man, que exibe o manual do comando. Ao executar man curl, temos acesso à sinopse, descrição, formato de uma URL, globbing (expansão de padrões) — um recurso do Bash (interpretador de comandos Bash) no qual podemos utilizar metacaracteres que permitem inserir várias possibilidades no mesmo ponto. Por exemplo, podemos ter uma lista de três nomes em uma única expressão, o que caracteriza globbing, ou expandir do arquivo 1 ao arquivo 100 em um mesmo comando. O manual também aborda variáveis e explica, de forma geral, como navegar pelo próprio manual.

Para abrir o manual do curl, use:

man curl

Esse manual utiliza uma navegação semelhante à do editor de texto mais comum no Linux (sistema operacional Linux), o Vim (editor de texto), com algumas combinações de teclas e atalhos. Para avançar, podemos usar as setas do teclado ou as teclas H, J, K, L, em que J desce, K sobe, H vai para a esquerda (em deslocamento lateral) e L vai para a direita. Se não quisermos memorizar essas teclas, podemos simplesmente usar as setas.

Há diversas formas de ir ao início ou ao fim da página: g minúsculo leva ao começo, e G maiúsculo leva ao final. Podemos usar Shift+G para ir ao final ou g simples para ir ao começo. Ao pressionar Ctrl+F, descemos mais rapidamente. Com Ctrl, deslocamos para cima mais rápido.

Se digitarmos / seguido de algum texto, realizamos uma busca dentro do manual. Em seguida, podemos pressionar N para ir a cada ocorrência. E Ctrl+O, pelo menos no Vim, embora aqui não, retornaria a referências anteriores.

Dentro do man, inicie uma busca com a barra e o termo desejado. Primeiro, apenas a barra para entrar no modo de busca:

/

Em seguida, um exemplo prático procurando por referências a libcurl:

/libcurl

Se digitarmos :, ...

:

Isso funciona no Vim; neste editor não é possível.

Utilizando pipes e filtrando com cat e grep

Se não quisermos utilizar a paginação, podemos fazer um pipe (canalização) com o símbolo | e usar cat, enviando a saída para a saída padrão. Com isso, já começamos a compor programas mais complexos, como grep, que serve para buscar texto. Podemos, por exemplo, procurar referências a libcurl (biblioteca cURL).

Para ver o conteúdo de man curl sem paginação:

man curl | cat

Para filtrar o manual do curl mostrando apenas linhas que contenham “libcurl”:

man curl | grep "libcurl"

Navegando com o less

Essa mesma paginação é a que utilizamos ao usar o programa less. Ao abrirmos um arquivo com less, veremos as mesmas informações que na página do man, porém sem formatação. O importante é que less tem os mesmos controles de navegação que man.

Para abrir o pager less (por exemplo, lendo da entrada padrão):

less

Descobrindo comandos relacionados com man, apropos e whatis

Também podemos verificar o que é o próprio man e quais opções ele oferece. A documentação mostra exatamente onde o man faz buscas. Além disso, existem outros comandos úteis, como apropos. Podemos consultar man apropos para entender seu uso. Caso não saibamos exatamente o nome de um comando, apropos procura comandos existentes com nomes parecidos. Por exemplo, ao executarmos apropos grep, veremos que há vários tipos de grep instalados, como ggrep, grepdiff, pcregrep, entre outros, inclusive pgrep e pkill. Se quisermos buscar qualquer um desses, executamos apropos grep. Também podemos consultar diretamente o que é grep, e o sistema mostrará comandos relacionados.

Para consultar o manual do próprio man:

man man

Para ver a documentação do apropos:

man apropos

Para procurar comandos relacionados a “grep”:

apropos grep

Para consultar diretamente “o que é” o grep:

whatis grep

Identificando usuário, local de programas e path

Há comandos simples que exibem informações sobre nós ou sobre algum programa. Por exemplo, whoami informa quem é o usuário conectado no sistema; no exemplo, o retorno foi animacedo. Já which, seguido do nome do programa, informa o que é esse programa e onde está localizado, inclusive se for um alias (apelido). No caso de curl, o que digitamos geralmente é uma forma abreviada do caminho completo, como /usr/bin/curl.

Para descobrir o usuário atual:

whoami

Para localizar o caminho de executáveis:

which grep

which curl

Eis o caminho completo do binário do curl, como citado no texto:

/usr/bin/curl

Isso é definido por uma variável de ambiente chamada PATH. Ao executarmos echo seguido do sinal de dólar $ e do nome da variável, veremos o valor atual. No caso de PATH, normalmente temos uma lista extensa: cada um desses diretórios é um diretório de busca onde o sistema operacional procura pelos binários, isto é, pelos executáveis e programas que compõem o sistema. Assim, ao utilizarmos which, o sistema mostrará onde está o executável correspondente.

Para inspecionar os diretórios de busca atuais do sistema:

echo $PATH

Encerramos o esclarecimento dessas dúvidas e seguiremos para o próximo módulo, que é a manipulação de dados e arquivos.

Sobre o curso Unix e Shell: automação com scripts e pipelines

O curso Unix e Shell: automação com scripts e pipelines possui 480 minutos de vídeos, em um total de 90 atividades. Gostou? Conheça nossos outros cursos de Linux em DevOps, ou leia nossos artigos de DevOps.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Aula 1
• Aula 2
• Aula 3
• Aula 4
• Aula 5