PARTE # 1: TORNANDO-SE UM USUÁRIO AVANÇADO NO LINUX

CAPÍTULO # 3: UTILIZANDO O SHELL

Shell: Um programa usado para interagir com o computador interpretando comandos.

Ele é um interpretador de comandos.

-----------------------------------------------------------------------------------
-------------------------------------------------------------------------
1 - SOBRE SHELLS E JANELAS DE TERMINAL
-----------------------------------------------------------------------------------
-------------------------------------------------------------------------

Três maneiras de se chegar ao Shell do Linux:

* Prompt de Shell - Interface em sistemas Linux que não contêm GUI.
* Janela de Shell - O terminal existente em sistemas com GUI.
* Console Virtual

* Usando o prompt de shell

Quando o sistema Linux não tem uma interface gráfica.

O prompt padrão para um usuário comum é um cifrão.

Para o usuário root, o padrão é o sinal do jogo da velha.

Sintaxe do prompt:

[usuário_comun@sistema diretório] $

[usuário_root@sistema diretório] #

* Usando uma janela de terminal

Com a interface gráfica rodando, é possível abrir um programa

emulador de terminal. Este programa é muitas vezes chamado de
janela de terminal.

* Usando consoles virtuais

Em sistemas Linux com interface gráficas, é possível abrirmos

sessões consoles virtuais. As consoles virtuais são terminais
de linha de comando. Eles dão a sensação de estarmos em um
sistema sem interface gráfica. É possível termos uma interface
gráfica e seis consoles virtuais. Para abrir uma console virtual,
pressiona-se as teclas ctrl + alt + [f1 até f7]. Pode se alternar
entre os ambientes.

-----------------------------------------------------------------------------------
-------------------------------------------------------------------------
2 - ESCOLHENDO SEU SHELL
-----------------------------------------------------------------------------------
-------------------------------------------------------------------------

Para sabermos qual é o nosso shell, podemos.

$ who am i : Para sabermos quem está logado.

$ grep usuário /etc/passwd : Para vermos as definições do usuário logado.

É possível alterar de shell padrão caso o usuário tenha em sua configuração

opções de shells. Para tal, o usuário simplismente digita o nome da shell em
questão como por exemplo; ksh, tcsh, csh, sh, dash, etc.

pts - Pseudoterminal and slave

Um programa que emula/simula um terminal de shell, como por exemplo, uma
janela de terminal.

tty - TeleTypewriter
Um programa que emula uma console virtual

who - É o comando que lista todos os usuários que estão logados no sistema. Pode
ser utlizado com algumas das suas opções para mais
detalhes.

saml pts/1 2013-04-11 16:41 (:0.0)

