Introdução
É bem comum no Linux utilizarmos o terminal para realizar algumas tarefas. Atualizar os sistema, preparar ambientes para programar, instalar programas, entre outras.
Algumas dessas tarefas são repetitivas, atualizar o sistema por exemplo. Se estamos utilizando alguma distribuição baseadas no Debian, como o Ubuntu, geralmente temos que atualizar a lista de repositórios, antes de atualizar os pacotes. Ou seja, executamos dois comandos para uma única tarefa.
Ou então, quando temos que preparar o ambiente para começarmos a desenvolver. Se compramos uma máquina nova, ou formatamos, temos que instalar todos os programas, interpretadores, compiladores e tudo mais.
Seria legal se pudéssemos digitar um comando no terminal como atualizar e preparar_ambiente e ele já fizesse isso para a gente. Mas como dizemos para o terminal o que ele deve fazer quando esse comandos forem executados?
Criando apelidos
Nas distribuições Linux, quando digitamos um comando pelo terminal, estes passam por um interpretador. É esse interpretador que executa os comandos que digitamos.
Existem vários interpretadores, um dos mais usados é o Bash, interpretador padrão na grande maioria das distribuições Linux. Tudo que digitamos no terminal, o Bash interpreta, se ele conhecer o comando ele o executa, senão ele fala que o comando não foi encontrado.
Nós queremos dizer para o terminal o comando atualizar, portanto, precisamos ensinar o Bash o que fazer quando nós digitarmos esse comando.
Existem algumas formas de ensinarmos um comando para o interpretador. Podemos criar um programa em linguagens como Java, C, Python, com o próprio Bash, entre outras. Mas, veja bem, os comandos para atualizar os repositórios e pacotes já existem no sistema. Faz sentido criarmos um novo programa que executará a mesma função desses dois comandos?
Se nós criarmos um comando que faça essas funções, ele seria redundante no sistema. Esses comandos já existem, nós apenas queremos chamar ele com outro nome, ou seja, queremos dar um apelido (alias) para eles.
Podemos dizer para o terminal que atualizar é um apelido para os comandos sudo apt-get update && sudo apt-get upgrade:
alias atualizar='sudo apt-get update && sudo apt-get upgrade'
Dessa forma, quando executamos o comando atualizar o terminal entende que na verdade ele é um apelido para esses outros dois comandos e os executa:
Na outra semana quando fui atualizar o sistema novamente, recebi essa mensagem de erro:
Nós criamos o apelido, mas agora o terminal não o reconhece mais. Isso acontece porque, o comando alias cria o apelido apenas para a instância do terminal que foi executado, ou seja, se fechamos o terminal perdemos o apelido.
O que nós podemos fazer é sempre que abrirmos o terminal, o Bash já declare os apelidos para a gente.
Toda vez que um terminal é iniciado, o Bash lê o conteúdo de arquivo oculto chamado .bashrc no diretório home do usuário. Nesse arquivo, nós podemos dizer para o Bash criar os apelidos para a gente, dessa forma, quando abrirmos o terminal, já teremos os apelidos criados.
No arquivo .bashrc podemos adicionar a linha que cria os apelidos, como esse arquivo já possui outras configurações, vou adicioná-la ao final dele:
alias atualizar='sudo apt-get update && sudo apt-get upgrade'
O arquivo .bashrc é único para cada usuário, portanto esse comando só funcionará para o nosso usuário. Se nós quisermos que ele seja utilizado por todos os usuários, nós podemos adicionar essa linha no arquivo /etc/profile.
Mas nesse caso os comandos já existiam, e se quisermos criar algo que façam coisas diferentes?
Criando scripts
Além de utilizar apelidos, nós podemos criar scripts que executam tarefas. Podemos criar um script em Bash que executa comandos pré definidos.
Por exemplo, podemos ter um script que prepara o ambiente de desenvolvimento. Já instalando os programas como a IDE, o sistema de controle de versão, entre outros. Vou chamar esse script de prepara-ambiente e vou colocá-lo dentro de um diretório chamado Scripts.
Precisamos falar que esse nosso script está escrito em Bash, portanto, na primeira linha do arquivo nós colocamos quem é o nosso interpretador:
#!/bin/bash
Agora podemos passar instruções em Bash para o nosso script:
#!/bin/bash
sudo add-apt-repository ppa:webupd8team/java
sudo apt-get update
sudo apt-get install oracle-java9-installer
# Restante dos comandos
Agora precisamos dizer para o Bash que sempre que digitarmos prepara-ambiente execute esse nosso código.
Quando digitamos um comando no terminal, o Bash procura por ele em todos os diretórios que ele conhece. Ou seja, existem diretórios no sistema com o local dos arquivos executáveis (PATH).
Logo, podemos colocar esse arquivo em um desses diretórios, ou então, adicionar o seu diretório como um local de arquivos executáveis. No Linux, essas informações ficam armazenadas em uma variável chamada PATH. Nós podemos pedir para o terminal imprimir seu conteúdo, para isso, devemos colocar o $ na frente do nome:
Ou seja, precisamos colocar nosso arquivo prepara-ambiente em um desses diretórios, ou então, colocar nossa pasta Scripts na variável PATH.
Para não ficar movendo os scripts pelos diretórios, vamos adicionar o nosso diretório Scripts na variável PATH. Ou seja, nós queremos exportar (export) para a variável PATH o conteúdo da própria variável $PATH junto (:) com nosso diretório /home/yuri/Scripts:
export PATH=$PATH:/home/yuri/Scripts
Com isso, nós conseguimos executar nosso programa:
Hum.. não conseguimos executar nosso script. Um script é um arquivo de texto, por isso, por padrão, o sistema não consegue executá-lo. Para resolver esse problema, nós precisamos dizer para o sistema que esse é um arquivo executável, para isso podemos alterar sua permissão de execução:
chmod +x
Agora nós devemos conseguir executar nosso programa:
Para saber mais
Nós podemos executar um script sem adicioná-lo na variável PATH. Para isso basta que ele contenha a permissão de execussão (x), então, nós entramos no seu diretório e digitamos ./prepara-ambiente, por exemplo. O ./ indica que queremos executar aquele script.
O comando export funciona de uma forma parecida com o comando alias. Ou seja, ele só é válido para aquela instância do terminal. Se quisermos que ele esteja sempre disponível, podemos colocar sua instrução dentro do arquivo .bashrc da mesma forma que fizemos com o comando alias.
Criar comandos pode ser uma forma de automatizar tarefas, ou então, deixar o sistema mais semântico para algum usuário, como no caso do comando atualizar. Além do Bash, é possível criar comando para outros Shells, como o ZSh, um Shell muito utilizado por desenvolvedores.
Apesar de os comando utilizados para atualizar o sistema serem de distribuições baseadas no Debian, como Ubuntu e Linux Mint, os modos de criar apelidos e comandos são parecidos em praticamente todas as distribuições Linux.
Automatizar tarefas é uma das tarefas de administrador de sistemas, aqui na Alura, temos um curso sobre como automatizar tarefas com o Shell Scripting.
Nele você aprenderá sobre a sintaxe do Shell, sobre como criar um script que converte muitas imagens de uma vez, como enviar um emails pelo shell e até como fazer backup na Amazon.
