105.1 Lição 1
Certificação: |
LPIC-1 |
---|---|
Versão: |
5.0 |
Tópico: |
105 Shells e scripts do Shell |
Objetivo: |
105.1 Personalizar e usar o ambiente do shell |
Lição: |
1 de 3 |
Introdução
O shell é, sem dúvida, a ferramenta mais poderosa de um sistema Linux. Ele pode ser definido como uma interface entre o usuário e o kernel do sistema operacional. Ele interpreta os comandos inseridos pelo usuário. Assim, todos os administradores de sistema devem saber usar o shell. Como você já deve ter entendido, o Bourne Again Shell (Bash) é o shell de facto na grande maioria das distribuições Linux.
Uma vez iniciado, a primeira coisa que o Bash — ou qualquer outro shell, aliás — faz é executar uma série de scripts de inicialização. Esses scripts personalizam o ambiente da sessão. Existem scripts que afetam todo o sistema e outros específicos do usuário. Podemos colocar as preferências ou configurações pessoais que melhor atendam às necessidades dos usuários nesses scripts na forma de variáveis, aliases e funções.
A série exata de arquivos de inicialização depende de um parâmetro muito importante: o tipo de shell. Vamos dar uma olhada na variedade existente.
Tipos de shell: Interativo x Não-interativo e Login vs sem login
Para começar, vamos esclarecer os conceitos de interativo e login no contexto dos shells:
- Shells interativos / não-interativos
-
Este tipo de shell refere-se à interação que ocorre entre o usuário e o shell: O usuário fornece a entrada digitando comandos no terminal com o teclado; o shell fornece a saída imprimindo mensagens na tela.
- Shells com login / sem login
-
Esse tipo de shell se refere ao caso de um usuário que acessa um sistema fornecendo suas credenciais, como nome de usuário e senha.
Os shells interativos e não interativos podem ser de login ou sem login; qualquer combinação possível desses tipos tem seus usos específicos.
Os shells de login interativos são executados quando os usuários fazem login no sistema, e são usados para personalizar as configurações de usuário de acordo com suas necessidades. Um bom exemplo do uso desse tipo de shell seria um grupo de usuários pertencentes ao mesmo departamento de uma empresa que precisam de uma determinada variável definida em suas sessões.
Shells sem login interativos são quaisquer outros shells abertos pelo usuário após o login no sistema. Os usuários empregam esses shells durante as sessões para realizar tarefas de manutenção e administrativas, como definir variáveis, data e hora, copiar arquivos, criar scripts, etc.
Por outro lado, os shells não-interativos não requerem nenhum tipo de interação humana. Assim, esses shells não pedem entrada de dados pelo usuário e sua saída — quando existe — é, na maioria dos casos, gravada em um log.
Os shells de login não-interativos são bastante raros e pouco práticos. Eles praticamente não têm utilidade e nós só estamos falando deles para você conhecer outros aspectos do comportamento do shell. Alguns exemplos incomuns incluem forçar um script a ser executado a partir de um shell de login com /bin/bash --login <algum_script>
ou canalizando a saída padrão (stdout) de um comando para a entrada padrão (stdin) de uma conexão ssh:
<some_command> | ssh <some_user>@<some_server>
No caso do shell não-interativo e sem login, não há interação nem login em nome do usuário; portanto, estamos nos referindo aqui ao uso de scripts automatizados. Esses scripts são usados principalmente para realizar tarefas administrativas e de manutenção repetitivas, como as incluídas em cronjobs. Nesses casos, o bash
não lê nenhum arquivo de inicialização.
Abrindo um terminal
Quando estamos em um ambiente de desktop, podemos abrir um aplicativo de terminal ou mudar para um dos consoles do sistema. Portanto, um novo shell pode ser um shell pts
, quando aberto a partir de um emulador de terminal na GUI, ou um shell tty
, quando executado em um console do sistema. No primeiro caso, não estamos lidando com um terminal, mas com um emulador de terminal. Por serem parte das sessões gráficas, os emuladores de terminal, como o gnome-terminal ou o konsole, são muito ricos em recursos e fáceis de usar em comparação com os terminais de interface de usuário baseados em texto. Dentre os emuladores de terminal com menos recursos estão — entre outros — o XTerm e o sakura.
Usando as combinações Ctrl+Alt+F1-F6 podemos ir para os logins do console, que abrem um shell de login interativo baseado em texto. Ctrl+Alt+F7 leva a sessão de volta para a área de trabalho.
Note
|
|
Lançando shells com o bash
Após fazer o login, digite bash
em um terminal para abrir um novo shell. Tecnicamente, este shell é um processo filho do shell atual.
Ao iniciar o processo filho bash
, podemos especificar diversas opções para definir que tipo de shell queremos iniciar. Eis algumas opções importantes de invocação no bash
:
bash -l
orbash --login
-
invoca um shell de login.
bash -i
-
invoca um shell interativo.
bash --noprofile
-
com shells de login, ignora o arquivo de inicialização do sistema
/etc/profile
e os arquivos de inicialização em nível de usuário~/.bash_profile
,~/.bash_login
e~/.profile
. bash --norc
-
com shells interativos, ignora tanto o arquivo de inicialização do sistema
/etc/bash.bashrc
quanto o arquivo de inicialização em nível de usuário~/.bashrc
. bash --rcfile <file>
-
com shells interativos, considera
<file>
como arquivo de inicialização, ignorando os arquivos de inicialização do sistema/etc/bash.bashrc
e em nível de usuário~/.bashrc
.
Discutiremos abaixo os diversos arquivos de inicialização.
Iniciando shells com su
e sudo
Graças a esses dois programas semelhantes, podemos obter tipos específicos de shell:
su
-
Muda o ID de usuário ou o torna superusuário (
root
). Com este comando, podemos chamar shells de login e sem login:-
su - user2
,su -l user2
ousu --login user2
iniciam um shell de login interativo comouser2
. -
su user2
inicia um shell sem login interativo comouser2
. -
su - root
ousu -
inicia um shell de login interativo comoroot
. -
su root
ousu
inicia um shell interativo sem login comoroot
.
-
sudo
-
Executa comandos como outro usuário (incluindo o superusuário). Como este comando é usado principalmente para obter privilégios de root temporariamente, o usuário que o emprega deve estar no arquivo
sudoers
. Para adicionar usuários asudoers
, precisamos nos tornarroot
e então executar:root@debian:~# usermod -aG sudo user2
Assim como o
su
, osudo
permite invocar shells de login e sem login:-
sudo su - user2
,sudo su -l user2
ousudo su --login user2
iniciam um shell de login interativo comouser2
. -
sudo su user2
inicia um shell sem login interativo comouser2
. -
sudo -u user2 -s
inicia um shell sem login interativo comouser2
. -
sudo su - root
ousudo su -
inicia um shell de login interativo comoroot
. -
sudo -i
inicia um shell de login interativo comoroot
. -
sudo -i <algum_comando>
inicia um shell de login interativo comoroot
, executa o comando e retorna ao usuário original. -
sudo su root
ousudo su
inicia um shell sem login interativo comoroot
. -
sudo -s
ousudo -u root -s
iniciam um shell sem login comoroot
.
-
Ao usar su
ou sudo
, é importante considerar o contexto particular antes de iniciar um novo shell: Precisamos ou não do ambiente do usuário de destino? Se a resposta for sim, usaríamos as opções que invocam shells de login; se não, as que invocam shells sem login.
Qual o meu tipo de shell?
Para descobrir em que tipo de shell estamos trabalhando, podemos digitar echo $0
no terminal e obter a seguinte saída:
- Interativo de login
-
-bash
ou-su
- Interativo sem login
-
bash
or/bin/bash
- Não-interativo sem login (scripts)
-
<nome_do_script>
Quantos shells nós temos?
Para ver quantos shells do bash
estão rodando no sistema, podemos usar o comando ps aux | grep bash
:
user2@debian:~$ ps aux | grep bash user2 5270 0.1 0.1 25532 5664 pts/0 Ss 23:03 0:00 bash user2 5411 0.3 0.1 25608 5268 tty1 S+ 23:03 0:00 -bash user2 5452 0.0 0.0 16760 940 pts/0 S+ 23:04 0:00 grep --color=auto bash
A usuária user2
em debian
se logou em uma sessão GUI (ou X Window System) e abriu gnome-terminal, depois pressionou Ctrl+Alt+F1 para entrar em uma sessão de terminal tty
. Finalmente, ela retornou à sessão GUI pressionando Ctrl+Alt+F7 e digitou o comando ps aux | grep bash
. Assim, a saída mostra um shell sem login interativo por meio do emulador de terminal (pts/0
) e um shell de login interativo por meio do terminal baseado em texto (tty1
). Note também como o último campo de cada linha (o comando) é bash
para o primeiro e -bash
para o último.
De onde os shells obtêm sua configuração: arquivos de inicialização
Bem, agora que sabemos os tipos de shell que podemos encontrar em um sistema Linux, é hora de aprender quais arquivos de inicialização são executados por qual shell. Observe que os scripts referentes a todo o sistema, ou globais, são postos no diretório /etc/
, enquanto que os scripts locais ou em nível de usuário são encontrados no diretório inicial do usuário (~
). Além disso, quando existe mais de um arquivo a ser pesquisado, logo que um é encontrado e executado, os outros são ignorados. Explore e estude esses arquivos com seu editor de texto favorito ou digitando less <startup_file>
.
Note
|
Os arquivos de inicialização podem ser divididos em específicos do Bash (limitados apenas a configurações e comandos do |
Shell de login interativo
Nível global
/etc/profile
-
Arquivo
.profile
de todo o sistema para o shell Bourne e shells compatíveis com Bourne (incluindo obash
). Através de uma série de instruçõesif
, esse arquivo define uma série de variáveis comoPATH
ePS1
conforme necessário, além de buscar e executar — se existirem — o arquivo/etc/bash.bashrc
e os que estão no diretório/etc/profile.d
. /etc/profile.d/*
-
Este diretório pode conter scripts que são executados por
/etc/profile
.
Nível local
~/.bash_profile
-
Este arquivo específico do Bash é usado para configurar o ambiente do usuário. Também pode ser usado para buscar e executar
~/.bash_login
e~/.profile
. ~/.bash_login
-
Também específico ao Bash, este arquivo só será executado se não houver um arquivo
~/.bash_profile
. Seu nome sugere que deve ser usado para executar comandos necessários no login. ~/.profile
-
Este arquivo não é específico ao Bash e só é originado se nem
~/.bash_profile
nem~/.bash_login
existirem — o que normalmente é o caso. Assim, a principal finalidade de~/.profile
é conferir se um shell Bash está sendo executado e — se estiver — buscar~/.bashrc
e executá-lo caso exista. Ele normalmente define a variávelPATH
para que ela inclua o diretório privado~/bin
do usuário se ele existir. ~/.bash_logout
-
Se existir, este arquivo específico do Bash faz algumas operações de limpeza ao sair do shell. Isso pode ser conveniente em certos casos, como as sessões remotas.
Explorando os arquivos de configuração do shell de login interativo
Vamos mostrar alguns desses arquivos em ação modificando /etc/profile
e /home/user2/.profile
. A cada um deles, anexamos uma linha para relembrar o arquivo que está sendo executado:
root@debian:~# echo 'echo Hello from /etc/profile' >> /etc/profile root@debian:~# echo 'echo Hello from ~/.profile' >> ~/.profile
Note
|
Dois operadores de redirecionamento |
Assim, através da saída de seus respectivos comandos echo
, sabemos quando cada um desses arquivos é lido e executado. Para demonstrar, vamos ver o que acontece quando user2
se loga via ssh
a partir de outra máquina:
user2@debian:~$ ssh user2@192.168.1.6 user2@192.168.1.6's password: Linux debian 4.9.0-8-amd64 #1 SMP Debian 4.9.130-2 (2018-10-27) x86_64 The programs included with the Debian GNU/Linux system are free software; the exact distribution terms for each program are described in the individual files in /usr/share/doc/*/copyright. Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent permitted by applicable law. Last login: Tue Nov 27 19:57:19 2018 from 192.168.1.10 Hello from /etc/profile Hello from /home/user2/.profile
Como mostram as duas últimas linhas, deu tudo certo. Além disso, observe três coisas:
-
O arquivo global foi executado primeiro.
-
Não havia arquivos
.bash_profile
ou.bash_login
no diretório inicial deuser2
. -
O til (
~
) expandiu-se para o caminho absoluto do arquivo (/home/user2/.profile
).
Shell interativo sem login
Nível global
/etc/bash.bashrc
-
Este é o arquivo
.bashrc
de todo o sistema para shellsbash
interativos. Ao longo de sua execução, obash
garante que ele esteja sendo executado de maneira interativa, verifica o tamanho da janela após cada comando (atualizando os valores deLINES
eCOLUMNS
se necessário) e define algumas variáveis.
Nível local
~/.bashrc
-
Além de realizar tarefas semelhantes às descritas para
/etc/bash.bashrc
no nível do usuário (como verificar o tamanho da janela ou se está sendo executado interativamente), este arquivo específico do Bash geralmente define algumas variáveis de histórico e busca e executa~/.bash_aliases
, se existir. Além disso, esse arquivo é normalmente usado para armazenar aliases e funções específicas dos usuários.Da mesma forma, também é importante notar que
~/.bashrc
é lido se obash
detectar que<stdin>
é uma conexão de rede (como era o caso com a conexão Secure Shell (SSH) no exemplo acima).
Explorando arquivos de configuração de shell interativo sem login
Vamos modificar /etc/bash.bashrc
e /home/user2/.bashrc
:
root@debian:~# echo 'echo Hello from /etc/bash.bashrc' >> /etc/bash.bashrc root@debian:~# echo 'echo Hello from ~/.bashrc' >> ~/.bashrc
E isso é o que acontece quando o user2
inicia um novo shell:
user2@debian:~$ bash Hello from /etc/bash.bashrc Hello from /home/user2/.bashrc
Novamente, os dois arquivos foram lidos e executados.
Warning
|
Lembre-se, devido à ordem em que os arquivos são executados, os arquivos locais têm precedência sobre os globais. |
Shell de login não interativo
Um shell não-interativo com as opções -l
ou --login
é forçado a se comportar como um shell de login, e assim os arquivos de inicialização a serem executados serão iguais aos dos shells de login interativos.
Para provar, vamos escrever um script simples e torná-lo executável. Não incluiremos nenhum shebang porque invocaremos o executável do bash (/bin/bash
com a opção de login) a partir da linha de comando.
-
Criamos o script
test.sh
contendo a linhaecho 'Hello from a script'
para ser possível provar que o script foi executado com sucesso:user2@debian:~$ echo "echo 'Hello from a script'" > test.sh
-
Tornamos o script executável:
user2@debian:~$ chmod +x ./test.sh
-
Finalmente, invocamos
bash
com a opção-l
para executar o script:user2@debian:~$ bash -l ./test.sh Hello from /etc/profile Hello from /home/user2/.profile Hello from a script
Funcionou! Antes de executar o script, o login foi feito e tanto
/etc/profile
quanto~/.profile
foram executados.
Note
|
Aprenderemos sobre shebangs e todos os outros aspectos dos scripts do shell em lições futuras. |
Vamos agora mandar a saída padrão (stdout) do comando echo
para a entrada padrão (stdin) de uma conexão ssh
por meio de um pipe (|
):
user2@debian:~$ echo "Hello-from-a-noninteractive-login-shell" | ssh user2@192.168.1.6 Pseudo-terminal will not be allocated because stdin is not a terminal. user2@192.168.1.6's password: Linux debian 4.9.0-8-amd64 #1 SMP Debian 4.9.130-2 (2018-10-27) x86_64 The programs included with the Debian GNU/Linux system are free software; the exact distribution terms for each program are described in the individual files in /usr/share/doc/*/copyright. Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent permitted by applicable law. Hello from /etc/profile Hello from /home/user2/.profile -bash: line 1: Hello-from-a-noninteractive-login-shell: command not found
Novamente, /etc/profile
and ~/.profile
são executados. Fora isso, a primeira e a última linha da saída são bastante reveladoras no que diz respeito ao comportamento do shell.
Shell não-interativo sem login
Os scripts não lêem nenhum dos arquivos listados acima, mas procuram a variável de ambiente BASH_ENV
, expandem seu valor se necessário e o usam como nome de um arquivo de inicialização para ler e executar comandos. Aprenderemos mais sobre variáveis de ambiente na próxima lição.
Como dito acima, tipicamente /etc/profile
e ~/.profile
garantem que /etc/bash.bashrc
e ~/.bashrc
sejam executados após um login bem-sucedido. A saída do comando a seguir mostra esse fenômeno:
root@debian:~# su - user2 Hello from /etc/bash.bashrc Hello from /etc/profile Hello from /home/user2/.bashrc Hello from /home/user2/.profile
Tendo em mente as linhas que anexamos anteriormente aos scripts de inicialização — invocando um shell de login interativo no nível do usuário com su - user2
— as quatro linhas da saída podem ser explicadas da seguinte forma:
-
Hello from /etc/bash.bashrc
significa que/etc/profile
buscou e executou/etc/bash.bashrc
. -
Hello from /etc/profile
significa que/etc/profile
foi inteiramente lido e executado. -
Hello from /home/user2/.bashrc
significa que~/.profile
buscou e executou~/.bashrc
. -
Hello from /home/user2/.profile
significa que~/.profile
foi inteiramente lido e executado.
Note que, com su - <username>
(e também su -l <username>
e su --login <username>
), garantimos a invocação de um shell de login, ao passo que su <username>
teria invocado somente /etc/bash.bashrc
e ~/.bashrc
.
Encontrar e executar (sourcing)
Nas seções anteriores, discutimos que alguns scripts de inicialização incluem ou executam outros scripts. Esse mecanismo é chamado de sourcing e é explicado nesta seção.
Sourcing de arquivos com .
O ponto (.
) normalmente é encontrado em arquivos de inicialização.
No arquivo .profile
de nosso servidor Debian, podemos encontrar — por exemplo — o seguinte bloco:
# include .bashrc if it exists if [ -f "$HOME/.bashrc" ]; then . "$HOME/.bashrc" fi
Já vimos como a execução de um script pode levar à de outro. Assim, a instrução if
garante que o arquivo $HOME/.bashrc
— se existir (-f
) — será lido e executado (source) no login:
. "$HOME/.bashrc"
Note
|
Como veremos na próxima lição, |
Além disso, podemos usar o .
sempre que tivermos modificado um arquivo de inicialização e quisermos que as alterações façam efeito sem reinicializar. Por exemplo, podemos:
-
adicionar um alias a
~/.bashrc
:user2@debian:~$ echo "alias hi='echo We salute you.'" >> ~/.bashrc
Warning
|
Ao enviar a saída de um comando em um arquivo, lembre-se de não confundir anexar ( |
-
exibir a última linha de
~/.bashrc
na saída para verificar se tudo correu bem:user2@debian:~$ tail -n 1 !$ tail -n 1 ~/.bashrc alias hi='echo We salute you.'
Note!$
se expande para o último argumento do comando anterior, em nosso caso:~/.bashrc
. -
abrir e executar o arquivo manualmente:
user2@debian:~$ . ~/.bashrc
-
e invocar o alias para demonstrar que funcionou:
user2@debian:~$ hi We salute you.
Note
|
Consulte a próxima lição para aprender sobre aliases e variáveis. |
Sourcing de arquivos com source
O comando source
é sinônimo de .
. Assim, para buscar e executar ~/.bashrc
, também podemos fazer desta forma:
user2@debian:~$ source ~/.bashrc
A origem dos arquivos de inicialização do shell: SKEL
SKEL
é uma variável cujo valor é o caminho absoluto para o diretório skel
. Esse diretório serve como modelo para a estrutura do sistema de arquivos dos diretórios pessoais dos usuários. Ele inclui os arquivos que serão herdados por qualquer nova conta de usuário criada (incluindo, é claro, os arquivos de configuração dos shells). SKEL
e outras variáveis relacionadas são armazenadas em /etc/adduser.conf
, que é o arquivo de configuração para adduser
:
user2@debian:~$ grep SKEL /etc/adduser.conf # The SKEL variable specifies the directory containing "skeletal" user SKEL=/etc/skel # If SKEL_IGNORE_REGEX is set, adduser will ignore files matching this SKEL_IGNORE_REGEX="dpkg-(old|new|dist|save)"
SKEL
está definido em /etc/skel
; assim, os scripts de inicialização que configuram nossos shells estarão lá:
user2@debian:~$ ls -a /etc/skel/ . .. .bash_logout .bashrc .profile
Warning
|
Lembre-se de que os arquivos que começam com |
Vamos agora criar um diretório em /etc/skel
para armazenar os scripts pessoais de todos os novos usuários:
-
Como
root
, entramos em/etc/skel
:root@debian:~# cd /etc/skel/ root@debian:/etc/skel#
-
Listamos o conteúdo:
root@debian:/etc/skel# ls -a . .. .bash_logout .bashrc .profile
-
Criamos o diretório e verificamos se tudo correu como esperado:
root@debian:/etc/skel# mkdir my_personal_scripts root@debian:/etc/skel# ls -a . .. .bash_logout .bashrc my_personal_scripts .profile
-
A seguir, removemos
user2
junto com seu diretóriohome
:root@debian:~# deluser --remove-home user2 Looking for files to backup/remove ... Removing files ... Removing user `user2' ... Warning: group `user2' has no more members. Done.
-
Adicionamos
user2
novamente para que receba um novo diretório inicial:root@debian:~# adduser user2 Adding user `user2' ... Adding new group `user2' (1001) ... Adding new user `user2' (1001) with group `user2' ... Creating home directory `/home/user2' ... Copying files from `/etc/skel' ... Enter new UNIX password: Retype new UNIX password: passwd: password updated successfully Changing the user information for user2 Enter the new value, or press ENTER for the default Full Name []: Room Number []: Work Phone []: Home Phone []: Other []: Is the information correct? [Y/n] y
-
Finalmente, nos logamos como
user2
e listamos todos os arquivos em/home/user2
para verificar se tudo correu como esperado:root@debian:~# su - user2 user2@debian:~$ pwd /home/user2 user2@debian:~$ ls -a . .. .bash_history .bash_logout .bashrc my_personal_scripts .profile
Deu tudo certo.
Exercícios Guiados
-
Analise como os shells foram iniciados na coluna “Shell iniciado com…” e complete com as informações necessárias:
Shell iniciado com… Interativo? Login? Resultado de echo $0
sudo ssh user2@machine2
Ctrl+Alt+F2
su - user2
gnome-terminal
Um usuário comum usa o konsole para iniciar uma instância de sakura
Um script chamado
test.sh
contendo o comandoecho $0
-
Escreva os comandos
su
esudo
para lançar o shell especificado:- Shell de login interativo como
user2
-
su
:sudo
: - Shell de login interativo como
root
-
su
:sudo
: - Shell sem login interativo como
root
-
su
:sudo
: - Shell sem login interativo como
user2
-
su
:sudo
:
- Shell de login interativo como
-
Qual arquivo de inicialização é lido quando iniciamos o shell da coluna “Tipo de shell”?
Tipo de shell /etc/profile
/etc/bash.bashrc
~/.profile
~/.bashrc
Shell de login interativo como
user2
Shell de login interativo como
root
Shell sem login interativo como
root
Shell sem login interativo como
user2
Exercícios Exploratórios
-
No Bash, podemos escrever uma função simples
Hello world!
incluindo o seguinte código em um arquivo vazio:function hello() { echo "Hello world!" }
-
O que devemos fazer a seguir para disponibilizar a função para o shell?
-
Uma vez que ela esteja disponível para o shell atual, como invocá-la?
-
Para automatizar o processo, em qual arquivo você colocaria a função e sua invocação para que ela seja executada quando
user2
abrir um terminal de uma sessão do X Window? De que tipo de shell se trata? -
Em qual arquivo você colocaria a função e sua invocação de forma que seja executada quando
root
iniciar um novo shell interativo, seja este um shell de login ou não?
-
-
Analise o seguinte script básico
Hello world!
dobash
:#!/bin/bash #hello_world: a simple bash script to discuss interaction in scripts. echo "Hello world!"
-
Suponha que tornemos o script executável e o executemos. Ele seria um script interativo? Por quê?
-
O que torna um script interativo?
-
-
Imagine que você alterou os valores de algumas variáveis em
~/.bashrc
e quer que essas alterações tenham efeito sem reinicializar. A partir de seu diretório pessoal, como fazer isso de duas maneiras diferentes? -
John acaba de iniciar uma sessão de X Window em um servidor Linux. Ele abre um emulador de terminal para realizar algumas tarefas administrativas mas, surpreendentemente, a sessão trava e ele precisa abrir um shell de texto.
-
Como ele pode abrir um shell
tty
? -
Quais arquivos de inicialização serão abertos e executados (sourcing)?
-
-
Linda é usuária de um servidor Linux. Ela gentilmente pede ao administrador para lhe atribuir um arquivo
~/.bash_login
para poder imprimir a hora e data na tela quando se logar. Outros usuários gostam da ideia e seguem o exemplo. O administrador tem dificuldades em criar o arquivo para todos os outros usuários no servidor, por isso ele decide implementar uma nova regra e criar~/.bash_login
para todos os novos usuários em potencial. Como o administrador pode realizar essa tarefa?
Resumo
Nesta lição, aprendemos:
-
Os shells definem o ambiente dos usuários em um sistema Linux.
-
O Bash é o shell mais usado nas distribuições GNU/Linux.
-
A primeira tarefa realizada por um shell é a leitura e execução de um ou vários arquivos de inicialização.
-
Os conceitos de interação e login relacionados aos shells.
-
Como lançar diferentes tipos de shells com
bash
,su
,sudo
e Ctrl+Alt+F1-F6. -
Como verificar o tipo de shell com
echo $0
. -
Os arquivos de inicialização locais
~/.bash_profile
,~/.profile
,~/.bash_login
,~/.bash_logout
e~/.bashrc
. -
Os arquivos de inicialização globais
/etc/profile
,/etc/profile.d/*
,/etc/bash.bashrc
. -
Os arquivos locais têm precedência sobre os globais.
-
Como redirecionar a saída de um comando com
>
(sobrescrever) e>>
(anexar). -
O significado do diretório
skel
. -
Como buscar e executar arquivos com sourcing.
Comandos usados nesta lição:
bash
-
Cria um novo shell.
su
-
Cria um novo shell.
sudo
-
Cria um novo shell.
usermod
-
Modifica uma conta de usuário.
echo
-
Exibir uma linha de texto.
ps
-
Exibir um instantâneo dos processos atuais.
less
-
Um paginador para arquivos longos.
ssh
-
Inicia uma conexão Open SSH (remotamente).
chmod
-
Alterar os bits de modo de um arquivo, por exemplo para torná-lo executável.
grep
-
Imprimir linhas de acordo com um padrão.
ls
-
Listar o conteúdo do diretório.
cd
-
Mudar de diretório.
mkdir
-
Cria um diretório.
deluser
-
Exclui um usuário.
adduser
-
Adiciona um novo usuário.
.
-
Buscar e executar um arquivo.
source
-
Buscar e executar um arquivo.
tail
-
Exibe a parte final dos arquivos na saída.
Respostas aos Exercícios Guiados
-
Analise como os shells foram iniciados na coluna “Shell iniciado com…” e complete com as informações necessárias:
Shell iniciado com… Interativo? Login? Resultado de echo $0
sudo ssh user2@machine2
Sim
Sim
-bash
Ctrl+Alt+F2
Sim
Sim
-bash
su - user2
Sim
Sim
-bash
gnome-terminal
Sim
Não
bash
Um usuário comum usa o konsole para iniciar uma instância de sakura
Sim
Não
/bin/bash
Um script chamado
test.sh
contendo o comandoecho $0
Não
Não
./test.sh
-
Escreva os comandos
su
esudo
para lançar o shell especificado:- IShell de login interativo como
user2
su
-
su - user2
,su -l user2
ousu --login user2
sudo
-
sudo su - user2
,sudo su -l user2
ousudo su --login user2
- Shell de login interativo como
root
su
-
su - root
ousu -
sudo
-
sudo su - root
,sudo su -
ousudo -i
- Shell sem login interativo como
root
su
-
su root
ousu
sudo
-
sudo su root
,sudo su
,sudo -s
ousudo -u root -s
- Shell sem login interativo como
user2
su
-
su user2
sudo
-
sudo su user2
ousudo -u user2 -s
- IShell de login interativo como
-
Qual arquivo de inicialização é lido quando iniciamos o shell da coluna “Tipo de shell”?
Tipo de shell /etc/profile
/etc/bash.bashrc
~/.profile
~/.bashrc
Shell de login interativo como
user2
Sim
Sim
Sim
Sim
Shell de login interativo como
root
Sim
Sim
Não
Não
Shell sem login interativo como
root
Não
Sim
Não
Não
Shell sem login interativo como
user2
Não
Sim
Não
Sim
Respostas aos Exercícios Exploratórios
-
No Bash, podemos escrever uma função simples
Hello world!
incluindo o seguinte código em um arquivo vazio:function hello() { echo "Hello world!" }
-
O que devemos fazer a seguir para disponibilizar a função para o shell?
Para tornar a função disponível para o shell atual, é preciso encontrar e executar o arquivo que a inclui.
-
Uma vez que ela esteja disponível para o shell atual, como invocá-la?
Ela é invocada digitando seu nome no terminal.
-
Para automatizar o processo, em qual arquivo você colocaria a função e sua invocação para que ela seja executada quando
user2
abrir um terminal de uma sessão do X Window? De que tipo de shell se trata?O melhor arquivo para colocá-la é
/home/user2/.bashrc
. O shell invocado seria um shell interativo sem login. -
Em qual arquivo você colocaria a função e sua invocação de forma que seja executada quando
root
iniciar um novo shell interativo, seja este um shell de login ou não?Em
/etc/bash.bashrc
, já que este arquivo será executado em todos os shells interativos — sejam de login ou não.
-
-
Analise o seguinte script básico
Hello world!
dobash
:#!/bin/bash #hello_world: a simple bash script to discuss interaction in scripts. echo "Hello world!"
-
Suponha que tornemos o script executável e o executemos. Ele seria um script interativo? Por quê?
Não, pois não há interação humana e nem comandos digitados pelo usuário.
-
O que torna um script interativo?
O fato de que requer entrada de dados pelo usuário.
-
-
Imagine que você alterou os valores de algumas variáveis em
~/.bashrc
e quer que essas alterações tenham efeito sem reinicializar. A partir de seu diretório pessoal, como fazer isso de duas maneiras diferentes?$ source .bashrc
ou
$ . .bashrc
-
John acaba de iniciar uma sessão de X Window em um servidor Linux. Ele abre um emulador de terminal para realizar algumas tarefas administrativas mas, surpreendentemente, a sessão trava e ele precisa abrir um shell de texto.
-
Como ele pode abrir um shell
tty
?Ele poderia pressionar Ctrl+Alt+F1-F6 para entrar em um dos seis shells tty.
-
Quais arquivos de inicialização serão abertos e executados (sourcing)?
/etc/profile
/home/john/.profile
-
-
Linda é usuária de um servidor Linux. Ela gentilmente pede ao administrador para lhe atribuir um arquivo
~/.bash_login
para poder imprimir a hora e data na tela quando se logar. Outros usuários gostam da ideia e seguem o exemplo. O administrador tem dificuldades em criar o arquivo para todos os outros usuários no servidor, por isso ele decide implementar uma nova regra e criar~/.bash_login
para todos os novos usuários em potencial. Como o administrador pode realizar essa tarefa?Para isso, ele poderia colocar
.bash_login
no diretório/etc/skel
.