nome linha data de login (hostname (:0 - monitor ou dispositivo

logado, .0 - monitor virtual)

who - Exibe todos os usuários logados no sistema

whoami - exibe apenas o nome do usuário logado
who am i / who -m - Exibem informações completas do usuário logado no sistema.
-----------------------------------------------------------------------------------
-------------------------------------------------------------------------
3 - EXECUTANDO COMANDOS
-----------------------------------------------------------------------------------
-------------------------------------------------------------------------

A forma mais simples de se executar um comando é digitalizando o nome do comando.

ex. $ date
Sat Nov 26 08:04:00 EST 2011

O comando date sem opções ou argumentos, exibe:

dia, mês, data, hora, fuso horário, e o ano.

Alguns outros comandos:

$ pwd : exibe em que diretório se está a trabalhar.

$ hostname : exibe o nome do computador.
$ ls : lista os diretórios e arquivos no diretório em que se está a trabalhar.

Nota:
Normalmente, os comandos tendem a ser digitalizados com mais carateres. Esses
carateres servem para determinar o comportamento do comando em si. Tais
carateres são normalmente as opções e os argumentos.

* Entendendo a sintaxe de comando

 As opções servem para alterar o comportamento do comando. Elas (as opções)
são representadas por uma letra precedida por um hífen.

Ex. comando -opção

ls -l

De notar que podemos escrever o nome completo da opção ao invés da letra.

Para
tal, usa-se dois hífens.De notar que nem todos os comandos têm tais opções.

Ex. comando --opção

ls --help

Também, podemos definir o comportamento de um comando, especificando várias

opções.

Ex. comando -opção1opção2

ls -lat

-l : lista longa
-a : exibir arquivos ocultos
-t : listar por tempo
-h : leitura humana

Muitos comandos aceitam argumentos depois de algumas opções.

Argumentos: objetos na qual um comando deve atuar.

Ex. um usuário, dispositivo, diretório, ficheiro, etc.

O comando uname exibe o nome do sistema operativo que está rodando. Se

adicionarmos a
opção -a, ele nos trás também o nome da máquina, a versão do kernel,etc.

Nota:

O comando date tem uns tipos de opções especias que começam com o + ao invés
de - .
Por exemplo, podemos formatar a forma na qual a data é exibida.
Para saber como usar estas opções, digite primeiro o seguinte comando:

date --help

%a : dia da semana abreviado

%A : dia da semana completo
%b : mês abreviado
%B : mês completo
%c : data e hora local
%d : dia do mês
%D : data, é a mesma coisa que %m/%d/%y

date "+%d-%b-%y"

date "+%d-%B-%y"

Note que todo o usuário no sistema Linux é atribuido uma identidade que
contém, informações
tais como, o nome do usuário no sistema, o seu id, os grupos nos quais ele
está inserido e os
seus ids nestes grupos.

Para obtermos tais informações, digitamos o comando:

$ id
uid=501(chris) gid=501(chris) groups=105(sales), 7(lp)

O usuário chris tem o id número 501, o seu grupo primário é o chris onde ele
tem o id 501, ele
pertence também a alguns grupos secundários tais como sales onde ele tem o id
105 e o grupo lp onde
ele tem o id número 7.

Para vermos informações sobre a sessão do usuário logado, usa-se o comando

who.

$ who -uH

-u : lista os usuários logados no sistema.

-H : apresenta as informações dos usuários por colunas.

NAME LINE TIME IDLE PID COMMENT

chris tty1 jan 13 20:57 . 2012

chris é o usuário logado. Ele está logado no tty1 que é o primeiro console
virtual no monitor conectado
ao computador e sua sessão de login começou às 20:57 no dia 13 de janeiro. O
tempo IDLE mostra quanto
tempo o shell ficou aberto sem qualquer comando ser digitado ou seja, tempo
de inatividade onde o ponto,
indica que ele está ativo no momento. PID exibe o ID do processo do shell de
login do usuário. COMMENT
iria mostrar o nome do computador caso o usuário tivesse logado apartir de um
computador remoto.

* Localizando comandos

Note que os comandos são armazenados em diretórios e o shell tem de percorrer

esses paths para poder
localizar os mesmos.

Se conhecemos o diretório que contém um certo comando, podemos simplismente

digitar o caminho completo
ou caminho absoluto deste comando.

Por exemplo, é sabido que o comando date está localizado no diretório bin,
logo:

$ /bin/date

Os caminhos dos comandos podem ser muito longos e para evitar ter que se
memorizar longos caminhos para
a execução de comandos, é recomendável armazenar os comandos em um diretório
conhecido e adicionálos para
a variável de ambiente PATH do shell do usuário.
 Esta variável contém os caminhos dos diretórios que armazenam os comandos e
os organiza de forma sequencial.

Para ver o conteúdo da variável de ambiente PATH:

$ echo $PATH
/usr/local/bin:/usr/bin:/bin:/usr/local/sbin:/usr/sbin:/sbin:/sbin:
/home/cn/bin:/sbin

Os diretórios na lista de caminhos são separados por dois pontos.

A maioria dos comandos dos usuários que vêm com Linux (comandos do usuário
são aqueles que não se precisa de privilégios administrativos) para a
sua execução.

Note que os diretórios /sbin e /usr/sbin contêm comandos administrativos e

logo, alguns sistemas Linux não
colocam esses diretórios em caminhos de usuários normais.

O Linux só executa executáveis que estiverem na variável PATH ou você digite

o path absoluto.

Nota:
Nem todos os comandos estão localizados em diretórios na variável PATH.
Alguns comandos estão
predefinidos no shell.

Para sabermos em qual diretório um comando ou executável se encontra:

$ type comando/executável ou
$ which comando/executável

Note que podemos ver se o comando reside em mais de um diretório:

$ type ou which -a comando/executável

O comando locate serve para procurar um comando em todas as partes do

sistema.

-----------------------------------------------------------------------------------
-------------------------------------------------------------------------
4 - LEMBRANDO COMANDOS COM O HISTÓRICO DE COMANDOS
-----------------------------------------------------------------------------------
-------------------------------------------------------------------------

O histórico do shell é uma lista de comandos que foram executados anteriormente.

Para se exibir os comandos executados
anteriormente, podemos utilizar o comando history que pode ser acompanhado de uma
opção ou um número para especificar
o número de comandos anteriores.

Umas das vantagens é que pode se dar o caso em que os comandos executados são
longos ou que queremos fazer
algumas alterações na forma na qual eles serão executados.

* Edição da linha de comando

Ex. $ ls /usr/bin | sort -f | less

 Este comando lista todo o conteúdo do diretório bin e redireciona o resultado
para ser organizado independentemente
da case e apresentar o resultado por páginas. Pressionando o ENTER, avançamos
linha por linha e pressionando o SPACE,
avançamos página por página. Para sair, pressionamos em q.

Agora, suponhamos que queremos alterar o /usr/bin para /bin.

1. Pressione a tecla da seta para cima para trazer o último comando

executado.
2. Pressione ctrl + A para mover o cursor para o início da linha do
comando.
ctrl E para o fim da linha
3. Pressione ctrl + F ou a tecla de seta para a direita para posicionar
o cursor sob a primeira barra.
4. Pressione ctrl + D para eliminar algo. (Hint: coloque o cursor no
início da palavra).
5. Pressione ENTER para executar a linha de comando.
Teclas de atalho:

Caractere para frente : ctrl + F

Caractere para trás : ctrl + B
Palavra para frente :
Palavra para trás :
Início da linha : ctrl + A
Fim da linha : ctrl + E
Limpar tela : ctrl + L

Note que existem ainda outros atalhos para a edição da linha de

comandos.

Note que podemos executar um comando anterior se conhecemos o número de ordem

no qual ele foi executado.

Ex. $ !17

Também podemos executar o último comando imediatamente:

Ex. $ !!

-----------------------------------------------------------------------------------
-------------------------------------------------------------------------
5 - CONECTANDO E EXPANDINDO COMANDOS
-----------------------------------------------------------------------------------
-------------------------------------------------------------------------
Expressão Regular

RegEx é uma metodologia utilizada para encontrar padrões em textos. Ou seja,

formulas utilizadas para
encontrar valores específicos em textos. Ele nos permite buscar informações
que se encaixam em um padrão
sem ter que passar pelo documento todo. Em expressões regulares, podemos
utilizar caracteres e
metacaracteres.
Metacaractere é um caractere que nos permite conectar ou expandir comandos no
shell. Os metacaracteres podem
ter mais de um significado, dependendo do contexto.

Os metacaracteres estão divididos em dois grupos: Expressões Regulares e Wild Cards

\ | ! $ % & {} () [] ? ^ ~ < > ; . :

Caractere único (.) - Representa qualquer caracter único.

Ex grep .erson Texto

grep . Texto - substitui cada caractere do arquivo

Caractere de escape (\) - Converte um metacaractere em um caractere comum.

Caracteres Wild Cards

? - Substitui um caractere normal em uma string.

Ex. ls Testo?

* - Substitui um ou mais caracteres normais em uma string.

Ex. ls Tes*

| - Redireciona a saída de um comando como a entrada de um próximo comando

Ex. cat /etc/passwd | sort -f | less

; - Execução de um comando após o término de um anterior.

Ex. date ; cal ; ls

& - Execução de um segundo comando no background/segundo plano.

Ex. top | cal &

$(comandos) - Passar a execução de um conjunto de comandos como argumento

para outros comandos.

Ex. vi $(find Documentos/Notas | grep Frutas)

echo " Existem $(ls | wc -w) arquivos neste diretório"

$[expressão aritmética] - Passando expressão aritmética como argumento para

um comando.

Ex. echo "I am $[2022 - 1986] years old"

-----------------------------------------------------------------------------------
-------------------------------------------------------------------------
6 - USANDO VARIÁVEIS DE SHELL
-----------------------------------------------------------------------------------
-------------------------------------------------------------------------

O shell armazena informações em variáveis que podem ser úteis para a sessão de
shell do usuário.
Exemplo de variáveis:

$SHELL: identifica o shell que o usuário está a usar.

$PS1: define a sua prompt de shell

$MAIL: identifica a localização da caixa de correio.

Para ver todas as variáveis definidas para o seu shell atual,

set

Variáveis de Ambiente são espaços na memória que armazenam informações que servem
para
customizar as sessões de shell dos usuários.

Para ver as variáveis de ambiente:

env

Para listar as variáveis de ambientes e os seus valores:

declare

* Criação e uso de aliases

Com o comando alias, é possível criar um atalho para um comando em específico

com uma execução involvendo opções e argumentos específicos.

Para listar aliases:

alias

Para adicionar aliases:

alias remfiles='rm -i'

alias rememptydir='rmdir'
alias remdir='rm -ri'

Para remover um alias:

unalias nome do alias

* Encerrando o shell

Para sair do shell:

exit ou ctrl + D

-----------------------------------------------------------------------------------
-------------------------------------------------------------------------
7 - CRIANDO SEU AMBIENTE DE SHELL
-----------------------------------------------------------------------------------
-------------------------------------------------------------------------

* Configurando seu shell

É possível ajustar (tuning) o seu shell de formas a ajudar a trabalhar de

forma mais eficiente.
É possível definir aliases que criam atalhos para as linhas de comando e
variáveis de ambiente
para armazenarem informações. Adicionando tais informações aos arquivos de
configuração do shell,
o usuário se dispõe de configurações próprias sempre que abrir um shell.

São vários os arquivos de configuração que suportam a maneira como o shell se

comporta.
Alguns arquivos são executados para cada usuário e cada shell, enquanto
outros são
específicos do usuário que cria o arquivo de configuração.

Arquivos de configuração do Bash:

etc/profile
etc/bashrc
bash_profile
bashrc
bash_logout

-----------------------------------------------------------------------------------
-------------------------------------------------------------------------
8 - OBTENDO INFORMAÇÕES SOBRE COMANDOS
-----------------------------------------------------------------------------------
-------------------------------------------------------------------------

Para listarmos os diretórios que contêm comandos imediatamente acessíveis:

$ echo $PATH

Nota:
A maior parte dos comandos acessíveis se encontram no diretório /bin.

Alguns comandos são predefinidos no shell e não aparecem em nenhum diretório.

Com o comando help, é possível ver a lista destes comandos.

help | less

Para sabermos mais sobre um comando interno:

help comando

Nota: o comando help funciona apenas com o shell bash.

Podemos também usar o comando info para comandos internos.

Para saber mais sobre um determinado comando:

man comando
-----------------------------------------------------------------------------------
-------------------------------------------------------------------------

CAPÍTULO # 4: MOVENDO-SE PELO SISTEMA DE ARQUIVIOS

Alguns diretórios comuns no sistema Linux:

/bin
Contém comandos de usuários Linux tais como, ls, sort, date, chmod, etc.

/boot
Contém o kernel inicializável do Linux e os arquivos de configuração do
carregador de inicialização.

/dev
Contém arquivos que representam os pontod de acesso a dispositivos em seus
sistemas. Alguns dispositivos são:

terminal (tty*)
disquetes (fd*)
discos rígidos(hd* ou sd*)
RAM (ram*)
CD-ROM(cd*)

Os usuários podem acesssar esses dispositivos através desses arquivos de

dispositivo.
Mas note que alguns dispositivos ocultam dos usuários finais o nome dos
dispositivos reais.

/etc
Contém os arquivos de configuração administrativa.

/home
Contém diretórios atribuídos a cada usuário regular com uma conta de login. O
usuário root é
uma exceção, usando o /root como seu diretório inicial.

/media
Fornece uma localização padrão para dispositivos de automantagem (mídia
removível). Se o produto
possuir um nome de volume, esse nome é normalmente usado como ponto de
montagem.

Ex.
Se um USB tem o nome de volume myusb, ele seria montado em /media/myusb.

/lib
Contém bibliotecas compartilhadas requeridas por aplicativos em /bin e /sbin
para inicializar o sistema.

/mnt
Um ponto de montagem comum para muitos dispositivos. Muito usado para montar
sistemas de arquivos locais
ou remotos que não são montados de forma permanente.

/misc
Um diretório usado às vezes para montar sistemas de arquivos mediante
solicitação.

/opt
Estrutura de diretórios disponíveis para armazenar software suplementar.

/proc
Contém informações sobre os recursos do sistema.

/root
Representa o diretório do usuário root

/sbin
Contém comandos administrativos e processos de daemon.

/usr
Contém a documentação do usuário, jogos, arquivos gráficos (X11), bibliotecas
(lib) uma variedade de outros comandos
e arquivos que não são necessários durante o processo de inicialização.

/var
Contém diretórios de dados utilizados por vários aplicativos.

-----------------------------------------------------------------------------------
-------------------------------------------------------------------------
USANDO COMANDOS BÁSICOS DO SISTEMA DE ARQUIVOS
-----------------------------------------------------------------------------------
-------------------------------------------------------------------------

Faça login e abra um shell.

$ cd : muda para outro diretório.

$ cd : leva-te ao diretório inicial (home directory) ou cd ~

$ cd .. ou cd ../ : leva um diretório acima.

$ pwd : print working directory, nos diz onde estamos no sistema de arquivos.

$ mkdir : cria um diretório

$ chmod : altera a permissão sobre um arquivo ou diretório

ls : lista o conteúdo de um diretório.

Nota:

Quando usamos o comando cd e especificamos o caminho comecando com /, está a se

dizer ao shell para começar na raíz. Este tipo de
caminho é chamado de caminho absoluto (absolute path).

-----------------------------------------------------------------------------------
-------------------------------------------------------------------------
USANDO METACARACTERES E OPERADORES
-----------------------------------------------------------------------------------
-------------------------------------------------------------------------

Os metacaracteres e operadores são caracteres especiais que nos ajudam a trabalhar

com os arquivos (listar, mover, copiar, remover,
editar, etc) de uma forma mais eficiente.

Os metacaracteres podem nos ajudar a localizar um ou mais arquivos sem digitar o

nome completo do arquivo.
Os operadores nos permitem direcionar a informação de um comando ou arquivo para
outro comando ou arquivo.

* Utilizando metacaracteres para correspondência de arquivo

* : Localiza qualquer número de caracteres

? : Localiza qualquer caractere.
[...] : Localiza qualquer um dos caracteres dentro dos colchetes.

touch apple banana grape grapefruit watermelon

o comando touch cria arquivos vazios.

ls a* : lista todos os arquivos que começam que a letra a termina com

qualquer número de caracteres.

ls g*t : lista os arquivos que começam com a letra g, têm qualquer número de
caracteres ao meio e terminam com o caractere t.

ls *e* : lista os arquivos que começam com qualquer caractere, têm o

caractere e no meio e terminam com qualquer número de caractere.

ls ????e :

ls g???e* :

ls [abw]* :

ls [agw]*[ne]

* Utilizando metacaracteres para redirecionamento de arquivos

< : Direciona o conteúdo de um arquivo para o comando. Na maior parte das

vezes, essa é a ação padrão esperada pelo comando e o uso do caractere
é opcional.

comando < arquivo ou comando arquivo

> : Direciona a saída padrão de um comando para um arquivo. Se o arquivo

existir, o conteúdo dele será sobescrito.

comando > arquivo´

>> : Direciona a saída de um comando para um arquivo, adicionando a saída ao

final do arquivo existente.

* Uso de caracteres de expansão

{} pode ser usado para expandir um conjunto de caracteres nos nomes dos
arquivos.

touch memo{1,2,3,4,5}

touch {Gerson, Aguinaldo, Walter}-{Muel}

touch {a..f}{1..5}

-----------------------------------------------------------------------------------
-------------------------------------------------------------------------
LISTANDO ARQUIVOS E DIRETÓRIOS
-----------------------------------------------------------------------------------
-------------------------------------------------------------------------

ls é o comando mais comumente usado para listar informações sobre arquivos e

diretórios. Com as várias opções deste comando, é possível se reunir diferentes
conjuntos de arquivos e diretórios, bem como ver diferentes tipos de informações
sobre eles.

-l : esta opção lista os arquivos em uma lista longa que involve mais
detalhes do arquivo.

- : arquivo
d : diretório
l : link
-h : lista os arquivos de uma forma compreendida facilmente pelos humanos.

-----------------------------------------------------------------------------------
-------------------------------------------------------------------------
ENTENDENDO PERMISSÕES E POSSE DE ARQUIVO
-----------------------------------------------------------------------------------
-------------------------------------------------------------------------

Permissões associadas a arquivos e diretórios no Linux foram criadas para im pedir

que os usuários acessem arquivos privados de outros e para proteger
arquivos importantes do sistema.

Os nove bits atribuídos para cada permissão de arquivo definem o acesso que você e
outros têm sobre um arquivo. Bits de permissão para um arquivo regular
aparecem como -rwxrwxrwx. Esses bits são usados para defenir quem pode ler, gravar
ou executar o arquivo.

Das permissões de nove bits, os três primeiros bits se aplicam à permissão do

proprietário, os três seguintes se aplicam ao grupo atribuído ao arquivo e os
três últimos se aplicam a todos os outros.

0 = --- : sem permissões

1 = --x : permissão de execução
2 = -w- : permissão de escrita
3 = -wx : permissão de escrita e execução
4 = r-- : permissão de leitura
5 = rw- : permissão de leitura e escrita
6 = r-x : permissão de leitura e execução
7 = rwx : permissão de leitura, escrita e execução

ls -ld ch3 test

* Alterando permissões com chmod (números)

# chmod 744 file

Para dar permissões recursivas, ou seja de uma estrutura de diretórios:

$ chmod -R 755 path

* Alterando permissões com chmod (letras)

* Configurando a permissão de arquivo padrão com umask

Quando se cria um arquivo com um usuário comum, este recebe a permissão

rw-rw-r-- por padrão.

Um diretório recebe a permissão rwxrwxr-x

Para o usuário root, as permissões sobre arquivo e diretório são rw-r--r-- e

rwxr-xr-x.

Esses valores padrão são determinados pelo valor de umask. Para ver o seu
valor
de umask:

$ umask

* Alterando a posse de arquivo

Apenas o proprietário

chown proprietáriofile path

O proprietário e o grupo

chown proprietário:grupo

-----------------------------------------------------------------------------------
-------------------------------------------------------------------------
* MOVENDO, COPIANDO, E EXCLUINDO ARQUIVOS
-----------------------------------------------------------------------------------
-------------------------------------------------------------------------

Alterar a localização de um arquivo: mv

Copiar um arquivo de um local para o outro: cp
Excluir um arquivo: rm

Esses comandos podem ser usados tanto sobre diretórios como sobre arquivos, ou
recursivamente para agir sobre muitos arquivos e diretórios de uma só vex.

mv abc def
mv abc ~
Note que normalmente o comando mv sobescreve um artigo caso já existe um arquivo
no distino com o mesmo nome. Mas muitos sistemas Linux fornecem um alias ao comando
mv para que ele
use a opção -i (que faz o mv perguntar antes se você quer sobescrever arquivos
existentes.

Para verificar se o sistema usa um alias para o comando mv:

alias mv

Para copiar arquivos de um local para o outro

cp abc def
cp abc ~
cp -r path_origem path_destino
cp -ra path_origem path_destino

opção archive (-a):

Serve para manter a data, hora e as permissões do arquivo original caso não,
ele terá novos valores
a quando da cópia.

o comando cp também usa o alias cp que contém a opção -i.

O comando rm também faz o uso do alias com a opção -i.

rm abc
rm * : remove todos os arquivos de um diretório excepto os que começam com
ponto.
rmdir path: remover um diretório vazio.
rm -r path: remover um diretório com seus conteúdos, mas antes pergunta
rm -rf path: remove um diretório e seu conteúdo sem perguntar.

-----------------------------------------------------------------------------------
-------------------------------------------------------------------------

CAPÍTULO # 5 : TRABALHANDO COM ARQUIVOS DE TEXTO

-----------------------------------------------------------------------------------
-------------------------------------------------------------------------
EDITANDO ARQUIVOS COM VIM E VI
-----------------------------------------------------------------------------------
-------------------------------------------------------------------------

Nota:
No Linux, é preciso saber editar arquivos (vi), mas é preciso primeiro encontrar o
arquivo a ser editado (find). Muitas
das vezes, precisamos apenas de alterar certas partes de um arquivo (grep).

* Iniciando com o vi

O vi apresenta dois modos principais de operação:

comando
entrada
 Para entrar no modo de entrada, digite um comando de entrada. Para começar,
digite qualquer um dos seguintes comandos.

Quando você terminar de introduzir texto, pressione a tecla Esc (às vezes,
duas vezes) para voltar ao modo de comando.

a - o comando add : com esse comando, é possível inserir texto a partir do

fim da linha atual.

i - o comando insert : com esse comando, é possível inserir texto que começa
no início da linha atual.

o - o comando open below : esse comando abre uma linha abaixo da linha atual
e coloca você no modo de inserção.

O - o comando open above : esse comando abre uma linha acima da linha atual e
coloca você no modo de inserção.

* Movendo-se pelo texto

Use as setas para se mover pelo texto.

h : esquerda
l : direita
j : baixo
k : cima

w : move o cursor para o início da próxima palavra

b : move o cursor para o início da palavra anterior
0 : move o cursor para o início da linha atual
$ : move o cursor para o fim da linha atual

* Excluindo, copiando e alterando texto

x : Exclui o caractere sob o cursor

X : Exclui o caractere imediatamente antes do cursor.
d<?> : Exclui algum texto
c<?> : Altera algum texto
y<?> : Copia (yanks) algum texto

<?> : lugar do comando de movimento para escolher oq se está excluir,

alterar, ou copiar.

dw : Excluir (d) uma palavra (w) após a posição atual do cursor

db : Excluir (d) uma palavra (w) antes da posição atual do cursor
dd : Exclui toda a linha atual (d)
c$ : Altera (c) os caracteres a partir do caractere atual até o final
da linha atual ($) e entra no modo de entrada.
c0 : Altera (c) a partir do caractere anterior até o início da linha
atual (0) e entra no modo de entrada.
cl : Apaga (c) a letra atual (l) e entra no modo de entrada.
cc : Apaga (c) a linha e entra no modo de entrada.
yy : copia (y) a linha atual (y) para o buffer.
y) : copia (y) a sentença atual ( ) ), à direita do cursor, para o
buffer.
 y} : copia o parágrafo atual ( } ), à direita do cursor, para o buffer.

