2018
.
Para algumas pessoas o GNU/Linux não tem como objetivo lucro. Para estes, o objetivo do Linux é garantir a tua liberdade. Trabalho colaborativo produz ótimos softwares disponíveis a todos em toda parte.
.
ARTIGO: Aprenda a usar o terminal do Linux, aprenda comandos do Linux e aprenda a criar shell scripts
.
Este artigo é para iniciantes. Pretende oferecer o máximo de informação possível em pouco tempo, para que a pessoa ao terminar de EXECUTAR este artigo, entenda bastante coisa sobre Linux, use o terminal fluentemente e saiba escrever e executar Shell Scripts. Escrevi este artigo para meu uso pessoal. Tudo que tem neste artigo executei por minha conta e risco sem problemas. Recomendo que faça o mesmo. Se alguém houvesse me oferecido este artigo quando eu era iniciante tudo teria sido mais fácil.
.
VAMOS LÁ!
.
APRENDENDO SHELL SCRIPT
.
Fluxos de Entrada/Saida Padrão e Operadores de Fluxo
.
Os fluxos padrão são canais de entrada/saída (E/S) entre um programa de computador e o seu ambiente (tipicamente um terminal de texto) que são pré conectados no início da execução.
.
A entrada padrão Stdin do Linux é o teclado. A gente se comunica com o sistema operacional e programas usando o teclado. Claro que podemos usar tela sensível ao toque, mouse, joystick, touchpad, etc...
Stdin = Standart Input
É representada pelo número 0.
.
Abra seu terminal pelo menu do sistema. Copie e cole no seu terminal:
ls /dev/stdin
.
A saída padrão Stdout do Linux é o monitor. Quase sempre as informações mais importantes são obtidas pelo terminal do sistema operacional. A gente recebe informação do sistema operacional e programas pelo monitor.
Stdin = Standart Output
É representada pelo número 1.
.
Copie e cole no seu terminal:
ls /dev/stdout
.
A saída de erro padrão Stderr do Linux é o monitor. Por ele são enviadas mensagens de erro geradas por aplicativos. A gente recebe informação de erro do sistema operacional e programas pelo monitor. Estas informações são muito úteis para podermos corrigir problemas. Quase sempre as informações de erro mais importantes são obtidas pelo terminal do sistema operacional.
Stderr = Standart Error
É representada pelo número 2.
.
Copie e cole no seu terminal:
ls /dev/stderr
.
Os 3 são usados por redirecionadores. Você redirecionar a saída deles para um arquivo de texto por exemplo. Podemos redirecionar a saída de um comando para um arquivo em determinado diretório. Então lembre que:
Stdin=0
Stout=1
Stderr=2
.
Podemos manipular as saídas e entradas com 3 operadores.
O Pipe (|) Liga a saída de um programa a entrada de outro.
O Write (>) Redireciona para arquivo de texto por exemplo sobrescrevendo.
O Append (>>) Redireciona para arquivo de texto por exemplo, sem apagar o que já estiver escrito.
.
OS PROMPTS PADRÃO DO LINUX SÃO:
.
Para root:
- # -
Para os outros usuários:
- $ -
.
SISTEMA DE PERMISSÃO DE ARQUIVOS
.
Todo arquivo possui uma dada permissão para cada usuário.
Leitura (r), escrita (w) e execução (x)
.
TUDO É ARQUIVO:
Pasta é arquivo.
Dispositivo é arquivo.
Usuário é arquivo.
.
Temos arquivos de texto, arquivos de áudio, arquivos de vídeo, arquivos de imagem, etc.
.
O SHELL SCRIPT É O MAIS ALTO NÍVEL QUE UM SISTEMA LINUX COMUM POSSUI.
.
O Shell padrão do Linux é o Bash. Quando o usuário digita comandos no terminal eles são interpretados pelo Bash.
.
Se o usuário escreve um arquivo de texto com comandos da maneira correta este arquivo de texto se torna um shell script.
.
O shell script é bastante usado pelas pessoas para a automação de tarefas. É muito perigoso executar Shell Scripts como root, isto pode
danificar o sistema.
.
O MELHOR TERMINAL PARA USAR É O QUE JÁ VEM INSTALADO NO TEU SISTEMA. MAS EXISTEM OUTROS TERMINAIS QUE PODE USAR. TEM O TILIX, TEM O TERMINATOR POR EXEMPLO.
.
USAR O TERMINAL CHAMADO TERMINATOR
.
Tem um terminal legal para estudar comandos e shell script Linux chamado TERMINATOR.
Ele pode ser dividido horizontalmente (Ctrl+Shift+O) e verticalmente (Ctrl+Shift+E).
Pode redimensionar as divisões do terminator com (Ctrl+Shift+seta).
Para mover de uma janela de terminal para outra (Ctrl+Shift+N) (Ctrl+Tab).
Para fechar o terminal (Ctrl+Shift+W).
Procuro o TERMINATOR pelo software center da minha distro. Instalo. Abro ele pelo menu do sistema.
Com o TERMINATOR posso ler este artigo em uma subdivisão do terminal e usar outras para executar as instruções do artigo por exemplo.
Isto porque é só copiar este texto para um editor de texto salvar como estudo-linux.txt e abrir ele no terminal.
.
TERMINATOR EXEMPLO DE USO
.
APERTO AS TECLAS:
Ctrl+Shift+O
Ctrl+Shift+E
Ctrl+Shift+N
Ctrl+Shift+Seta para esquerda/direita/cima/baixo
Ctrl+Shift+W
.
Após escrever comandos no meu terminal, eles são examinados pelo Shell, que no meu caso é o Bash. Após o exame do Shell, os comandos informados são passados para o Linux, que executa o comando ou exibe uma mensagem de erro que ajuda quando for executar o comando correto.
.
COMANDOS DO LINUX TEM QUASE SEMPRE A SEGUINTE FORMA:
comando [- opções] [argumentos]
comando [- opções] [parâmetros]
.
Exemplo:
.
Digite no terminal: whoami
Aperte a tecla Enter.
Digite no terminal: cd
Aperte a tecla Enter.
.
Use o exemplo abaixo para digitar no terminal:
ls -tli /home/seu_user_whoami/Downloads/
.
No exemplo acima;
ls (É o comando.)
-tli (É a opção.)
/home/seu_user_whoami/Downloads/ (É o parâmetro/argumento.)
.
Executo os exemplos abaixo para entender como obter ajuda:
man --help
man grep
apropos mkdir
whatis bash
whereis sh
.
QUERO SABER A VERSÃO DA DISTRIBUIÇÃO ENTÃO DIGITO:
.
lsb_release -a
.
cat /etc/issue
.
ME INFORMO SOBRE O KERNEL E ARQUITETURA DA MÁQUINA (faço sempre que posso pra eu não esquecer):
.
uname -a
.
uname -r
.
arch
.
EU QUERO APRENDER ATALHOS DE TERMINAL DO GNU/LINUX ENTÃO EU LEIO O TEXTO ABAIXO:
.
Atalho Função
Ctrl + a Move o cursor para o início da linha
----------------------------------------------------
Ctrl + e Move o cursor para o final da linha
----------------------------------------------------
Ctrl + l Limpa a tela, semelhante ao comando clear
----------------------------------------------------
Ctrl + u Apaga do cursor ao início da linha.
----------------------------------------------------
Ctrl + k Apaga do cursor ao final da linha.
----------------------------------------------------
Ctrl + w Apaga uma palavra antes do cursor.
----------------------------------------------------
Ctrl + Shift + _ Desfaz as últimas mudanças.
----------------------------------------------------
!! Executa o último comando no histórico.
----------------------------------------------------
!abc Executa o último comando no histórico começando com abc.
----------------------------------------------------
!n Executa o comando de número n no histórico.
----------------------------------------------------
.
PARA APRENDER O QUE LI ACIMA, EXECUTO O ENSINAMENTO ABAIXO:
.
Abro o terminal pelo menu do sistema.
.
Colo o texto abaixo no terminal, mas poderia ser qualquer frase:
.
Frase: "Ctrl + Apaga do cursor ao início da linha."
.
Agora aperto duas teclas, as teclas:
Ctrl + A
.
Aperto a seta do teclado para a direita quatro vezes. Então aperto as teclas:
.
Ctrl + U
.
Aperto duas teclas, as teclas Ctrl + E
(Control e E)
.
Aperto a tecla seta para esquerda 7 vezes.
.
Aperto as teclas Ctrl + K
.
Aperto as teclas Ctrl + W
.
Aperto 3 teclas: Crtl + Shift + _
(Control, Shift e Underline.)
.
Aperto a tecla seta para cima algumas vezes.
.
Aperto a tecla seta para baixo algumas vezes.
.
Pronto. Já estou sabendo alguma coisa. Com isto, já aprendi bastante sobre atalhos de teclado para o terminal Linux.
.
O PIPE "|"
.
O pipe "|" é um operador que liga um comando a outro comando. Liga a saída de um comando a entrada de outro comando.
.
LER UM ARQUIVO DE TEXTO PELO TERMINAL DO LINUX
.
Copie e cole o código abaixo no seu terminal Linux:
echo -e '\nQuando a luz dos olhos meus\nE a luz dos olhos teus\nResolvem se encontrar\nAi que bom que isso é meu Deus\nQue frio que me dá o encontro desse olhar\nMas se a luz dos olhos teus\nResiste aos olhos meus só para me provocar\nMeu amor, juro por Deus me sinto incendiar\nMeu amor, juro por Deus\nQue a luz dos olhos meus já não pode esperar\nQuero a luz dos olhos meus\nNa luz dos olhos teus sem mais lará-lará\nPela luz dos olhos teus\nEu acho meu amor que são se pode achar\nQue a luz dos olhos meus precisa se casar.\n' > arq-poema.txt
.
Para ler o arq-poema.txt todo pelo terminal copie e cole os comandos abaixo em seu terminal Linux um de cada vez:
cat arq-poema.txt
cat -n arq-poema.txt
.
Para ler as três primeiras linhas do poema:
cat arq-poema.txt | head -n 3
cat -n arq-poema.txt | head -n 3
.
Para ler as três ultimas linhas do poema:
cat arq-poema.txt | tail -n 3
cat -n arq-poema.txt | tail -n 3
.
Será que nas quatro primeiras linhas existe a palavra olhos? Vamos ver. Copie e cole o comando abaixo no terminal:
cat arq-poema.txt | head -n 4 | grep olhos
cat -n arq-poema.txt | head -n 4 | grep olhos
.
Quais das 7 primeiras linhas que NÃO POSSUEM a palavra olhos?
cat arq-poema.txt | head -n 7 | grep -v olhos
cat -n arq-poema.txt | head -n 7 | grep -v olhos
.
Para remover arq-poema.txt use o comando abaixo no mesmo terminal em que está executando os comandos até o momento:
rm -f arq-poema.txt
.
ACHOU INTERESSANTE ATÉ AGORA?
.
ENTÃO SIGAMOS EM FRENTE!
.
Para criar uma pasta pelo terminal use o comando mkdir. Ex:
mkdir pasta-teste
.
Para criar um arquivo use o direcionador >. Ex:
> arquivo-teste.txt
.
Para ver o dois arquivos criados digite:
ls -t
.
Para mover o arquivo-teste.txt para pasta-teste use o comando mv:
mv arquivo-teste.txt pasta-teste
.
Para navegar para a pasta-teste use o comando cd:
cd pasta-teste/
.
Para ver o que tem na pasta-teste use o comando ls -t:
ls -t
.
Para voltar uma pasta atrás use o comando cd ..:
cd ..
.
Confere:
ls -t
.
Para remover a pasta-teste use o comando rm -r:
rm -r pasta-teste
.
Confere se a pasta foi removida:
ls -t
.
EXECUTANDO MAIS COMANDOS ÚTEIS PELO TERMINAL
.
VERIFICO INFORMAÇÕES DA MINHA CPU:
cat /proc/cpuinfo
.
Me lembro que o terminal do Linux tem sensibilidade a letras maiúsculas e minúsculas. Um arquivo chamado Texto.txt é diferente de texto.txt
.
VERIFICO INFORMAÇÕES SOBRE A MEMÓRIA:
cat /proc/meminfo
.
Quero saber que dia é hoje para o terminal, digito:
date
.
Quero saber quando cairá certo dia em outro ano anterior ou posterior usando pipe "|" e "less":
~$ cal 2017 | less
~$ cal 2018 | less
~$ cal 2019 | less
.
Aperto a tecla Q para sair do calendário. O pipe "|" serve para unir um comando a outro. No GNU/Linux posso unir programas que trabalharão juntos.
.
Se quiser mandar o calendário para um arquivo de texto para depois imprimir este arquivo de texto em um folha de papel:
cal 2018 | less > calendario-de-2018.txt
.
EM QUAL DIA DA SEMANA CAIRÁ O DIA DAS CRIANÇAS?
date --date='12 Oct' +%a
.
QUE DIA FOI ONTEM?
date --date='1 day ago'
.
QUE DIA SERÁ AMANHÃ?
date --date='1 day'
.
A PARTIR DESTE DIA, DAQUI A UM ANO UM MÊS E UM DIA, QUE DIA SERÁ?
date --date='1 day 1 month 1 year'
.
QUE DIA FOI A UM ANO UM MÊS E UM DIA?
date --date='1 day 1 month 1 year ago'
.
PARA SABER INFORMAÇÃO SOBRE O SISTEMA E O HARDWARE:
.
Info CPU
cat /proc/cpuinfo
.
Info memória
cat /proc/meminfo
.
Detalhes da versão
cat /proc/version
.
Detalhes da partição
cat /proc/partitions
.
Detalhes dispositivos SCSI/Sata
cat /proc/scsi/scsi
.
Info dispositivos SATA
hdparam /dev/sda1
.
Lista componentes do Hardware
sudo lshw
.
Imprime info do hardware
sudo hwinfo --short
.
Lista dispositivos scsi
sudo lsscsi
.
Lista todos os dispositivos PCI
lspci
.
Lista dispositivos USB
lsusb
.
Lista dispositivos de bloco
lsblk
.
Mostra informação sobre a arquitetura da CPU
lscpu
.
Comandos para manipulação de arquivos e diretórios:
.
pwd (Informa o nome do diretório corrente)
cd (Navega entre diretórios)
cd (Volta para a home)
cd . (Diretório atual)
cd .. (Retrocede um diretório)
cd - (Avança para o último diretório em que esteve)
ls (Lista arquivos e diretórios)
ls -a (Lista diretórios, arquivos e arquivos ocultos)
ls -t (Lista arquivos e diretórios por data de modificação)
cp (Copia arquivos e diretórios)
mv (Move ou renomeia arquivos e diretórios)
ln (Estabelece ligações entre arquivos)
ln -s (Estabelece ligações simbólicas entre arquivos)
mkdir (Cria um diretório)
mkdir -p (Cria um diretório e um sub-diretório)
mkdir ../nome-da-pasta-a-ser-criada (Cria uma pasta abaixo da pasta onde estou)
rmdir (Remove um diretório vazio)
rm -f (Apaga arquivos)
rm -r (Apaga pastas/diretórios)
rm -I (Pede confirmação antes de remover)
file (Indica tipo de arquivo)
grep (Pesquisa arquivos por conteúdo)
grep -i palavra-que-procura arquivo-de-texto.txt
grep -i arquivo-que-procura caminho/para/pasta
find (Localiza arquivo por suas características)
find -name "palavra-termo-de-busca"
find -iname "palavra-termo-de-busca"
.
find -name nome-do-arquivo -exec rm {} \; (Executa o comando cmd . O escopo de comando é considerado encerrado quando um ponto e vírgula (;) é encontrado. A cadeia {} é substituída pelo nome de cada arquivo que satisfaz ao critério de pesquisa e a linha assim formada é executada. Assim como foi dito para a opção - name, o ponto e vírgula (;)deve ter antes uma contra barra, ou deve estar entre aspas ou apóstrofos)
.
Exemplo (faça o teste pelo terminal):
~ $touch 01-arquivo.txt
~ $ls -t
~ $find -name 01-arquivo.txt -exec rm {} \;
~ $ls -t
.
basename nome-do-arquivo (Devolve o nome de um arquivo recebendo o caminho completo)
Exemplo:
~ $basename Documentos/
Documentos
.
dirname nome-do-diretório (Devolve o nome do diretório recebendo o caminho completo)
> nome-do-arquivo.extensão (Cria arquivo vazio)
touch nome-do-arquivo.extensão nome-do-arquivo2.extensão (Cria um ou mais arquivos vazios)
cat nome-do-arquivo.extensão > nome-do-arquivo.extensão (Cria arquivo vazio)
.
REPETINDO:
cd - Navegando entre pastas/diretórios
cd . (pasta atual)
cd .. (pasta anterior)
cd ~ (pasta home do usuário)
cd - (última pasta)
.
ls - Lista arquivos
.
ls [opções ] [arquivo/diretório/pasta]
.
ls -l
.
ls -t
.
ls *.txt
(asterisco representa qualquer coisa ligada a .txt)
.
ls *.sh
(asterisco representa qualquer coisa ligada a .sh)
.
ls -lat
.
ls -lah
.
ls ????.txt
.
ls ????.sh
(o ponto de interrogação substitui um e somente um caractere)
.
ls [at]*.mp3
(listar todos os arquivos começados por a ou t, seguido por qualquer coisa * e terminados por .mp3). Exemplo:
$ls [at]*.mp3
alcione_ne_me_quitte_pas.mp3 alex_cohen_quem_de_nos_dois.mp3
alex_cohen_hotel_california.mp3
.
cp - Copia de arquivos e diretórios
.
cp [opções]
.
Se usar:
.
cp -i
.
É o modo interativo. Uso se não tenho certeza de que o arquivo foi copiado previamente, pois copiar novamente sobrescreve o arquivo copiado e posso perder alguma coisa...
.
Se usar:
.
cp -v
.
Mostra o que está copiando
.
Se usar:
.
cp -r
.
Copia recursivamente arquivos pastas e subpastas
.
mv - MOVER ARQUIVOS E PASTAS/DIRETÓRIOS
.
É usado para renomear arquivos, é quase o mesmo que copiar o arquivo origem para o arquivo destino e depois remover o arquivo origem. As opções do mv são parecidas com as do comando cp.
.
Se eu crio o arquivo-teste.txt pelo terminal com o comando touch e escrevo algo nele com o comando echo redirecionando a saída do echo para o arquivo-teste.txt, depois leio o que escrevi com o comando cat eu posso copia-lo para o 2arquivo-teste-novo.txt com o comando mv.
.
Execute copiando e colando os comandos abaixo um de cada vez:
.
cd
echo -e '\nOlá!\nTudo\nFirme?' >> 05-arq.txt
echo -e '2-Olá!\n2-Tudo\n2-Firme?\n' >> 05-arq.txt
ls -tli
cat 05-arq.txt
cat -n 05-arq.txt
rm -f 05-arq.txt
touch arquivo-teste.txt
ls -li
ls -t
echo 'Aprendendo Linux!' >> arquivo-teste.txt
cat -n arquivo-teste.txt
echo 'Estou Aprendendo Linux!' > arquivo-teste.txt
cat arquivo-teste.txt
find -name "arq*"
find -iname "arq*"
find *.txt
mv arquivo-teste.txt 2arquivo-teste-novo.txt
ls -li
ls -t
cat 2arquivo-teste-novo.txt
find -name "2arq*"
find -iname "2arq*"
.
Por exemplo, o comando mv é útil quando eu tenho um arquivo que vou refazer mas quero guardar o arquivo antigo como base para o novo arquivo.
.
O comando mv pode mover o 2arquivo-teste-novo.txt para a pasta Downloads.
.
cd
ls -li
ls -t
pwd
mv 2arquivo-teste-novo.txt Downloads/
cd Downloads/
pwd
ls -li
ls -t
cat 2arquivo-teste-novo.txt
find -name "2arq*"
find *.txt
.
Agora renomeio o 2arquivo-teste-novo.txt para 3arquivo-teste-velho.txt:
.
mv 2arquivo-teste-novo.txt 3arquivo-teste-velho.txt
cat 3arquivo-teste-velho.txt
find -name "3ar*"
.
CONTINUE EXECUTANDO UM COMANDO DE CADA VEZ.
.
pwd
ls -t
mv -b 3arquivo-teste-velho.txt 3arquivo-teste-back.txt
ls -t
pwd
cat 3arquivo-teste-back.txt
mv -i 3arquivo-teste-back.txt 4arquivo-teste-velho.txt
ls -t
pwd
cat -n 4arquivo-teste-velho.txt
find -name "4arq*"
find *.txt
find -iname "4arq*" -exec rm {} \;
ls -t
find *.txt
.
LN - ESTABELECE LIGAÇÕES ENTRE ARQUIVOS
.
ln [-s]
.
O comando ln cria ligações (links).
.
Existem dois tipos de ligações:
HARD LINK E LINK SIMBÓLICO.
.
Hard Link: neste caso, os dois compartilham os dados. Se apagar o arquivo original o hardlink permanece funcionando. Somente é possível fazer hardlink em arquivos que estejam em uma mesma partição de disco. Somente o usuário proprietário do sistema pode criar/desfazer hardlinks.
.
Ex:
> arq3-test.txt
ls -lit
ln arq3-test.txt arq3-hard-link
ls -lit (veja se possuem o mesmo número Inode e o mesmo device)
echo '1-Aprendendo sobre hard link.' >> arq3-test.txt
cat arq3-hard-link
echo '2-Mais uma linha escrita: Aprendendo sobre hard link.' >> arq3-hard-link
ls -lit
cat arq3-test.txt
rm -f arq3-test.txt
ls -lit
cat arq3-hard-link
.
Link Simbólico é somente o caminho do
arquivo-origem. Diferente do hard link pode-se fazer links simbólicos em arquivos e pastas. Nenhum dos dois precisam estar na mesma partição de disco.
.
Uso mais Link Simbólico. Para entender vou criar links. Executo os comandos abaixo um de cada vez.
.
Ex:
touch arq4-test.txt
ls -t
ln -s arq4-test.txt arq4-link-simb
ls -tli
echo 'Aprendendo sobre link simbolico.' >> arq4-link-simb
cat arq4-test.txt
ls -t
rm -f arq4-test.txt (Este é o arquivo origem)
cat arq4-link-simb
ls -t
rm arq4-link-simb
.
Comandos que leem da entrada padrão (stdin/teclado) e escrevem na saída padrão (stdout/monitor de vídeo). O propósito destes filtros quase sempre é o de modificar a saída de outros, por isso, geralmente são utilizados em combinação com mais comandos. Exemplo:
cat, wc, sort, head, tail
.
cat (Exibe conteúdo de arquivos)
wc (Conta caracteres, palavras e/ou linhas de arquivos)
sort (Ordena o conteúdo de arquivos)
head (Exibe o início dos arquivos)
tail (Exibe o final dos arquivos)
.
Os comandos/filtros acima se não forem direcionados para um arquivo, irão aparecer na tela do terminal.
.
APRENDENDO SHELL SCRIPT - COMANDOS MAIS USADOS DO SHELLSCRIPT
.
SOBRE O COMANDOS MAIS USADOS DO SHELLSCRIPT:
É para iniciantes. Pretende oferecer o máximo de informação possível em pouco tempo, para que a pessoa ao terminar de EXECUTAR este artigo entenda bastante coisa sobre shell script e seja capaz de criar scripts úteis para si mesma. Desde o primeiro artigo eu editei ele umas oito vezes. Para mim este ficou mais interessante. Longe de ser perfeito, peço que faça vista grossa a erros de digitação ou definições ligeiramente incoerentes. O negócio é que este artigo é realmente útil para mim e espero que seja útil para você também. A maior parte deste artigo é pesquisa, mas alguns pedaços foram reescritos.
.
Não esqueça de dar intervalos em seus estudos para se esticar, hidratar, etc.
.
SABE POR QUE?
Porque depois de executar alguns trechos deste artigo a ficha cai, a pessoa fica animada e não quer parar (tipo eu).
.
VAMOS LÁ?
.
Qual é o seu usuário?
.
Se você não tem certeza qual é o seu usuário, use o comando "whoami" sem aspas, para saber.
.
Abra o terminal pelo menu do sistema. Não mude de terminal, eu recomendo.
.
DIGITE ESTES COMANDOS ABAIXO UM DE CADA VEZ:
.
apropos shell
whereis bash
whatis bash
echo $SHELL
echo$$
clear
echo
echo ''
echo ""
echo "Olá!"
printf 'Bem vindo ao bash!' (Aperte a tecla enter e digite: ls)
echo '#!/bin/bash'
echo "#!/bin/bash"
ls -t
ls -a
echo ; echo "Olá!" ; echo
echo -e 'Bom\nDia\nMundo!'
echo -e "Bom\nDia\nMundo!"
echo "Hello world!"
echo "Hello "world"!"
echo "Hello \"world\"!"
echo -e "1\t2\t3"
echo -e '1\t2\t3'
echo -e "Nós\tVós\tEles(as)"
echo -e 'Nós\tVós\tEles(as)'
printf "Hello world" (Aperte a tecla enter e digite: df -h)
pwd
clear
ls -ta
sleep 7
echo ; echo 'Olá!' ; sleep 3 ; ls -t
free -h -t
free -th
sleep 4
date
date -d "yesterday"
date -d "2 days ago"
date +"%d/%m/%Y"
cal
du -h
clear
du -hcs
uptime
uname -a
free -tmlh
whatis df
df -a -h
df -k -l
df -T -m
whatis history
history
echo ; whoami ; echo
ls ; echo ; pwd ; echo
echo ; ls -at ; echo
echo "sou \n um \n texto"
echo -e "sou \n um \n texto"
whatis du
du *
ls -lah
du -hcs
du -ach
lsb_release
lsb_release -a
whatis cat
cat /etc/hostname
cat -n /etc/hostname
cd ..
pwd
VARIAVEL="Meu diretório atual é o `pwd`"
echo $VARIAVEL
unset VARIAVEL
echo $VARIAVEL
ls
cd -
pwd
ls
clear
echo ; echo 'df: Relata o espaço de disco usado pelo sistema (Usado e Livre)' ; echo ; df -h ; echo
ls -hat
echo ; echo "du: Relata o espaço utilizado no disco de tal arquivo ou diretório" ; echo ; du -hcs ; echo
echo ; echo 'env (Este comando oferece uma lista de variáveis. Entre elas PWD, USER, SESSION_MANAGER e LANG)' ; sleep 4 ; echo ; env ; echo
clear
echo $PWD
echo ${PWD}
echo $USER
echo "Eu estou logado como usuário $USER"
echo $SESSION_MANAGER
echo ${SESSION_MANAGER}
echo $LANG
VALOR="Linux"
echo $VALOR
echo ${VALOR}
echo $VALOR $VALOR
echo ${VALOR} ${VALOR}
VALOR='ls -t'
$VALOR
${VALOR}
VALOR='history'
echo $VALOR
$VALOR
echo ${VALOR}
${VALOR}
unset VALOR
VALOR=$(cat /etc/hostname)
echo $VALOR
$VALOR
clear
VALOR='free -h -t'
$VALOR
${VALOR}
echo $VALOR
echo ${VALOR}
echo VALOR
echo -e '\nSaiba que ao usar o comando read VALOR\n \n(Aperte a tecla enter, digite: "ls" sem aspas e aperte enter.)\n \nDepois execute $VALOR\n \nVamos ver isto logo abaixo:\n'
read VALOR
$VALOR
${VALOR}
read VALOR
.
OBS: Aperte a tecla enter, digite: "uptime" sem aspas e aperte enter.
.
echo $VALOR
$VALOR
${VALOR}
echo "Entre com o valor para a variável: " ; read VARIAVEL
$VARIAVEL
unset VARIAVEL
VALOR='du -hcs'
echo ; $VALOR ; echo ; $VALOR ; echo
echo ; $VALOR ; sleep 4 ; echo ; $VALOR ; echo
echo ; ${VALOR} ; sleep 4 ; echo ; ${VALOR} ; echo
clear
unset VALOR
echo ; $VALOR
$VALOR
${VALOR}
echo ; ${VALOR}
VALOR='lsb_release -a'
$VALOR
VALOR=$(lsb_release -a)
echo $VALOR
echo -e '\nOlá!\nVamos\nSaber\nOs\nComandos\ndo\nShellscript Linux!'
clear ; echo -e '\n \nOlá!\n \nVamos\n \nSaber\n \nOs\n \nComandos\n \ndo\n \nShellscript Linux!\n'
HOJE=$(lsblk)
echo "Informação sobre dispositivos de bloco: $HOJE"
echo "Informação sobre dispositivos de bloco: ${HOJE}"
HOJE=$(cal)
echo "Informação sobre o calendário atual: $HOJE"
HOJE=$(uptime)
echo "Informação sobre tempo de funcionamento desta máquina: $HOJE"
clear
HOJE=$(lsblk)
echo 'Informação sobre dispositivos de bloco: $HOJE'
echo 'Informação sobre dispositivos de bloco: ${HOJE}'
unset HOJE
echo $HOJE
echo ${HOJE}
echo `expr 3 + 2`
echo $((3+2))
echo `expr 9 + 4`
echo $((9+4))
echo $((2*3))
echo 'dois vezes três é:' $((2*3))
echo $((2*4-2/2+3))
VALOR=44
echo $VALOR
echo $((VALOR*1))
echo $((VALOR*2))
echo $((VALOR*3))
echo $VALOR
VALOR=$((VALOR+1))
echo $VALOR
VALOR=$((VALOR+11))
echo $VALOR
VALOR=$((VALOR+1))
echo $VALOR
VALOR=$((VALOR+11))
echo $VALOR
unset VALOR
echo $VALOR
VALOR="echo -e \nBom\nDia\nMundo\nLinux\n"
$VALOR
echo $VALOR
echo ${VALOR}
VALOR=$(uname -a)
echo $VALOR
HOJE=$(arch)
echo $HOJE
clear
VALOR=$(uname -a) ; echo ; echo "Informação sobre o kernel: $VALOR" ; sleep 4 ; echo ; VALOR=$(arch) ; echo "Informação sobre a arquitetura do sistema: $USER" ; echo ; sleep 2
unset VALOR
unset HOJE
clear
printf "%-5s %-10s %-4s\n" No Nome Pontos
printf "%-5s %-10s %-4.2f\n" 1 Marta 8
printf "%-5s %-10s %-4.2f\n" 2 Joel 9
printf "%-5s %-10s %-4.2f\n" 3 Carlos 7
echo -e "\e[1;31m Este é o texto em vermelho \e[0m"
echo -e "\e[1;32m Este é o texto em verde \e[0m"
echo -e "\e[1;32m Este é o \e[1;34mtexto \e[1;31mmisturado \e[0m"
VALOR="echo -e \e[1;31m\nBom\nDia\nMundo\nLinux\n\e[0m"
$VALOR
echo $VALOR
echo ${VALOR}
unset VALOR
$VALOR
echo $VALOR
unset HOJE
echo $HOJE
clear
exit
.
Muito bom que você digitou um comando de cada vez.
Os comandos mais longos pode copiar e colar no terminal se quiser, mas no início seria melhor digitar.
Saiba que a partir deste momento você já está entendendo coisas extremamente úteis para escrever shellscript usando o Bash!
Uma coisa interessante sobre a maior parte dos comandos acima, é que para estudar eles, você não precisa estar conectado a internet.
Os comandos acima oferecem informações interessantes e úteis. Podemos colocar todos eles em um só script e executar. Dependendo do caso, é mais fácil que digitar um a um de cada vez toda vez que precisar.
.
SE PUDER, ANTES DE CONTINUAR EXECUTE OS COMANDOS ACIMA QUE TE CHAMARAM MAIS A ATENÇÃO DE NOVO POIS, EXECUTAR ELES É MUITO DIDÁTICO. NADA MELHOR QUE APRENDER PRATICANDO.
.
ALGUMAS DICAS ÚTEIS QUE SERÃO REPETIDAS DURANTE O CAMINHO (Vou repetir muitas coisas pelo caminho):
.
1
Não execute shell script como root.
.
2
O shell script Linux usando o interpretador de comandos Bash começa com o shebang:
#!/bin/bash
.
3
Abra um editor de texto e cole nele o script salvando com um nome que termine com extensão .sh
.
4
Dar permissão para executar o script pode ser só para você ou para todos usarem:
chmod +x MeuScript.sh (só você)
chmod a+x MeuScript.sh (todos os usuários do PC)
.
5
Um script pode ser executado de 3 modos:
bash MeuScript.sh
sh MeuScript.sh
./MeuScript.sh
.
Exemplo para começar bem. Copie e cole o código abaixo no terminal que você vai abrir pelo MENU DO SISTEMA:
.
echo -e '#!/bin/bash\nclear\necho\necho Olá usuário Linux!\nsleep 2\necho\necho Olá Mundo!\nsleep 2\necho\nVALOR=GNU/Linux\nVALOR2=whoami\necho Você quer aprender comandos $VALOR?\nsleep 2\necho\necho Então vamos aprender comandos $VALOR!\nsleep 2\necho\necho Vamos aprender Shell Script!\nsleep 2\necho\necho 'Até Breve usuário Linux:' ; sleep 2 ; echo ; $VALOR2\necho\nsleep 2\nexit' > 03-olauser.sh ; chmod +x 03-olauser.sh ; bash 03-olauser.sh
.
Para remover o script criado pelo código acima, o arquivo 03-olauser.sh, use o mouse e o gerenciador de arquivos ou copie e cole o comando abaixo no mesmo terminal onde executou o código:
.
clear ; unset VALOR ; sleep 2 ; rm -f 03-olauser.sh ; sleep 2 ; ls -t ; sleep 2 ; exit
.
# (O nome deste símbolo é tralha)
.
! (O nome deste símbolo é exclamação)
.
./ (Ponto e barra significa onde você está)
.
#! (Tralha e exclamação significa Shebang)
.
: arq-uptime1.txt
uptime > arq-uptime1.txt
.
>> (Este direcionador adiciona ao que estiver escrito)
Exemplo execute os comandos abaixo um de cada vez:
uptime >> arq-uptime2.txt
uptime >> arq-uptime2.txt
.
A Shebang para o Bash é a primeira coisa que se escreve em um shell scripr no Linux:
#!/bin/bash
.
Para ver qual é o shell padrão:
printenv SHELL
.
Para mudar o Shell padrão (não faça isto!) Ex:
chsh -s /bin/ash
.
Para sair do shell:
exit
.
Geralmente o primeiro script para quem nunca criou um shell script é criar uma pasta chamada pasta-estudos na pasta home.
cd ; mkdir pasta-estudos
Abrir a pasta-estudos e nela criar um arquivo de texto chamado de 01-script.sh.
cd pasta-estudos/
> 01-script.sh
Dá poder de execução ao arquivo 01-script.sh.
chmod a+x 01-script.sh
Abre o 01-script.sh com um editor de texto. Escreve com um editor de texto no arquivo 01-script.sh o seguinte:
#!/bin/bash
# Um comentário
echo "Olá, mundo!"
# Fim do Shell Script
.
Comentários também podem ser escritos assim:
#!/bin/bash # Um comentário
echo "Olá, mundo!" # Fim do Shell Script
.
SALVE O QUE FOI ESCRITO. FECHE O EDITOR DE TEXTO.
.
EXECUTA O SCRIPT USANDO UM COMANDO DE CADA VEZ.
comando 1:
sh 01-script.sh
comando 2:
./01-script.sh
comando 3:
bash 01-script.sh
.
TUDO ISTO ACIMA PODE SER FEITO DE UMA SÓ VEZ COM O CÓDIGO ABAIXO:
echo ; printenv SHELL ; echo ; cd ; mkdir pasta-estudos ; cd pasta-estudos/ ; > 01-script.sh ; chmod a+x 01-script.sh ; echo -e '#!/bin/bash\n# Um comentário\necho "Olá, mundo!"\n# Fim do Shell Script' > 01-script.sh ; sh 01-script.sh ; echo ; ./01-script.sh ; echo ; bash 01-script.sh ; ./01-script.sh ; sh 01-script.sh
.
Bloco de comentários tudo que estiver entre :<<'OUTRO_COMENTARIO' e OUTRO_COMENTARIO não irá aparecer quando o shell script for executado. Exemplo a ser executado:
#!/bin/bash
# Um comentário
echo 'Olá quem?'
:> .bashrc ; source .bashrc
.
EXECUTE O COMANDO ABAIXO:
echo $PATH
.
FAÇA UM TESTE CRIANDO UM SCRIPT NA PASTA bin/ copiando e colando no terminal o código abaixo:
cd ; cd bin/ ; echo -e '#!/bin/bash\nclear\nVALOR="Olá Mundo!"\n \necho $VALOR\n \nsleep 3\necho\nunset VALOR\nexit' > bin-script.sh ; chmod a+x bin-script.sh ; cd ; cd Downloads/ ; bin-script.sh ; sleep 3 ; echo ; echo 'Estamos em:' ; echo ; sleep 2 ; echo ; pwd ; echo ; sleep 3 ; echo ; echo 'Funcionou porque o script foi executado na pasta Downloads' ; echo
.
VOCÊ NOTOU SE JÁ É CAPAZ DE LER ESTE CÓDIGO ACIMA E ENTENDER O QUE ELE FAZ?
.
ACRESCENTANDO O NOVO VALOR À VARIÁVEL $PATH:
cd
whoami
PATH=$PATH:/home/seu-usuario-whoami/bin/
.
PARA TORNAR O VALOR, QUE VOCÊ QUISER, PERMANENTE, TEM GENTE QUE FAZ O AJUSTE DA VARIÁVEL DENTRO DO ARQUIVO ".profile" OU ".bash_profile"
export PATH="$HOME/bin:$HOME/.local/bin:$PATH"
.
Exemplo:
cd
pwd
ls -a
echo 'PATH=$PATH:/home/seu-usuario-whoami/bin/' >> .profile
ls -a -t
.
PARA FUNCIONAR, TENTE EXECUTAR:
cd ; source .profile ; source .bashrc
.
PODE TAMBÉM ATUALIZAR E REINICIAR O SISTEMA. COMANDO PARA REBOOT:
sudo shutdown -r now
.
VERIFICANDO A NOVA VARIÁVEL:
echo $PATH
.
LINUX SHELL SCRIPT BRINCANDO COM 5 VARIÁVEIS:
#!/bin/bash
clear
# Este script testa o uso de variáveis
# Definindo 5 variáveis
echo ; echo 'Definindo 5 variáveis em 10 segundos.' ; sleep 3 ; echo
VALOR1='ls -t' ; sleep 2 ; VALOR2='pwd' ; sleep 2 ; VALOR3='cal' ; sleep 2 ; VALOR4='uptime' ; sleep 2 ; VALOR5='whoami' ; sleep 2
# Executando as 5 variáveis
echo 'Executando as 5 variáveis com explicações.' ; sleep 4 ; echo
echo 'Vamos listar o conteúdo desta pasta:' ; echo ; $VALOR1 ; sleep 4 ; echo ; echo 'Vamos saber onde estamos localizados no sistema:' ; sleep 4 ; echo ; $VALOR2 ; sleep 4 ; echo ; echo 'Vamos ver o calendário atual' ; sleep 4 ; echo ; $VALOR3 ; echo ; echo 'Vamos saber o tempo de funcionamento da máquina:' ; sleep 4 ; echo ; $VALOR4 ; sleep 4 ; echo ; echo 'Vamos saber qual é o usuário logado' ; sleep 4 ; echo ; $VALOR5 ; echo
sleep 5
echo 'Executando apenas as variáveis:' ; echo ; $VALOR1 ; sleep 2 ; $VALOR2 ; sleep 2 ; $VALOR3 ; sleep 2 ; $VALOR4 ; sleep 2 ; $VALOR5
# Removendo as 5 variáveis pois este script é apenas um teste
echo ; echo 'Removendo as 5 variáveis em 10 segundos, pois este script é apenas um teste' ; sleep 4 ; echo
unset VALOR1 ; sleep 2 ; unset VALOR2 ; sleep 2 ; unset VALOR3 ; sleep 2 ; unset VALOR4 ; sleep 2 ; unset VALOR5 ; sleep 2
echo ; echo '10 seg para testar as variáveis que não devem ecoar valores' ; sleep 4 ; echo
echo 'Testando as variáveis:' ; echo ; $VALOR1 ; sleep 2 ; $VALOR2 ; sleep 2 ; $VALOR3 ; sleep 2 ; $VALOR4 ; sleep 2 ; $VALOR5
exit
# Fim do script
.
LINUX SHELL SCRIPT - OlaUsuario.sh
.
#!/bin/bash
# Titulo: 01-olauser.sh
clear
USERL='Usuário-Linux'
echo
echo "Olá $USERL"
sleep 2
echo
echo "Tchau $USERL"
sleep 2
clear
exit
# Fim do script
.
ABRA O TERMINAL PELO MENU DO SISTEMA. ABRA O GERENCIADOR DE ARQUIVOS. COLOQUE OS DOIS LADO A LADO NA TELA DO COMPUTADOR. EXECUTE O SCRIPT ACIMA COPIANDO E COLANDO NO TERMINAL O CÓDIGO ABAIXO QUE VAI EXECUTAR O SCRIPT E DEPOIS VAI APAGAR O SCRIPT:
.
cd ; mkdir praticando-shellscript ; cd praticando-shellscript/ ; echo -e '#!/bin/bash\n \n# Titulo: 01-olauser.sh\n \nclear\n \nUSERL=Usuário-Linux\necho\necho Olá $USERL\n \nsleep 4\necho\necho Tchau $USERL\n \nsleep 4\necho\n \nsleep 2\nclear\n \nexit\n \n# Fim do script' > 01-olauser.sh ; chmod a+x 01-olauser.sh ; sh 01-olauser.sh ; sleep 2 ; cd .. ; unset USERL ; rm -rf praticando-shellscript/ ; echo ; pwd ; sleep 2 ; echo ; ls -t ; sleep 2 ; $USERL
.
LINUX SHELL SCRIPT IMPRIMIR SAÍDA COLORIDA:
.
Um script pode usar sequências de escape para produzir textos coloridos no terminal. As cores são representadas por códigos, temos 9 códigos:
reset = 0
black = 30
red = 31
green = 32
yellow = 33
blue = 34
magenta = 35
cyan = 36
white = 37
.
O caractere de escape para vermelho é: "\e[1;31m" após o texto em vermelho, usa "\e[0m" para resetar a cor voltando ao padrão. Substitua o código 31 por outra cor que desejar. Temos 9 códigos: 0, 30, 31, 32, 33, 34, 35, 36, 37.
.
Exemplo:
echo -e "\e[1;36m texto que vai ficar colorido \e[0m"
.
PARA IMPRIMIR UM TEXTO COLORIDO USE ESTES EXEMPLOS ABAIXO:
.
echo -e "\e[1;34m Este é o texto em azul! \e[0m"
echo -e "\e[1;30m Este é o texto em preto! \e[0m"
echo -e "\e[1;32m Este é o texto em verde! \e[0m"
echo -e "\e[1;33m Este é o texto em amarelo! \e[0m"
echo -e "\e[1;35m Este é o texto em magenta! \e[0m"
echo -e "\e[1;36m Este é o texto em cyan! \e[0m"
echo -e "\e[1;37m Este é o texto em branco! \e[0m"
.
PODEMOS IMPRIMIR TODOS ESTE TEXTOS AO MESMO TEMPO PARA TESTAR.
.
Copie o código que eu escrevi abaixo e cole no seu terminal:
.
echo -e "\e[1;34m Este é o texto em azul! \e[0m" ; sleep 3 ; echo -e "\e[1;30m Este é o texto em preto! \e[0m" ; sleep 3 ; echo -e "\e[1;32m Este é o texto em verde! \e[0m" ; sleep 3 ; echo -e "\e[1;33m Este é o texto em amarelo! \e[0m" ; sleep 3 ; echo -e "\e[1;35m Este é o texto em magenta! \e[0m" ; sleep 3 ; echo -e "\e[1;36m Este é o texto em cyan! \e[0m" ; sleep 3 ; echo -e "\e[1;37m Este é o texto em branco! \e[0m"
.
DÁ PARA CRIAR UM SHELL SCRIPT COM ISTO VEJA SÓ:
.
#!/bin/bash
clear
echo
echo -e "\e[1;34mVamos criar uma \e[1;31mpasta. \e[0m"
echo
sleep 4
mkdir pasta-teste
echo
echo -e "\e[1;30mVamos ver se a \e[1;31mpasta \e[1;30mfoi criada. \e[0m"
echo
sleep 4
ls -t
echo
sleep 3
echo -e "\e[1;32mVamos criar um \e[1;31marquivo de texto \e[1;32mvazio \e[0m"
echo
sleep 4
> texto-teste.txt ; echo ; ls -t ; echo ; sleep 5 ; echo
echo -e "\n\e[1;33mVamos \e[1;31mescrever \e[1;33me \e[1;35mmover \e[1;33mo \e[1;32mtexto-teste.txt \e[1;33mpara:\n \n\e[1;34mpasta-teste\n \e[0m"
echo
sleep 4
echo -e "Esta frase\nserá escrita\nem\ntexto-teste.txt" > texto-teste.txt ; sleep 3 ; mv texto-teste.txt pasta-teste
echo
echo -e "\n\e[1;35mEntrar em \e[1;32mpasta-teste \e[1;35me conferir o conteúdo dela \e[0m\n"
echo
cd pasta-teste/ ; echo ; ls -t ; sleep 4 ; echo ; pwd ; echo ; sleep 4
echo
echo -e "\e[1;36mCopiando \e[1;37mtexto-teste.txt \e[1;36mpara \e[1;34mtexto-teste2.txt \e[0m"
echo
sleep 4
cp texto-teste.txt texto-teste2.txt ; echo ; ls -t ; echo ; sleep 4 ; echo ; pwd ; echo ; sleep 4
echo -e "\e[1;37mFim do script. \e[1;31mPode apagar tudo \e[1;32musando o \e[1;37mmouse. \e[0m"
echo
sleep 4
echo -e "\e[1;37mOu pode executar o comando: \e[1;31mrm -rf pasta-teste\e[1;32m mas antes confere os arquivos de texto.\e[0m"
echo
sleep 4
exit
# Fim do script
.
COMANDOS MAIS USADOS EM SHELL SCRIPT NO LINUX
.
ASPAS SIMPLES ' E ASPAS DUPLAS ":
.
Aspas duplas permitem interpretar caracteres especiais.
Aspas simples desabilitam esta interpretação.
Ambas são úteis.
.
CARACTERES DE ESCAPE:
echo "Hello \"world\"!"
.
TODO SCRIPT ESCRITO PARA RODAR NO BASH COMEÇA COM:
#!/bin/bash
Após "#!/bin/bash" de um espaço entre linhas e então pode começar a digitar comandos.
.
Exemplo para executar:
#!/bin/bash
clear
echo ; date ; echo ; sleep 4
echo ; cal ; echo ; sleep 4
echo ; uptime ; echo ; sleep 4
echo ; df -h ; echo ; sleep 4
echo ; free -html ; echo ; sleep 4
echo ; whoami ; echo ; sleep 4
echo ; pwd ; echo ; sleep 4
echo ; ls -at ; echo ; sleep 4
echo ; whereis bash ; echo ; sleep 4
echo ; echo 'Este é o fim do script 01-script.sh' ; echo ; sleep 4
exit
# Fim do script
.
ESTE SCRIPT ÚTIL E INOFENSIVO ACIMA SERÁ SALVO NA PASTA HOME, A PASTA DA CASINHA, USANDO UM EDITOR DE TEXTO E TERÁ O NOME DE:
01-script.sh
.
Posso melhorar/tornar mais amigável este script acima explicando sobre cada comando:
.
#!/bin/bash
clear
echo ; echo 'Hoje é data:' ; echo ; sleep 2
echo ; date ; echo ; sleep 4
echo ; echo 'Hoje pelo calendário é:' ; echo ; sleep 2
echo ; cal ; echo ; sleep 4
echo ; echo 'Esta máquina está funcionando a:' ; echo ; sleep 2
echo ; uptime ; echo ; sleep 4
echo ; echo 'Sobre o tamanho desta pasta:' ; echo ; sleep 2
echo ; df -h ; echo ; sleep 6
echo ; echo 'Sobre a memória RAM:' ; echo ; sleep 2
echo ; free -html ; echo ; sleep 6
echo ; echo 'Você está logado como:' ; echo ; sleep 2
echo ; whoami ; echo ; sleep 4
echo ; echo 'Você está em:' ; echo ; sleep 2
echo ; pwd ; echo ; sleep 4
echo ; echo 'Neste diretório/pasta tem:' ; echo ; sleep 2
echo ; ls -at ; echo ; sleep 6
echo ; echo 'O Bash está em:' ; echo ; sleep 2
echo ; whereis bash ; echo ; sleep 4
echo ; echo 'Este é o fim do script 01-script.sh' ; echo ; sleep 4
exit
# Fim do script
.
No Linux o script deve ter permissão de execução, isto pode ser feito abrindo o terminal pelo menu do sistema e executando o comando:
chmod +x 01-script.sh
.
Depois de salvo você tem que executar o arquivo, dessa forma:
./01-script.sh
.
Viu alguma utilidade neste pequeno script?
Então siga adiante.
.
IMPORTANTE:
Para estudar shell script tem que ser como usuário normal. Se você está acessando o sistema como usuário administrador (root), saia e entre como um usuário normal. É muito perigoso estudar shell usando o superusuário, você pode danificar o sistema com um comando errado.
Ok, continuemos.
.
Para exibir um manual do bash ou mesmo do comando 'chmod', digite na linha de comando:
man bash
man chmod
.
É possível executar o arquivo mesmo sem modificar a permissão de execução, por exemplo, se for um arquivo escrito para ser executado pelo bash, usar:
sh ./"Nome do arquivo, sem aspas"
.
SHELL
É importante saber o que é um Shell.
Na linha de comandos de um shell, podemos utilizar diversos comandos um após o outro, ou mesmo combiná-los numa mesma linha.
Se colocarmos diversas linhas de comandos em um arquivo texto simples, teremos em mãos um Shell Script, ou um script em shell, já que Script é uma descrição geral de qualquer programa escrito em linguagem interpretada, ou seja, não compilada.
Outros exemplos de linguagens para scripts são o PHP, Perl, Python, JavaScript e muitos outros. Podemos então ter um script em php, um script perl e assim em diante.
Uma vez criado, um ShellScript pode ser reutilizado quantas vezes for necessário.
Seu uso, portanto, é indicado na automação de tarefas que serão realizadas mais de uma vez.
Todo sistema Unix e similares são repletos de scripts em shell para a realização das mais diversas atividades administrativas e de manutenção do sistema.
Os arquivos de lote (batch - arquivos *.bat) do Windows são também exemplos de ShellScripts, já que são escritos em linguagem interpretada e executados por um Shell do Windows, em geral o command.com ou hoje em dia o cmd.exe.
Os Shells do Unix, porém, são inumeras vezes mais poderosos que o interpretador de comandos do Windows, podendo executar tarefas muito mais complexas e elaboradas.
.
OS SCRIPTS SHELL PODEM SER AGENDADOS PARA EXECUÇÃO ATRAVÉS DA TABELA CRONTAB, ENTRE OUTRAS COISAS.
.
O shell é uma ferramenta indispensável aos administradores de sistemas Unix.
O Shell mais comum e provavelmente o que possui mais scripts escritos para ele é também um dos mais antigos e simples, o sh.
Este shell está presente em todo o sistema tipo Unix, incluído o Linux, FreeBSD, AIX, HP-UX, OpenBSD, Solaris, NetBSD, Irix, etc. Por ser o shell nativo mais comum é natural que se prefira escrever scripts para ele, tornando o script mais facilmente portável para outro sistema.
Os Shells não estão diretamente associados a um ou outro tipo de Unix, embora várias empresas comerciais tenham suas próprias versões de Shell. No software livre o Shell utilizado em um sistema em geral é exatamente o mesmo utilizado em outro. Por exemplo, o bash encontrado no Linux é o mesmo shell bash encontrado no FreeBSD e pode também facilmente ser instalado no Solaris, Windows através do Cygwin [1] ou outros sistemas Unix comerciais para passar a ser utilizado como interface direta de comandos ou como interpretador de scripts. O mesmo acontece com o tcsh e vários outros shells desenvolvidos no modelo de software livre.
.
INTERAGIR COM O USUÁRIO
.
Para o script ficar mais completo, vamos colocar uma interação mínima com o usuário, pedindo uma confirmação antes de executar os comandos.
.
#!/bin/bash
clear
echo "Vou buscar os dados do sistema. Posso continuar? [S/n] "
read RESPOSTA
test "$RESPOSTA" = "n" && exit
echo ; echo "Data e Horário:" ; echo
date
echo
echo "Uso do disco:" ; echo
df -ht
echo
echo "Usuários conectados:" ; echo
w
echo ; echo "Seu nome de login é:"
whoami
echo
exit
# Fim do script
.
O comando "read" leu o que o usuário digitou e guardou na variável RESPOSTA. Logo em seguida, o comando "test" verificou se o conteúdo dessa variável era "n". Se afirmativo, o comando "exit" foi chamado e o script foi finalizado. Nessa linha há vários detalhes importantes:
O conteúdo da variável é acessado colocando-se um cifrão "$" na frente
O comando test é útil para fazer vários tipos de verificações em textos e arquivos
O operador lógico "&&", só executa o segundo comando caso o primeiro tenha sido OK. O operador inverso é o "||"
.
MELHORAR O CÓDIGO DO SCRIPT
Com o tempo, o script vai crescer, mais comandos vão ser adicionados e quanto maior, mais difícil encontrar o ponto certo onde fazer a alteração ou corrigir algum erro. Para poupar horas de estresse, e facilitar as manutenções futuras, é preciso deixar o código visualmente mais agradável e espaçado, e colocar comentários esclarecedores.
.
#!/bin/bash
# nome-do-script - script que mostra informações sobre o sistema
# Autor: Fulano da Silva
# Pede uma confirmação do usuário antes de executar
clear
echo "Vou buscar os dados do sistema. Posso continuar? [S/n]"
read RESPOSTA
# Se ele digitou 'n', vamos interromper o script
test "$RESPOSTA" = "n" && exit
# O date mostra a data e a hora correntes
sleep 3 ; echo "Data e Horário:" ; echo
date
sleep 3
echo
# O df mostra as partições e quanto cada uma ocupa no disco
echo "Uso do disco:"
sleep 3
echo
df
echo
sleep 6
# O w mostra os usuários que estão conectados nesta máquina
echo "Usuários conectados:"
sleep 3
echo
w
sleep 3
echo
# Fim do script
.
Basta iniciar a linha com um "#" e escrever o texto do comentário em seguida. Estas linhas são ignoradas pelo shell durante a execução. O cabeçalho com informações sobre o script e seu autor também é importante para ter-se uma visão geral do que o script faz, sem precisar decifrar seu código. Também é possível colocar comentários no meio da linha # como este
.
FERRAMENTAS PARA FUNÇÕES
.
O COMANDO RETURN INFORMA O FIM DA FUNÇÃO. EXEMPLO:
MinhaFuncao(){
echo "Isto será exibido"
return
echo "Isso não será exibido, pois está depois de return"
}
MinhaFuncao
.
Se criar uma variável dentro de uma função, mesmo chamando ela fora da função, o valor da variável será exibido, pois ela será tratada como variável GLOBAL, caso tente imprimi-la, para que o valor de uma variável seja exibido somente dentro da função, precisamos usar o comando local antes da variável para que não seja exibido. Para entender isto só mesmo com exemplo na prática. Vamos a ele:
.
EU ABRO O EDITOR DE TEXTO E COLO O TEXTO ABAIXO NELE:
#!/bin/bash
# Meu comentário
VARIAVEL="Olá Mundo do Shell Script!"
echo $VARIAVEL
sleep 2
echo
echo "Vou buscar os dados do sistema. Posso continuar? [S/n] "
read RESPOSTA
test "$RESPOSTA" = "n" && exit
echo ; echo "Data e Horário:" ; echo
date
echo
echo "Uso do disco:" ; echo
df -hi
echo
echo "Usuários conectados:" ; echo
w
echo ; echo "Seu nome de login é:"
whoami
echo
ARRAY5=("Shell" "Madrugada" "Script" "Amanhece" "Linux")
echo "O ARRAY5 possui ${#ARRAY5[@]} elemento(s)"
MinhaFuncao(){
echo "Eu estou passando $# parâmetros"
#return
echo "Muitas coisas"
}
MinhaFuncao $@
echo 'Se o resultado é zero está tudo certo!'
sleep 2
echo
echo $?
exit
# Fim do script: 09-ferramentas-funcoes.sh
.
SALVO COMO: 09-ferramentas-funcoes.sh
.
DOU PODER DE EXECUÇÃO:
chmod a+x 09-ferramentas-funcoes.sh
.
EXECUTO:
sh 09-ferramentas-funcoes.sh
sh 09-ferramentas-funcoes.sh Linux Brasil GNU
.
AGORA ALTERO O SCRIPT 09-ferramentas-funcoes.sh (REMOVO A TRALHA # DE RETURN) E EXECUTO DE NOVO:
.
#!/bin/bash
# Meu comentário
VARIAVEL="Olá Mundo do Shell Script!"
echo $VARIAVEL
sleep 2
echo
echo "Vou buscar os dados do sistema. Posso continuar? [S/n] "
read RESPOSTA
test "$RESPOSTA" = "n" && exit
echo ; echo "Data e Horário:" ; echo
date
echo
echo "Uso do disco:" ; echo
df -hi
echo
echo "Usuários conectados:" ; echo
w
echo ; echo "Seu nome de login é:"
whoami
echo
ARRAY5=("Shell" "Madrugada" "Script" "Amanhece" "Linux")
echo "O ARRAY5 possui ${#ARRAY5[@]} elemento(s)"
MinhaFuncao(){
echo "Eu estou passando $# parâmetros"
return
echo $VARIAVEL
echo "Muitas coisas"
}
MinhaFuncao $@
echo 'Se o resultado é zero está tudo certo!'
sleep 2
echo
echo $?
exit
# Fim do script: 09-ferramentas-funcoes.sh
.
COPIO E COLO O COMANDO ABAIXO NO TERMINAL:
sh 09-ferramentas-funcoes.sh Amanhecer ANOITECER Estudar DORMIR
.
CONSTANTES NÃO MUDAM. EXEMPLO:
.
#!/bin/bash
MinhaFuncao(){
local OLA="Olá, mundo!"
echo "Eu estou passando $# parâmetro(s)"
return
echo $OLA
echo "Muita coisa"
}
MinhaFuncao
declare -r MinhaConstante='Estamos constantes'
echo $MinhaConstante
# Fim do 3d-script-constante.sh
.
PODER DE EXECUÇÃO:
chmod +x 3d-script-constante.sh
.
EXECUTAR O SCRIPT:
sh 3d-script-constante.sh
sh 3d-script-constante.sh LINUX BASH
.
PARA APAGAR CONSTANTES E FUNÇÕES É O MESMO PROCEDIMENTO DE APAGAR VARIÁVEIS (unset).
.
CONDIÇÕES EM SHELL SCRIPT
O Shell tem estruturas para se fazer condições. Por exemplo o comando TEST. O comando TEST é útil para fazer vários tipos de verificações em textos e arquivos, testa o conteúdo de uma string, poder ser um arquivo, uma variável, compara valores numéricos ou não. O test avalia uma determinada condição dada e se ela for verdadeira a variável $? é retornada com o valor zero (0) e se falsa o valor é 1.
.
COM O COMANDO TEST PODEMOS VER SE É UM DISPOSITOVO DE:
-b (Bloco), -c (Caractere), -d (Diretório), -e (Se existe), -f (Se é um arquivo normal), -G (O grupo do arquivo é o do usuário atual), -L (O arquivo é um link simbólico), -r (O arquivo tem permissão de leitura), -s (O tamanho é maior que zero), -nt (O arquivo é o mais recente), -ot (O arquivo é mais antigo), -w (Se o arquivo tem permissão de escrita), -x Se o arquivo tem permissão de execução), -ef (Se o arquivo é o mesmo), e por aí vai... etc;
.
Podemos usar a COMPARAÇÃO NUMÉRICA no comando test. Veja estas opções abaixo por exemplo:
.
-lt (É menor que)
-gt (É maior que)
-le (É menor igual)
-ge (É maior igual)
-eq (É igual)
-ne (É diferente)
.
COMPARAÇÃO DE STRINGS:
.
= (É igual)
!= (É diferente)
-n (É não nula)
-z (É nula)
.
OPERADORES LÓGICOS:
! (NÃO lógico)
-a (E lógico) (AND)
-o (OU lógico)
.
VAMOS EXECUTAR OS EXEMPLOS ABAIXO NO TERMINAL:
test 1 = 1 ; echo $? (É igual a...)
test 1 = 2 ; echo $? (É igual a...)
test 1 != 2 ; echo $? (É diferente de...)
test 1 != 1 ; echo $? (É diferente de...)
.
- PRATICANDO O COMANDO TEST -
.
Vamos testar se o arquivo: 08-test-script.sh existe? Se é uma pasta? Se é um arquivo normal? Execute os comandos abaixo:
touch 08-test-script.sh
ls -t
test -e 08-test-script.sh ; echo $? (Verifica se existe)
test -d 08-test-script.sh ; echo $? (Verifica se é uma pasta)
test -f 08-test-script.sh ; echo $? (Verifica se é um arquivo comum)
test -s 08-test-script.sh (Verifica se o tamanho é maior que zero)
rm -fi 08-test-script.sh
.
Exemplo:
~ $rm -fi 08-test-script.sh
rm: remover arquivo comum vazio '08-test-script.sh'? S
.
Execute os comandos abaixo:
ls -t
test -e 08-test-script.sh ; echo $?
test -d 08-test-script.sh ; echo $?
test -s 08-test-script.sh
.
SE CORRESPONDE A OPÇÃO ESCOLHIDA A RESPOSTA É ZERO. SE NÃO A RESPOSTA É 1.
.
OS SCRIPTS SHELL PODEM CONTER ESTRUTURAS DE PROGRAMAÇÃO/condição TAIS COMO:
if, them, else, elif, fi
.
ESTRUTURAS DE DECISÃO (if)
If testa um comando e não uma condição. O comando que testa condições é o test. Usamos o test junto com o if. O if é um recurso utilizado para dar sequencia em fluxos de execução baseado em decisões. Cuja sintaxe é:
- Condição Verificada é o teste que definirá se controle deve ser passado para dentro do bloco then.
- Ação são comandos a serem executados em caso verdadeiro da condição verificada.
.
OPERADORES PARA NÚMEROS
.
-eq Verifica se é igual,
-ne Verifica se é diferente,
-lt Verifica se é menor,
-gt Verifica se é maior,
-le Verifica se é menor ou igual,
-ge Verifica se é maior ou igual.
.
OPERADORES PARA TEXTO
.
!= Verifica se é diferente,
= Verifica se é igual.
.
OPERADORES LÓGICOS
.
! Lógica NOT,
-o Lógica OU, (OR) ou ||,
-a Lógica E, (AND) ou &&.
.
OPERADOR PARA arquivos/
.
-d Verifica se é diretório,
-f Verifica se é arquivo,
-e Verifica se existe.
.
EXEMPLOS A SEREM EXECUTADOS:
.
#!/bin/bash
# Este script é para saber se uma variável é maior
# ou menor # do que 10 e mostrar uma mensagem na
# tela informando.
# No fim do script fechamos a condição com fi.
# Não esqueça de fechar a condição com fi, se não dá
# erro.
VARIAVEL=9;
if test "$VARIAVEL" -gt 10
then
echo "é maior que 10"
else
echo "é menor que 10"
fi
# Fim do script: 07w-script-if.sh
.
COPIE E COLE O CÓDIGO ABAIXO NO TERMINAL E VEJA O RESULTADO:
.
echo -e '#!/bin/bash\n \nVARIAVEL=9;\nif test "$VARIAVEL" -gt 10\n then\n echo "é maior que 10"\nelse\n echo "é menor que 10"\nfi\n \n# Fim do script: 07w-script-if.sh' > 07w-script-if.sh ; chmod a+x 07w-script-if.sh ; sh 07w-script-if.sh
.
RESULTADO:
é menor que 10
.
MAIS UM EXEMPLO IF, THEN, ELSE, ELIF, FI:
.
No exemplo abaixo a variável é igual a 10.
Neste caso tem que usar o "elif" se não vai dar erro.
Sem o "elif" o script vai dizer que é MENOR que 10.
É mais ou menos o seguinte, se (if) não é (then) maior, ou (elif) é (then) igual ou então (else) é menor. Fim (fi).
.
EXECUTE NO TERMINAL O SHELL SCRIPT EXEMPLO ABAIXO:
.
#!/bin/bash
VARIAVEL=10;
if test "$VARIAVEL" -gt 10
then
echo "é maior que 10"
elif test "$VARIAVEL" -eq 10
then
echo "é igual a 10"
else
echo "é menor que 10"
fi
# Fim do script:
# 08kw-script-if-then-else-elif-fi.sh
.
RESULTADO:
~ $sh 08kw-script-if-then-else-elif-fi.sh
é igual a 10
~ $
.
SE A VARIÁVEL FOSSE 11 EXEMPLO:
.
#!/bin/bash
VARIAVEL=11;
if test "$VARIAVEL" -gt 10
then
echo "é maior que 10"
elif test "$VARIAVEL" -eq 10
then
echo "é igual a 10"
else
echo "é menor que 10"
fi
# Fim do script:
# 03kw-script-if-then-else-elif-fi.sh
.
O RESULTADO É:
~ $sh 03kw-script-if-then-else-elif-fi.sh
é maior que 10
.
COPIE E COLE O CÓDIGO ABAIXO NO TERMINAL E VEJA O RESULTADO:
echo -e '#!/bin/bash\nVARIAVEL=11;\nif test "$VARIAVEL" -gt 10\nthen\necho "é maior que 10"\nelif test "$VARIAVEL" -eq 10\nthen\necho "é igual a 10"\nelse\necho "é menor que 10"\nfi\n# Fim do script:\n# 03kw-script-if-then-else-elif-fi.sh' > 03kw-script-if-then-else-elif-fi.sh ; chmod a+x 03kw-script-if-then-else-elif-fi.sh ; sh 03kw-script-if-then-else-elif-fi.sh
.
Consegue entender (ler) o código acima e sabe o que ele faz?
.
IF VEM ACOMPANHADO DO THEN
ELIF VEM ACOMPANHADO DO THEN
ELSE E O SCRIPT TERMINA COM FI
.
EXECUTE ESTE EXEMPLO NO TERMINAL:
.
#!/bin/bash
# Uso de Estrutura de Decisão
clear
echo 'opções'
echo '======'
echo ' -> Data do Sistema'
echo ' -> Uso do Sistema'
read opcao
if [ "$opcao" -eq 1 ]
then
echo 'Data do sistema: ' && date
elif [ "$opcao" -eq 2 ]
then
echo 'Uso do disco: ' && df -Th
fi
# Fim do script: 08cw-script-if.sh
.
PODEMOS CRIAR UMA FUNÇÃO
.
#!/bin/bash
MinhaFuncao(){
VARIAVEL=$1;
if test "$VARIAVEL" -gt 10
then
echo "é maior que 10"
elif test "$VARIAVEL" -eq 10
then
echo "é igual a 10"
else
echo "é menor que 10"
fi
}
MinhaFuncao $1
# Fim do script:
# 09ks-funcao-if-then-else-elif-fi.sh
.
JÁ SABE OS PROCEDIMENTOS. EXECUTE O SCRIPT ACIMA ASSIM:
sh 09ks-funcao-if-then-else-elif-fi.sh 8
bash 09ks-funcao-if-then-else-elif-fi.sh 19
./09ks-funcao-if-then-else-elif-fi.sh 868
sh 09ks-funcao-if-then-else-elif-fi.sh 2
.
ESTRUTURAS DE REPETIÇÃO (for) (while)
.
ESTRUTURA DE REPETIÇÃO for:
Permite que ações de iteração sejam executadas sobre determinados comandos ou variáveis até que a condição seja satisfeita.
.
# !/bin/bash
clear
echo "DIAS DA SEMANA"
for dia in seg ter qua qui sex sab dom
do
echo "$dia"
done
# Fim do script 7s-etrut-repet-for-while.sh
.
Resultado:
DIAS DA SEMANA
seg
ter
qua
qui
sex
sab
dom
~ $
.
ESTRUTURA DE REPETIÇÃO while:
Em situações onde sabemos até onde o loop irá realizar uma contagem o ideal é usar o for entretanto em cenarios onde a iteração deve cessar somente após se satisfazer uma condição o uso do laço while é mais indicado. Ex:
.
# /bin/bash
clear
var=1
while [ $var -le 7 ]
do
echo "Valor de var: $var"
var=$((var+1))
done
# Fim do script 7g-estr-rep-while.sh
.
Resultado:
Valor de var: 1
Valor de var: 2
Valor de var: 3
Valor de var: 4
Valor de var: 5
Valor de var: 6
Valor de var: 7
~ $
.
UM USO INTERESSANTE DO WHILE PARA VER O LOOP FUNCIONANDO:
.
Por vezes queremos acompanhar a cópia de um arquivo na console do Linux e o caminho mais normal é abrir um outro terminal e ficar repetitivamente executando o comando ls, ou algum outro comando, haja dedo para apertar a seta pra cima e enter, seta pra cima e enter, seta pra cima e enter. Podemos resolver isto usando o comando while de forma bem simples, por exemplo se quisermos executar um ls por várias vezes, podemos fazer assim:
.
OBS: Execute um de cada vez, parar o comando com Ctrl+C.
.
1
while true; do ls; done;
2
while true; do ls; echo; sleep 5; done;
3
while true; do ls; echo; sleep 5; clear; done;
.
ISTO VAI EXECUTAR O COMANDO LS ATÉ PRESSIONARMOS CTRL + C PARA QUEBRÁ-LO.
.
FUNÇÕES E ARGUMENTOS
.
Ex:
.
# !/bin/bash
# REALIZAR BACKUP DO DIR
echo -e " \033[1;33m Digite o caminho de origem.: \033[0m "
read DIR_ORIGEM
clear
echo -e " \033[1;34m Digite o caminho de destino.: \033[0m "
read DIR_DESTINO
clear
verifica_argumentos(){
if [ $# -lt 1 ];
then
echo "Faltou informar um dos argumentos (parametros) necessarios!"
exit 1
fi
}
copia_arquivos(){
verifica_argumentos
clear
echo "Realizando backup..."
#Verificando se o dir de destino existe
if ! [ -d $DIR_DESTINO ]
then
mkdir $DIR_DESTINO
echo "Diretorio de Destino Criado"
fi
#COPIANDO ARQUIVOS
for arq in `ls $DIR_ORIGEM`
do
cp /$DIR_ORIGEM/$arq $DIR_DESTINO/$arq.bak
done
}
copia_arquivos
# Fim do script 08b-funcoes-e-arg.sh
.
DEFINIÇÕES DE VARIÁVEIS E ESCOPO DESTAS
.
Variáveis são definidas pela nomenclatura NOME_VARIAVEL="Valor da Variável". O valor pode ser tanto numérico quanto texto.
.
Nome="Joel"
.
Se quisermos acessá-la, basta fazer referência a ela com o caractere $ (cifrão) antes do nome: o comando echo $Nome, por exemplo, retornará a palavra "Joel".
.
Se quiser sabe informações sobre os sistemas de arquivo nos quais cada ARQUIVO reside ou, por padrão, sobre todos os sistemas de arquivos posso abrir um terminal e digitar:
VarInfo="df -h"
.
Depois digito no terminal "$VarInfo" sem aspas.
.
VARIÁVEIS DE AMBIENTE
.
As variáveis de ambiente independem da definição do usuario. Elas são criadas automaticamente, no momento em que se faz o login no sistema.
.
Ex:
PATH: define diretórios de procura por programas executados no shell;
USER: informa o nome do usuário do shell;
HOME: informa o caminho do diretório home do usuário;
PWD: diretório atual;
.
As variáveis são a base de qualquer script. É dentro delas que os dados obtidos durante a execução do script serão armazenados. Para definir uma variável, basta usar o sinal de igual "=" e para ver seu valor, usa-se o "echo":
.
Execute estes comandos abaixo no terminal:
.
VARIAVEL="um dois tres"
echo $VARIAVEL
echo $VARIAVEL $VARIAVEL
.
Para remover a variável acima:
unset VARIAVEL
.
Teste:
echo $VARIAVEL
.
É possível armazenar a saída de um comando dentro de uma variável. Ao invés de aspas, o comando deve ser colocado entre "$(...)", execute no terminal os comandos abaixo:
HOJE=$(date)
echo "Hoje é: $HOJE"
sleep 2
unset HOJE
echo $HOJE
HOJE=$(ls)
echo "O conteúdo desta pasta tem: $HOJE"
sleep 2
unset HOJE
echo $HOJE
HOJE=$(free -hmt)
echo "Informando sobre a memória desta máquina: $HOJE"
sleep 2
unset HOJE
echo $HOJE
.
EXEMPLOS DE USO DO SHELL SCRIPT:
.
Apagar arquivos velhos - Apagar periodicamente arquivos mais velhos que 30 dias do diretório /tmp:
.
#!/bin/bash
cd /tmp
find . -type f -mtime +30 -delete
# Fim do script
.
Este seria o conteúdo de um shell script que sempre que fosse executado apagaria arquivos com data de modificação maior que 30 dias a partir do diretório /tmp do sistema de arquivos.
.
Notem que ele é nada mais do que uma associação de 2 comandos (cd e find) em um arquivo para facilitar a repetição da tarefa. Este poderia ser, por exemplo, o conteúdo do arquivo /bin/limpatmp.sh e poderíamos chamar este script pela linha de comandos sempre que desejássemos repetir esta ação:
.
$ limpatmp.sh
.
Onde o símbolo "$" representa o prompt de comandos. Do ponto de vista do usuário este seria mais um comando disponível para uso.
.
Os scripts em shell são também muito empregados junto à inicialização do sistema (para auto-iniciar tarefas) ou como mini-aplicativos, que facilitam tarefas dos usuários, tais como montagem de dispositivos, menus de ajuda, etc.
.
Sua primeira linha obrigatoriamente começa com um "#!" (que não se deve confundir com um comentário qualquer, pois realmente é uma exceção; este par se chama, em inglês, de shebang), informando diretamente ao núcleo (kernel) qual interpretador ele deverá usar, juntamente com seu caminho, de acordo com a necessidade de cada caso. Exemplo:
#!/bin/bash
.
Em seguida, são adicionados os comandos desejados, um por linha, ou separados por ponto e vírgula. Exemplo:
.
mount -t reiserfs /dev/hda1 /mnt/hda1
ls /mnt/hda1
cp -r /mnt/hda1/* /home/user/backup
umount /dev/hda1
.
Por fim, dá-se a permissão de execução a este arquivo de texto simples ("chmod +x arquivo").
.
DATA ANTERIOR
.
#!/bin/bash
# Função em Bash para retornar a data anterior, levando em conta o mês e ano.
fn_data_anterior()
{
DIA=$D
MES=$M
ANO=$A
# Dado DIA, MES e ANO numéricos, obtém a data do dia anterior
DIA=`expr $DIA - 1`
if [ $DIA -eq 0 ]; then
MES=`expr $MES - 1`
if [ $MES -eq 0 ]; then
MES=12
ANO=`expr $ANO - 1`
fi
DIA=`cal $MES $ANO`
DIA=`echo $DIA | awk '{ print $NF }'`
fi
}
ano=`date +%Y`;
mes=`date +%m`;
let dia=10\#`date +%d`;
if (( $dia". Para guardar a saída do comando anterior no arquivo "saida", basta fazer:
cat /etc/passwd | grep root | cut -c1-10 > saida
cat saida
.
REPETINDO: O COMANDO TEST
.
O canivete suíço dos comandos do shell é o "test", que consegue fazer vários tipos de testes em números, textos e arquivos. Ele possui várias opções para indicar que tipo de teste será feito, algumas delas:
-lt Núm. é menor que (LessThan)
-d É um diretório
-gt Núm. é maior que (GreaterThan)
-f É um arquivo normal
-le Núm. é menor igual (LessEqual)
-r O arquivo tem permissão de leitura
-ge Núm. é maior igual (GreaterEqual)
-s O tamanho do arquivo é maior que zero
-eq Núm. é igual (EQual)
-w O arquivo tem permissão de escrita
-ne Núm. é diferente (NotEqual)
-nt O arquivo é mais recente (NewerThan)
= String é igual
-ot O arquivo é mais antigo (OlderThan)
!= String é diferente
-ef O arquivo é o mesmo (EqualFile)
-n String é não nula
-a E lógico (AND)
-z String é nula
-o OU lógico (OR)
.
SCRIPT QUE TESTA ARQUIVOS
Tente fazer um script "testa-arquivos", que pede ao usuário para digitar um arquivo e testa se este arquivo existe. Se sim, diz se é um arquivo ou um diretório.
.
CONCEITOS MAIS AVANÇADOS:
.
CASE
.
O CASE É PARA CONTROLE DE FLUXO, TAL COMO É O IF. Mas enquanto o if testa expressões não exatas, o case vai agir de acordo com os resultados exatos. Abre com case e fecha com esac. Se nao fizer assim dá erro. Vejamos uns exemplos:
.
case $VARIAVEL in
10) echo "é 10" ;;
9) echo "é 9" ;;
7|8) echo "é 7 ou 8" ;;
*) echo "é menor que 6 ou maior que 10" ;;
esac
.
case $1 in
parametro1) comando1 ; comando2 ;;
parametro2) comando3 ; comando4 ;;
*) echo "Você tem de entrar com um parâmetro válido" ;;
esac
.
Aqui acima aconteceu o seguinte: o case leu a variável $1 (que é o primeiro parâmetro passado para o programa), e comparou com valores exatos. Se a variável $1 for igual à “parametro1″, então o programa executará o comando1 e o comando2; se for igual à “parametro2″, executará o comando3 e o comando4, e assim em diante. A última opção (*), é uma opção padrão do case, ou seja, se o parâmetro passado não for igual a nenhuma das outras opções anteriores, esse comando será executado automaticamente. Com o case fica muito mais fácil criar uma espécie de “menu” para o shell script do que com o if.
.
EXEMPLO DE SCRIPT PARA EXECUTAR NO TERMINAL:
#!/bin/bash
# Aprendendo shell script
MinhaFuncao (){
case $1 in
10) echo "é 10" ;;
9) echo "é 9" ;;
7|8) echo "é 7 ou 8" ;;
*) echo "é menor que 6 ou maior que 10" ;;
esac
}
MinhaFuncao $1
# Fim script 07hr-funcao-case-esac.sh
.
RESULTADOS:
~ $sh 07hr-funcao-case-esac.sh 8
é 7 ou 8
~ $sh 07hr-funcao-case-esac.sh 15
é menor que 6 ou maior que 10
~ $sh 07hr-funcao-case-esac.sh 9
é 9
.
REPETINDO: If, for e while
.
Assim como qualquer outra linguagem de programação, o shell também tem estruturas para se fazer condicionais e loop. As mais usadas são if, for e while.
.
ATÉ ESTE PONTO EM QUE ESTAMOS, JÁ SABEMOS O BÁSICO, O NECESSÁRIO PARA SE FAZER UM SCRIPT DE FUNCIONALIDADE MÍNIMA. E ESTE MÍNIMO PODE FAZER COISAS INCRÍVEIS. AVANÇAR:
case, if, for e while.
.
Comando if:
.
Comando if - else:
if ( condição ) {
comandos a serem executados se a condição for verdadeira;
}
else {
comandos a serem executados se a condição for falsa;
}
.
COMANDOS DE CONTROLE DE FLUXO
.
Controle de fluxo são comandos que vão testando algumas alternativas, e de acordo com essas alternativas, vão executando comandos. Um dos comandos de controle de fluxo mais usados é certamente o if, que é baseado na lógica “se acontecer isso, irei fazer isso, se não, irei fazer aquilo”.
.
EXEMPLO DE UM PEDAÇO DE CÓDIGO:
.
if [ -e $linux ]
then
echo 'A variável $linux existe.'
else
echo 'A variável $linux não existe.'
fi
.
O que este pedaço de código faz? O if testa a seguinte expressão: Se a variável $linux existir, então (then) ele diz que que existe com o echo, se não (else), ele diz que não existe. O operador "-e" é pré-definido, e você pode encontrar a listagem dos operadores na tabela:
.
-eq Igual
-ne Diferente
-gt Maior
-lt Menor
-o Ou
-d Se for um diretório
-e Se existir
-z Se estiver vazio
-f Se conter texto
-o Se o usuário for o dono
-r Se o arquivo pode ser lido
-w Se o arquivo pode ser alterado
-x Se o arquivo pode ser executado
.
Exemplo de uso do if:
.
if [COMANDOS]
then
comandos
else
comandos
fi
# Fim do script
.
Ex:
for VAR in LISTA
do
comandos
done
# Fim do script
.
Ex:
while COMANDO
do
comandos
done
# Fim do script
.
REPETINDO: Diferente de outras linguagens, o if testa um comando e não uma condição. Porém como já conhecemos qual o comando do shell que testa condições, é só usá-lo em conjunto com o if. Por exemplo, para saber se uma variável é maior ou menor do que 10 e mostrar uma mensagem na tela informando:
.
Ex:
if test "$VARIAVEL" -gt 10
then
echo "é maior que 10"
else
echo "é menor que 10"
fi
# Fim do script
.
Há um ATALHO PARA O TEST , que é o comando [. Ambos são exatamente o mesmo comando, porém usar o [ deixa o if mais PARECIDO COM O FORMATO TRADICIONAL de outras linguagens:
.
O test pode ser escrito assim:
test 1 = 1 ; echo $?
test 1 != 1 ; echo $?
.
Ou assim:
[ 1 = 1 ] ; echo $?
[ 1 != 1 ] ; echo $?
.
Execute os comandos acima no terminal.
.
O Resultado é:
~ $test 1 = 1 ; echo $?
0
~ $test 1 != 1 ; echo $?
1
~ $[ 1 = 1 ] ; echo $?
0
~ $[ 1 != 1 ] ; echo $?
1
~ $
.
EXEMPLO A SER EXECUTADO:
.
#!/bin/bash
VARIAVEL=17;
if [ "$VARIAVEL" -gt 10 ]
then
echo "é maior que 10"
elif [ "$VARIAVEL" -eq 10 ]
then
echo "é igual a 10"
else
echo "é menor que 10"
fi
# Fim do script 06r-atalho-test.sh
.
Resultado:
~ $sh 06r-atalho-test.sh
é maior que 10
.
OUTRO EXEMPLO A SER EXECUTADO:
.
#!/bin/bash
VARIAVEL=4;
if [[ "$VARIAVEL" -gt 10 ]];
then
echo "é maior que 10"
elif [[ "$VARIAVEL" -eq 10 ]];
then
echo "é igual a 10"
else
echo "é menor que 10"
fi
# Fim do script 07r-atalho-test.sh
.
Resultado:
~ $sh 07r-atalho-test.sh
é menor que 10
.
Se usar o [, também é preciso fechá-lo com o ], e sempre devem ter espaços ao redor. É recomendado evitar esta sintaxe para diminuir suas chances de erro.
.
Percebeu que neste ponto a gente está sabendo usar de verdade TEST IF THEN ELIF ELSE FI?
.
COMANDO WHILE
.
O while é um laço que é executado enquanto um comando retorna OK. Novamente o test é bom de ser usado. Por exemplo, para segurar o processamento do script enquanto um arquivo de lock não é removido:
.
Ex:
while test -f /tmp/lock
do
echo "Script travado..."
sleep 1
done
# Fim do script
.
O COMANDO FOR
.
E por fim, o "for" percorre uma lista de palavras, pegando uma por vez:
.
Ex:
for numero in um dois três quatro cinco
do
echo "Contando: $numero"
done
# Fim do script
.
Uma ferramenta muito útil para usar com o "for" é o "seq", que gera uma seqüência numérica.
.
Para fazer o loop andar 10 passos, pode-se fazer:
for passo in $(seq 10)
.
O mesmo pode ser feito com o while, usando um contador:
.
i=0
while test $i -le 10
do
i=$((i+1))
echo "Contando: $i"
done
# Fim do script
.
LOOPS EM SHELL QUANDO USAR?
.
Precisamos digitar um código talvez com ligeira mudança. Para não ter que repetir a tarefa digitando o código 20 vezes ou mais, usamos loops. Podemos usar vários loops. Tem pelo menos tres tipos de loops para o comando FOR por exemplo.
.
Exemplos abaixo:
.
for ((i=0;i 01-while1.sh ; chmod a+x 01-while1.sh ; ./01-while1.sh
.
Exemplo:
.
~ $cd ; mkdir pasta-while-loop ; cd pasta-while-loop/ ; echo -e '#!/bin/bash\n \nn=1\n \nwhile [ $n -le 5 ]\ndo\necho "Este é o loop $n"\n(( n++ ))\ndone' > 01-while1.sh ; chmod a+x 01-while1.sh ; ./01-while1.sh
Este é o loop 1
Este é o loop 2
Este é o loop 3
Este é o loop 4
Este é o loop 5
pasta-while-loop $
.
EXECUTE O SCRIPT ABAIXO:
.
#!/bin/bash
# Aprendendo loops Shell Script
# Nome: 06s-loop-while.sh
_INPUT_STRING="Olá"
while [[ "$_INPUT_STRING" != "tchau" ]]
do
echo "Você deseja ficar aqui ?"
read _INPUT_STRING
if [[ $_INPUT_STRING = 'tchau' ]]; then
echo "Você disse Tchau"
else
echo "Você ainda deseja ficar aqui"
fi
done
# Fim do 06s-loop-while.sh
.
Resultado:
~ $sh 06s-loop-while.sh
Você deseja ficar aqui ?
Sim
Você ainda deseja ficar aqui
Você deseja ficar aqui ?
Claro
Você ainda deseja ficar aqui
Você deseja ficar aqui ?
Tchau
Você ainda deseja ficar aqui
Você deseja ficar aqui ?
tchau
Você disse Tchau
~ $
.
O loop serve para scripts avançados, redes de computadores, e outros.
.
CRIE SEU PRÓPRIO EPUB USANDO O PROGRAMA SIGIL
.
LINUX COMANDOS DE MANIPULAÇÃO DE ARQUIVOS PARA USAR EM SHELL SCRIPT
.
Crie uma pasta, abra o terminal nesta tua pasta criada e execute:
.
ls -t -a -h -l
pwd
cd ..
ls -a
pwd
cd -
ls -t
pwd
touch nome-do-arquivo-a-ser-criado1.txt nome2.txt
ls -t
cat nome2.txt
echo 'Olá Mundo!' > nome2.txt
cat nome2.txt
ls ; echo ; echo "E ..." ; sleep 4 ; echo ; ls -t
clear
mkdir pasta-teste
ls -a
ls -t ; echo
rmdir pasta-teste
ls -t ; pwd
mkdir -p pasta-mama/pasta-filha
ls -t ; echo
> nome-do-arquivo-a-ser-criado3.txt ; > nome4.txt
ls -at ; echo
pwd
cp nome2.txt nome3.txt
ls -t ; echo
mv nome2.txt nome1.txt
ls -t
find -name nome2.txt
find -name nome3.txt
find -name nome1.txt
mv nome1.txt pasta-mama/
find -name nome1.txt
find -name nome3.txt
rm nome3.txt
find -name nome3.txt
ls -t
pwd
find nome-do-arquivo-a-ser-criado3.txt
rm nome-do-arquivo-a-ser-criado3.txt
ls -t
rm nome4.txt nome-do-arquivo-a-ser-criado1.txt
ls -t ; echo
clear
ls
cd pasta-mama/
cd ..
pwd
ls
cd -
ls ; echo
echo -e 'Este texto\n \né do arquivo\n \nnome1.txt\n' >> nome1.txt
cat nome1.txt
ls
mv nome1.txt pasta-filha/
ls ; echo
mkdir pasta-bro
ls
cd pasta-filha/
> texto-filha.txt
ls -t
echo -e "\n \nEste texto\n \nEstá escrito em\n \ntexto-filha.txt!" > texto-filha.txt
cat texto-filha.txt
echo -e "\n \nEste texto\n \nSobreescreve\n \ntexto-filha.txt!" > texto-filha.txt
cat texto-filha.txt
echo -e "\n \nEste texto\n \nSerá adicionado a\n \ntexto-filha.txt\n" >> texto-filha.txt
cat texto-filha.txt
ls -t
cat nome1.txt
cp nome1.txt nome8.txt
clear
ls -t
cat nome8.txt
cd ..
ls
rm -rf pasta-filha/
ls
rmdir pasta-bro/
ls
cd ..
pwd
ls
rmdir pasta-mama/
ls
clear
pwd
echo -e 'L1ee\n L2nn\nL3cc\nL4yy\nL5rr\nL6ii\nL7hh\n L8jj\nL9ss\n L10mm\n L11ww\nL12oo\n L13ff' > 09-texto_teste.txt
mkdir 09-texto_teste ; mv 09-texto_teste.txt 09-texto_teste/ ; cd 09-texto_teste/ ; ls -c
cat 09-texto_teste.txt
head -5 09-texto_teste.txt
head -2 09-texto_teste.txt
tail -6 09-texto_teste.txt
tail -3 09-texto_teste.txt
head -5 09-texto_teste.txt | tail
tail -6 09-texto_teste.txt | head
wc -m 09-texto_teste.txt
wc -w 09-texto_teste.txt
wc 09-texto_teste.txt
more 09-texto_teste.txt
cd ..
rm -r 09-texto_teste/
ls -t
clear
exit
.
Criação/backup de/em links com ln:
ln -s
ln -b
ln -i
.
COMANDOS DE COMPACTAÇÃO / DESCOMPACTAÇÃO
.
TAR
Armazena ou extrai arquivos e diretórios dentro de um único arquivo ou dispositivo.
.
Sintaxe: tar [opções] arquivos_ou_diretórios
Opções:
-c :: cria um novo arquivo .tar e adiciona a ele os arquivos especificados
-x :: retira os arquivos agrupados no arquivo .tar
-f :: indica que o destino é um arquivo em disco e não uma fita magnética
-v :: exibe o nome de cada arquivo processado
-Z :: compacta ou descompacta arquivos utilizando o comando compress
-z :: compacta ou descompacta arquivos utilizando o comando gzip
-j :: compacta ou descompacta arquivos utilizando o comando bzip2
-M :: múltiplos volumes
-b n :: define o tamanho do bloco de dados utilizado pelo tar (n*512 bytes)
.
Exemplos:
1. Gera um arquivo de backup do diretório "documentos1":
tar -cvf documentos.tar documentos1
2. Exibe o conteúdo do arquivo "documentos.tar":
tar -tvf documentos.tar
3. Extrai o conteúdo do arquivo "documentos.tar":
tar -xvf documentos.tar
5. Gera um arquivo de backup compactado com bzip2 do diretório "documentos1":
tar -cvjf memorandos.tar.bz2 documentos1
6. Divide em vários disquetes o arquivo "documentos.tar.bz2":
tar -cvMf /dev/fd0 /operftp/documentos.tar.bz2
7. Extrai o arquivo de backup armazenado no disquete:
tar -xvMf /dev/fd0
.
CPIO
Executa funções de arquivamento de dados.
.
Sintaxe: cpio [opções]
Opções:
-o :: lê nomes de arquivos da entrada padrão e os copia para a saída padrão com a informação necessária para a sua recuperação posterior com o comando: cpio -i
-i :: lê da entrada padrão um arquivo criado pelo comando cpio -o e extrai os arquivos armazenados
-v :: exibe o nome de cada arquivo processado
.
Exemplos:
1. Copia todos os arquivos mencionados em "lista.txt" para o arquivo "backup.cpio":
cpio -o /operftp/lista.txt > /operftp/backup.cpio
2. Extrai todos os arquivos armazenados em "backup.cpio":
cpio -i procedimento.zip
.
COMPRESS
Compacta um ou mais arquivos utilizando a compactação Lempel-Ziv.
Sintaxe: compress [opções] arquivos
Opções:
-c :: grava o arquivo compactado na saída padrão e retém o arquivo original
-d :: descompacta o arquivo
-r :: compacta recursivamente arquivos em todos os subdiretórios
Exemplos:
compress documentos.tar
$ compress -d documentos.tar.Z
.
UNCOMPRESS
Descompacta um ou mais arquivos que tenham sido compactados com o comando compress.
Sintaxe: uncompress [opções] arquivos
Opções:
-c :: grava o resultado na saída padrão e retém o original
-r :: descompacta recursivamente arquivos em todos os subdiretórios
Exemplo:
uncompress documentos.tar.Z
.
GZIP
Compacta um ou mais arquivos.
Sintaxe: gzip [opções] arquivos
Opções:
-c :: grava o arquivo compactado na saída padrão e retém o arquivo original
-d :: descompacta arquivo. O mesmo que gunzip
-f :: sobrescreve arquivos já existentes
-h :: mensagem de ajuda
-l :: lista o conteúdo de um arquivo compactado
-t :: testa a integridade do arquivo compactado
-n :: não salva o nome original
-r :: compacta recursivamente arquivos em todos os subdiretórios
-L :: exibe a licença do comando
Exemplos:
gzip documentos.tar
$ gzip -d documentos.tar.gz
.
GUNZIP
Descompacta arquivos compactados pelos comandos gzip e compress. Utiliza as mesmas opções de gzip.
Sintaxe: gunzip [opções] arquivos
Exemplo:
gunzip documentos.tar.gz
.
BZIP2
Compacta um ou mais arquivos.
Sintaxe: bzip2 [opções] arquivos
Opções:
-z :: força a compressão
-c :: grava na saída padrão
-t :: testa a integridade do arquivo compactado
-f :: sobrescreve arquivos já existentes
-d :: descompacta arquivos. O mesmo que bunzip2
-k :: não apaga os arquivos de entrada
-L :: licença do comando
Exemplos:
bzip2 documentos.tar
$ bzip2 -d documentos.tar.bz2
.
BUNZIP2
Descompacta arquivos compactados pelos comandos gzip ou compress. Utiliza as mesmas opções de bzip2.
Sintaxe: bunzip2 [opções] arquivos
Exemplo:
bunzip2 documentos.tar.bz2
.
ZIP
Compacta um ou mais arquivos.
Sintaxe: zip [opções] arquivo-destino arquivo-origem
Opções:
-e :: permite encriptar o conteúdo de um arquivo ZIP através de senha. A senha será pedida no momento da compactação
-m :: apaga os arquivos originais após a compactação
-r :: compacta recursivamente arquivos em todos os subdiretórios
Exemplos:
zip documentos.zip *.txt
$ zip -r documentos.zip /usr/*.txt
.
UNZIP
Descompacta arquivos compactados pelo comando zip.
Sintaxe: unzip [opções] arquivo.zip arquivos-origem [diretório]
Opções:
-l :: exibe os arquivos existentes dentro do arquivo ZIP
-d :: diretório onde os arquivos serão descompactados
-o :: substitui arquivos existentes sem perguntar
Exemplos:
unzip documentos.zip
$ unzip documentos.zip -d /operftp
.
ZCAT, ZMORE, ZLESS, BZ2CAT
Visualiza o conteúdo de um arquivo texto compactado, sem precisar descompactar o arquivo.
Os comandos zcat, zless e zmore funcionam da mesma forma que cat, less e more. A única diferença, é que esses comandos podem ler diretamente arquivos compactados com gzip ou compress sem precisar descompactar os arquivos.
.
Exemplos:
.
zcat nome_arquivo
zless nome_arquivo
zmore nome_arquivo
bz2cat nome_arquivo
.
Linux permissoes de pastas e arquivos
.
As permissões são usadas para definir quem pode acessar determinados arquivos ou diretórios, assim mantendo segurança e organização em sistemas e redes. Cada arquivo ou pasta tem 3 permissões:
(Usuário Dono) (Grupo Dono) (outros)
.
Usuário dono: é o proprietário do arquivo. Grupo Dono: é um grupo, que pode conter vários usuários. Outros: se encaixam os outros usuários em geral. O comando "ls -lh" faz uma listagem longa e detalhada no diretório onde eu estiver com o terminal aberto.
.
PARA ENTENDER AS PERMISSÕES DE PASTAS E ARQUIVOS, VOU FAZER O SEGUINTE:
.
Abro o terminal pelo menu do sistema. Não sou root, sou um usuário comum com alguns poderes administrativos, mas o prompt do terminal não está em root (#) está ($).
.
CRIO UMA PASTA COM O COMANDO:
mkdir pasta-estudo-permissoes
.
ENTRO NA PASTA COM O COMANDO:
cd pasta-estudo-permissoes/
.
CRIO UM ARQUIVO DE TEXTO CHAMADO estudo-permissoes.txt COM O COMANDO:
> estudo-permissoes.txt
.
CRIO OUTRO ARQUIVO COM O COMANDO:
touch permissoes-estudos.txt
.
DIGITO:
ls -lh
.
O RESULTADO É:
pasta-estudo-permissoes $ls -lh
total 0
-rw-rw-r-- 1 user user 0 mar 8 05:15 estudo-permissoes.txt
-rw-rw-r-- 1 user user 0 mar 8 05:16 permissoes-estudos.txt
.
AS PERMISSÕES DE ARQUIVOS SÃO INFORMADAS A MIM POR 5 CARACTERES. SÃO ELES:
r (significa leitura ), w (significa escrita ), x (significa execução ), - (hífen), d (indica que é uma pasta/diretório)
.
A PERMISSÃO DE ARQUIVOS E PASTAS ESTÁ DIVIDIDA EM QUATRO PARTES POR EXEMPLO:
Parte 1: -, Parte 2: rw-, Parte 3: r--, Parte 4: r--
.
NO TERMINAL ESTAS QUATRO PARTES SERÃO VISTAS ASSIM:
-rw-r--r--
.
EXEMPLO:
-rw-rw-r-- 1 user user 0 mar 8 05:15 estudo-permissoes.txt
.
Parte 1 (-)
hífen: o caractere "-" no início da sequência indica que aquele é um arquivo comum. Caso contrário, indica que a permissão de escrita, leitura ou execução está negada.
.
Parte 2 (rw-)
r: leitura permitida do arquivo ou diretório
.
w: permite editar um arquivo ou modificar o conteúdo de um diretório
.
hífen: o caractere "-" no início da sequência indica que aquele é um arquivo comum. Caso contrário, indica que a permissão de escrita, leitura ou execução está negada.
.
Parte 3 (r --)
r: leitura permitida do arquivo ou diretório
.
hífen: o caractere "-" no início da sequência indica que aquele é um arquivo comum. Caso contrário, indica que a permissão de escrita, leitura ou execução está negada.
.
hífen: o caractere "-" no início da sequência indica que aquele é um arquivo comum. Caso contrário, indica que a permissão de escrita, leitura ou execução está negada.
.
Parte 4 (r--)
r: leitura permitida do arquivo ou diretório
.
hífen: o caractere "-" no início da sequência indica que aquele é um arquivo comum. Caso contrário, indica que a permissão de escrita, leitura ou execução está negada.
.
hífen: o caractere "-" no início da sequência indica que aquele é um arquivo comum. Caso contrário, indica que a permissão de escrita, leitura ou execução está negada.
.
EU POSSO ALTERAR AS PESMISSÕES DESTES ARQUIVOS USANDO CHMOD.
.
O CHMOD É UM COMANDO QUE ALTERA AS PERMISSÕES DE ARQUIVOS E DIRETÓRIOS.
.
APRENDER COMO INTERPRETAR AS PERMISSÕES AJUDA A USAR O COMANDO CHMOD, POIS QUE ESSE COMANDO TRABALHA COM UMA SINTAXE SEMELHANTE.
.
A "FÓRMULA" DE USO MAIS SIMPLES DO CHMOD É:
chmod ugoa+-=rwx arquivo/diretório
.
SENDO QUE:
u: define que as regras serão aplicadas ao usuário
g: define que as regras serão aplicadas ao grupo
o: define que as regras serão aplicadas aos outros usuários do sistema
a: define que as regras serão aplicadas a todos
+: adiciona permissão
-: remove permissão
=: informa que a permissão aplicada deve ser exatamente igual a que será indicada a seguir
r: atribui a permissão de leitura
w: atribui a permissão de escrita
x: atribui a permissão de execução
.
COM ESTE PEQUENO/GRANDE CONHECIMENTO ADQUIRIDO, POSSO EXECUTAR UM COMANDO ALTERANDO AS PERMISSÕES DE UM ARQUIVO QUE EU CRIEI. O ARQUIVO "permissoes-estudos.txt".
.
EXECUTO NO TERMINAL:
sudo chmod g+w permissoes-estudos.txt
.
O chmod precisa ser usado com o comando sudo, pois apenas o usuário root tem a permissão de executá-lo. Depois de informar a senha e de ter concluído a execução, basta listar o arquivo com o ls -l para conferir a nova permissão. Percebo que onde antes era r--, agora se tornou rw-
.
CASO QUEIRA REMOVER A PERMISSÃO DE LEITURA, ESCRITA E EXECUÇÃO DE PESSOAS QUE NÃO PERTENCEM AO GRUPO, USO:
sudo chmod o-rwx permissoes-estudos.txt
.
SE QUISER DAR A PERMISSÃO DE ESCRITA E LEITURA PARA TODOS OS USUÁRIOS DO SISTEMA, BASTA EXECUTAR:
sudo chmod a+rw permissoes-estudos.txt
.
O PARÂMETRO a+rw VAI APENAS ADICIONAR A PERMISSÃO DE LEITURA E ESCRITA, ISTO É, CASO O DONO DO ARQUIVO, GRUPO E OUTROS USUÁRIOS JÁ POSSUAM A PERMISSÃO DE EXECUÇÃO, ELA NÃO SERÁ REVOGADA. SE EU QUISER IMPOR A REGRA DE APENAS LEITURA E ESCRITA, REVOGANDO UMA PERMISSÃO DE EXECUÇÃO PRÉ-EXISTENTE, USO O SINAL DE IGUAL:
sudo chmod a=rw permissoes-estudos.txt
.
OUTRA FORMA DE USAR O CHMOD
.
Existe mais de uma forma de usar o chmod e muitos preferem esta segunda, que ensinaremos a seguir. Em vez de digitar letras e operadores matemáticos, como o caso de a+rw, por exemplo, muitos administradores preferem estipular as permissões com códigos numéricos.
.
PARA ISSO, VOCÊ PRECISA PENSAR NA REGRA DE PERMISSÃO COMO SE FOSSE UMA SEQUÊNCIA DE BITS. A PERMISSÃO rwx, POR EXEMPLO, EQUIVALERIA A 111, ENQUANTO QUE RW- SE TRANSFORMARIA EM 110. RESUMINDO: 1 PARA LETRA, 0 PARA HÍFEN. CONVERTER ESSES NÚMEROS DE BASE BINÁRIA PARA DECIMAL, 111 VIRARIA 7, ENQUANTO QUE 110 SE TORNARIA 6.
.
VEJA O EXEMPLO ABAIXO BEM FÁCIL:
.
rwx
111
7
rw-
110
6
.
SEGUINDO ESSA LÓGICA, SE VOCÊ QUISESSE FORNECER AS PERMISSÕES DE LEITURA, ESCRITA E EXECUÇÃO PARA TODOS OS USUÁRIOS DO SISTEMA, PODERIA DIGITAR A SEGUINTE LINHA:
sudo chmod 777 nome-do-arquivo
.
SE PREFERIR MANTER A OPÇÃO DE EXECUTAR O ARQUIVO APENAS PARA O DONO E GRUPO DELE, ENTÃO A LINHA MUDA PARA:
sudo chmod 776 nome-do-arquivo
.
PARA FACILITAR E NÃO TER QUE CONVERTER DE CABEÇA TODOS ESSES NÚMEROS, EXISTE UMA PEQUENA TABELA DE APENAS OITO (8) PERMISSÕES, QUE PODE SER CONSULTADA SEMPRE QUE NECESSÁRIO:
.
Permissão1: 0 ; Permissão2: 1 ; Permissão3: 2 ; Permissão4: 3 ; Permissão5: 4 ; Permissão6: 5 ; Permissão7: 6 ; Permissão8: 7. Onde a:
.
# A permissão 1:
---
Convertida para binário:
000
Tem o decimal:
0
# A permissão 2:
--x
Convertida para binário:
001
Tem o decimal:
1
# A permissão 3:
-W-
Convertida para binário:
010
Tem o decimal:
2
# A permissão 4:
-WX
Convertida para binário:
011
Tem o decimal:
3
# A permissão 5:
r--
Convertida para binário:
100
Tem o decimal:
4
# A permissão 6:
r-x
Convertida para binário:
101
Tem o decimal:
5
# A permissão 7:
rw-
Convertida para binário:
110
Tem o decimal:
6
# A permissão 8:
rwx
Convertida para binário:
111
Tem o decimal:
7
.
CASO NÃO HAJA TODAS AS PERMISSÕES, PODERÁ APARECER INCOMPLETO:
rwxrw_ _ _x, ou seja, neste exemplo:
Dono do arquivo tem permissão de Ler, Escrever e executar (rwx).
Grupo tem permissão de Ler e Escrever (rw_).
Outros tem permissão apenas de executar. (_ _ x).
.
CONCLUSÃO:
.
EXISTEM DOIS MODOS DE DEFINIR UMA PERMISSÃO, ATRAVÉS DO MODO OCTAL E MODO TEXTUAL.
.
TEXTUAL - Usamos letras antes das permissões (chmod é o comando para modificar permissões de arquivos):
$ chmod u+rw, g+w, o-rwx teste.txt
Onde:
U - representa usuário;
G - representa grupo;
O - representa outros.
ugo
.
MODO OCTAL
.
O modo Octal tem a mesma função de definir permissões, só que em números. Exemplo:
$ chmod 620 permissoes-estudos.txt
(comando) (permissão) (arquivo)
.
Tipo de permissão Octal:
4 - Indica permissão de leitura;
2 - Permissão de escrita;
1 - Indica permissão de execução;
0 - Indica sem permissões.
.
Agora é simples, é só somar e ditar as permissões, exemplo:
4 + 2 + 1 = 7 (permissão de rwx)
4 + 2 = 6 (permissão rw)
4 = (permissão r)
.
Exemplo: A permissão 610 indica que o arquivo tem permissão:
6 para dono do arquivo
1 para grupo e
0 para outros ou seja
dono= (rw_) Grupo=(_ _ x) outros=(_ _ _)
.
Percebo que quando é feita a listagem longa "ls -l", o primeiro caractere não é uma permissão.
.
O primeiro caracter "d" indica o tipo do arquivo, neste caso "d" indica que é um diretório.
.
Existem também outras permissões especiais mas não quero saber no momento.
.
Com um pouco de prática talvez um dia eu esteja alterando permissões de arquivos e diretórios de maneira automática. Mas eu garanto que você e eu, nunca mais vamos esquecer do que faz um chmod 777.
.
Posso ler este texto em formato .txt no celular usando o FBreader ou algum outro programa do Android.
.
CREIO QUE ISTO É UM BOM COMEÇO. A GENTE NUNCA PARA DE APRENDER. QUER CONTINUAR?
.
CURIOSIDADE:
.
Quem desenvolve software com Linux para usar no Linux, tem que disponibilizar o código fonte.
Muitos desenvolvedores disponibilizam um código fonte sem muita informação, sem instrução detalhada de como compilar. Algo tão complexo e trabalhoso que, para dele se obter o software e usa-lo só pagando a um outro profissional especializado.
A complexidade do código fonte é uma barreira criada com propósito.
Um deles é este.
Nega o software a grupos, empresas e o usuário comuns por causa da sua extrema complexidade de compilação.
Pode ser que isto já seja a regra.
Tente instalar alguns programas usando o código fonte e tire sua própria conclusão.
.
Ganhar dinheiro vendendo serviços e criando programas com software Linux é bom.
.
Criar barreiras para dificultar o uso do código fonte não é bom.
.
Existem pessoas que creditam que melhores softwares podem resultar de um modelo
aberto de desenvolvimento do que de modelos proprietários.
Teoricamente, qualquer empresa criando um software para uso próprio pode economizar dinheiro adicionando suas contribuições as dos outros a fim de obter um produto final muito melhor para ela mesma.
Quem quer ganhar dinheiro com a venda de software precisa ser extremanente criativo atualmente.
A pessoa ou empresa pode vender o software que cria usando Linux, mas tem que incluir um software GPL, o código-
fonte dele que deve ser passado para frente.
Outros podem recompilar esse produto, e assim usar o software e pode até revender sem custos.
.
ENTÃO PARA GANHAR DINHEIRO GRUPOS, PESSOAS E EMPRESAS PODEM:
Vender seus produtos com base em uma assinatura. Por uma determinada quantia de dinheiro por ano, você obtém o código binário para rodar o Linux (assim você não tem que compilar por conta própria), suporte garantido, ferramentas para monitoramento de hardware e software no seu computador, acesso à base de conhecimento da empresa e outros recursos.
.
A maioria dos sistemas operacionais oferecidos gratuitamente, inclui grande parte do mesmo software que outros oferecem com base em uma assinatura. Também estão disponíveis em forma binária, mas não há garantias associadas com o software ou futuras atualizações dele.
.
Dizem que pequeno escritório ou um usuário pessoal pode arriscar usar sistemas operacionais Linux excelentes e gratúitos, mas uma grande empresa que está executando aplicações de missão crítica provavelmente acabará investindo algum dinheiro em produtos com base em uma assinatura.
.
Para lucrar, gerar capital, ganhar dinheiro empresas que trabalham com Linux oferecem:
.
1
Treinamento e certificação
2
Recompensas de software
uma maneira fascinante de as empresas de software de código-fonte aberto fazerem dinheiro. Digamos que uma empresa/grupo/usuário está usando o pacote de software ABZ e precisa de um novo recurso imediatamente. Ao pagar uma recompensa de software para o projeto em si, ou para outros desenvolvedores, a empresa/grupo/usuário pode ter as melhorias que precisa deslocadas para o início da fila.
O software que empresa/grupo/usuário paga permanecerá coberto pela sua licença de código-fonte aberto, mas a empresa/grupo/usuário terá os recursos de que precisa provavelmente mais barato que o custo da construção do projeto a partir zero.
3
Doações
Muitos projetos de código-fonte aberto aceitam doações de pessoas físicas ou empresas de desenvolvimento de código-fonte aberto que usam código a partir de seus projetos. Surpreendentemente, muitos projetos de código-fonte aberto suportam um ou dois desenvolvedores e funcionam exclusivamente com base em doações. Estojos, canecas e camisetas - Muitos projetos de código-fonte aberto têm lojas online onde podemos comprar CDs e uma variedade de canecas, camisetas, mouse pads e outros souvenires. Se tu amas um projeto de verdade, compre uma camiseta e uma caneca. Formas mais criativas estão a ser inventadas diariamente para apoiar quem esta a produzir software de código-fonte aberto.
4
Retorno obtido
Pessoas/Grupos se tornam colaboradoras e mantenedoras de software de código-fonte aberto porque precisavam ou queriam o software. As contribuições que elas fazem gratuitamente valem a pena pelo retorno que elas obtêm de outras pessoas que fazem o mesmo.
.
Não esqueça que para algumas pessoas, o Linux não tem como objetivo lucro. O objetivo do Linux é garantir a tua liberdade. O trabalho colaborativo produz ótimos softwares disponíveis a todos em toda parte.
.
APRENDENDO SHELL SCRIPT - CONTINUE, BREAK E EXIT
.
A instrução continue é usada para retomar a iteração seguinte do loop FOR, WHILE ou UNTIL.
Use a instrução break para sair de dentro de um loop FOR, WHILE ou UNTIL, isto é, pare a execução do loop.
O exit é usado para definir o status da execução do programa, se o valor de $? for 0 então tudo ocorreu naturalmente, se não houve erro.
Você pode por o exit 0 no final do seu script para sair sem problemas, e um echo $? para saber qual foi o código de retorno na execução do programa.
No exemplo abaixo só irá imprimir 8 e 9, perceba o uso continue , break e exit.
.
#!/bin/bash
for i in $(seq 1 10);
do
if [[ "$i" "9" ]]; then
break;
fi
echo $i;
done
exit 0;
# Fim do arquivo: i8-continue-break-exit.sh
.
Execute o exemplo abaixo:
.
#!/bin/bash
_INPUT_STRING="Olá"
while :
do
echo "Você deseja ficar aqui?"
read _INPUT_STRING
if [[ $_INPUT_STRING = 'tchau' ]]; then
continue
else
echo "Você ainda deseja ficar aqui"
fi
done
# Fim do arquivo: 0n4-read-continue.sh
.
OBS:
Se for o caso, SAIA COM: Ctrl +C
.
Execute o script abaixo:
#!/bin/bash
_INPUT_STRING="Olá"
while :
do
echo "Você deseja ficar aqui?"
read _INPUT_STRING
if [[ $_INPUT_STRING = 'tchau' ]]; then
continue
else
break
fi
done
# Fim do arquivo: 1n5-read-continue.sh
.
OBS:
Se for o caso, SAIA COM: Ctrl +C
.
Executa o script abaixo:
#!/bin/bash
_INPUT_STRING="Olá"
while :
do
echo "Você deseja ficar aqui?"
read _INPUT_STRING
if [[ $_INPUT_STRING != 'tchau' ]]; then
continue
else
break
fi
done
# Fim do arquivo: 1n5-continue-break.sh
.
Resultado:
~ $sh 0n4-read-continue.sh
Você deseja ficar aqui?
Hmhm
Você deseja ficar aqui?
Sim
Você deseja ficar aqui?
Não sei
Você deseja ficar aqui?
Pare!
Você deseja ficar aqui?
tchau
~ $
.
Executa o script abaixo:
#!/bin/bash
_INPUT_STRING="Olá"
while :
do
echo "Você deseja ficar aqui?"
read _INPUT_STRING
if [[ $_INPUT_STRING != 'tchau' ]]; then
continue
else
exit 0
fi
done
# Fim do arquivo: 2n-continue-exit.sh
.
COMANDO EVAL
O comando eval é perigoso evite usar ele. Aqui um exemplo de uso do eval. Quem desenvolve software é que sabe usar o eval.
.
Execute os comandos abaixo no terminal:
A='ls'
B=A
echo $B
echo '$'$B
eval echo '$'$B
.
O COMANDO EXEC
O comando exec substitui o processo shell atual pelo comando especificado. O exec cria a segunda parte da junção, o que não seria possível usando o pipe |.
.
APRENDENDO SHELL SCRIPT - MATEMÁTICA EM SHELL SCRIPT
.
Expressões com parênteses são efetuadas em primeiro lugar.
.
\*, % e / são efetuados antes de + e -
.
Todo o resto é efetuado da ESQUERDA para a DIREITA.
.
No caso da multiplicação utiza-se \*, pois o asterisco é um curinga do Linux.
.
FORMAS DE CÁLCULO:
.
echo $((2+2))
echo $((2+2*5))
echo $((2+2*5/2))
a=2+2 ; echo $a
declare -i a
a=2+2 ; echo $a
a=2+2 ; echo $a
echo "5/2" | bc
echo "scale=2;5/2" | bc
bc
2+2
scale=2;5/2
quit
expr 2 + 2
bc << calc.txt
dc calc.txt
echo "obase=2;2" | bc
echo "obase=2;54" | bc
expr lenght "Linux"
.
APRENDENDO SHELL SCRIPT - CRIAR PROGRAMAS GRÁFICOS E INTERATIVOS COM SHELL SCRIPT
.
Podemos criar programas interativos pelo terminal e programas gráficos. Tem muitas ferramentas de comandos. Algumas já vem pré-instaladas nas Distros Linux. Vamos tentar entender duas.
.
Dialog - Para programas cli modo texto mas que criam uma interatividade com o usuário. Dialog cria widgets, menus, avisos, barras de progresso, entre outras coisas que colocamos em Shell Script e aparecem no terminal ao executar o script. Pode usar o mouse para clicar nas janelas do Dialog. Existem várias caixas de Dialog que podemos usar.
.
Instale o Dialog pela central de programas da sua Distro, ou usando o gerenciador de pacotes da sua Distribuição. Verifique se tem o Yad instalado também.
.
Para criar uma tela simples execute o comando abaixo no terminal:
dialog --msgbox 'Programa primeiro com Dialog Shell Script - bash 4.4.19' 5 50
.
OBS:
5 = Altura
50 = Largura
.
Yad - Para programas gráficos. Evolução do Zenity. Tem mais opções.
.
Site para aprender comandos:
http://explainshell.com/
.
Este artigo acaba aqui. Tudo de graça. Saiba que você foi longe e depois deste artigo, se houver necessidade de reconhecimento, pode se considerar um usuário auto-didata avançado de GNU/Linux.
Porque estas palavras só tem valor na mente daqueles que buscam algum conhecimento e o praticam.
Sempre estudante. Existe muito mais a saber sobre Shell Script. Mas se você for um usuário comum como eu, este conhecimento adquirido aqui aliado a necessidade e criatividade, é ferramenta para fazer muita coisa útil e se não for criador, vai mesmo assim, entender muita coisa quando encontrar shell scripts pelo caminho.
.
Até Breve!
.
:)
.
semanickz 