3dd : apaga as trâs linhas (3d) comecendo

3dw : apaga as próximas três palavras
5cl : Altere as próximas cinco letras remove as letras e entra no modo
de entrada.
12j : move-se para baixo 12 linhas
5cw : apaga as próximas cinco palavras e entra no modo de entrada.
4y : copia as próximas quatro sentenças.

* Colando texto

Depois que o texto foi copiado para o buffer (apagando, alterando ou

copiando-o), é possível colocá-lo de volta em seu arquivo
usando a letra p ou P. Com ambos os comandos, o texto mais recentemente
armazenado no buffer é copiado para o arquivo de
diferentes maneiras.

P : Coloca o texto copiado à esquerda do cursor se ele contiver letras

ou palavras; coloca o texto copiado acima da linha atual
se ele contiver linhas de texto.

p : Coloca em buffer à direita do cursor se ele contiver letras ou

palavras; coloca o texto em buffer abaixo da linha atual se ele
contiver linhas de texto.

* Repetindo comandos

Depois de excluir, alterar ou colar texto, você pode repetir essa ação,
digitando um ponto (.). Por exemplo, com o cursor no início
do nome Joe, você digita cw e digita Jim para alterar Joe para Jim.
Você pesquisa a próxima ocorrência de Joe no arquivo, posiciona
o cursor no início desse nome e pressiona um ponto. A palavra muda para
Jim e você pode pesquisar a próxima ocorrência.

* Saindo do vi

Comandos para salvar ou fechar o arquivo:

zz : Salva as mudanças atuais no arquivo e sai do vi.

:w :Salve o arquivo atual, mas continua no modo de edição.
:wq : O mesmo que zz
:q : Sai do arquivo atual. Isso sófunciona se você não tiver nenhuma
alteração não salva.
:q! : Sai do arquivo atual e não salva as alterações feitas no arquivo.

Considerações:

ESC : para voltar ao modo de comandos

zz : para sair do modo de comandos, salvar o arquivo e sair do vi
u : pressione quantas vezes for necessária para desfazer
alterações feitas
CTRL+R : desfazer o undo
* Procurando texto

* Localizando arquivos

Usa-se o comando locate para encontrarmos arquivos com base nos nomes.
Na maioria dos sistemas Linux, o comando updatedb é executado uma vez
por dia para coletar os nomes de arquivos em todo seu sistema Linux
em uma base de dados. Ao executar o comando locate, você pode pesquisar
a base de dados para encontrar a localização de arquivos armazenados nele.

Considerações ao usar o comando locate:

O comando locate localiza arquivos mais rápidos do que find,

porque ele pesquisa em uma base de dados, em vez de ter de procurar no
sistema de arquivos inteiros. Uma das desvantagens é que o
comando locate não pode encontrar todos os arquivos adicionados ao
sistema desde a última vez que a base de dados foi atualizada.

Nem todo arquivo no sistema de arquivos está armazenado na base

de dados. O conteúdo do arquivo /etc/updatedb.conf limita os nomes
que são coletados, deixando de fora tipos de montagem, tipos de
sistemas de arquivos, tipos de arquivo e pontos de montagem.

Se arquivos forem adicionados depois da execução do updatedb,

estes arquivos não serão localizados até que se execute novamente o
comando updatedb. Para que a base de dados tenha todos os
arquivos, execute o updatedb com o usuário root.

* Procurando arquivos com o find

O comando find é o melhor comando para procurar arquivos no sistema de arquivos,

com base em uma variedades de atributos. Depois de encontrar os arquivos,
é possível agir sobre eles usando as opções -exec ou okay executando todos os
comandos que quiser sobre os arquivos.

O comando find procura os arquivos em tempo real, oque o torna mais lento em
relação ao comando locate, mas trás uma atualização mais completa dos
arquivos no sistema. É possível especificar ao find em qual ponto começar a
pesquisa, desta forma, limitar o tempo de busca.

Quase todo tipo de atributo dos arquivos pode ser utilizado como opção de busca.

$ find
# find

Uma das opções mais usadas do find é a opção -ls (longa lista).

# find -ls

localizar arquivos por nome

 Para localizar arquivos por nome, pode se usar as opções -name, -iname.

find /etc -name passwd

find /etc -iname '*passwd*'

localizar arquivos por tamnaho

Se por exemplo o disco está cheio e você quer saber onde estão os
maiores arquivos, pode se pesquisar o sistema pelo tamanho dos arquivos.
A opção -size permite pesquisar por arquivos que têm exatamente o
tamanho selecionado ou que são menores que ou maiores que o tamanho
selecionado.

$ find /usr/share -size +10M

$ find /mostlybig -size -1M
$ find /bigdata -size +500M -size -5G -exec du -sh {} \;

localizar arquivos por usuário

É possível procurar um arquivo pelo proprietário (-user) ou pelo grupo

(-group). Usando -not e -or, é possível refinar a pesquisa por
arquivos associados a usuários e grupos específicos.

$ find /home -user oracle -ls

# find /home -user oracle -or -user joe -ls
# find /etc -group ntp -ls
# find /var/spool -not -user root -ls

localizar arquivos por permissão

$ find /bin -perm 755 -ls

$ find /home/oracle/ -perm -222 -type d -ls

localizar arquivos por data e hora

Data e hora são armazenados por todos os arquivos quando eles são
criados, acessados, modificados, ou metados são alterados. Os metados
são incluem o proprietário, o grupo, um registro de data/hora, o
tamanho do arquivo, permissões e outras informações armazenadas no inode
do arquivo.É possível pesquisar as alterações nos dados ou nos metados
dos dos arquivos por qualquer um dos seguintes motivos:

O conteúdo de uma arquivo foi alterado. Para ver o conteúdo dos

arquivos que foram alterados nos últimos 10 minutos:

$ find /etc/ -mmin -10

Para ver com que proprietário os comandos foram executados ou se as

permissões foram alteradas nos últimos três dias:

$ find /bin /usr/bin /sbin /usr/sbin -ctime -3

 Usando not e or ao localizar arquivos

$ find /var/allusers \(-user joe -or -user oracle\) -ls

$ find /var/allusers/ -user joe -not -group joe -ls
$ find /var/allusers/ -user joe -and -size +1M -ls

localizar arquivos e execuar comandos

A opção exec do comando find nos ajuda a executar comandos sobre os

arquivos encontrados sem parar para perguntar se está tudo bem.
Já a opção -ok, vai parar em cada arquivo localizado e perguntar se
você deseja executar o comando sobre o arquivo ou não.

$ find [options] -exec command {} \;

$ find /etc/ -iname iptables -exec echo "I found it {}" \;

$ find /usr/share -size +5M -exec du {} \; | sort -nr

Esse comando localiza todos os arquivos sob diretório

especificado que tem mais de 5MB. Em seguida, ele lista o tamanho de
cada arquivo com o comando du. A saída do find é depois
ordenada por tamanho, do maior para o menor. Inserindo -exec,
todas as entradas encontradas são processadas, sem
confirmação.

Pesquisando o conteúdo de arquivos com grep

Se quiser localizar arquivos que contêm um termo de pesquisa

específico, pode se usar o comando grep. Com grep, é possível pesquisar um
único arquivo ou uma estrutura de diretórios inteira de arquivos
recursivamente.

# grep desktop /etc/services

# grep -i desktop /etc/services

-----------------------------------------------------------------------------------
-------------------------------------------------------------------------

CAPÍTULO # 6 : GERENCIANDO PROCESSOS EM EXECUÇÃO

Processo : Um processo é uma instância de um programa em execução.Em outras

palavras, podemos dizer que um processo é um programa em execução.

-----------------------------------------------------------------------------------
-------------------------------------------------------------------------
ENTENDENDO PROCESSOS
-----------------------------------------------------------------------------------
-------------------------------------------------------------------------
Um mesmo programa pode ser executado por vários utilizadores no sistema logo,
podemos ter vários processos do mesmo programa. Os processos por sua vez,
são identificados pelo seu ID. Um processo não pode ser utilizado por outro
processo. Mas quando um processo é encerrado, ai sim, outro processo já poderá
utilizar o mesmo ID.

Para além do número de ID, os processos têm outros atributos. Cada processo está
associado a uma conta de usuário e a uma conta de grupo. Essas informações
ajudam a determinar os recursos da máquina a serem atribuídos. Os processos
executados pelo usuário root tem muito mais acesso aos arquivos e recursos do
sistema do que um processo executado por um usuário regular.

Nota:
A capacidade de gerenciar os processos em seu sistema é fundamental para um
administrador de sistema Linux. Existem ocasiões em que "processos desenfreados"
(runaway processes) podem matar o desempenho do seu sistema.
Encontrar e lidar com esses processos, com base em atributos como memória e uso
CPU, etc.

-----------------------------------------------------------------------------------
-------------------------------------------------------------------------
LISTANDO PROCESSOS
-----------------------------------------------------------------------------------
-------------------------------------------------------------------------

Para listar os processos em execução, usamos o comando ps.

$ ps
# ps

O comando top lista os processos em execução em tempo real.

$ top
# top

* Listando processos com ps

O ps é o utilitário mais comum para verificar os processos em execução. Ele é

usado para vermos quais programas estão em execuação, os recursos que
eles estão consumindo e quem os está executando.

$ ps u

Colunas:

USER
Indica o nome do usuário que iniciou o processo.

PID
Indica o ID de cada processo

%CPU
Percentagem de processador que o processo está consumindo

%MEM
Percentagem de memória que o processo está consumindo
 STAT - Status
O S significa sleeping enquanto o R significa Running.

VSZ - Virtual Set Size

Tamanho da memória virtual
Indica o tamanho do processo de imagem (em kilobytes)
A quantidade de memória alocada para o processo

RSS - Resident Set Size

Tamanho da memória residente
Exibe o tamanho do programa na memória.
A quantidade que está realmente sendo usada.

START
Exibe a hora em que o processo começou a rodar.

TIME
Exibe o tempo acumulado de uso do sistema.

Nota:
Muitos processos consomem pouco tempo da CPU, como refletido por 0.0 ou 0:0
para processos que ainda não usaram nem um segundo inteiro de tempo da
CPU.

Muitos processos executados em um computador não estão associados a um

terminal. Um sistema Linux normal tem muitos processos em execução em
segundo plano executam tarefas como registrar em log a atividade do sistema
ou ouvir dados provinientes da rede. Eles costuman ser iniciados
quando o Linux inicializa e são executados continuamente até que o sistema
seja desligado. Para percorrer todos os processos do usuário atual
em execução no sistema, adiciona a barra vertical e o comando less a ps ux

$ ps ux | less

Para percorrer todos os processos em execução para todos os usuários no

sistema:

$ ps aux | less

O comando ps pode ser personalizado para exibir colunas selecionadas. Para

indicar as colunas que queremos, usamos a opção -o e para exibir apenas
processos em execução, -e.

$ ps -eo 'pid,user,uid,group,gid,vsz,rss,comm' | less

Para ordenar os resultados de acordo ao consumo de memória:

$ ps -eo 'pid,user,uid,group,gid,vsz,rss,comm' --sort=rss| less

* Listando e alterando processos com top

O comando top exibe os processos com base em quanto tempo de CPU eles estão
atualmente consumindo. Mas é possível também ordenar por outras colunas. Depois de
identificar um processo mal comportado, você também pode usar top para
eliminar ou repriorizar esse processo. Mas para se poder eliminar ou
repriorizar processos, o top deve ser executado com o usuário root.
 As informações são exibidas de acordo a porcentagem de CPU que cada processo
consome.

Lista de ações que pode se realizar com o top para mostrar informações de
maneiras diferentes e modificar os processos em execução:

h : para ver as opções de ajuda

M : para ordenar por uso de memória

P : para voltar a ordenar por uso de CPU

1 : para exibir o uso de todas as CPUs caso existam mais de uma CPU.

R : para ordenar de forma reversa

u : para exibir os processos de um usuário em particular.

Nota:

Uma das práticas mais comuns é utilizar o comando top para identificar os
processos que estão a consumir muita memória. ou poder de processamento,
e então agir sobre eles. Um processo que consome muito CPU, pode ser
repriorizado para receber menos prioridade sobre os processadores.
Um processo consumindo muito memória, pode ser eliminado.

Repriorizando um processo:

Pressione r
Coloque o PID
Coloque o valor entre 19 ou 20

Eliminando um processo:

Observe o PID do processo a ser eliminado

Pressione k
Introduza o PID
Digite 15 para terminar o processo de forma limpa
Digite 9 para simplesmente eliminar o processo imediatamente

* Listando processos com o System Monitor

Applications >>> System Tools >>> System Monitor

Aqui, podes fazer qualquer atividade com os processos.

-----------------------------------------------------------------------------------
-------------------------------------------------------------------------
GERENCIANDO PROCESSOS EM PRIMEIRO E SEGUNDO PLANOS
-----------------------------------------------------------------------------------
-------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-------------------------------------------------------------------------
CAPÍTULO # 7 : ESCREVENDO SCRIPTS DE SHELL SIMPLES

Um script de shell é um grupo de comandos, funções, variáveis, ou qualquer outra

coisa que pode ser usada em uma shell. Esses itens são digitados em um
arquivo de texto simples que pode ser executado como um comando. A maioria dos
sistemas Linux utiliza scripts de shell durante a inicialização do sistema
para executar comandos necessários para fazer os serviços funcionarem. É possível
se criar scripts de shell para se automatizar tarefas que se faz
regularmente.

-----------------------------------------------------------------------------------
-------------------------------------------------------------------------
ENTENDENDO SCRIPTS DO SHELL
-----------------------------------------------------------------------------------
-------------------------------------------------------------------------

Para tarefas que precisam ser realizadas regularmente e que exigia muito trabalho
de digitação na linha de comando, um script de shell pode ser a solução,
uma vez que só precisarás pressionar um comando.

* Executando e depurando scripts de shell

Uma das grandes vantagens dos scripts de shell é que eles podem ser abertos
por qualquer editor de texto.
Uma das grandes desvantagens é que se eles forem muito grandes ou complexos,
a sua execução se torna mais lenta em comparação aos programas
compilados.

Duas formas básicas de se executar um script de shell:

O nome do arquivo é usado como um argumento para o shell (bash

myscript). Nesse método, o arquivo não precisa ser executável; ele apenas
contém uma lista de comandos de shell. O shell especificado na linha de
comando é utilizado para interpretar os comandos no arquivo de
scripts. Isso é mais comum para tarefas simples e rápidas.

O script de shell também pode ter o nome do interpretador colocado na

primeira linha do script precedido por #!(#!/bin/bash) e ter o bit
de execução do arquivo contendo o script configurado (usando chmod +x
nome_do_arquivo). Daí, é possível executar o script como qualquer
outro programa em seu caminho simplesmente digitando o nome do script
na linha de comando.

Para comentários, usa-se o sinal de jogo da velha #.

* Entendendo variáveis de shell

As variáveis são utilizadas em scripts de shell para o armazenamento de

informações que podem ser reutilizadas dentro da shell.

variable = value
 COUNTRY="Angola"
NUMBER_OF_PROVINCES=18

As variáveis podem ser atribuídos com os valores obtidos das saídas (outputs)
dos comandos.

DATA=$(date)