LPIC1 - Guia de Estudo PDF

ÍNDICE
Sobre o LPI........................................................................................................................5
CONCEITOS.......................................................................................................................6
O projeto GNU...............................................................................................................6
A GPL..........................................................................................................................6
Open Source x Free.......................................................................................................6
O Linux e as Distribuições................................................................................................7
O Kernel Linux...............................................................................................................9
Terminais do Linux........................................................................................................10
PROGRAMAS E COMANDO BÁSICOS.....................................................................................11
Comandos de desligamento............................................................................................17
Editor vim...................................................................................................................18
DISCOS E PARTIÇÕES........................................................................................................20
Discos.........................................................................................................................20
Partições.....................................................................................................................21
Esquemas de particionamento........................................................................................21
O FHS.............................................................................................................................22
GERENCIAMENTO DE PACOTES...........................................................................................23
Pacotes .deb (DEBIAN)..................................................................................................23
APT (Advanced Packaging Tool).......................................................................................25
Pacotes .rpm (RED HAT)................................................................................................27
YUM (Yellow dog Updater Modified).................................................................................28
INSTALAÇÃO DE SISTEMA OPERACIONAL.............................................................................29
Particionando o disco.....................................................................................................29
Configuração pós-instalação...........................................................................................30
O SHELL..........................................................................................................................31
Scripts do Shell............................................................................................................31
DOCUMENTAÇÃO NO LINUX................................................................................................33
Tipos de arquivos de documentação.................................................................................33
Seções de manuais.......................................................................................................33
Comandos de documentação..........................................................................................34
COMANDOS DE CONTEÚDO................................................................................................35
EXPRESSÕES REGULARES..................................................................................................42
Metacaracteres.............................................................................................................42
“Pipes”, redirecionamentos e execução de comandos em sequência......................................43
Codificação de caracteres...................................................................................................45
USUÁRIOS E GRUPOS........................................................................................................46
Arquivos importantes....................................................................................................46
Comandos de usuário e grupos.......................................................................................48
SUDO..........................................................................................................................53
PERMISSÕES....................................................................................................................55
Tipos e aplicações.........................................................................................................55
Permissões especiais.....................................................................................................55
Campos de permissões..................................................................................................55
Modo octal de permissões..............................................................................................56
Guia de Estudo para LPIC1 - Bruno Odon - howtoonline.com.br 1

Aplicação.................................................................................................................56
Umask........................................................................................................................57
SISTEMAS DE ARQUIVOS...................................................................................................58
EXT2...........................................................................................................................58
EXT3...........................................................................................................................58
EXT4...........................................................................................................................58
ReiserFS......................................................................................................................59
UFS............................................................................................................................59
JFS.............................................................................................................................59
XFS............................................................................................................................59
Swap..........................................................................................................................59
Proc............................................................................................................................59
ISO9660......................................................................................................................59
Comandos administrativos de filesystems.........................................................................60
Sistema de arquivos SWAP.............................................................................................63
Diretório /dev e gerenciador UDEV..................................................................................64
Montagem de volumes...................................................................................................65
LINKS..............................................................................................................................68
Hardlink (link físico)......................................................................................................68
Softlink (link simbólico).................................................................................................68
COMANDOS DE BUSCA......................................................................................................69
RAID...............................................................................................................................70
Criando arranjo RAID....................................................................................................71
Verificando funcionamento do arranjo..............................................................................72
Formatando e montando o arranjo...................................................................................73
Discos falhando no arranjo.............................................................................................73
BACKUP E COMPACTAÇÃO..................................................................................................74
Tipos de backup...........................................................................................................74
Diretórios importantes..................................................................................................74
Arquivamento de backups..............................................................................................74
Agentes compactadores.................................................................................................76
AGENDAMENTO DE TAREFAS...............................................................................................78
Diretórios importantes...................................................................................................78
Programas de agendamento...........................................................................................79
Controle de acesso a agendamentos................................................................................81
COTAS DE ARMAZENAMENTO..........................................................................................82
Limites de cotas............................................................................................................82
Aplicação.....................................................................................................................83
GERENCIAMENTO DE PROCESSOS E INICIALIZAÇÃO..............................................................86
Comandos de gerenciamento de processos.......................................................................87
Processo INIT...................................................................................................................91
SysVinit......................................................................................................................91
SystemD.....................................................................................................................93
KERNEL...........................................................................................................................97
Compilação de Kernel....................................................................................................97
Comandos de Kernel......................................................................................................99
Comandos de Hardware...............................................................................................101

GERENCIADORES DE BOOT...............................................................................................102
LILO (Linux Loader).....................................................................................................102
GRUB (Gran Unified Boot Loader) - Legacy......................................................................103
GRUB 2.....................................................................................................................106
COMPILAÇÃO DE PACOTES E BIBLIOTECAS.........................................................................107
SHELL SCRIPT.................................................................................................................109
Aliases.......................................................................................................................109
Funções.....................................................................................................................109
Variáveis de Shell........................................................................................................110
Criação de scripts de Shell............................................................................................112
Estruturas de análise lógica.....................................................................................114
REDES EM LINUX.............................................................................................................120
Protocolos e portas......................................................................................................120
Configuração de rede...................................................................................................122
Comandos de rede......................................................................................................124
Interfaces de rede virtuais............................................................................................126
Rotas........................................................................................................................127
CLIENTES DE SEVIDORES LINUX.......................................................................................129
DHCP........................................................................................................................129
FTP...........................................................................................................................129
DNS..........................................................................................................................130
SERVIDOR DE LOGS........................................................................................................133
Rotatividade dos logs...................................................................................................134
SUPERSERVIDORES.........................................................................................................136
Inetd.........................................................................................................................136
Xinetd.......................................................................................................................136
TCP WRAPPERS...............................................................................................................137
SSH...............................................................................................................................138
Comandos............................................................................................................138
SINCRONIZAÇÃO DE DATA E HORA....................................................................................140
SERVIDOR X...................................................................................................................142
Gerenciadores de Desktop............................................................................................143
Gerenciadores de login.................................................................................................144
SERVIÇO DE IMPRESSÃO..................................................................................................145
Comandos de impressão..............................................................................................145
LINGUAGEM SQL.............................................................................................................146
Comandos SQL...........................................................................................................146
MTA...............................................................................................................................148
Comandos de MTA.......................................................................................................149

Sobre o LPI
O Linux Professional Institute , com sede em Ontário (Canadá), tem a

missão de certificar profissionais Linux em 3 níveis:
✔ Administrador Linux Júnior – LPIC1
✔ Administrador Linux Pleno – LPIC2
✔ Administrador Linux Sênior (especialistas)
✗ Ambientes Mistos – LPIC3-300
✗ Segurança – LPIC3 – 303
✗ Virtualização e alta disponibilidade – LPIC3-304
Os objetivos e especialidades das certificações oferecidas por este instituto não se prendem a
nenhuma distribuição ou fabricante específico, ou seja: seu conteúdo é totalmente aplicável em qualquer
plataforma que esteja sob qualquer sistema GNU/Linux, certamente por este motivo é um grande peso
no currículo de qualquer profissional de infra-estrutura de TI.
O candidato a qualquer nível de certificação deve sempre estar atualizado com as informações
do site lpi.org pois as versões dos exames têm vida útil e sofrem atualizações.
Regras do exame
✔ A prova é composta de questões de múltipla escolha e também de discursivas (geralmente

pedindo texto simples como resposta, como comandos, caminhos de arquivos ou opções de comando);
✔ O aluno tem 90 minutos para a conclusão da prova;

✔ A pontuação mínima para passar em qualquer exame é de 500 mas não se engane: o total de
pontos da prova é de no máximo 850;
✔ Os objetivos têm pesos diferentes, o que significa que um determinado assunto pode ter mais
questões dentro da prova do que outro;
✔ Dependendo do nível, a prova não possui versão em português;
✔ O exame é realizado em formato presencial em um dos centros de aplicação de provas (Testing
Center).
Passos para certificar-se
1. Registrar-se em lpi.org ;
2. Já com o seu LPI ID, realizar a compra do voucher em lpimarketplace.com;
3. Obter o exame junto à Pearson Vue em pearsonvue.com/lpi utilizando o voucher. Na verdade,
você pode comprar o voucher direto na Pearson Vue;
4. Marcar o exame junto ao centro de aplicação.

CONCEITOS
Antes de começar a administrar sistemas operacionais Linux, é preciso ter alguns conceitos bem
fundamentados:
O projeto GNU
Este projeto surgiu em 1983 (criado por Richard

Stallman) e, desde este momento, teve como objetivo a criação
de softwares livres baseados em sistemas operacionais Unix. O
nome GNU vem de “GNU is Not Unix”, e não somente do nome
do animal Gnu, como muitos pensam. Este projeto é o
responsável por desenvolver alguns softwares muito conhecidos
pelo público que usa sistemas open-source, como GIMP e
GNOME, por exemplo.
É sempre importante ressaltar que Linux também não é
GNU, mas que os sistemas operacionais Linux utilizados hoje em
dia pode tranqulilamente ser chamados de GNU/Linux. Este fato
se explica porque o que se aplica do projeto GNU em sistemas
operacionais GNU/Linux é apenas a estrutura de arquivos e diretórios, o núcleo aplicado foi desenvolvido
por Linus Torvalds (que não tem nada a ver com o projeto) e, desde então, vem sendo aplicado em
conjunto com sistemas operacionais GNU.
A GPL
A FSF (Free Software Foundation) criou, como parte do projeto GNU, a GPL (General Public
License, ou Licença Pública Geral), para que houvesse um padrão de licenciamento para os softwares
livres a serem desenvolvidos a partir do fim da década de 80. O desenvolvedor da GPL foi Richard
Stallman.
Ela é baseada em 4 liberdades:
Execução do software(liberdade nº 0);

Estudo do software(liberdade nº 1);
Distribuição do software(liberdade nº 2);
Aperfeiçoamento do software(liberdade nº 3).
Como integrantes da lista de softwares baseados em GPL (os chamados “open-source”) estão
sistemas operacionais como FreeBSD, OpenSolaris e IBM-AIX (que são baseados em Unix), Debian,
Red Hat, Slackware e Suse, que funcionam sobre Kernel Linux.
Open Source x Free
Ser open-source não significa ser grátis. Empresas como a Red Hat e a Novell cobram pelo
suporte de seus produtos Red Hat Enterprise e Suse Linux Enterprise, respectivamente.

O motivo de se poder cobrar pelo suporte de produtos é que, sobre isso, não se opõe a GPL, já
que o Kernel continua sendo Linux (cujo código fonte pode ser facilmente encontrado em kernel.org para
download) e as outras liberdades continuam garantidas ao usuário.
Existem sim alguns exemplos de “distros” que, além de serem open-source, são também “free” e
são excelentes opções para Servers e(ou) Desktops. Exemplos bem claros disso são as distribuições
Debian, Ubuntu, CentOS e Fedora.
Para maiores detalhes sobre a GPL, pode-se consultar a URL gnu.org/licenses.
O Linux e as Distribuições
Criado pelo até então universitário Linux Torvalds em Helsinki (Finlândia), o Linux surgiu de um
estudo de uma versão reduzida de kernel Unix (o Minix) em um projeto de faculdade.
A primeira versão do Kernel foi lançada em 1991 e, a partir daí, este kernel Linux começou a ser
utilizado por diversas distribuições open-source.
As distribuições mais significativas são:
Debian, Red Hat, Suse, Slackware, Gentoo, Arch Linux, Mandriva, Ubuntu, CentOS e
Fedora.
Algumas “distros” se originaram de outras, pois é bem mais prático e coerente desenvolver uma
grande solução em cima de outra que já funcione muito bem nos mesmo padrões desejados.
O Ubuntu há muito tempo já conquistou a confiança de usuários e empresas

como sistema operacional para desktops e mobiles. Já no início, a Canonical (empresa
que desenvolveu a solução) enviava de graça ao usuário um CD com a distribuição para
o usuário instalar, era só solicitar o envio no próprio site. Ele é disponibilizado até hoje
gratuitamente para Download no dite ubuntu.com nas versões Desktop e Server. As 2
versões são baseadas em Debian e são bem robustas e bem avaliadas por seus usuários
finais e administradores.
Como desktop manager, o Ubuntu utiliza o Unity, que traz um layout que favorece o uso do
sistema por dipositivos com touch screen.

O Ubuntu Desktop hoje é o sistema operacional GNU/Linux mais utilizado por usuários finais.
Isso também se deve ao fato de ter tantos aplicativos já embutidos na Distro, como a suíte de aplicativos
LibreOffice, por exemplo.
O Debian já é um sistema operacional muito mais focado em

aplicações para servidores e é preferido pela maioria dos estudantes de
especialistas em Linux pelo fato de ele ser 100% free e de ter o modo
de instalação CORE, que não carrega nenhum tipo de aplicação além
do próprio sistema básico, o que quer dizer que o sistema fica
totalmente “cru” para que o próprio administrador escolha,
efetivamente, que tipo de papel ele vai desempenhar como sevidor de
rede. Outra grande vantagem do Debian é o seu caráter modular, onde a maioria dos recursos adicionais
do Kernel são carregados na imagem INITRD como módulo e não junto com o Kernel, tornando o boot
mais rápido e a execução do sistema operacional mais “enxuta”, visto que requer menos espaço em
memória RAM. Dependendo da aplicação, um servidor com Debian requer apenas 512MB de RAM.
Talvez seja a distribuição que mais segue à risca os conceitos de GPL, pois todo o seu
desenvolvimento é colaborativo e é uma fundação sem fins lucrativos, que vive de doações de grandes
empresas e pessoas físicas. Muitos repositórios oficiais do Debian estão dentro de grandes
universidades do mundo inteiro. No Brasil, UFRJ, PUC e UniCamp são exemplos.
O Red Hat hoje existe apenas em versão Enterprise, onde você paga
pelo suporte e pelo uso dos repositórios mas nem sempre foi assim. Ele foi 100%
gratuito até a versão 9. A grande vantagem é que o Red Hat Enterprise Linux
(RHEL) é homologado para aplicações de grande porte, como gerenciamento de
storages e bancos de dados Oracle,. A parceria com empresas como IBM e Dell
permite aos RHEL ocupar um alto posto de confiabilidade por parte dos clientes
que conta com eles em seus data centers, pois é a certeza de que todos os
recursos de hardware foram otimizados para o Sistema Operacional, seja por
módulos, seja built-in (inserido no corpo do Kernel).
É também uma distro de referência para a criação de outras. O Fedora, o CentOS e o Oracle
Enterprise Linux são grandes exemplos de distribuições baseadas em Red Hat.
O Slackware talvez seja a distribuição mais evitada por quem está começando a
sua caminhada em sistemas GNU/Linux. É um sistema operacional voltado apenas para
administradores experientes. A configuração de rede já é completamente diferentes das
“irmãs” anteriores, assim como a própria instalação do sistema operacional. Outro
detalhe interessante é que os pacotes precisam ser instalados via código-fonte, o que
desanima até os mais experiantes na área. É um projeto pouco atualizado e muito pouco
implementado no mercado justamente por conta da relação “complexidade x benefício”. É complexo e
ultrapassado.

O Kernel Linux
O Kernel é a camada lógica entre o sistema operacional e e a parte física do sistema. É dele a
responsabilidade de reconhecer e operar cada recurso de hardware e sotware que será disponibilizado
para o usuário. Protocolos de rede, tipos de discos, quantidade máxima de RAM, recursos de
processamento e virtualização são exemplos de o que o Kernel tem que oferecer ou não ao sistema
operacional.
Seguindo as 4 liberdades da GPL, o Kernel pode ser facilmente baixado de kernel.org , estudado
recompilado e distribuído à vontade.
O que acontece muito é uma empresa ou desenvolvedor independente criar sua própria
distribuição e customizar o Kernel Linux para otimização dos recursos. O SmoothWall é uma
distribuição Linux que oferece serviço de firewall e proxy, assim como o Endian Firewall, sendo assim,
por que elas precisariam dos módulos de aceleração gráfica? Em contrapartidada, é necessário o
máximo de suporte possível a drivers e protocolos de rede, assim como a camada 7 do modelo OSI
aplicada no Kernel.
Importante: o Kernel Linux não é o único núcleo de sistema operacional open source. O kernel
KfreeBSD é um outro grande exemplo de Kernel que segue a GPL. Já existiu um esforço do Debian em
trabalhar também com este kernel mas o Debian/KfreeBSD infelizmente foi abandonado.
Um kernel pode ser classificado de 2 formas:
Monolítico: carrega todos os recursos de que precisa na

própria imagem de boot do kernel.
Modular: carrega grande parte dos recursos de kernel em
módulo que podem ou não ser carregados após o boot do sistema.
A maioria dos sistemas operacionais prefere trabalhar com kernel
modular.
Estas definições podem ser feitas quando o administrador
configura e compila o kernel.
Versões do kernel
A partir do Kernel 3, o versionamento do Kernel mudou. No
modelo antigo (até o Kernel 2.6) o versionamento funcionava desta
forma:
<versão_maior>.<versão_menor>.<compilação/patch>.<versão extra>
As alterações comuns eram todas feitas no campo 'compilação/patch' e as modificações mais
bruscas eram feitas na versão menor. Praticamente não se mudava a versão maior. Um grande exemplo
foi a transição do Kernel 2.4 para o 2.6, onde houveram transformações muito grandes mas apenas a
versão menor foi modificada.
Hoje funciona assim:
<versão_maior>.<versão_menor>.<compilação_patch>
Pode parecer que não mudou nada mas a verdade é que está bem diferente o versionamento. A
versão menor agora é modificada em qualquer alteração feita no Kernel e modificações mais
siginificativas são feitas na versão maior mesmo.

Terminais do Linux
Um terminal nada mais é do que a interface de interação entre o sistema operacional e o

usuário/administrador. Alguns terminais de sistemas GNU/Linux disponibilizam apenas a interface em
modo texto (para trabalhar com linhas de comandos e editores de arquivos de configuração) mas
também existem os terminais destinados à interface gráfica. A grande maioria dos adminstradores
preferem a interface em modo texto (a famosa tela preta) pois consome muito menos recursos de
Hardware e também dá uma possibilidade muito maior de depuração.
Terminal Uso Teclas de atalho
/dev/tty1 Modo de comandos CTRL+ALT+F1
/dev/tty7 Interface Gráfica CTRL+ALT+F7

Estes terminais são utilizados por interpretadores de comandos, como BASH, SH e KSH, no uso
dos comandos administrativos e de usuários.
Para logins remotos e emulações de terminais em modo gráfico, são utilizados os terminais
/dev/pts/<num>.
Exemplos:
/dev/pts/0 – um terminal emulado por xterm.

/dev/pts/1 – um terminal utilizado por shell seguro (SSH).
/etc/securetty : é o arquivo onde se encontram todos os terminais suportados pela distribuição.

Ele pode ser usado para restringir ou permitir o uso de terminais no sistema.
A tendência clara de um usuário final é “fugir” dos terminais do Linux, até porque sua usabilidade
não atende às aplicações das quais ele faz uso, portanto, é importante que sejam utilizados
gerenciadores de desktop em sistemas Linux que forem para este fim. Exemplos de gerenciadores de
desktop são KDE e GNOME.
PROGRAMAS E COMANDO BÁSICOS
Os comandos GNU/Linux são totalmente SENSITIVE CASE. Isso significa que se uma opção de
um comando ou um comando for minúscula, ela não funcionará se for trocada por maiúscula.
Alguns comandos têm opções em modo curto e modo longo. Algo do tipo: -a que também pode
ser usado como --arg.
#ls
Lista conteúdo de diretórios.
Sintaxe:
#ls <opções> <diretório>
Opções:
-l : modo longo. Lista detalhes sobre os objetos, como o dono, o grupo, as permissões,
data de última alteração e tamanho (a unidade padrão é o byte).
-a ou --all : lista todos os objetos contidos no diretório, inclusive os ocultos.
-i ou –inode : lista o número inode de todos os objetos (índice que o sistema de arquivos usa
para identificar o arquivo ou diretório).
-c : lista em odem alfabética.
-h ou --human-readable: lista o conteúdo no modo “mais humano”. A unidade de tamanho de
cada objeto é a mais compreensível possível.
-C : lista o conteúdo em colunas.
-t : classifica o conteúdo pela data de última modificação (ctime).
-S : classifica os arquivos pelo tamanho.
-R: lista o conteúdo recursivamente, subdiretórios e arquivos.
-r: classifica o conteúdo em ordem alfabética reversa.
Exemplos:

Listando todo o conteúdo do diretório /root/LPI, inclusive arquivos ocultos, em modo longo e
“mais humano”:
#ls –lha /root/LPI
Listando por ordem alfabética reversa e de modo recursivo, todo o conteúdo de /etc:
#ls –lrR /etc
Listando em modo longo os arquivos e diretórios de /var/www e o número inode de cada um:
#ls –li /var/www
Detalhes de um arquivo:
Ao listar um diretório específico com 'ls -l', foram verificados alguns itens interessantes:
Acontece que a primeira coluna representa o tipo do arquivo e as permissões aplicadas a ele.
Dessa primeira coluna, vamos destacar por hora o tipo (primeiro campo).
Os arquivos estão divididos em alguns tipos:
_ : é um arquivo regular.
d : é um diretório.
l : é um link simbólico.
b: é um arquivo de bloco (um disco ou uma partição).
c: é um arquivo de caracteres (um terminal, por exemplo).
p: é um pipe.
s: é um socket.
As outras colunas são:

<arquivos contidos> <dono> <grupo> <tamanho> <data de última modificação>
#file
Mostra qual o tipo de arquivo em questão.
Sintaxe:
#file <objeto>

#touch
Cria arquivos vazios e/ou troca data de modificação de arquivos.
Sintaxe:
#touch <opções> <arquivo>
Opções:
-d : especifica data.
-m : troca data de última modificação.
-r : utiliza data de última modificação de um outro arquivo como referência.
Exemplos:
#touch -m -d 20160512 arq1 : troca a data de última modificação para 12/05/2016.
#touch arq2 : cria um arquivo vazio chamado 'arq2'.
#cd
Troca de diretórios.
Sintaxes:
#cd <diretório_destino>
#cd .. - retorna um nível na hierarquia.
#cd ../.. - retorna 2 níveis na hierarquia.
#cd ~ - muda para o diretório pessoal do usuário em seção. É o mesmo que cd sem
argumentos.
#cd ~user1 – muda para o diretório pessoal do usuário user1.
#cd ../<dir1> – muda para o diretório 'dir1', que está um nível hierárquico acima.
#mkdir
Cria diretórios.
Sintaxe:
$mkdir <opções> <diretórios>
Opções:
-v : “verbose”. Exibe detalhes do que foi feito.
-m <perm>: cria o diretório já com as permissões determinadas.
-p : cria subdiretórios e diretórios de uma vez só. Não há a necessidade de existir o
diretório pai para que seja criado o subdiretório.
Exemplos:
Criando os diretótios linux/debian/ubuntu de uma só vez e exibindo a saída do comando:

#mkdir -pv linux/debian/ubuntu
Criando o diretório suse com permissão 733 (permissões de arquivos e diretórios serão
detalhadas mais à frente).
#mkdir -mv 733 suse
Criando diretórios dir1, dir2, dir3 e dir4 em um só comando, exibindo também a saída do
comando:
#mkdir -v dir{1,2,3,4}
Criando diretórios dir10, dir11, dir12, dir13, dir14, dir15 em um só comando, em modo
“verbose”:
#mkdir -v dir{10..15}

#rmdir
Exclui diretórios vazios.
Sintaxe:
#rmdir <diretório>
#rm
Exclui arquivos e diretórios.
Sintaxe:
#rm <opções> <arquivo/diretório>
Opções:
-v : verbose.
-i : modo interativo. Espera confirmação do usuário para excluir.
-r : modo recursivo. Exclui diretório e seu conteúdo.
#mv
Move ou renomeia arquivos e diretórios.
Sintaxe:
#mv <opções> <arquivo/diretório> <dir_destino/nome_destino>
Opções:
-i : modo interativo. Pergunta antes de sobrescrever um arquivo existente com o mesmo nome.
-v : modo verbose.
-n : não sobrescreve um arquivo de destino com o mesmo nome.
-f : modo forçado.
#cp
Cria cópias de arquivos ou diretórios.
Sintaxe:
#cp <opções> <origem> <destino>
Opções:
-R : modo recursivo. Copia diretório e seu conteúdo.
-v : modo verbose.
-i : modo interativo. Pergunta antes de sobrescrever destino.
-u : modo “update”. Apenas copia para o destino arquivos que o mesmo não tem ou que, a
pesar de ter o mesmo nome, são diferentes em seus conteúdos.
-f : modo forçado de cópia.
-p : preserva os atributos originais do arquivo.
-d : preserva ligação simbólica.
Exemplos:
Copia todos os arquivos de /etc/network para /tmp mantendo seus atributos em modo verbose:
#cp -vp /etc/network/* /tmp
Apenas copia o arquivo /etc/passwd se houver alguma modificação do original em relação ao

arquivo de destino com o mesmo nome:
#cp -vu /etc/passwd /tmp

#du
“Disk usage” - exibe o tamanho em disco ocupado por diretórios.
Sintaxe:
#du <opções> <diretório>
Opções:
-k : em KB.
-m : em MB.
-h : modo mais “humano”. Exibe o resultado no múltiplo de byte mais compreensível.
-s : modo simples. Só exibe o tamanho ocupado pelo diretório, não o de seu conteúdo.
Exemplo:
Exibindo o tamanho ocupado por todos os subdiretórios de /etc/network e por ele próprio em
modo mais “humano”:
#du -h /etc/network
#df
Exibe informações sobre armazenamento de volumes montados.
Sintaxe:
#df <opções> <volume>
Opções:
-k : em KB.
-m : em MB.
-h : modo mais “humano”. Exibe o resultado no múltiplo de byte mais compreensível.
-i : ao invés de exibir informações sobre blocos, exibe informações sobre inodes.
Exemplo:
Exibindo o espaço ocupado pela partição /dev/sda5, que está montada:

#df -h /dev/sda5
Mostrando informações sobre a reserva de inodes da partição montada /dev/sda5:

#df –hi /dev/sda5

#cal
Exibe o calendário no terminal.
Opções:
-j : exibe calendário juliano (dias corridos do ano).
-3 : exibe calendário do mês anterior, do atual e do posterior.
-m <num> : exibe calendário do mês específico.
Exemplo:
Exibindo o calendário dos dias corridos até hoje desde o início do ano:
#cal -j
#date
Exibe ou modifica a data e hora do sistema.
Opções:
--utc : exibe data e hora no padrão UTC(Universal Time Clock).
-r <arquivo>: exibe data e hora de última modificação de um arquivo.
-R : exibe data e hora no formato RFC2822.
+<var> : utiliza variáveis do comando para exibir em formato específico.
Variáveis do date:
%d : dia.
%m : mês.
%y : ano com 2 dígitos.
%Y : ano com 4 dígitos.
%H : hora.
%M : minuto.
%S : segundo.
%e : dia do mês.
%b : mês por extenso.
Sintaxes:
$date <opções>
$date +<variáveis>
#date MMDDhhmmAAAA (mês,dia,hora,minuto e ano) – modificação da data.
Exemplos:
Modifica a data para 27/07/2016 e hora para 08:31.

#date 072708312016
3 Formas diferentes de representação de data:

#free
Exibe informações sobre uso de memórias RAM e Swap.
Sintaxe:
#free <opçoes>
Opções:
-k : em KB.
-m : em MB.
-g : em GB.
-t : exibe RAM+Swap.
Exemplos:
Exibindo o tamanho total de memória ocupado em MB:

#free -m
Exibindo em tempo real (executando o comando de 1 em 1 segundo) o uso de RAM + Swap:

#watch -n1 free -mt
*Obs: O comando watch tem a função de repetir a cada ‘x’ segundos um comando específico, o
padrão é o intervalo de repetição de 2 segundos.
Comandos de desligamento
#halt e #poweoff
Desligam o sistema.
#shutdown
Desliga, reinicia ou simula desligamento.
Sintaxe:
#shutdown <opções>
Opções:
-h : desliga o sistema.
-r : reinicia o sistema.
-k : simula o desligamento do sistema enviando mensagens de aviso para todos os
terminais.
-f : pula verificação de disco no próximo boot.
-F : força verificação de disco no próximo boot.
Exemplos:
Desliga o sistema.
#shutdown -h now
Agenda desligamento do sistema para 23:30.

#shutdown -h 23:30
Simula desligamento imediato enviando mensagem para os terminais ativos:

#shutdown -k now

Editor vim
Editor de texto sucessor do VI, que possui compatibilidade com qualquer sistema Linux.
#vim <arquivo> – edita arquivo.
Opções internas do editor:
<insert> – modo de inserção de texto.

<insert>2x – modo 'replace'. Sobrescreve conteúdo posterior.
<esc> – entra em modo de comandos.
v – entra em modo 'visual'. Seleção de texto.
Comandos:
yy – copia linha inteira.
y – copia conteúdo selecionado.
p – cola.
x – recorta conteúdo selecionado.
dd – exclui linha inteira.
d – exclui conteúdo selecionado.
:set number – exibe linhas numeradas.
:set nonumber – desliga numeração.
:%s /<texto>/<texto> – substitui texto.
/<texto> – busca por texto. A tecla n continua a busca.
:<num> – vai para a linha <num>.
:split <arquivo> ou :sp <arquivo> – abre outro arquivo no editor.
CTRL+ALT+W – troca de documentos em modo 'split'.
:!<comando_do_shell> – executa um comando do shell dentro do vim.
:.!<comando_do_shell> – além de executar o comando do shell dentro do vim, copia sua
saída padrão para o arquivo.
:w – salva arquivo.
:q – sai sem salvar.
:wq ou :x – sai salvando.
:w <caminho>/<nome> – salva como...
:<comando>! - força o uso do comando.
ALT+U – desfaz alteração.
CTRL+R – refaz alteração
.
O editor VIM é, com certeza, uma ótima ferramenta para um administrador de sistema e rede
Linux, uma vez que muitos serviços de sistema dependem única e exclusivamente de um arquivo de
configuração, sem contar a programação em Shell Script, que fica muito mais interessante com os
recursos do VIM. O arquivo de coniguração de recursos do VIM é o /etc/vim/vimrc no Debian e /etc/vimrc
em Red Hat. Uma instalação padrão do Debian não contempla o VIM, o que quer dizer que o
admininstrador terá que instalar o editor manualmente.
Outro recurso importantíssimo do VIM é a manutenção de um arquivo de backup para cada

documento que está sendo redigido, protegendo o seu conteúdo contra qualquer desligamento
involuntário ou contra qualquer outro tipo de acidente que impossibilite o administrador de salvar o
arquivo antes. Neste caso, é mantido um arquivo com o seguinte nome: .<nome_original>.swp, que é o
chamado arquivo de swap, este conteúdo que está dentro dele só pode ser restaurado com o seguinte
comando:
#vim -r <nome_original>

Logo após, o documento tem que ser salvo com a opção w e depois que já tiver tudo “OK” com o
arquivo é recomendável excluir o arquivo de swap, pois, se isto não for feito, toda vez que for abrir o
arquivo o editor irá te avisar de que existe um arquivo de swap e irá te perguntar de o que você deseja
fazer em função disso.
#vim /etc/vim/vimrc
No caso acima, estamos habilitando alguns padrões para o VIM em seu arquivo de configuração:
'syntax on' habilita as cores de sintaxe do VIM. Para quem vai usar o VIM para programar é
uma ótima opção, assim como a numeração automática;
'set background=dark' modifica o esquema de cores de sintaxe para fundo preto;
'set number' habilita a numeração automática;
As outras linhas descomentadas são respectivamente para habilitar a abertura do arquivo na
mesma linha em que o administrador estava antes e auto-indentação.

DISCOS E PARTIÇÕES
Discos
A nomenclatura de discos no Linux é bem particular. Ela consiste em, ao identificar o volume
físico, criar um arquivo de bloco dentro de /dev correspondente a ele. Exemplo: /dev/sda (1º disco
SATA).
O caso mais particular de discos é o do antigo padrão IDE. Qualquer placa-mãe de qualquer
computador pode abrigar apenas 4 discos IDEs. Para este caso, fica assim a nomenclatura:
/dev/hda – Primary Master.

/dev/hdb – Primay Slave.
/dev/hdc – Secondary Master.
/dev/hdd – Secondary Slave.
NOTA: o conceito de Primário, Secundário, Mestre ou Escravo é genérico para qualquer

plataforma.
Esta nomenclatura acima engloba também CDs/DVDs IDEs. Para este caso, existirá um link
simbólico de um desses endereços para /dev/cdrom, facilitando assim a montagem por parte do usuário.
No caso de discos SATA, SAS, SCSI e discos externos em geral, já fica diferente:
/dev/sda – 1º disco.
/dev/sdb – 2º disco.
/dev/sdc – 3º disco.
/dev/sdd – 4º disco, e assim por diante.
Para um drive de CD/DVD SATA, é criado o arquivo de bloco correspondente /dev/sr(0,1,2,3..),
com link para /dev/cdrom, da mesmo forma.
Os disquetes são reconhecidos por /dev/fd0 e /dev/fd1.
Drives de fita SCSI são reconhecidos como /dev/ft0(1,2,3..).
Para fazer a consulta de quais discos estão disponíveis para uso e quais os seus tipos, deve-se
ler o arquivo /proc/partitions. Este arquivo é onde o Kernel vai consultar e escrever as tabelas de
partições e discos que podem ser utilizados pelo sistema. Nele surgirão algumas informações
importantes como o major number dos discos, que é o numero de identificação do tipo dos mesmos. O
exemplo abaixo mostra a interpretação de um arquivo desse:
Pelo que o arquivo mostrou acima, temos um disco pronto para uso (sda), que é SATA. O que
indica que ele é SATA é o major number 8.
Os major numbers são assim classificados:
3 – disco IDE.
7 – dispositivo de Loop(não ligado a disco físico).
8 – disco SATA, SAS, SCSI e discos externos.
9 – RAID via software.

Partições
Quanto à nomenclatura de partições, é preciso ter muita atenção pois o Linux as trata de
maneira bem conceitual, a começar pelo limite de partições: 63 no total.
Os minor numbers definem o tipo de cada partição:
De 1 a 4 : simbolizam partições primárias ou extendidas.

De 5 em diante : simbolizam partições lógicas.
Se forem ocupados todos os minor numbers de 1 a 4, o restante do espaço em disco (se houver)
fica inutilizável, por isso, é importante saber que, para que se possa utilizar mais de 4 partições em um
disco, uma partição extendida deve ser criada.
A função da partição extendida é apenas abrigar as partições lógicas, ou seja : ela nunca vai ser
montada em diretório algum do sistema.
Vamos conferir outra tabela de partições:
#cat /proc/partitions
No caso acima, vamos analisar a tabela de particionamento de /dev/sda:

/dev/sda1 é uma partição primária.
/dev/sda2 é uma partição extendida, que foi criada com o único objetivo de serem criadas
partições lógicas dentro dela.
/dev/sda5 é uma partição lógica.
Esquemas de particionamento
Como já havia sido comentado em FHS, é muito importante que se pense bem no layout de
particionamento antes de fazer uma nova instalação em um servidor qualquer. É importante que alguns
diretórios fiquem em partições separadas do sistema raiz, são elas:
/tmp – é o único diretório que tem permissão de escrita para qualquer usuário comum, sendo
assim, qualquer usuário pode acabar com os blocos disponíveis da partição do sistema raiz, deixando
muitos serviços sem funcionar mais;
/home – por ser o diretório onde, por padrão, irão ficar os arquivos pessoais de cada usuário, é
preciso analisar a necessidade e o tipo de estratégia de armazenamento que vai ser usado para a
partição que será montada neste diretório. O recomendável para um servidor que possui muito volume
de arquivos nesse diretório que a partição montada aqui esteja em LVM;
/var – é importante deixar este diretório em outra partição pois nele podem estar arquivos de
sites de um servidor web, as caixas de entrada dos usuários em um servidor de e-mail, bancos de dados
do MySQL-Server, logs do sistema que têm apenas o programa logrotate para garantir sua rotatividade;
/usr/local – é o diretório de hierarquia secundária. A grande maioria dos programas que são
instalados via compilação do código-fonte têm suas bibliotecas e arquivos executáveis copiados para
este diretório, por isso é importante isolá-lo do sistema raiz;
Partição Swap – para a realidade atual, criar uma partição Swap está se tornando cada vez
mais desnecessário.
Ela funciona como memória de auxílio à memória principal (RAM) mas com o crescente uso de
memórias RAM de capacidades altíssimas de armazenamento temporário ela tornou-se cada vez mais
desnecessária.
Costumava-se destinar o dobro do espaço de RAM para a criação de uma Swap, hoje fica a
critério do administrador criá-la. 2GB estaria de bom tamanho, se necessário.

O FHS
O Filesystem Hierarchy Standard (Padrão Hierárquico de Sistema de Arquivos) é mantido pela

Free Standards Group, que é composta por empresas como HP, IBM e Dell.
O projeto inicial foi aproveitado porém personalizado pela maioria das distros, a maioria delas
aproveita o formato original do FHS em 80%.
O FHS consiste na padronização da estrutura de diretórios do sistema, afim de que as

diferenças de diretórios entre um sistema operacional open-source e outro sejam mínimas.
A estrutura padrão de diretórios para sistemas Linux é :

/ - é o sistemas raiz, o nível mais alto da hierarquia de diretórios.
/bin – diretório onde são armazenados programas binários de interesse de todos os usuários.
/boot – diretório onde estão localizados arquivos de interesse do boot do sistema, como a
imagem do kernel e os arquivos de configuração do boot loader GRUB.
/dev – diretório onde estão os arquivos especiais que, para o Linux, podem ser discos, partições,
memória RAM, mouse, teclado, terminais do sistema, etc.
/etc – é o diretório onde são armazenados arquivos de configuração e scripts de serviços em
geral, como DHCP, FTP, LDAP e Proxy, por exemplo. É extremamente importante ter um backup
completo deste diretório.
/home – diretório onde, por padrão, os usuários têm seus diretórios pessoais.
/lib – diretório onde se encontram bibliotecas de sistema e módulos já instalados do kernel.
/media – diretório onde geralmente são montadas as mídias removíveis.
/media/cdrom – diretório pronto para montagem de CD/DVD.
/media/floppy - diretório pronto para montagem de Floppy Disk.
/mnt – diretório pronto para servir como ponto de montagem para discos adicionais.
/opt – alguns programas não oficiais da distribuição utilizam este diretório para armazenar
arquivos de instalação.
/proc – é um sistema de arquivos virtual que possui arquivos e diretórios de status de recursos
de sistema.
/root – é o diretório pessoal do usuário root.
/sbin – diretório onde são armazenados programas de interesse apenas do
superusuário(comandos administrativos).
/srv – diretório de dados de serviços providos pelo sistema.
/usr – diretório de hierarquia secundária.
/usr/src – diretório da localização esperada do código-fonte do kernel antes da
compilação.
/usr/local – diretório de instalação de programas que não são oficiais da distribuição.
/usr/share/man – diretório de manuais do sistema.
/usr/share/doc – diretório de documentação de sistema.
/var – diretório de dados variáveis.
/var/log – diretório de logs de eventos diversos.
/var/mail – diretório padrão de recebimento de e-mails de todos os usuários.
/var/cache – diretório utilizado como cache de programas como o apt, por
exemplo.
/tmp – diretório de arquivos temporários. É extremamente recomendável que este esteja em
outra partição pois ele é o único diretório da hierarquia padrão que tem permissão de gravação para
todos os usuários do sistema.

GERENCIAMENTO DE PACOTES
Programas no Linux são instaláveis através de pacotes, que geralmente contém os binários, as
bibliotecas e arquivos de documentação que serão copiados para o sistema com a instalação.
Pacotes .deb (DEBIAN)
As distribuições que são baseadas em Debian e ainda o próprio Debian aceitam pacotes de
extensão .deb como arquivos de pacotes instaláveis, além de pacotes .tar.gz ou .tar.bz2.
#dpkg
Instala e manipula arquivos .deb. Ele também faz operações de consultas em pacotes já
instalados.
Sintaxe:
#dpkg <opções> <pacote>
Opções:
-i : instala pacote através de arquivo .deb.
-x : extrai conteúdo de um pacote.
-r : remove os arquivos binários de um pacote instalado.
-P : “purge” - remove os binários e todos os arquivos relativos ao pacote.
-l : consulta pacotes instalados.
-c : exibe o conteúdo de um arquivo de pacote .deb.
-L : pesquisa arquivos que pertencem a um pacote já instalado.
-S : exibe quais arquivos foram copiados para o sistema após a instalação do pacote.
-s : exibe o status do pacote já instalado e informações reduzidas sobre o mesmo.
-p : exibe informações detalhadas sobre pacote já instalado.
Exemplos:
Instala o pacote 'ldap-utils' através de um arquivo de pacote .deb.

#dpkg -i ldap-utils_2.4.21-0ubuntu5.2_i386.deb
Expurga o pacote slapd:

#dpkg -P slapd
Remove o pacote samba sem remover seus arquivos:

#dpkg -r samba
Mostra o conteúdo do arquivo de pacote ldap-utils_2.4.21-0ubuntu5.2_i386.deb:

#dpkg -c ldap-utils_2.4.21-0ubuntu5.2_i386.deb
Mostra detalhes sobre o pacote samba, que já está instalado:

#dpkg -p samba
A instalação de um programa no Debian pode ser feita através de um pacote de extensão .deb
ou dos chamados repositórios, que armazenam os pacotes e sua dependências. Um repositório pode ser
uma mídia de CD/DVD, um servidor HTTP ou um FTP. Cada distribuição costuma ter alguns repositórios
oficiais espalhados pelo mundo, e este é o caso do Debian.

Repositórios
O arquivo de configuração de repositórios para pacotes .deb é /etc/apt/sources.list, contém a

lista de servidores ou mídias onde podem ser encontrados os pacotes para a distribuição. Geralmente,
opta-se por trabalhar com repositórios em rede (LAN ou WAN) pois a dinâmica de atualização dos
pacotes funciona muito mais.
O uso de repositórios poupa o administrador do trabalho de procurar arquivos .deb por sites de
download da internet ou por mídias externas.
Os repositórios de internet são mais comuns de serem usados, o repositório br.debian.org é o
repositório oficial do Debian no Brasil. Algumas universidades pelo Brasil (como Unicamp e PUC, por
exemplo) também disponibilizam seus “mirrors” para download de pacotes .deb.
Exemplo de arquivo de repositório do Debian:
Cada linha dessas é a configuração de apontamento para um repositório diferente, sendo, por
exemplo, a primeira de pacotes principais da distribuição 'jessie' e a segunda, dos códigos-fonte desses
pacotes.
Ao invés de 'jessie', o nome da distribuição poderia muito bem se chamar 'stable'. Isso porque a
versão estável do Debian é o Jessie.
Versões de Distros Debian:

oldstable : versão anterior estável;
stable : versão atual estável;
testing : próxima versão já em fase de testes;
unstable : os repositórios instáveis não são recomendáveis pois ainda estão em fase de
discussão e desenvolvimento.
Repositórios Debian:
main : pacotes open-source;
contrib : pacotes open-source que dependem da contribuição de terceiros;
non-free: pacotes não-livres;
multimedia : pacotes de aplicações multimedia;
backports : pacotes ainda fora do repositório estável provavelmente por serem muito atuais.
É sempre mais interessante que a instalação de um programa seja feita através de repositório,
porque neste caso é instalado o pacote e todas as suas dependências ao mesmo tempo.

APT (Advanced Packaging Tool)
Gerenciador de arquivos e dependências de pacotes através de repositórios do Debian, este

gerenciador consulta os dados de /etc/apt/sources.list.
Comandos APT:
#apt-get update
Atualiza a base de dados de pacotes contida no diretório /var/lib/dpkg com os dados do
repositório.
Este comando não tem a função de atualizar nenhum pacote já instalado.
Sintaxe:
#apt-get update
#apt-get install
Instala um pacote e suas dependências a partir de repositórios que estão listados dentro de
/etc/apt/sources.list.
Sintaxe:
#apt-get install <opções> <pacote(s)>
Opções:
-s : simula a instalação do pacote.
-d : apenas faz o download dos pacotes dentro do diretório /var/cache/apt/archives/.
-y : assume como “Yes” todas as respostas de instalação.
--reinstall : reinstala um pacote.
#apt-get remove
Remove pacote instalado.
Sintaxe:
#apt-get remove <pacote>
Para “expurgar” uma instalação:

#apt-get remove <pacote> --purge
Exemplo:
Expurgando o pacote bind9:

#apt-get remove --purge bind9 -y
#apt-get upgrade
Atualiza a versão de todos os pacotes que estão instalados.
Sintaxe:
#apt-get upgrade
#apt-get dist-upgrade
Atualiza toda a distribuição mediante mudança de versão em /etc/apt/sources.list.
Sintaxe:
#apt-get dist-upgrade

#apt-cache pkgnames
Exibe a lista de nomes de pacotes disponíveis nos repositórios para instalação.
Sintaxe:
#apt-cache pkgnames
#apt-cache search
Busca descrição sobre programas disponíveis no repositório por assunto.
Sintaxe:
#apt-cache search <nome>
Exemplo:
Procurar com algum pacote que tenha a ver com DNS no repositório:
#apt-cache search dns
No caso acima, ele buscou na lista de repositórios do Ubuntu todos os pacotes que tenham a ver
com DNS.
#apt-cdrom add
Adiciona uma mídia de CD como um repositório em /etc/apt/sources.list.
Sintaxe:
#apt-cdrom add
#aptitude
É uma interface mais amigável para o apt. É possível visualizar a lista de pacotes disponíveis
para instalação de uma forma muito organizada.
Sintaxe:
#aptitude <opção>
As opções do aptitude são as mesmas do apt-get.

Exemplos:

Instala o pacote samba através de um repositório:
#aptitude install samba
Atualiza a base da dados do apt:

#aptitude update
Remove o pacote samba:

#aptitude remove samba
Pacotes .rpm (RED HAT)
Distribuições baseadas em Red Hat e o próprio Red Hat aceitam a instalação de pacotes .rpm e
.tar.gz.
A questão das dependências é a mesma: um pacote sozinho pode não ter todas as
dependências necessárias para a sua instalação e, para resolvê-las, é muito importante instalar os
pacotes por repositórios.
#rpm
Chamado de Red Hat Package Manager, o comando rpm instala e consulta arquivos .rpm.
Sintaxe:
#rpm <opções> <pacote>
Opções do modo de instalação:

-i : instala um pacote através de arquivo de pacote.
-U : faz upgrade em um programa já instalado através de um arquivo.
-v : modo verbose de instalação.
-vv: modo verbose com mais detalhes.
-h : modo hash. Exibe barra de rolagem ao instalar.
-e : remove um programa instalado.
--nodeps : ignora dependências não satisfeitas do pacote na instalação. Esta opção não é
recomendável, pois há grandes chances de o programa não funcionar.
Opções do modo de consulta:

Para o modo de consulta, a opção q deve estar sempre presente antes de qualquer outra.
-qa: consulta todos os programas instalados.
-ql: consulta por arquivos pertencentes a programas instalados.
-qf : descobre a qual pacote pertence um determinado arquivo.
-qi : exibe informações detalhadas sobre um programa instalado.
-qd ou –-configfiles : mostra todos os arquivos de configuração do programa instalado.
-qd ou –-docfiles : mostra todos os arquivos de documentação do programa instalado.
-qpl : exibe os arquivos e diretórios contidos em um arquivo de pacote.
-qpd: exibe os arquivos de documentação contidos dentro de um arquivo de pacote.
-qpc: exibe os arquivos de configuração de um arquivo de pacote.
Exemplos:
Remove o pacote samba.i386 instalado:

#rpm –e samba.i386
Instala o pacote samba_3.0.2_i386.rpm em modo “hash” e verbose:

#rpm –ivh samba_3.0.2_i386.rpm
Consultando detalhes sobre o pacote samba.i386 já instalado:

#rpm –qi samba.i386
Consultando os arquivos de configuração do pacote samba.i386 já instalado:

#rpm –qc samba.i386
Consulta arquivos de documentação do arquivo do pacote de instalação do Adobe Flash Player:
#rpm –qpd samba_3.0.2_i386.rpm
YUM (Yellow dog Updater Modified)

O YUM está para os pacotes .rpm assim como o APT está para os pacotes .deb. É um robusto
gerenciador dependências e pacotes para padrão Red Hat.
#yum update
Atualiza a base de dados do yum, assim como todos os pacotes instalados até o momento.
Sintaxe:
#yum update
#yum install
Instala pacotes e suas dependências.
Sintaxe:
#yum install <opções> <pacotes>
Opções:
-y : assume como “yes” todas as respostas de instalação.
#yum upgrade
Atualiza pacotes instalados para a versão mais nova existente no repositório.
Sintaxe:
#yum upgrade <pacote1> <pacote2> ...
#yum list
Lista os nomes dos pacotes disponíveis no repositório para instalação.
Sintaxe:
#yum list
#yum search
Busca descrição sobre pacotes pelo assunto.
Sintaxe:
#yum search <pacote>
#yum info
Exibe detalhes sobre pacotes já instalados. Exibe a mesma saída do comando ‘rpm –qi
<pacote>’.
Sintaxe:
#yum info <pacote>
Exemplo:
Exibindo informações detalhadas sobre o pacote samba.i386:

#yum info samba.i386

INSTALAÇÃO DE SISTEMA OPERACIONAL
A instalação de um sistema operacional Linux em um servidor, principalmente, deve seguir à

risca os esquemas de particionamento citados acima. Alguns diretórios, se mantidos juntos com a
partição do sistema raiz ( / ) podem causar inconvenientes de estouro de reserva de inodes ou de blocos,
parando por completo o servidor. Imagina só se um usuário qualquer resolve criar um número exagerado
de arquivos vazios (que ocupam inodes) em /tmp e acaba com a reserva de inodes, não sobrando mais
espaço no sistema raiz para a criação de um arquivo sequer?!?!
Seria um verdadeiro desastre criar um servidor PDC de clientes Windows se o diretório /home,
que carrega os perfis móveis de cada usuário, estivesse na mesma partição do sistema raiz. Bastaria,
neste caso, que um usuário sem cotas configuradas fosse ocupando espaço com arquivos fúteis à
vontade para que o espaço em disco no servidor se reduzisse a zero, de repente e causasse a
paralisação dos serviços ativos.
Outros pontos importantes a se analisar são: flexibilidade, redundância e performance de discos,
para saber se utilizar arranjos LVM ou RAID em discos seria necessário.
A escolha da versão do sistema operacional ideal para a necessidade também é muito
importante, assim como a arquitetura do mesmo, para que ele possa tirar o máximo de proveito dos
recursos de Hardware do sistema. Faz toda a diferença de performance para um servidor com 2
processadores Intel Xeon operar com o sistema operacional com arquitetura ia64 (arquitetura de
processadores Intel 64-bits) ao invés de trabalhar com um sistema operacional de arquitetura de 32 bits
(i386).
Se vai ser Slackware, Red Hat, Debian, Ubuntu, Suse ou CentOS vai depender da preferência
do administrador ou da empresa.
Particionando o disco
Um bom esquema de particionamento para um servidor de arquivos Samba de usuários em uma
rede com um HD de 500GB seria:
/ - 10 GB
/usr/local – 10GB
/var – 10GB
/tmp – 2GB
/boot – 200MB
swap – 2GB (se necessário)
/home – 465,8GB (aproximadamente)
Para um servidor web com o Apache, o diretório /var é quem precisaria de mais espaço em
disco:
/ - 10 GB
/usr/local – 10GB
/var – 475,8GB(aproximadamente)
/tmp – 2GB
/boot – 200MB
swap – 2GB (se necessário)
Pensando que, geralmente, um web server também conta com servidor FTP e que as contas de
usuário são mapeadas para o diretório /var/www(diretório de publicação de arquivos do servidor), não
seria preciso isolar o /home.

O uso de uma partição para uso como swap, ainda mais em servidores com quantidade grande
de espaço em RAM, torna-se cada vez mais dispensável ao longo do tempo. Pode ter certeza que se o
servidor precisar usar swap é porque alguém não planejou corretamente o hardware para o tipo de
servidor que íria ser implementado.
Configuração pós-instalação
Passado todo o processo de planejamento e instalação do servidor, o processo de configuração
é o próximo passo.
É hora de configurar a rede, repositórios, configurar o login de usuários, decidir se vai ou não
usar interface gráfica, etc..
A primeira providência, já que se trata de um servidor, é configurar a interface de rede. Para isso,
é preciso que o administrador conheça primeiro os conceitos de IPV4/6 necessários, e isto é realmente
um pré-requisito para que o administrador possa ter sucesso na administração dos sevidores.
O arquivo de configuração de rede no Debian é /etc/network/interfaces. É preciso editá-lo e
reiniciar o serviço de rede após isso para que as alterações façam efeito:
Editando o aquivo:
#vim /etc/network/interfaces
A interface lo se refere à interface de loopback e não deve ser desativada, pois alguns serviços
dependem dela para funcionar, enquanto a interface eth0(zero) é a primeira interface de rede
reconhecida pelo sistema (mais detalhes sobre configuração de redes será dados mais à frente).
Reiniciando o serviço de rede:

#invoke-rc.d networking restart
Conferindo a conectividade:
#ifconfig
#ping 10.23.1.1
Conferindo rotas:
#route -n
Configurando DNS:
#vim /etc/resolv.conf
nameserver <ip do servidor>

O SHELL
Conceitualmente, o Shell é o interpretador dos comandos que serão enviados ao sistema, afim
de que sejam executadas as tarefas necessárias para o seu funcionamento.O Linux é capaz de trabalhar
com uma variedade enorme de shells, estando todos os suportados em /etc/shells:
De todos os Shells disponíveis para uso no Linux, os mais importantes, sem dúvida, são sh e
bash(Bourne Again Shell). O sh inclusive é o shell padrão do comando useradd. Ele é usado por muitas
distros baseadas em Unix, como FreeBSD e OpenDSB, por exemplo. Já o bash é o shell padrão do
Linux em todas as distros.
Scripts do Shell
Alguns scripts de bash são comumente encontrados em um S.O Linux:
/etc/rc.local
Este script é executado antes do logon do usuário após o boot do sistema pela imagem do
kernel.
/etc/profile
É o primeiro script a ser executado após o logon dos usuários. Ele é global, ou seja: todos os
usuário que fazem login sofrem os efeitos deste script. Geralmente nele estão duas variáveis de bash
importantíssimas:
PATH - define em quais diretórios o bash vai procurar os comandos digitados pelos usuários.
PS1 – define qual vai ser o rótulo de prompt dos usuários.
Exemplo:
PS1='\u@\h:\w\$' ficaria para o usuário user1 no host 'server' e no diretório home dele assim:
user1@server$
O arquivo acima explica o porquê de quando o usuário comum digita um comando exclusivo de
root retorna para ele o erro : “-<comando> : comand not found” . É só verificar que a variável PATH
do root (o que tem UID=0) contém os diretórios onde estão os comandos de administração do sistema
(os ../sbin) e o PATH do usuário comum não.

Hierarquia de scripts de usuário:
Há sempre uma ordem de execução de scripts após o login de cada usuário.

Na falta de algum destes scripts abaixo, o posterior é executado. A ordem oficial é esta abaixo:
/etc/bash.bashrc
~/.bash_profile
~/.profile
~/.bashrc
O ~/.bashrc tem uma característica muito especial em relação a outros scripts de login: ele pode
ser executado em sessões não interativas (aquelas que não requerem login). Exemplo: sessão gráfica.
Por padrão, este script vem com alguns campos comentados, mas que são de grande
importância para ajudar a tornar o shell um ambiente de trabalho mais amistoso:
O script /etc/bash_completion facilita e muito a vida do usuário, pois auto-completa um comando
se for digitada parte dele seguinda da tecla TAB. este script deve ser ativado em algum script de login.
Os aliases para os comandos rm, cp e mv evitam que muitos arquivos sejam sobrescritos sem
que o usuário seja avisado antes que isso vai acontecer (cada alias recebe um comando com a opção
interativa '-i'). Como no Linux a falta de um arquivo pode significar o colapso de um sistema inteiro,
dependendo de qual arquivo seja, esses aliases são providenciais.
~/.bash_logout
Script executado no logoff do usuário.
~/.bash_history
Arquivo que contém o histórico de comandos digitados pelo usuário.
#history
Exibe histórico de comandos digitados pelo usuário.
Limpando o histórico:
#history -c
#fc
Comando que usa o editor de textos padrão do sistema para manipular o arquivo de histórico.
Para que o editor padrão seja modificado, basta usar a linha de comando abaixo:
#update-alternatives –config editor
Impedindo login de usuários comuns

Por motivo de manutenção no sistema, por exemplo, é necessário que às vezes apenas o root
tenha o direito de abrir uma sessão. Para que isso seja possível, é preciso que seja criado o arquivo
/etc/nologin. Ele vazio já é o suficiente para que ninguém, além do root, possa abrir uma sessão, mas o
arquivo pode conter um texto qualquer que ele funciona com o mesmo efeito.
Os usuários comuns só vão poder abrir alguma sessão após este arquivo ser removido.
Mensagens para o usuário:

Alguns arquivos contém mensagens para os usuários no terminal em momentos diferentes:
/etc/issue
Mensagens na tela de login local.
/etc/issue.net
Mensagens após login do usuário.
/etc/motd
Mensagens logo após login do usuário.

DOCUMENTAÇÃO NO LINUX
A difusão e aprendizado de sistemas operacionais open-source passa também pela
documentação sempre bem organizada que estes sistemas têm. Um exemplo bem prático é que um
Administrador de Redes que entende profundamente sobre protocolos, portas e serviços mas que não é
usuário de Linux teria uma dificuldade muito maior em implementar regras no firewall Iptables se ele não
pudesse consultar uma página de manual local para ajudá-lo.
O responsável por manter essa documentação toda funcionando é o LDP (Linux Documentation
Project), cujo site é www.tldp.org. Ele possui links para as seções abaixo:
Wiki - detalhamento de alguns assuntos pesquisados;

HOWTOs - guias passo a passo de tarefas;
FAQs - respostas para dúvidas eventuais;
Manpages – páginas de manuais de comandos.
Os diretórios que contém documentação local são:

/usr/share/doc – diretório de documentação local oficial do LDP;
/usr/share/man – diretório de páginas de manuais de comandos, arquivos e programas.
Tipos de arquivos de documentação

Dentro dos diretórios /usr/share/doc e /usr/share/man existem arquivos de documentação de
diversos tipos:
README : instruções de uso relevantes ao usuário;
Copyright : informações de autoria e direitos sobre programa;
Changelog : log de modificação do programa;
Manpages : manuais lidos pelo comando man;
FAQs : perguntas e respostas frequentes sobre o assunto.
Seções de manuais
Um arquivo de configuração, um programa e um comando de root podem, coincidentemente, ter
o mesmo nome. Isso seria a causa de uma confusão muito grande caso os mantenedores do projeto não
tivessem pensado em separar os manuais por seções. Elas são identificadas numericamente e possuem,
cada uma, um diretório dentro de /usr/share/man, como ../man8, que é o diretório de manuais de seção
8. Mas por que seção 8?!?! Basta olhar a tabela abaixo:
Seção Descrição
1 Programas de uso comum de todos os usuários do sistema
2 Chamadas de sistema
3 Chamadas de bibliotecas
4 Arquivos especiais contidos em /dev
5 Arquivos de configuração
6 Games
7 Miscelânea
8 Comandos de root.

Comandos de documentação
#<comando> --help
Exibe informações reduzidas sobre opções de comando, geralmente.
Exemplo:
Ajuda sobre opções do comando shutdown :

#shutdown --help
#apropos
Busca, por tópico, a descrição de cada comando ou arquivo encontrado.
#whatis
Busca, por nome exato, a descrição de cada comando ou arquivo encontrado.
#man
Exibe informações sobre manuais contidos em /usr/share/man.
Sintaxe:
#man <opções> <assunto>
Opções:
-w : busca o caminho do arquivo de manual ao invés de exibir algum tipo de ajuda sobre o tema.
-k : busca resumo sobre um tópico específico.
-f : busca resumo sobre um comando ou arquivo exato.
-P : modifica o programa de paginação do man.
Obs:
#man -k corresponde a #apropos.
#man -f corresponde a #whatis.
Exemplos:
Buscar manual do comando iptables:
#man iptables
Buscar definição sobre comandos relacionado ao assunto iptables:

#man -k iptables
Ou
#apropos iptables
Buscar definição sobre comando iptables em específico:

#man -f iptables
Ou
#whatis iptables
Buscar por manual de um comando na seção 5, para o caso de haver algum outro objeto de
busca chamado interfaces:
#man 5 interfaces
#info
Programa de leitura de manuais preferido pelo projeto GNU. Sua exibição dos manuais é mais
organizada.
#mandb
Atualiza a base de dados de manuais do sistema.
Se alguma modificação for feita em /etc/manpath.config, este comando precisa ser executado.

COMANDOS DE CONTEÚDO
#less
Pagina o conteúdo de arquivos ou saídas de texto. Ele é muito versátil, pois permite o
deslocamento para cima, para baixo, para a direita e para a esquerda quando estiver paginando um
documento. Existe também o recurso de procurar por um texto com / no meio da paginação.
Sintaxe:
#less <arquivo>
Exemplo:
Paginando arquivo /etc/shadow:
#more
Também pagina um documento de texto ou saída em modo texto, só que de forma básica,
permitindo apenas a paginação para baixo e pressionando a tecla ENTER.
Sintaxe:
#more <arquivo>
#zless
Usa o less para paginação de conteúdo em modo texto de arquivos compactados com o agente
de compactação GZIP.
Sintaxe:
#zless <arquivo>.gz
#zmore
Usa o more para paginação de conteúdo em modo texto de arquivos compactados com o
agente compactador GZIP.
Sintaxe:
#zmore <arquivo>

#head
Visualiza as primeiras linhas de um arquivo. Padrão: 10 primeiras linhas.
Sintaxe:
#head <opção> <arquivo>
Opções:
-c : mostra os primeiros bytes de um arquivo.
-n : especifica o número de linhas.
Exemplos:
Mostrar os primeiros 128 bytes do arquivo /etc/passwd:

#head -c 128 /etc/passwd
Mostrar as 5 primeiras linhas de /etc/passwd

#head -n 5 /etc/passwd
Ou
#head -5 /etc/passwd
#tail
Lê as últimas linhas de um arquivo, Padrão: 10 últimas linhas.
Sintaxe:
#tail <opções> <arquivo>
Opções:
-n : especifica o número de linhas.
-f : monitora as últimas linhas de um arquivo. Muito útil para leitura de arquivos de log.
Exemplos:
Exibir as últimas 5 linhas do arquivo /var/log/messages.

#tail -n 5 /var/log/messages
Ou
#tail -5 /var/log/messages
Monitorar as mudanças que estão sendo feitas no arquivo /var/log/auth.log.

#tail -f /var/log/auth.log
#pr
Prepara um arquivo para ser impresso mas não o imprime
Sintaxe:
#pr <arquivo>
#nl
Exibe conteúdo de um arquivo com as linhas numeradas.
Sintaxe:
#nl <arquivo>

#wc
Conta linhas, caracteres e palavras de um arquivo.
Sintaxe:
#wc <opções> <arquivo>
Opções:
-l : número de linhas do arquivo.
-w : palavras contidas no arquivo.
-c : quantidade de caracteres.
Exemplo:
Contando linhas, palavras e caracteres de /etc/passwd:

#wc /etc/passwd
#od
Exibe arquivo em formatos diferentes.
Sintaxe:
#od <opções> <arquivo>
Opções:
-o : modelo octal.
-u : decimal.
-x : hexadecimal.
#grep
Busca textos dentro de documentos.
Sintaxe:
#grep <opções> <texto> <arquivos>
Opções:
-i : modo insensitivo. Não diferencia maiúsculas de minúsculas quando faz a busca.
-v : exceção. Apenas não filtra o texto selecionado.
-w : busca por palavra específica.
-E : habilita o comando a trabalhar com as expressões regulares avançadas (REGEXP).
-n : exibe o número das linhas onde estavam os registros encontrados.
-H : mostra o nome do arquivo ao lado de cada registro achado.
Exemplos:
Buscar dentro do arquivo /etc/passwd a linha contendo 0:

#grep 0 /etc/passwd
Buscar dentro do arquivo /etc/passwd linhas que contenham apenas 0 como valor absoluto:
#grep -w 0 /etc/passwd

Buscar apenas as linhas do arquivo /etc/passwd que não tenham /bin/bash e nem 0 como valor
absoluto (ou seja: usuários que não usam o Shell bash e que não sejam ‘root’):
#grep -vw ‘/bin/bash*.0’ /etc/passwd

Onde *. significam E TAMBÉM.
Buscar dentro dos arquivos /etc/passwd, /etc/shadow e /etc/group e /etc/gshadow registros do

usuário ‘root’ mostrando o nome do arquivo no início das linhas do resultado:
#grep -H root /etc/passwd /etc/shadow /etc/group /etc/gshadow
#cut
Exibe apenas os campos desejados de um arquivo.
Sintaxe:
#cut <opções> <arquivo>
Opções:
-c : exibe as colunas desejadas.
-d : usa um delimitador.
-f : “fields”. Campos do arquivo, levando em conta o delimitador.
Exemplos:
Exibir a coluna 1 do arquivo /etc/shadow:

#cut -c 1 /etc/shadow
Exibir as colunas 1,2 e 4 do arquivo /etc/passwd:

#cut -c 1,2,4 /etc/passwd
Exibir da coluna 1 até a 5 do arquivo /etc/group:

#cut -c 1-5 /etc/group
Entendendo o ‘ : ‘ como delimitador, exibir os campos 1,3 e 6 do arquivo /etc/passwd:

#cut -d : -f 1,3,6 /etc/passwd
Com o mesmo delimitador, agora exibindo do campo 1 até o 5 do arquivo /etc/shadow:
#cut -d : -f 1-5 /etc/shadow

#shred
Destrói o conteúdo de um arquivo.
#Sintaxe:
#shred <arquivo>
#split
Cria cópias de pedaços de um arquivo.
Opções:
-b : quebra por quantidade de bytes.
-l : quebra por quantidade de linhas.
Sintaxe:
#split <opção> <arquivo> <primeiro nome do arquivo de destino>
Exemplos:
Criando arquivos com 128 bytes de /etc/passwd cada um. Neste caso, serão criados os arquivos
arqaa, arqab, arqac, etc :
#split -b 128 /etc/passwd arq
Criando arquivos com 4 linhas do arquivo /etc/profile cada um, esclarecendo que o último arquivo
pode ficar com menos linhas se for o caso de a quantidade de linhas do arquivo não for múltipla de 4,
neste caso:
#split -l 4 /etc/passwd arq
#uniq
Exibe as linhas únicas de um arquivo.
Sintaxe:
#uniq <arquivo>
#cat
Lê o conteúdo de um arquivo ou reconstrói o mesmo, se for o caso de ele estar em pedaços
criados pelo comando split.
Sintaxe:
#cat <opção> <arquivo>
Opções:
-b : lê o arquivo com as linhas não vazias numeradas.
-n : lê o arquivo com todas as linhas numeradas.
Exemplos:
Ler o conteúdo do arquivo /etc/motd:

#cat /etc/motd
Ler o conteúdo do arquivo /etc/profile com as linhas não-vazias numeradas:

#cat -b /etc/profile
Ler o conteúdo do arquivo /etc/profile com todas as linhas numeradas:

#cat -n /etc/profile

Reconstruir as cópias fragmentadas do arquivo /etc/passwd com nomes de arqaa, arqab e
arqac:
#cat arqaa arqab arqac > passwd
#tac
Tem a mesma sintaxe do cat mas lê o arquivo da última linha para a primeira.
#sort
Ordena o conteúdo do arquivo.
Sintaxe:
#sort <opções> <arquivo>
Opções:
-d : ordem alfanumérica.
-n : ordem numérica.
-t : usa um delimitador.
-k : usa um campo como referência.
-r : ordem reversa.
-R : ordem randômica (aleatória).
Exemplos:
Classificar o conteúdo do arquivo /etc/passwd em ordem alfabética:

#sort -d /etc/passwd
Classificar o conteúdo do arquivo /etc/shadow em ordem alfabética inversa:

#sort -dr /etc/passwd
Usando ‘ : ’ como separador, classificar o arquivo /etc/passwd em ordem numérica, tendo como
referência o campo 3 do arquivo:
#sort -n -t : -k 3 /etc/passwd
#sed
Substitui texto e números de um arquivo.
Sintaxe:
#sed s/<texto_original>/<texto_substituto>/g <arquivo>
Exemplo:
Substituindo o termo ‘root’ do arquivo /etc/passwd pelo termo ‘administrador’ :

#sed s/root/administrador/g /etc/passwd
#<comando> | tr
Comando que só pode ser utilizado em combinação com outro de leitura de arquivo através do
“pipe”, o tr substitui caracteres em sequência.
Sintaxe:
#<comando> | tr <opção> <caracteres>
Algumas variáveis são utilizadas pelo comando:
\\ - backslash.
\b - backspace.
\\t - tabulação horizontal.
\n - nova linha (pula uma linha).
\v - tabulação vertical.

Exemplos:
Remover ‘ : ’ do arquivo /etc/passwd :

#cat /etc/passwd | tr -d :
Trocar ‘ : ‘ e ‘ , ‘ por tabulação no arquivo /etc/passwd:

#cat /etc/passwd | tr : \\t
Trocar letras maiúsculas do arquivo /etc/shadow por minúsculas e depois trocando ‘ : ‘ por
tabulação :
#cat /etc/shadow | tr [a-z] [A-Z] | tr : \\t
#fmt
Formata um texto.
Sintaxe:
#fmt <opção> <arquivo>
Opções:
-w : limita a largura de cada linha.
-u : uniformiza os espaços dentro do arquivo.
#join
Exibe as linhas comuns a dois arquivos.
Sintaxe:
#join <arquivo1> <arquivo2>
#expand
Troca tabulação por espaço simples
Sintaxe:
#expand <opção> <arquivo>
Exemplo:
Convertendo linhas que tenham 2 tabulações para espaço simples do arquivo /etc/syslog.conf:
#expand -t 2 /etc/syslog.conf

#diff
Mostra as linhas diferentes de dois arquivos.
Sintaxe:
#diff <arquivo1> <arquivo2>
Exemplo:
Exibindo as linhas diferentes do arquivo arq1.txt e arq2.txt:

#diff arq1.txt arq2.txt
EXPRESSÕES REGULARES
Para conseguir a saída de texto que um relatório precisa, extrair dados específicos da infinidade
de arquivos de processos que existem em /proc, realizar buscas condicionais em um arquivo e outras
tarefas avançadas no tratamento de dados é que são usadas as expressões regulares. Trata-se de um
conjunto de metacaracteres, comandos, números ou letras que, irão produzir efeitos diversos em
resultados de comandos do Shell.
Um exemplo claro de uso de expressão regular (ou REGEX, como queira) é quando se quer
visualizar apenas os subdiretórios de um diretório através do comando ls :
#ls -l /etc | grep ^d
Explicação:
O comando ls não tem opção nenhuma que diferencie o tipo do arquivo, portanto, foi preciso
utilizar o grep para buscar dentro da saída dele linhas que, no modo longo do ls, comecem com ‘ d ‘,
papel do metacaractere ^.
Metacaracteres
Meta Significado
* Todos os caracteres, inclusive o anterior
?
^ Início de linha
$ Fim de linha
[-] Lista de caracteres
[^] Lista de caracteres de exceção
{,} Lista numérica ou alfa-numérica
\ Escapamento de caracteres especiais (espaço, parênteses, chaves,
etc..)
(|) Ou
.* E
. Posição de um caractere omitido
Exemplos:
Exibindo de /etc/passwd apenas os usuários quem usem Shells BASH ou que tenham login
negado:
#grep -E ‘(bash|false)’ /etc/passwd
Exibindo de /etc/shadow apenas os usuário que comecem com a,d,r ou s :

#grep -E ^[adrs] /etc/shadow

Exibindo de /etc/passwd apenas os usuários que usem Shells BASH ou SH e também comecem
com letras no intervalo de f a l :
#grep -E ^[f-l].*’(bash|sh)’ /etc/passwd
O grep é utilizado com E por que algumas expressões regulares fazem parte do grupo de
REGEXP (expressões regulares avançadas), como é o caso do { }.
O comando grep -E é o mesmo que egrep.
Para exibir as linhas que tenham exatamente 5 caracteres de um arquivo chamado Linux.txt , as
seguintes expressões poderiam ser utilizadas:
#grep ^....$ Linux.txt
Ou
#egrep ‘^.{5}$’ Linux.txt
Onde o {5} iria ser o responsável por dizer que . repete 5 vezes e o motivo de o “ponto” estar
entre ^e $ é dizer para a expressão regular que “entre início e fim existem 5 posições”.
Exibindo as linhas que tenham pelo menos 70 caracteres:

#egrep ‘^.{70,}$’ /etc/passwd
Outro bom exemplo de uso de expressão regular é na hora de excluir arquivos de extensão mp3,
ppt, txt e jpg de um diretório sendo todos com nomes diferentes:
#rm *.{mp3,ppt,txt,jpg}
“Pipes”, redirecionamentos e execução de comandos em sequência
Como já se pode notar pelos capítulos anteriores, o | tem uma função importantíssima dentro de
uma expressão regular, pois ele concatena a saída de um comando com a de outro posterior, como a
seguir:
O comando cut -d : -f 1-5 /etc/passwd envia a sua saída para o comando tail -5, possibilitando
assim a paginação do conteúdo do arquivo apenas com os campos 1,2,3,4 e 5 :
#cut -d : -f 1-5 /etc/passwd | tail -5
Antes de redirecionar saídas ou entradas de comandos, vamos entender quais tipos de

entrada/saída podem existir:
STDOUT - saída padrão. Quando o comando é executado com sucesso, ele produz esta saída,
exceto para comandos que não possuem “verbose” em suas saídas.
STDERR - Saída de erros. Quando o resultado da execução é um erro, esta saída é mostrada,
exceto em comandos que não produzem “verbose”.
STDIN - Entrada padrão. Entrada de dados em um comando.
Tipos de redirecionamento :
> - redireciona saída padrão de um comando para um arquivo novo.
>> - redireciona saída padrão de um comando para a última linha de um arquivo (append), mas
se este não existir ele o cria.
< - redireciona entrada padrão para um comando.
<< - append de entrada padrão.
2> - redireciona apenas saída de erros para um arquivo novo.
2>> - append de saída de erros.
&> - envia saída padrão e de erros para um arquivo novo.
Exemplos:
Enviando o resultado do comando de verificação de uso de discos montados para o arquivo

/root/discos.txt :
#df -h > /root/discos.txt

Enviando mais um relatório de uso de discos para o mesmo arquivo sem sobrescrevê-lo :
#df -h >> /root/discos.txt
Enviando um e-mail com o conteúdo do arquivo de log /var/log/syslog :

#mail -s “LOG” adm@brunoodon.com.br < /var/log/syslog
Enviando o erro ao se executar o comando LS -L para o arquivo erro_ls.txt:

#LS -L 2> erro_ls.txt
#<comando> | tee <opção> <arquivo>

Além de enviar saída do comando para um arquivo, exibe a saída no terminal.
Exemplos:
Enviar últimas 15 linhas do log /var/log/auth.log para o arquivo log_auth.txt exibindo a saída dele
no display :
#tail -n 15 /var/log/auth.log | tee log_auth.txt
Enviar linhas numeradas do arquivo /etc/passwd para o mesmo arquivo sem sobrescrevê-lo :
#nl /etc/passwd | tee -a log_auth.txt
Nem sempre interessa esperar a execução de um comando para poder executar outro e é por
isso que existem os caracteres ; e && . Eles permitem que isso aconteça da seguinte forma:
; - permite que um comando posterior seja executado independentemente do resultado do
anterior.
&& - apenas permite a execução do próximo comando se o anterior der certo.
Exemplos:
Esta combinação de comandos abaixo funcionaria pois a pesar do primeiro estar com sintaxe
errada, o segundo é válido e o ; não leva isso em consideração:
#LS -L; df -hi
Fará toda a diferença se a mesma combinação for tentada com o &&:

#LS -L && df -h
Vamos analisar então a expressão abaixo:

#mail -s “TESTE DE EXPRESSÃO” administrator@brunoodon.com.br < log_auth && rm log_auth;
apt-get update
O resultado sera: rm log_auth só será executado se o primeiro comando de envio de e-mails der
certo, mas independente dos dois, a base de dados do APT será atualizada.

Codificação de caracteres
Os caracteres que são escritos e lidos precisam de codificação, pois o sistema só consegue
mesmo interpretar bits, que por sua vez são representados por números binários. A primeira tabela de
codificação criada foi uma tabela chamda ASCII, que contava com 7 bits para representação de
caracteres, que davam exatos 128 caracteres, esta cidificação foi criada baseada na linguagem de
povos de origem anglo-saxônica, pois os mesmos não fazem uso de acentos. Como no mundo existem
muitos povos que utilizam caracteres direfentes dos utilizados na lingua inglesa, por exemplo, foi preciso
criar uma tabela de caracteres capaz de representar estes caracteres a mais que os povos de origem
latina, por exemplo, usam, desta forma, foi implementado mais 1 bit na tabela ASCII, ficando assim esta
tabela com a possibilidade de representar 256 caracteres (8 bits).
Mesmo com todo o esforço descrito acima, ainda faltavam caracteres para representar alfabetos
de países do Leste Europeu e Ásia, foi desta necessidade que surgiram tabelas de 8 bits, normatizadas
pelo ISO, onde a compatibilidade com ASCII nos primeiros 128 bits é nativo e os outros 128 bits são
destinados a caracteres especiais da tabela específica. As distros Linux podem utilizar dois tipos de
tabelas para codificação: a UTF-8 e a ISO8859-1, sendo o primeiro mais flexível, pois dá suporte tanto a
idiomas provenientes do Latin quanto a idiomas asiáticos e europeus. O que acontece com o UTF-8 é
que, em caso de representação de dieletos asiáticos, por exemplo, ele assume 16 bits e não 8 (UTF-16),
sendo assim compativel com qualquer tipo de dialeto possivel.
Para configurar a codificação e a linguagem do sistema, assim como o idioma do teclado, é
preciso atribuir esta configuração às variáveis LANG e LANGUAGE, sendo a primeira a variável que
define o idioma padrão do sistema e a codificação de caracteres e a segunda a que define o idioma do
teclado.
O arquivo onde estas conigurações podem ser realizadas de forma permanente é o
/etc/default/locale.
O conjunto inteiro de variáveis é exibido pelo comando locale, como no exemplo abaixo:
#locale
Onde cada variável dessa recebe a linguagem e codificação atribuída à variável LANG.
Para fazer qualquer tipo de conversão de caracteres, o administrador pode utilizar o comando
iconv, como no exemplo abaixo:
#iconv -f UTF-8 -t ISO-8859-1 ~/arquivo_original.txt > ~/arquivo_convertido.txt
Onde -f para o comando significa “from” e -t significa “to”, ou seja: converter de UTF-8 para ISO-
8859-1 o arquivo ~/arquivo_original.txt e enviar esta saída convertida para o arquivo
~/arquivo_convertido.txt.

USUÁRIOS E GRUPOS
Uma das tarefas mais importantes para um administrador é saber gerenciar de forma segura os
usuários e grupos do sistema.
O usuário root é o primeiro usuário criado no sistema após a instalação. Ele é o administrador do
sistema e “pode tudo”, desde deixar o servidor com um nível de segurança altíssimo com serviços
configurados por ele até destruir o sistema de arquivos por completo. Ou seja: a senha do usuário root
não deve ser distribuída para pessoas que não sejam habilitadas a desempenhar as tarefas
administrativas.
Os usuários comuns utilizam o rótulo de prompt $ enquanto o root utiliza o # em seu login.
Qualquer outro usuário criado não tem qualquer privilégio administrativo, por padrão, ou seja: um usuário
comum vai continuar sendo um usuário com tarefas limitadas até que o root decida dar permissão para
que ele possa desempenhar algumas ou até todas as tarefas de root.
Arquivos importantes
O banco de dados em modo texto que contém os dados dos usuários do sistema é o
/etc/passwd. Sua estrutura só deve ser alterada manualmente em último caso, pois uma “sujeirinha”
dentro desse arquivo pode custar a impossibilidade de se fazer login com o usuário root, por exemplo, ou
paralisar um serviço de HTTP do apache, que utiliza a conta do usuário www-data para tal.
Abrindo o arquivo:
#vim /etc/passwd
Onde seus campos são:

<login>:<senha>:<UID>:<GID>:<descrição>:<homedir>:<shell utilizado pelo usuário>
Repare que o campo root:x:0:0:root:/root:/bin/bash da senha do usuário root está como “x”.
Isto significa que o sistema está fazendo uso de senhas shadow, que é o sombreamento de senhas do
arquivo /etc/passwd para o arquivo /etc/shadow. Isto acontece por um simples motivo: o arquivo
/etc/passwd tem permissão de leitura para qualquer usuário, pois eles precisam ler suas informações
de contas após logon (sua permissão padrão é 644 ou rw_r__r__), sendo assim, qualquer usuário
poderia copiar a senha criptografada para outro lugar.

UID
O UID é o número de identificação dado a cada usuário no ato de sua criação. O UID 0 é dado
para o usuário root e não deve ser dado a qualquer outro usuário além dele, pois se isto for feito, o
usuário que receber o UID 0 vai assumir a identidade de root e ter os mesmos poderes que ele.
Por definição padrão no arquivo /etc/login.defs, qualquer usuário novo criado em sistemas
baseados em Debian terá um UID de 1000 para cima, começando por este. Em ambiente Red Hat, este
número já é de 500 em diante. É lógico que isso é um padrão que pode ser modificado facilmente no
arquivo ou através da criação de um usuário com o UID especificado pelo comando useradd.
GID
É a identidade dada a cada grupo criado no sistema. A presença dele dentro desse arquivo
representa que ele é o grupo primário do usuário. Cada arquivo ou diretório que é criado por um usuário
(salvo em caso específico de existência de permissão especial de herança de grupo) tem o mesmo como
dono e o grupo primário dele como grupo do arquivo ou diretório.
O GID 0 também é reservado para o grupo root e, pelos mesmos motivos citados anteriormente,
não deve ser atribuído a mais nenhum usuário.
Homedir
O diretório pessoal do usuário, ou homedir, deve ser o único diretório do sistema (além do /tmp)
onde ele irá ter permissão de leitura, execução (se for o caso) e escrita.
O diretório pessoal do usuário não precisa necessariamente ser em /home. O exemplo mais
prático disto é que em um servidor Web Apache, que tem diretório de publicação de conteúdo /var/www
por padrão, geralmente também é instalado um servidor FTP, como Proftpd ou Vsftpd, e a conta do web
developer é feita com homedir /var/www/[nome_do_usuário], para que o mesmo, quando faça logon, já
entre direto no diretório onde está publicado o conteúdo de se site hospedado pelo servidor.
Shell do usuário
O BASH é o Shell padrão para sistemas Linux mas não quer dizer que todo usuário tenha que
usá-lo como interpretador de comandos. Alguns podem usar o SH por algum motivo específico, como por
exemplo, um usuário que era de BSD acostumado com scripts de SH e que está ainda migrando para
Linux.
Quando o usuário não pode ou não precisar fazer logon em um terminal, é determinado para ele
o SHELL /bin/false. Este recurso é utilizado com muita freqüência em usuários de e-mail e de um servidor
PDC ou BDC Samba pelo motivo de que em nenhum destes casos o usuário vai precisar usar nenhum
terminal do Linux.
O arquivo /etc/shadow, como já foi dito, é o arquivo onde por padrão são armazenadas as
senhas dos usuários.
É altamente recomendável trabalhar com senhas shadow por 2 motivos:

O controle de parâmetros de login de usuários (expiração de senha e conta, por exemplo) só
existe quando este arquivo existe;
O usuário comum não pode nem ler este arquivo, não tendo assim acesso à senha
criptografada de todos os usuários.
Os grupos existentes do sistema estão em /etc/group. Dentro deste, estão:
<nome_do_grupo>:<senha>:<GID>:<usuários relacionados ao grupo>
A senha de grupo está em /etc/gshadow.

Como foi explicado anteriormente, e existência do arquivo /etc/shadow é imprescindível para que
a segurança de informações se autenticação possa ser garantida. Vamos agora entender o que cada
campo deste arquivo significa:
Login: o login do usuário cadastrado em /etc/passwd.
Senha: a senha do usuário criptografada. Caso este campo esteja vazio, o usuário estará
utilizando senha em branco (nada recomendável!). Caso haja neste campo o sinal !, o usuário estará
com a sua conta travada, de forma a não conseguir nem efetuar o próximo logon.
Dias entre 1 de Janeiro de 1970 e a data da última mudança de senha.
Mínimo de dias entre mudanças de senhas: é a quantidade de dias que o usuário tem que
esperar até que ele possa novamente aterar a sua própria senha.
Máximo da duração da senha do usuário: é a própria informação dos dias de validade da

senha do usuário após ele ter modificado sua senha pela última vez. Após este dia, ele será obrigado a
mudar sua própria senha no logon.
Dias anteriores à expiração da senha onde o usuário será avisado para trocar se
senha: o padrão é sempre que 7 dias antes de a senha expirar, o usuário seja avisado a trocá-la.
Número de dias após a expiração da senha onde a conta será inativada.
Número de dias entre 1 de Janeiro de 1970 e a data exata de expiração da conta do
usuário.
Vejamos o exemplo das configurações da conta do usuário operador dentro de /etc/shadow:
É importante lembrar que, como todas as informações relativas aos controles de contas de
usuário estarão dentro deste arquivo, no caso de o administrador escolher por não utilizar senhas
shadow este controle não será possível.
Comandos de usuário e grupos
#whoami
Exibe qual o usuário em sessão.
#id
Sintaxe:
#Id <usuário>
Exibe UID, GID e grupos do usuário.
#useradd
Cria usuários.
Sintaxe:
#useradd <opções> <login_do_usuário>
Opções:
-d :homedir do usuário.
-s : shell que o usuário vai usar.
-c : descrição(comentários).
-m :cria o homedir.
-u : especifica um UID.
-g : especifica um grupo primário.
-G : relaciona o usuário a grupos.

-k : escolhe um diretório de skel alternativo.
-e : cria o usuário com data para sua conta expirar.
*Obs1
O Shell padrão do comando useradd é o SH, ou seja: se não for especificado outro shell, o
usuário vai utilizar o SH como interpretador de comandos.
*Obs2:
O diretório de skel é de onde são tirados os arquivos e diretórios que vão para o homedir do
usuário na hora que ele é criado.
O diretório de skel padrão é o /etc/skel e por padrão ele contém os scripts de logon do usuário.
Exemplos:
Criando um usuário com login user1, homedir /home/user1, shell /bin/bash e nome “Operador 1”:
#useradd –m –d /home/user1 –s /bin/bash –c “Operador 1” user1
Criando usuário webmaster com UID 1400, grupo primário cdrom, grupos relacionados audio e
backup, shell /bin/bash e homedir /var/www/webmaster:
#useradd –m –d /var/www/webmaster –u 1400 –g cdrom –G audio,backup –s /bin/bash
webmaster
Criando usuário user2 com data de expiração da conta para 10/12/2016, sem uso de shell e com
diretório de skel alternativo /dados :
#useradd –m –s /bin/false –e 2016-12-10 –k /dados user2
#adduser
Cria usuários conforme as configurações do arquivo /etc/adduser.conf.
A grande vantagem é que em um simples comando, sem argumentos, pode-se criar um usuário
de forma pré-configurada no arquivo do comando adduser.
Exemplo:
Adicionando o usuário bsd:

#adduser bsd
#addgroup
Também consulta /etc/adduser.conf, mas só que para criar grupos.
Exemplo:
Criando o grupo howtoonline:

#addgroup howtoonline

#usermod
Modifica parâmetros de contas de usuários. As opções são bem parecidas com as opções do
comando anterior.
Sintaxe:
#usermod <opções> <login>
Opções:
-d : modifica o diretório pessoal (homedir).
-s : modifica o shell utilizado.
-c : modifica a descrição.
-g : modifica o grupo primário.
-G : relaciona o usuário com outros grupos.
-a : se for utilizado junto com o ‘–G’, adiciona usuário nos grupos sem desfazer as relações que
ele tem com outros grupos.
-l : modifica o login do usuário.
-u : modifica o UID do usuário.
-L : trava a conta do usuário.
-U : destrava o usuário.
-e : especifica uma data para a expiração da conta do usuário.
Exemplos :
Modificando o homedir do usuário user1 para /var/www:

#usermod –d /var/www user1
Modificando o shell do usuário user1 para /bin/sh:

#usermod –s /bin/sh
Travando a conta do usuário user1:

#usermod –L user1
Destravando a conta do usuário user1:

#usermod –U user1
Modificando o login de user1 para usuario1:

#usermod –l usuario1 user1
Mudando o grupo primário de user1 para ‘unix’:

#usermod -g unix user1
Adicionando o usuário user1 ao grupo cpd:

#usermod -G cpd -a user1
#chfn
Modifica o campo de descrição do usuário.
Sintaxe:
#chfn <usuário>
Exemplo:
Modificando a descrição do usuário user1:

#chfn user1

#passwd
Cria, consulta e modifica parâmetros de autenticação de usuário.
Sintaxe:
#passwd <opções> <usuário>
Opções:
-S : consulta parâmetros de logon fornecidos por /etc/shadow.
-d : cria senha e branco para o usuário.
-l : trava usuário.
-u : destrava usuário.
Exemplos:
Criando senha em branco para o usuário operador:

#passwd –d operador
Travando a conta do usuário operador:

#passwd –l operador
Destravando a conta do usuário operador:

#passwd -u operador
Conferindo o status da conta:

#passwd –S operador
#chage
Modifica parâmetros de logon de usuários.
Sintaxe:
#chage <opções> <usuário>
Opções:
-l : lista parâmetros de logon.
-M : modifica o tempo (em dias) da validade da senha do usuário após a última modificação
(MAX_DAYS)
-m : modifica o tempo mínimo (em dias) entre mudanças de senha (MIN_DAYS).
-W : modifica a quantidade de dias anteriores à expiração as senha do usuário onde ele será
avisado a trocar a senha (WARN_DAYS).
-e : informa uma data específica para a expiração da conta do usuário.
-I : informa em quantos dias após a expiração da senha do usuário a conta do mesmo será
inativada.
Exemplos:
Informando que a conta do usuário user1 irá expirar exatamente dia 31/12/2016:
#chage -e 2016-12-31 user1
Mudando para 5 dias o tempo enterior à expiração da senha onde o usuário user1 será avisado a
trocá-la:
#chage -W 5 user1
Modificando a validade da senha do usuário user1 para 60 dias (2 meses) após ser modificada:

#chage –M 60 user1
Listando parâmetros de login de user1:

#chage –l user1
A interpretação do comando acima é a seguinte: a senha do usuário user1 irá expirar dia
11/10/2016, pois é o 20º dia depois da última alteração da mesma, que foi definido pelo
PASS_MAX_DAYS. Sua conta expira dia 12/12/2016.
Informando que após, a mudança de senha, o usuário user1 terá que esperar 20 dias para
mudá-la de novo:
#chage –m 20 user1
#pwunconv
Desabilita o uso de senhas shadow, enviando a senha para /etc/passwd e excluindo o arquivo
/etc/shadow.
#pwconv
Habilita novamente o uso de senhas shadow, criando o arquivo /etc/shadow com as senhas que
estavam em /etc/passwd sendo copiadas para este arquivo.
#who
Exibe a lista de usuário em sessão por terminal.
#w
Exibe a lista de usuários em sessão por terminal e os programas que eles estão utilizando.
#last
Exibe todas as conexões feitas pelos usuários no sistema.
#lastlog
Exibe o último login de todos os usuários cadastrados no sistema.
#groupadd
Cria um grupo no arquivo /etc/group.
Sintaxe:
#groupadd <opções> <grupo>
Opções:
-g : especifica um GID para o novo grupo.
-o : cria o grupo com o GID não-único.
#users
Exibe os logins de usuários em sessão.
#userdel
Exclui uma conta de usuário.
Exemplos:
Excluindo a conta do usuário user1 sem excluir o seu homedir:

#userdel user1

Excluindo a conta do usuário user1, seu diretório home e todos os arquivos contidos dentro dele.
#userdel –r user1
#groupdel
Exclui um grupo do sistema.
Sintaxe:
#groupdel <grupo>
#su
Faz logon com outro usuário sem fazer logoff da sessão atual
Sintaxe:
#su <login>
SUDO
#sudo
Permite que o usuário comum execute comandos de root caso os comandos que ele queira
executar estejam permitidos a ele dentro de /etc/sudoers. Esta é uma ótima prática para casos em que é
necessário ter um ou outro usuário usando alguns comandos de root. Exemplo: se em uma empresa
existe um usuário que deve administrar o Firewall Iptables e outro que deve monitorar e fazer
modificações nos discos do servidor apenas, não teria nenhum motivo para nenhum dos dois ter a senha
do usuário root,bastaria que seus nomes fossem incluídos em /etc/sudoers e, neste arquivo, fossem
habilitados a executar apenas comandos relativos às tarefas descritas acima, em algumas distros,
inclusive, o usuário root é travado por medida de segurança, neste caso, o /etc/sudoers foi configurado
previamente para dar acesso de root ao usuário em qualquer comando que ele digitar (isso não é o
mesmo que ser root, pois o sudo não dá permissão nenhuma ao usuário comum de ter as mesmas
permissões de acesso a arquivos e diretórios que o root).
Sintaxe do comando sudo:
#sudo <comandos>
O arquivo de configuração dos usuários do sudo tem permissão R__ R__ ___, o que quer dizer
que nem o usuário root teria permissão de editá-lo, só que o diretório /etc é de propriedade do root e ele
tem permissão de escrita sobre ele, o que também garante permissão de escrita sobre todos os arquivos
do diretório. Basta forçar a gravação para escrever nesse arquivo, isto pode ser feito no editor vim (com !
após a opção) ou no editor visudo, que já força a gravação por padrão. É bom lembrar que o editor
padrão do sistema é o nano, mas por causa de suas funcionalidades, vamos usar o vim, mudando o
editor padrão:
#update-alternatives --config editor
Editando o arquivo:
#visudo
No caso acima, temos a representação do serguinte cenário:

O usuário bruno pode executar comandos como qualquer usuário, sem precisar lançar a sua
própria senha para isso, e ele apenas pode executar como root os comandos fdisk e mkfs. Já o usuário
axl, pode executar comando como qualquer usuário, também sem senha, e pode também executar todos
os comandos de root, à exceção do programa iptables.

Feitas todas as configurações, vamos à implementação:
#chown
Modifica dono e grupo de arquivos ou diretórios.
Sintaxes:
#chown <opções> <dono> <diretório/arquivo>
#chown <opções> <dono>.<grupo> <diretório/arquivo>
#chown <opções> <dono>:<grupo> <diretório/arquivo>
Exemplos:
Modificando o dono do arquivo ~/arquivo1.txt para o usuário operador:

#chown operador ~/arquivo1.txt
Modificando o dono do arquivo ~/arquivo1.txt para o usuário operador e o grupo para cpd:
#chown operador.cpd ~/arquivo1.txt
Modificando o dono do diretório /backups, todos os seus subdiretórios e arquivos para o usuário
operador e o grupo para cpd:
#chown –R operador:cpd /backups

PERMISSÕES
Entender e saber aplicar as permissões necessárias é essencial para um administrador de
qualquer distribuição Linux. Uma política permissiva demais em arquivos ou diretórios pode levar todo
um projeto de TI por água abaixo em questão de segundos. Basta imaginar um servidor de arquivos com
permissões de leitura, gravação e escrita para todos os usuários em todos os compartilhamentos,
quando na verdade existem diretórios que não devem ser nem lidos por mais de um grupo de usuários.
Tipos e aplicações
Leitura
Representada em modo literal por R, a permissão de leitura concede ao usuário ao usuário
copiar e ler o conteúdo de arquivos ou diretórios.
Gravação
Representada em modo literal por W, esta permissão concede ao usuário mover, renomear e
modificar o conteúdo de um arquivo ou diretório.
Execução
Esta com certeza merece uma atenção muito especial, pois sua aplicação em arquivos e
diretórios é totalmente diferente.
Ela só é aplicada a arquivo quando o mesmo for um programa executável (exemplo: programa
de Shell Script). Já em diretórios ela é essencial se o objetivo for permitir o acesso a um usuário
qualquer. Sem tal permissão, não haverá como o usuário executar o comando cd no diretório.
A permissão de execução é representada em modo literal por X.
Permissões especiais
SUID
Permite que qualquer usuário tenha a mesma permissão de execução que o dono sobre o
arquivo.
Em modo literal, é representada no campo de dono por s.
SGID
Faz com que cada arquivo ou subdiretório criado em um diretório seja do grupo do “diretório pai”
(herança de grupo).
Em modo literal, é representada no campo de grupo por s.
Sticky Bit
Proíbe que qualquer usuário que não seja o dono do objeto ou o próprio root exclua o mesmo,
mesmo que tenha permissão para isso.
Em modo literal, é representada no campo de outros por t.
Campos de permissões
Dono (USER)
São permissões relativas ao dono do arquivo ou diretório.
Grupo (GROUP)
Toda vez que um arquivo ou diretório é criado, o dono do mesmo fica sendo o usuário que cria e
o grupo proprietário acaba ficando aquele que é o grupo primário do usuário que criou.
Este campo se refere às permissões aplicadas àquele que fazem parte do grupo do objeto.
Outros (OTHERS)
É o nível de permissão para usuário que não são o dono do objeto e também não fazem parte do
grupo do mesmo.

Modo octal de permissões
Além de poderem ser representadas por letras (R,W e X), as permissões também podem ser
representadas por números no modelo octal:
Número Tipos de permissão

4 Leitura ou SUID.
2 Gravação ou SGID.
1 Execução ou Sticky bit
0 Sem permissão alguma.
Para agregar mais de uma permissão, pode-se somar os números, como no exemplo:
Leitura, gravação e execução para dono e leitura e execução para grupo e outros:
RWXR_XR_X = 755
Leitura e gravação para o dono e apenas leitura para grupo e outros:

RW_R__R__ = 644
Leitura, gravação e execução para dono e leitura e execução para grupo e outros mais SGID e
Sticky bit:
RWXR_sR_t = 3755
Como se pode perceber, no modo octal de permissões especiais, o número referente à elas vem
antes das outras permissões.
Outro detalhe: quando o campo de execução do nível onde se aplica as permissões especiais
estiver sem permissão de execução, estas letras referentes a essas permissões ficaram em caixa alta.
Aplicação
#chmod
Modifica permissões de arquivos e diretórios.
Sintaxe:
#chmod <opções> <permissões> <arquivo/diretório>
Opções:
-R : modo recursivo.
-v : modo verbose.
Exemplos:
Aplicando permissão para dono de RWX, adicionando permissão de gravação para o grupo e
especificando permissão de apenas leitura para outros no arquivo ~/arq1.txt (tudo em modo literal):
#chmod –v u=rwx,g+w,o=r ~arq1.txt
Retirando a permissão de execução de todos os níveis no arquivo do exemplo acima:

#chmod –x ~/arq1.txt
Adicionando permissão de gravação para grupo e outros no mesmo arquivo:

#chmod g+w,o+w ~/arq1.txt
Aplicando SUID e Sticky bit em modo literal ao mesmo arquivo:

#chmod u+s,g+s ~/arq1.txt
Aplicando as permissões RWXRWXR__ ao diretório /backups e a todo o seu conteúdo em

modo octal:

#chmod -R 774 /backups
Aplicando SGID e Sticky bit, e permissão RWX para todos os níveis no diretório /backups em
modo octal:
#chmod 3777 /backups
Umask
Ao serem criados, por padrão, arquivos e diretórios ganham as permissões 644 e 755,
respectivamente. Este fato só ocorre por causa de um número chamado de Umask. Este número,
subtraído de 666 para arquivos e 777 para diretórios, vai determinar as permissões padronizadas para
os novos objetos a serem criados pelo usuário.
Exemplos:
Umask : 022 (padrão)
Permissão padrão para arquivos novos: 644
Permissão padrão para diretórios novos: 755
Umask : 024
Permissão padrão para arquivos novos: 642
Permissão padrão para diretórios novos: 753
*Obs:
Quando o valor de Umask configurar permissão padrão de execução em qualquer nível para
arquivo, esta não será aplicada. No lugar dela, será aplicada a permissão de gravação.
Geralmente, o valor de Umask é definido em algum dos scripts de logon de usuário pelo
comando umask.
#umask
Comando que define e consulta a umask do usuário.
Sintaxe:
#umask <valor>
Exemplo:
Transformando Umask do usuário para 020:

#umask 020

SISTEMAS DE ARQUIVOS
Alguns conceitos são imprescindíveis antes que o estudo deste assunto seja iniciado:
INODES
São números que servem como índices para arquivos e diretórios. Cada arquivo terá um número
reservado para ele, isto acontece por causa da reserva de inodes existente no filesystem (que, por
padrão, é de 5%). A reserva de inodes deve ser sempre verificada com a linha de comando df –hi, pois o
estouro desta reserva causa a incapacidade de criação de novos arquivos ou diretórios no sistema de
arquivos em questão.
JOURNALING
Este recurso é encontrado em sistemas de arquivos diversos suportados pelo Linux, como
EXT3, EXT4 e ReiserFS. Ele consiste na criação de um log de atividades recentes do sistema, que
podem ser recuperadas em um próximo boot, caso ocorra um desligamento não programado, por
exemplo, proporcionando maior probabilidade de recuperação de “crashes” de sistema.
SUPERBLOCO
São cópias de blocos que armazenam informações detalhadas sobre um sistema de arquivos.
Estas cópias, por padrão, são feitas a cada 8192 blocos e elas sevem para auxiliar a recuperação de um
filesystem que esteja com inconsistência.
São muitos sistemas de arquivos suportados pelo Linux e é sempre importante estar
sincronizado com o suporte oferecido pelo Kernel a eles, para que não haja nenhum tipo de perda de
tempo ao tentar usar um sistema de arquivos que não é suportado.
Os mais importantes sistemas de arquivos suportados pelo Linux são:
EXT2
Sistema de arquivo padrão de distribuições antigas. É adotado muito comumente como padrão
por programas como o tune2fs, o mke2fs e o e2fsck. Seu limite de criação de blocos é de 8TB e o
tamanho de cada bloco pode chegar a 4096 bytes.
EXT3
Este sistema de arquivos possui limitação por tamanho de arquivo de 2TB e limite de criação de
blocos de 32TB. Ele também possui o recurso de Journaling, diferença mais marcante entre ele e o
EXT2.
É importante ressaltar que, em caso de fim dos inodes, nenhum dos dois sistemas de arquivos
acima os recria. Será preciso que o próprio administrador redefina a reserva de inodes.
EXT4
Sucessor do EXT3, este sistema de arquivos suporta arquivos de até 16TB de tamanho e 1
exabyte de blocos no total.Um recurso muito interessante neste filesystem é o de verificação de
integridade de Journaling, o que incrementa mais confiabilidade para o recurso, que foi melhorado. A
gravação atrasada de dados também pode ser considerada como um recurso muito útil deste sistema de
arquivos, pois aumenta a velocidade de leitura e gravação, apenas gravando um dado quando ele
realmente for sair de cache. O tamanho do inode também é maior do que no EXT3 (256bytes ao invés de
128bytes de EXT3), isso é necessário para que o inode possa armazenar informações extras, como
versão do inode ou data de modificação do mesmo.

ReiserFS
Sistema de arquivos desenvolvido por Hans Reiser, este sistema de arquivos proporciona de
vantagem em relação aos outros o fato de garantir maior recuperação de danos à estrutura existente de
dados. A grande desvantagem é que ele já não garante um Journaling tão eficiente assim para arquivos
que estiverem sendo utilizados no ato de um “crash”.
UFS
O Unix File System é o sistema de arquivos padrão de distribuições Unix como FreeBSD, por
exemplo.
JFS
O Journaling File System foi concebido pela IBM para ser o sistema de arquivo do IBM-AIX.
XFS
Desenvolvido pela Silicon Graffics, o XFS suporta até 8 exabytes de tamanho por volume.
Swap
Chamado de área de troca, este sistema de arquivos funciona como memória virtual para o
sistema.
Costumava-se destinar o dobro do espaço da memória RAM para uma memória Swap em
versões antigas de distros Linux. Hoje esta prática está em desuso por causa do crescente
desenvolvimento de tecnologias de armazenamento temporário. Hoje em dia, é muito comum encontrar
um servidor com até 64GB de memória RAM.
Proc
Este sistema de arquivos na verdade contém pseudo-arquivos, que são criados pelo Kernel
Linux conforme haja necessidade de manipular algum recurso de sistema. Estes arquivos são os
processos executados em tempo real pelo Kernel e consultados pelo mesmo.
O sistema de arquivos Proc fica montado em /proc e sem ele o kernel Linux não pode interagir
com o sistema operacional.
Alguns exemplos de pseudo-arquivos de processos do Kernel:
/proc/partitions – arquivo de partições disponíveis para uso.
/proc/cpuinfo – arquivo de informações detalhadas sobre CPU.
/proc/meminfo – arquivo de informações detalhadas sobre memória RAM.
/proc/swaps – arquivo de reconhecimento de sistemas de arquivo SWAP.
/proc/mounts – arquivo de reconhecimento de sistemas de arquivos montados (mesma
informação de /etc/mtab)
/proc/version – arquivo de informações sobre versão do sistema operacional e do kernel.
ISO9660
Sistema de arquivos padrão para mídias de CD ou DVD.
FAT16 e FAT32 são tratados em Linux como MSDOS e VFAT, enquanto NTFS é tratado como
NTFS mesmo.

Comandos administrativos de filesystems
#fdisk
Particionador modo texto padrão para distribuições Linux.
Sintaxe:
#fdisk <opções> <disco>
Exemplos:
Exibindo a tabela de partições do disco /dev/sda:

#fdisk –l /dev/sda
No caso acima, o disco /dev/sda tem 1 partição primária, 1 extendida e 3 lógicas.
Particionando /dev/sda:
#fdisk /dev/sdb
As principais opções do prompt do fdisk são:
P : exibe a tabela de partições do volume.

T : muda o tipo da partição.
C : cria uma partição.
D : exclui uma partição.
A : torna a partição ativa.
W : sai salvando as alterações na tabela de partições.
Q : sai sem salvar qualquer mudança feita na tebela de partições.
#cfdisk
Particionador modo texto com interface mais amigável.
Sintaxe:
#cfdisk <disco>
#mkfs
Cria sistemas de arquivos em volumes.
Sintaxe:
#mkfs <opções> <volume>
Opções:
-t : especifica o tipo do sistema de arquivos (na verdade, o programa que será utilizado na
formatação).
-L : aplica um rótulo em volumes EXT2 e EXT3.
-c : faz a verificação de disco antes de formatar o volume.
-V ou –v : modo verbose.
-n : cria rótulos em filesystems VFAT e MSDOS.
*Obs:
Os comandos abaixo são equivalentes:
#mkfs –t ext3 <volume>
#mkfs.ext3 <volume>
#mke2fs –j <volume>
Exemplos:

Criando sistema de arquivos ext3 em partição /dev/sda5, com aplicação de rótulo “Backups” e
verificação de integridade de disco:
#mkfs –t ext3 –L “Backups” –c /dev/sda5
Criando sistema de arquivos ext2 em /dev/sda6:

#mkfs /dev/sda6
#tune2fs
Verifica e modifica parâmetros ajustáveis de sistemas de arquivos EXT2 e EXT3.
Sintaxe:
#tune2fs <opções> <volume>
Opções:
-l : lista os parâmetros do filesystem.
-j : aplica recurso de Journaling em sistemas de arquivos ext2 (converte para ext3).
-L : aplica um rótulo ao volume.
-m : modifica o percentual de blocos reservados para inodes.
-r : modifica o número de blocos reservados para inodes.
-c : configura o número de montagens do volume antes de ele ser verificado por fsck.
Exemplos:
Modificando o percentual de blocos reservados para inodes de /dev/sda7 para 15%:

#tune2fs –m 15 /dev/sda7
Convertendo /dev/sda8 para ext3:

#tune2fs –j /dev/sda8
Listando parâmetros de volume /dev/sda7:

#tune2fs –l /dev/sda7
Na figura acima, que é o resultado do comando em questão, pode-se observar que o parâmetro
hás_journal está presente, o que caracteriza um sistema de arquivos com recurso de Journaling ativado.
#fsck
Verifica a integridade de sistemas de arquivos.
Sintaxe:
#fsck <opções> <volume>
Opções:
-t : especifica o tipo do sistema de arquivos que vai ser verificado.
-f : força o a checagem mesmo em sistemas de arquivos aparentemente “limpos”.
-p : repara automaticamente inconsistências no sistema de arquivos.
-c : verifica badblocks.
-N : não executa. Apenas simula o que seria feito.
-M : não verifica sistemas de arquivos montados.
-C : exibe barra de progresso.
Exemplos:
Verificando integridade do volume ext3 /dev/sdb6 e corrigindo as falhas no mesmo, se houverem:

#fsck –t ext3 –p /dev/sdb6

Simulando verificação em /dev/sdb6:
#fsck –N /dev/sdb6
*Obs:
É muito importante ressaltar que uma verificação de disco feita em um volume montado pode
causar inconsistência no sistema de arquivos do mesmo.
#badblocks
Verifica a existência de badblocks em um disco.
Sintaxe:
#badblocks <opções> <volume>
#hdparm
Ajusta parâmetros de configuração de HDs.
Sintaxe:
#hdparm <opções> <disco>
Opções:
-d : ativa o modo DMA.

-c : ativa o I/O de 32 bits.
-i : exibe identificação do disco.
Exemplos:
#hdparm –i /dev/sda
#dumpe2fs
Exibe informações sobre blocos e superblocos de um sistema de arquivos.
Sintaxe:
#dumpe2fs <volume>
#dd
Cria imagens “bit a bit” de sistemas de arquivos.
Sintaxe:
#dd if=<origem> of=<destino> <opções>
Opções:
bs : “block size” – é o tamanho do bloco a ser criado.
count : define quantos blocos serão criados.
notrunc : não truncar arquivo de destino.
Exemplos:
Criando um clone da partição /dev/sda1 em /dev/sdb1:
#dd if=/dev/sda1 of=/dev/sdb1
Criando um arquivo de imagem /root/part2 da partição /dev/sda2:

#dd if=/dev/sda1 of=/root/part2
Criando o arquivo /root/swp a ser usado como sistema de arquivos swap:

#dd if=/dev/zero of=/root/swp

#mknod
Cria arquivos especiais dentro de /dev.
Sintaxe:
#mknod <dispositivo> <tipo> <major number> <minor number>
Tipos de arquivos:
b : cria arquivo de blocos.
c ou u : cria arquivo de caracteres.
p : cria um fifo.
Exemplo:
Criando um arquivo de blocos que vai servir como arranjo RAID (software):
#mknod /dev/md0 b 9 0
Sistema de arquivos SWAP
O sistema de arquivos SWAP (ou área de troca) funciona como memória virtual para o sistema
(auxilia a memória RAM).
Este sistema de arquivos pode ser um arquivo propriamente dito ou pode ser também uma
partição separada para este fim, o que leva o administrador a seguinte conclusão: em qualquer caso,
para utilizar SWAP o sistema vai ter que utilizar o disco rígido, o que diminui bruscamente a performance
do sistema. Por esse motivo específico é que apenas em último caso é recomendado o uso deste
recurso.
Era comum em sistemas antigos (pela falta de memória RAM) a atribuição do dobro da
capacidade de armazenamento em RAM para a SWAP, ou seja: se um sistema possui 256MB de RAM,
o correto é destinar 512MB para a criação da SWAP. Hoje em dia essa prática é cada vez mais
desnecessária, uma vez que as tecnologias de armazenamento em RAM já proporcionam a capacidade
de armazenamento temporário necessária para qualquer servidor.
Criando sistemas de arquivos SWAP:
Levando em consideração que foi criada uma partição tipo 82 para abrigar um sistema de
arquivos SWAP e o seu caminho é /dev/sda2, o que, primeiro deve ser feito é a criação do sistema de
arquivos SWAP:
Cria o sistema de arquivos SWAP em /dev/sda2 (não existe ‘mkfs –t swap’):

#mkswap /dev/sda2
O próximo passo é ativar a swap:

#swapon /dev/sda2
Verificando a sua atividade:

#swapon –s ou #cat /proc/swaps
Configurando o SWAP para ativar automaticamente no boot:

#vim /etc/fstab
Como o SWAP não precisa de ponto de montagem, este deve ser definido como ‘none’ no
campo de opções.
Se for necessário desativar o SWAP, pode-se usar a linha de comando abaixo:
#swapoff /dev/sda2

Diretório /dev e gerenciador UDEV
O diretório /dev tem em seu conteúdo arquivos especiais, que podem ser arquivos de blocos
(discos ou partições, por exemplo), arquivos de caracteres (terminais de controle, memórias RAM,
placas de som, por exemplo).
O gerenciador de dispositivos UDEV cuida de atualizar os dispositivos disponíveis dentro de /dev
de forma em dinâmica. Assim que um dispositivo é conectado fisicamente, o UDEV cria o arquivo
correspondente ao mesmo em /dev.
Quando a interfae gráfica está instalada em distros que contam com o Kernel 2.6 do Linux
instalado, UDEV monta automaticamente todo volume novo em /media/<rótulo do volume> assim que o
reconhece. Isto facilita e muito a vida do usuário de desktop Linux a medida que o mesmo não terá
trabalho algum de sequer montar manualmente o volume.
A visão da listagem dos arquivos de disco do diretório /dev é esta:

Montagem de volumes
Para que um volume seja utilizado como sistema de arquivos no sistema, é preciso montá-lo em
algum dos diretórios existentes, pois, a princípio, ele é um arquivo de blocos qualquer antes que isso
ocorra.
O diretório onde este volume vai ser acessado é chamado de ponto de montagem, ou mount
point. Este mount point pode ser um diretótio já existente do modelo FHS (/mnt ou /media, por exemplo)
ou pode ser um diretório criado pelo usuário.
É bom lembrar também o seguinte: as permissões do mount point são mandatórias sobre as
permissões de montagem do volume, ou seja: um volume pode ter sido montado com permissão de
gravação mas se o diretório onde ele foi montado não tiver permissão para que o usuário que vai acessar
possa escrever, o mesmo não o fará.
O arquivo /etc/fstab contém as configurações de montagem de volumes. Sua sintaxe interna é a

seguinte:
<sistema de arquivos> <ponto de montagem> <tipo do sistema de arquivos> <opções de
montagem> <uso de dump> <flag de checagem de disco no boot>
É importante reparar que também é possível montar um volume neste arquivo de configuração
através do UUID do seu sistema de arquivos, este número de identificação pode ser obtido através do
comando ‘tune2fs -l <volume>’.
No caso deste arquivo /etc/fstab acima, ao invés de montar o sistema de arquivos pelo nome
dele em /dev, ele esta configurado para montar os volumes pelo o UUID (ID de partição), independente
de quantos discos têm juntos com ele.
Opções de montagem
ro : monta o volume com permissão de apenas leitura para todos.

rw : monta o volume com permissão de leitura e grevação para todos.
auto : monta automaticamente o volume assim que o arquivo /etc/fstab for relido.
noauto : neste caso, o volume precisaria ser montado manualmente através do comando mount.
dev : o volume pode abrigar arquivos especiais.
nodev : o contrário de dev.
exec : o volume permite que sejam executados programas dentro do volume (permissão x em
arquivos).
noexec : o contrário de exec.
suid : permite que permissões especiais aplicadas a arquivos e diretórios tenham efeito.
nosuid : o contrário de suid.
user : permite que o usuário comum monte o volume e apenas aquele que montou pode
desmontar o mesmo.
users : qualquer usuário monta e desmonta o volume.
nouser: proíbe que qualquer usuário não-root monte ou desmonte o volume.
async : entrada e saída assíncrona de gravação e escrita no volume.
sync : o contrário de async.
defaults : é o mesmo que as opções rw,auto,suid,nouser,async e exec juntas.
loop : alvo é um arquivo loop.
guest : mounta como convidado, em caso de montar volumes CIFS.

Quando for o caso de o volume ser montado durante o processo de boot, nas opções de
montagem dele dentro de /etc/fstab deve constar a opção ‘auto’.
Comandos de montagem
#mount
Monta manualmente um sistema de arquivos.
Sintaxe:
#mount <opções> <volume> <ponto de montagem>
Opções:
-a : monta todo volume com opção ‘auto’ em /etc/fstab.
-v : verbose.
-r : monta como apenas leitura.
-w : monta como leitura e gravação.
-o : especifica as opções de montagem.
Exemplos:
Montando o volume /dev/fd0, que está com opção ‘noauto’ em /etc/fstab:

#mount /dev/fd0
Montando o volume /dev/sdb1, formatado como vfat, em /dados, em modo verbose:

#mount –t vfat –v /dev/sdb1 /dados
Montando o volume /dev/sdb2, que é ext3, em /backup como leitura e gravação, sem verbose:
#mount –t ext3 –w /dev/sdb2 /backup
Montando todos os volumes com opção ‘auto’ dentro de /etc/fstab:

#mount –a
Montando o volume /dados exportado pelo servidor NFS 172.16.0.1 em /media/dados:

#mount –t nfs 172.16.0.1:/dados /media/dados
Montando o compartilhamento do Windows ARQUIVOS em 192.168.0.2 em /mnt :

#mount –t CIFS //192.168.0.2/ARQUIVOS /mnt
Montando o arquivo de imagem de CD /root/debian_jessie.iso em /media/debian como apenas

leitura:
#mount –t iso9660 –r /dev/debian_jessie.iso /media/debian –o loop
#umount
Desmonta sistemas de arquivos.
Sintaxe:
#umount <opções> <volume/ponto de montagem>
Exemplos:
Desmontando o volume /dev/sdb3:

#umount /dev/sdb3
Desmontando um volume qualquer montado em /media/debian:

#umount /media/debian
Desmontando todos os volumes montados:

#umount –a

Diferentemente de ‘mount –a’, ‘umount –a’ desmonta todo e qualquer volume que não estiver um
uso.
Toda vez que um volume está montado, todos os seus parâmetros de montagem e seu caminho
são enviados o arquivo de tabelas de volumes montados, o /etc/mtab, que recebe informações de
/proc/mounts.

LINKS
Criar ligações entre arquivos e diretórios não é uma tarefa tão fácil quanto parece, existem
regras e conceitos que precisam ser respeitados.
Primeiramente, vamos entender os tipos de links existentes:
Hardlink (link físico)
Um hardlink é a ligação entre arquivos onde o arquivo original é praticamente o mesmo que o
link, tanto que os dois possuem o mesmo número inode e, por isso, não podem estar em sistemas de
arquivos diferentes.
Em uma ligação física entre arquivos, se o arquivo original for renomeado, movido ou até
removido, o link continua existindo com os mesmos dados e o mesmo tamanho do arquivo original. Ele é
ideal para se fazer cópias de segurança de arquivos em tempo real.
Softlink (link simbólico)
Um softlink assume o papel de “simples atalho”, como o usuário costuma chamar. Ele assume
um número inode diferente do arquivo original, podendo assim, ser implementado entre sistemas de
arquivos diferentes.
Em uma ligação simbólica entre arquivos, se o arquivo original for movido, excluído ou
renomeado, a ligação fica quebrada (não existe mais).
#ln
Cria links entre arquivos (hardlink, por padrão).
Sintaxe:
#ln <opção> <origem> <link>
Exemplos:
Cria ligação física entre os arquivos /etc/passwd e /etc/users:

#ln /etc/passwd /etc/users
Cria ligação simbólica entre /etc/shadow e /mnt/senhas:

#ln –s /etc/shadow /mnt/senhas

COMANDOS DE BUSCA
#which e #type
Buscam por arquivo executável de um comando do sistema que esteja no PATH do usuário.
Sintaxe:
#which <comando>
#whereis
Busca por arquivos e diretórios de manuais, de configuração de binários de um programa
qualquer.
Sintaxe:
#whereis <programa>
#locate
Procura por arquivos e diretórios em todo o sistema mediante atualização em sua própria base
de dados pelo comando ‘updatedb’.
Sintaxe:
#updatedb
#locate <arquivo/diretório>
Exemplo:
Procurando por ‘samba’ no sistema inteiro:
#find
Faz a busca avançada em uma árvore de diretórios específica.
Sintaxe:
#find <diretório> <opções>
Opções:
-type : procura por tipo de objeto.
-name : procura por nome.
-iname: procura por nome em modo insensitivo (ignora diferenças entre maiúsculas minúsculas).
-fstype : procura por sistema de arquivos do um tipo específico.
-maxdepth : máximo de profundidade da busca em diretórios (máximo de subdiretórios
buscados).
-mindepth : mínimo de profundidade da busca em diretórios.
-executable : procura por objeto executável.
-perm : especifica qual a permissão exata do objeto que vai ser buscado.
-size : busca por tamanho.
-amin : procura por objetos acessados a minutos atrás.
-atime : procura por objetos que tenham sido acessados dias atrás.
-mmin : procura por objetos que tenham sido modificados a minutos atrás.
-mtime : procura por arquivos que tenham sido modificados a dias atrás.
Exemplos:
Buscando apenas por links simbólicos dentro de /etc, de 4 subdiretórios em diante:

#find /etc -mindepth 4 -type l

Busca apenas por arquivos regulares com permissão 644 em /var/log:
#find /var/log –perm 644 –type f
Busca apenas por arquivos executáveis em /usr/local:

#find /usr/local –executable
RAID
O termo RAID vem de Reduntant Array of Independent Disks (arranjo redundante de discos
independentes) mas nem sempre a parte “redundante” pode ser levada a sério, pois nem todos os tipos
de arranjos proporcionam a redundância anunciada.
A tecnologia permite agregar recursos diversos de disponibilidade e performance com diversos
discos fazendo parte de um “bloco” só.
O RAID é aplicável através de controladas RAID ou de software. Vamos tratar aqui neste
capítulo a implementação do RAID via software no Linux, já que se o RAID for via hardware, o sistema
operacional Linux vai enxergá-lo como um disco serial comum.
Os principais níveis de RAID são:
RAID0 (Stripping)
Em RAID0, não existe redundância alguma entre discos. O

que acontece no arranjo é que a performance de leitura e gravação
melhora significativamente, à medida que dois discos, no mínimo
dividem esta tarefa, pois os dados ficam fragmentados entre os
discos.
Esta prática não proporciona qualquer tipo de segurança aos
dados, uma vez que não há tolerância a falhas de nenhum dos discos
(se isto ocorrer, os dados serão perdidos completamente). A pesar
disso, é uma prática bastante usada em bancos de dados, pela boa
performance de I/O proporcionada. Utilizar RAID0 com 2 HDs SATA2
com 300MB/s cada proporcionaria (em tese) 600MB/s de taxa de
transferência.
RAID1 (Mirroring)
Em RAID1, a performance de I/O cai significativamente

mas, em compensação, a segurança dos dados (disponibilidade, na
verdade) é garantida em caso de problemas com um dos discos do
arranjo. Isso porque o RAID1 é o nível que proporciona redundância
completa de dados. Acontece que um dos discos serve de
“espelho” para os dados do outro. É preciso pensar muito antes de
implementar RAID neste nível pois, como foi dito antes, a
performance de I/O cairá significativamente por causa da
sincronização em tempo real dos dados de um disco para o outro.
RAID10 (0 + 1)
Neste caso, os dói níveis acima são combinado para poder proporcionar redundância e
performance ao mesmo tempo. O mínimo é de 4 discos para este arranjo.
Primeiro são implementados dois arranjos RAID0 independentes e após estes serem criados, é
criado um RAID1 com esses dois arranjos.

RAID5
O RAID5 pode ser implementado com, no mínimo, 3

discos e é uma ótima solução para aliar disponibilidade,
segurança e maior aproveitamento da capacidade de
armazenamento dos discos.
Neste nível. há um RAID0 funcionando em todos os
discos, só que dentro de cada um deles é reservada uma
área de paridade que faz o papel de “mirror” de arquivos, as
áreas de paridade dos discos somadas devem ter o espaço
referente a um dos discos do arranjo, fazendo assim com
que a tolerância a falhas do arranjo seja de um disco. A
diferença entre fazer RAID5 com 3 discos ou com mais é
que cada disco que entra no arranjo ajuda a dividir a área de
paridade de forma que fique um espaço igual para todos os discos, diminuindo a perda de espaço no
arranjo.
Um arranjo RAID5 com 6 HDS de 1TB cada um ficaria com 5TB de espaço total e ainda teria
tolerância a falha de 1 dos discos.
RAID6
Este nível é bem parecido com o RAID5, só que o

mínimo é de 4 discos no arranjo.
A área de paridade é distribuída entre os discos de
forma que o total de espaço no arranjo fique com o espaço
referente a dois discos reservado para redundância,
proporcionando tolerância a falhas de 2 discos.
Em um arranjo RAID6 com 8 discos de 1TB cada, o
tamanho final do arranjo ficaria de 6TB, com tolerância a falha
de 2 discos.
Criando arranjo RAID
O programa mdadm administra os arranjos RAID no Linux.
Instalando o programa:
#apt-get install mdadm –y
Para melhor viabilidade de aprendizado, vamos fazer RAID com partições.

Primeiro vamos criá-las:
cfdisk /dev/sda
As partições para integrar o arranjo têm que ser do tipo “fd” (detecção automática de RAID).
Vamos fazer o laboratório com 5 partições lógicas, onde 3 irão ficar no arranjo, compondo um
RAID5, e 2 ficarão de disco reserva (spare disk).

Criando o arquivo de bloco do arranjo:
#mknod /dev/md0 b 9 0
Criando o arranjo RAID5:

#mdadm –C /dev/md0 –l 5 –n 3 /dev/sda[5-7] –x 2 /dev/sda{8,9}
Onde:
-C : cria um arranjo RAID.
-l : indica qual o nível de RAID a ser criado.
-n : indica quantos e quais discos farão parte do arranjo (não conta com os reservas).
-x : indica quantos e quais discos vão ficar de “spare disks”.
Os metacaracteres [-] e {,} foram utilizados para facilitar a declaração desses discos, pois se não
fosse assim, o administrador teria que digitar disco por disco separado por espaço.
Verificando funcionamento do arranjo
O arquivo /proc/mdstat pode ser consultado caso o administrador queira ver como está a
sincronização do arranjo:
#watch –n1 cat /proc/mdstat
O comando watch repete de ‘n’ em ‘n’ segundos um comando específico. Desta forma, o arquivo
será lido de 1 em 1 segundo, proporcionando ao administrador monitorar em tempo real a criação do
arranjo.
Para mais detalhes sobre o mesmo, pode ser utilizada a seguinte linha de comando:
#mdadm –D /dev/md0
Onde:
-D : descreve detalhes sobre o arranjo.

Formatando e montando o arranjo
RAID não é sistema de arquivos, mas sim um arranjo de discos, como já foi visto. Por esse
motivo, não há nenhum sistema de arquivos especial para que ele seja formatado. O arranjo pode ser
formatado com qualquer sistema de arquivos suportado pelo sistema.
Outro fato importante é o de que o arranjo será formatado, e não cada disco individualmente:
#mkfs –t ext3 –L “RAID5” –c /dev/md0
Se for necessário usar o arranjo permanentemente, como é o caso da maioria dos arranjos, ele
deve ser configurado em /etc/fstab:
#vim /etc/fstab
Montando o arranjo antes de reinicializar o sistema:

#mount -a
Discos falhando no arranjo
Vamos forçar uma falha em um dos discos do arranjo para testar a participação dos discos
reservas:
#mdadm /dev/md0 –f /dev/sda5
Observa-se que o disco fica marcado como falhado, enquanto o reserva entra em seu lugar e faz
novamente a sincronização com o arranjo.
Para remover de vez o disco que falhou:

#mdadm /dev/md0 –r /dev/sda5
Para adicionar mais um spare disk:

#mdadm /dev/md0 –a /dev/sda9
Para parar todo o arranjo:

#mdadm –S /dev/md0

BACKUP E COMPACTAÇÃO
Em todo servidor instalado, uma boa prática de backup é sempre requerida. Manter estratégias
de backup eficientes não é uma tarefa simples, com às vezes se imagina. O administrador deve analisar
vários pontos antes de montar estas estratégias, como por exemplo: tipo do backup, freqüência com que
vai ser feito, dados a serem copiados, mídias de armazenamento e o programa que vai gerenciar este
backup.
Tipos de backup
Backup Completo : é o tipo de backup onde todos os dados de um determinado local são
copiados para outra mídia, de forma que, a cada backup completo seja criado um destino diferente para
o mesmo.
Backup diferencial : é o tipo de backup que apenas copia o que foi modificado ou criado desde o
último backup completo.
Backup incremental : apenas faz o backup de tudo que tenha sido modificado ou criado desde o
último backup diferencial.
Diretórios importantes
Fazer um backup completo, diferencial ou incremental do sistema todo implica em incluir estes
diretórios abaixo na lista:
/etc – por ter todos os arquivos de configuração de serviços de sistema a servidores instalados,
este diretório nunca deve ser esquecido em um alista de backup.
/home – dependendo do tipo de servidor, será importante fazer backup dos arquivos pessoais de
usuários. Na verdade, como nem todo usuário precisa usar /home como diretório de arquivos pessoais, o
ideal primeiro seria verificar em /etc/passwd antes a lista de diretórios ‘home’ de usuários antes de
montar este backup ou fazer com que isso seja feito por um script cheio de expressões regulares (muito
melhor!!).
/var/mail – para um servidor de correio que trabalhe com os padrões de armazenamento de
mensagens de usuários, este diretório é crucial, pois nele estão os e-mails recebidos pelos usuários
/var /www – para um servidor web que também opere nos padrões, este diretório é fundamental,
pois é nele que se encontram os arquivos de publicação de sites no servidor.
/var/lib/mysql – diretório de banco de dados do MySql-Server.
Arquivamento de backups
#tar
Arquiva dados de diretórios em um arquivo apenas. É padrão para todas as distribuições Linux.
Ele é muito versátil para backups, podendo corresponder a qualquer tipo de backup citado acima.
Sintaxe:
#tar <opções> <arquivo de backup> <origens dos dados>
Opções:
-c : cria uma arquivo da backup.
-t : consulta o conteúdo de arquivos tar.
-v : verbose.
-x : extrai conteúdo de arquivo tar.
-u : modo “update”. Apenas atualiza o conteúdo de um arquivo tar.

-M : habilita backup em múltiplos volumes.
-C : muda o destino da extração de conteúdo de arquivo tar.
-z : utiliza o agente de compactação gzip.
-j : utiliza o agente de compactação bzip2.
-a : adiciona conteúdo a um arquivo tar.
-f : toda a saída deve ser redirecionada para um arquivo tar.
Exemplos:
Criando um arquivo de backup do diretório /etc inteiro em /backups/bkp.tar

#tar –cvf /backups/bkp.tar /etc
Adicionando ao arquivo de backup anterior os diretórios /var/mail, /var/mysql e /home:

#tar –uvf /backups/bkp.tar –a /var/mail /var/mysql /home
Conferindo conteúdo do arquivo da backup:

#tar –tf /backups/bkp.tar
Atualizando o conteúdo do backup com o que foi modificado nesses diretórios:

#tar –uvf /backups/bkp.tar /etc /var/mysql /var/mail /home
Criando arquivo de backup /backups/homedir.tar.gz (arquivo também compactado com gzip) do

diretório /home/user1:
#tar –czvf /backups/homedir.tar.gz /home/user1
Criando arquivo de backup /backups/mails.tar.bz2 (arquivo também compactado com o bzip2)

do diretório /var/mail:
#tar –cjvf /backups/mails.tar.bz2 /var/mail
Conferindo o backup /backups/homedir.tar.gz:

#tar –tzf /backups/homedir.tar.gz
Extraindo todo o conteúdo do arquivo /backups/homedir.tar.gz para /mnt:

#tar –xzf /backups/homedir.tar.gz –C /mnt
#cpio
Este agente de backup trabalha com backups tirando os dados das origens de uma lista. Ele
pode ser combinado com outros comandos, como é muito comum ver com o find.
Exemplos de backup com o cpio:
Criando um arquivo de backup de uma lista de diretórios pronta chamada lista.txt:

#cpio –o < lista.txt > /backups/backup_lista.bin
Verificando o conteúdo deste backup:

#cpio –t < lista.txt
Combinando o comando find com cpio para obter o backup de todos os arquivos com permissão
de execução contidos em /etc:
#find /etc –type f –executable | cpio –o > backup_etc.bin
Restaurando este backup:

#cpio –i –F backup_etc.bin
As opções mais usadas do cpio são:

-o : cria um arquivo de backup.

-t : verifica um arquivo de backup.
-i : extrai o conteúdo de um arquivo de backup.
-F : aponta para um arquivo de backup, eliminando a necessidade de se utilizar
redirecionamentos (< ou >).
Agentes compactadores
O tar não é capaz de compactar o conteúdo de arquivos de backup sozinho. Agentes
compactadores precisam ser utilizados em conjunto com ele, caso de gzip e bzip2.
Os agente mais importantes de compactação são:
#gzip
Gera arquivos de extensão .gz e tem taxa de compactação média quando o arquivo a ser
compactado é grande.
Este agente compactador não mantém o arquivo original compactado. A única versão que vai
estar disponível desde então será a versão compactada.
Sintaxe:
#gzip <opção> <arquivo>
Exemplos:
Compactando o arquivo arq1.txt em modo forçado:

#gzip –f arq1.txt
Listando o conteúdo deste arquivo:

#gzip –l arq1.txt.gz
Descompactando este arquivo:

#gzip –d arq1.txt.gz
ou
#gunzip arq1.txt.gz
Obs: Representar um arquivo com extensão .tgz é o mesmo que representá-lo como .tar.gz.
#bzip2
Agente compactador que possui uma alta taxa de compressão de arquivos grandes, podendo
compactar em até 10% do tamanho original. Arquivo manipulados pelo agente bzip2 têm extensão .bz2.
Sintaxe:
#bzip2 <opção> <arquivo>
Exemplos:
Compactar arquivo disco.iso, mantendo o arquivo original:

#bzip2 –k disco.iso
Descompactar o arquivo:
#bzip2 –d disco.iso.bz2
ou
#bunzip2 disco.iso.bz2
Testando a integridade do arquivo:
#bzip2 –t disco.iso.bz2
Restaurando o arquivo danificado:

#bzip2recover disco.iso.bz2

#zip
Compactador compatível com Windows.
Sintaxe:
#zip <arquivo zip> <origem>
Exemplos:
Criando arquivo /backups/prog.zip contando um programa chamado game1.exe:

#zip /backups/prog.zip game1.exe
Descompactando este arquivo:

#unzip /backups/prog.zip
Compactando arquivo game1.exe com criptografia:

#zip –e /backups/prog.zip game1.exe
Compactando subdiretórios de /etc em /backups/etc.zip:

#zip –r /backups/etc.zip /etc
#rar
Compactador proprietário que tem versões para sistemas GNU/Linux, MacOS, Windows e
outros.
Sintaxe:
#rar <ações> <opções> <arquivo rar> <origem>
Ações:
a : cria arquivo rar com conteúdo selecionado.
x : extrai conteúdo de arquivo rar.
l : lista conteúdo de um arquivo rar.
r : repara arquivo danificado.
m : apaga conteúdo de origem após compactar.
r : inclui subdiretórios no arquivo rar.
Exemplos:
Criando arquivo logs.rar contendo todos os arquivos do diretório /var/log:

#rar a mail.rar /var/mail
Extraindo o conteúdo deste arquivo:

#rar x mail.rar
Criando um arquivo chamado etc.rar do todos os subdiretórios de /etc:

#rar r etc.rar /etc
listando os arquivos existentes dentro do arquivo compactado logs.rar:

#rar l mail.rar

AGENDAMENTO DE TAREFAS
Automatizar tarefas é uma prática muito comum entre administradores de servidores Linux. Um
backup “full” que deve sempre ser feito de um diretório de publicação de sites, por exemplo, toda sexta-
feira, precisaria de intervenção manual do administrador se não houvesse a possibilidade de agendá-lo
para executar neste dia em um horário específico.
Os daemons que gerenciam todos os agendamentos do sistema são o cron e o atd, mas eles
não são os programas que configuram a instalam os agendamentos de tarefas no Linux. Para esta tarefa,
são utilizados o at ou o crontab, sendo o mais “expert” dos 2 o crontab.
Diretórios importantes
/var/spool/cron/crontabs : diretório de agendamentos de usuários que foram produzidos com o

crontab.
/var/spool/cron/atjobs : diretório de agendamentos de usuários que foram produzidos com o
at.
/etc/cron.hourly : diretório on scripts que serão executados de hora em hora podem ser
amazenados.
/etc/cron.daily : diretório onde scripts que serão executados diariamente podem ser
armazenados.
/etc/cron.weekly : diretório onde scripts que serão executados semanalmente podem ser
armazenados.
/etc/cron.mounthly : diretório onde scripts que serão executados mensalmente podem ser
armazenados.
Os scripts contidos nos diretórios acima são executados pelo comando run-parts, que tem a
função de executar scripts de diretórios em demanda. O agendamento da execução deste comando nos
diretórios está dentro do arquivo /etc/crontab, como no exemplo abaixo:
É importante que estes diretórios sejam lembrados em um backup de dados ou em uma

migração de um servidor para outro, pois os agendamentos, em muitos casos, fazem parte da “vida
funcional” de um sistema, uma vez que tarefas imprescindíveis podem já estar agendadas, como por
exemplo, uma aplicação que faz cache de arquivos pesados e que são excluídos de 30 em 30 minutos
para não estourar o espaço de uma determinada partição.

Programas de agendamento
#at
Cria agendamento para executar uma única vez e depois ser excluído.
Quando for utilizado para agendar alguma tarefa, o at vai abrir seu prompt de comandos de Shell
SH para que o administrador possa digitar os comandos que vão ser executados.
Sintaxe:
#at <opções> <tempo>
Exemplos:
Listando agendamentos do at:

#atq
ou
#at –l
Removendo o quinto agendamento:

#atrm 5
Os formatos de data e hora podem ser diferentes, como nos exemplos abaixo:
Criar agendamento para ser feito dia 05/10/2016, às 13:00 ou 1:00PM:

#at 1:00PM 10/05/2016
Criar agendamento para às 14:00 de amanhã:

#at 14:00 tomorrow
#crontab
Agenda tarefas de forma muito mais versátil e dinâmica. Com ele, a mesma tarefa pode se
repetir várias vezes e é possível criar tarefas com intervalos de tempos diversos. Ele é nativo de todas as
distros GNU/Linux.
É importante ressaltar que nem o cron e nem o atd precisam que seja reinicializado nenhum
serviço para que os agendamentos possa passar a valer, basta editar os arquivos e pronto!
Sintaxe:
#crontab <opção> <usuário> <opção>
Opções:
-u : especifica o usuário.
-l : lista agendamentos de usuários.
-e : edita agendamentos do usuário.
-r : remove todos os agendamentos de um usuário.
Intervalos de agendamentos
Os intervalos são peça fundamental para o crontab. Na verdade é um dos diferenciais deste
programa.
* : todo.
*/n : de n em n.
n-r : de n até r.
n,r : n e r.
n-r,x : de n até r e também x.

Campos do arquivo de agendamentos
A visão destes campos é horizontal, e é assim representada:
<MINUTO> <HORA> <DIA/MÊS> <MÊS> <DIA/SEMANA> <COMANDO>
Onde:
Minuto vai de 0 a 59.
Hora vai de 0 a 23.
Dia do mês vai de 1 a 31 (quando for o caso, á claro).
Dia da semana vai de 0 até 7, onde 0 e 7 simbolizam o domingo.
Para que o editor padrão para a nossa edição de agendamentos seja o vim vamos trocá-lo, pois
os recursos de sintaxe dele nos ajudarão a entender melhor os campos.
#update-alternatives –config editor
Exemplos:
Criando tarefa para o root executar o script de backup /backups/backup_lista.sh todo dia 15 do
mês, às 17 horas e 30 minutos:
#crontab –u root -e
Os campos do mês e do dia da semana ficaram com *, pois o agendamento vai mesmo ser
executado todo dia da semana e todo mês.
Criando um agendamento para o usuário user1, de 10 em 10 minutos, nos meses de abril a

junho e também dezembro, toda 2ª e 4ª-feira, remover os arquivos .mp3 de seu diretório pessoal:
#crontab –u user1 –e
(não seria necessário que o root agendasse tarefas para o usuário, pois todos eles, por padrão,
podem criar e administrar os seus agendamentos).
Listando todos os agendamentos do usuário user1:

#crontab –u user1 –l
Removendo todos os agendamentos do usuário user1:

#crontab –u user1 –r

Controle de acesso a agendamentos
É possível controlar o acesso de usuários ao crontab e ao at.

Os arquivos que o administrador pode criar para fazer este tipo de controle são:
/etc/at.deny : lista de negação de acesso dos usuários que estão nesta lista ao programa at.
/etc/at.allow : lista de únicos usuários que podem acessar agendamentos próprios no at.
/etc/cron.deny : lista de negação de acesso de usuários ao programa crontab.
/etc/cron.allow : lista de únicos usuários que podem acessar os agendamentos próprios no
crontab.
Basta incluir o nome dos usuários (um em cada linha) e salvar o arquivo criado para que possa
passar a valer o bloqueio/aceitação de acesso dos usuários.
Nenhum dos agendamentos já criados pelo usuário é afetado por este bloqueio, eles persistem.
Exemplo:
Criando lista de negação de acesso a agendamentos dos usuários user1, operador e cpd:
#vim /etc/cron.deny
Tentando agendar tarefas com o usuário operador:

COTAS DE ARMAZENAMENTO
Pense você, administrador, que um servidor Web Apache, que tem um sistema de arquivos de
2TB funcionando sobre RAID e LVM montado em /var/www para abrigar arquivos de publicação de sites
de diversos clientes e que um deles resolve hospedar vídeos a vontade e estoura a capacidade de
espaço em disco em 3 meses, parando o serviço de hospedagem até que o administrador, manualmente,
remova os arquivos que estão excedendo o limite de blocos disponíveis do volume, causando
constrangimento e desconfiança em seus usuários.
Este acontecimento catastrófico citado acima com certeza seria evitado com a configuração bem
planejada de cotas de armazenamento para usuários e (ou) grupos, onde cada um teria seu limite de
espaço ou quantidade de arquivos em disco, estando este limite bem longe dos limites reais de
armazenamento do disco.
Alguns conceitos sobre cotas em Linux devem ser muito bem assimilados pelo administrador
antes que ele pense em criar cotas:
Cotas em volumes
Não é possível criar cotas em diretórios de um sistema de arquivos qualquer. Elas só podem ser
criadas em sistemas de arquivos.
Cotas para usuários

As cotas para usuários dizem respeito aos diretórios ou arquivos de propriedade deles em um
volume, ou seja: se o usuário user2 quiser criar arquivos em um sistema de arquivos com cota estourada
para user1, ele pode.
Cotas para grupos
A mesma regra que se aplica a usuários se aplica a grupos. Só que se, por exemplo, o usuário
user1 tem limite de cota de 1GB livres para utilização, mas algum outro usuário do grupo criou uma
imagem ISO de 2GB e estourou a cota de grupos para o volume, user1 fica sem ter permissão de escrita
no volume do mesmo jeito, por esse motivo é que toda cota deve ser bem planejada antes de criada.
Permissões
Nunca se pode esquecer que a permissão de execução e escrita em diretórios é essencial para
que se possa garantir que os usuários possam ter acesso à gravação no volume. Não há motivo para se
criar cotas de armazenamento para um volume montado como apenas leitura ou montado em algum
diretório que não tenha permissão de gravação.
Limites de cotas
Limite Soft
É o primeiro limite a ser estabelecido para cota de usuários ou grupos. Quando o usuário chega
a este limite, ele passa a ficar em grace time, que é o período de tolerância dado ao usuário ou grupo
para que eles possam remover o conteúdo excedente e continuem tendo permissão de escrita no
volume. Caso eles não o façam durante este período, terão a permissão de escrita negada no volume.
Limite Hard
Este é o último limite de cotas possível. Atingindo este nível, o usuário vai ter a permissão de
escrita no volume negada automaticamente. Se o limite Soft for igual ao limite Hard, o primeiro vale como
último nível de cotas no volume.

Aplicação
Primeiramente, é importante instalar os pacotes necessários para administração de cotas:
#apt-get install quota quotatool –y
Levando em consideração que já existe um sistema de arquivos ext3 criado e montado em

/home, o próximo passo é ativar o uso de cotas para usuário e grupos neste volume. Isso é possível
adicionando as opções usrquota e grpquota (separadas por vírgula) no campo de opções de
montagem do volume em /etc/fstab:
#vim /etc/fstab
A habilitação de sistemas de cotas para usuários e grupos vai implicar na criação de 2 arquivos,
que vão funcionar como bancos de dados de cotas (aquota.user e aquota.group) na raiz do sistema de
arquivos com cota. Estes arquivos não podem ser apagados nem pelo usuário root.
É ideal, para pleno funcionamento do sistema de cotas, que o sistema seja reiniciado após a
configuração do arquivo /etc/fstab.
Após este passo ter sido dado, o próximo é editar as cotas:
#edquota
Edita cotas em volumes para usuários ou grupos.
Sintaxe:
#edquota <opção>
Opções:
-u : edita cotas de usuários.
-g : edita cotas de grupos.
-t : edita o “grace time” padrão do sistema.
-T : edita o “grace time” individual de usuário ou grupo.
-p : replica as cotas de um usuário ou grupo para outro(s).
Exemplos:
Aplicando cotas de 500MB soft e 600 hard para blocos, 150 soft e 200 hard para inodes para o
usuário user1 no volume /dev/sdb1:
#edquota –u user1
eplicando as cotas de user1 para user2,user3 e user4:
#edquota –p user1 user{2..4}
Editando o “grace time” do usuário user2:

#edquota –T user2
#repquota
Emite relatório de cotas de usuários ou grupos.
Sintaxe:
#repquota <opção> <volume>
Opções:
-a : lista cotas de todos os volumes.
-u : se refere a cotas de usuários.
-g ; se refere a cotas de grupos.
-v : modo verbose.
Exemplos:

Emitindo relatório de cotas de todos os volumes e usuários:
#repquota -auv
#quotacheck
Verifica existência sistemas de arquivos com cotas habilitadas e aplica configurações de cotas já
definidas.
Sintaxe:
#quotacheck <opções> <volume>
Opções:
-a : aplica a todos os volumes montados (verifica /etc/mtab)
-f : força a aplicação de novas cotas criadas.
-m : não tenta remontar sistemas de arquivos “read only”.
-u : aplica cotas a usuários.
-g : aplica cotas a grupos.
-v : verbose.
Exemplo:
Aplicando cotas a todos os sistemas de arquivos com suporte a cotas para usuários:
#quotacheck –aufmv
#quotaon
Ativa cotas em um volume específico.
Sintaxe:
#quotaon <opção> <volume>
Exemplos:
Ativando cotas em /dev/sdb1:

#quotaon /dev/sdb1
Verificando o status das cotas n volume /dev/sdb1:

#quotaon –p /dev/sdb1
#quotaoff
Desativa as cotas em sistemas de arquivos:
Sintaxe:
#quotaoff <opção> <volume>
Exemplos:
Desativando cotas em /dev/sdb1:

#quotaoff /dev/sdb1
Verificando status de cotas em /dev/sdb1:

#quotaoff –p /dev/sdb1

$quota
É o único comando de cota que o usuário comum pode executar. Ele emite um resumo as
situação de cotas do usuário.
Sintaxe:
$quota <opções> <usuário/grupo>
Opções:
-u : emite relatório de cotas de usuário.
-g : emite relatório de cotas de grupo.
-s : modo mais legível (mais humano).
Exemplo:
Verificando a situação das cotas do usuário user1 no modo mais legível possível:
#quota –us user1

GERENCIAMENTO DE PROCESSOS E INICIALIZAÇÃO
O administrador precisa ter muito conhecimento sobre este assunto antes de chegar a gerenciar
algum servidor Linux. O usuário root tem poderes ilimitados sobre o sistema e, por isso mesmo, ele tanto
pode executar uma operação de término de um processo de forma a não danificar os arquivos envolvidos
no mesmo como pode também o interromper de forma brusca e danificar um arquivo importante nesta
ação apenas pelo fato de não ter escolhido o sinal certo a envia para o processo. Pode o administrador
também escolhe mal a prioridade de execução de um processo pesado e paralisar todo o sistema por
causa disso. Justamente por esse fato, é que é preciso dominar os conceitos e comandos que vão ser
ministrados neste capítulo.
PID
É o “Process ID”, o número de identificação que cada processo recebe. O único PID fixo
existente é o PID do processo INIT, que é o de nº 1.
NICE NUMBERS
É o número de prioridade de execução de um processo. Se um processo é executado com maior
prioridade, ele usa os melhores recursos de processamento para sua execução, enquanto se for
prioridade baixa, ele depende que outros processo não estejam utilizando estes recursos para que ele
também possa fazer uso. OS NICE NUMBERS vão de -20 até 19, sendo a maior a prioridade negativa.
SINAIS DE PROCESSOS
Para saber o que se pode fazer com cada processo que está em execução é preciso entender os
sinais de processos.
Os mais importantes são:
1 - HUP ou SIGHUP : instrui o serviço a reler o seu arquivo de configuração (operação de
“reload”).
2 – INT ou SIGINT : interrompe um processo em primeiro plano (é o mesmo que CTRL+C).
9 – KILL ou SIGKILL : Interrompe bruscamente um processo. Este sinal deve ser utilizado em
último caso, pois ele pode causar danos aos arquivos envolvidos no processo.
12 – USR2 ou SIGUSR2 : interrompe processo do usuário fazendo logoff no mesmo.
15 – TERM ou SIGTERM : é enviado para todos os processos do sistema assim que ele entra
em desligamento. Este sinal fecha todos os arquivos abertos do processo antes de terminá-lo, não
causando nenhum tipo de dano a eles. Este é o sinal padrão da maioria dos comandos e programas que
terminam processos justamente pela sua “elegância”.
18 – CONT ou SIGCONT : continua processos que foram parados pelo sinal 20, enviando-os
para background.
20 – TSTP ou SIGTSTP : pára processos de forma que eles possam ser reiniciados depois pelo
sinal 18. É o mesmo que a combinação de teclas CTRL + Z.
RUNLEVELS
Um Runlevel é o estado em que se encontra o sistema.
0 – sistema em desligamento.
1 – modo “single user”. Ideal para modo de manutenção do sistema, pois apenas uma instância
de logon e terminal será permitida.
2 – é o Runlevel padrão do sistema. Este é o nível multi-user, onde múltiplos logons podem ser
efetuados e todos os terminais podem ser utilizados.
3 – o mesmo que o Runlevel 2.
4 – em desuso.
5 – “GUI”. Interface gráfica.
6 – sistema em reinicialização.

Comandos de gerenciamento de processos
#ps
Exibe os processos do sistema.
Sintaxe:
#ps <opções>
Opções:
-a : mostra processos de todos os terminais.
-x : mostra processos que não precisam de terminal de controle.
-u : exibe o nome do usuário responsável pelo processo ao lado do mesmo.
-U : exibe apenas processos de um usuário específico.
-f : modo “floresta”. Exibe “processos pai” e “processos filho”.
-w : exibe na linha de baixo o conteúdo que não coube na linha de cima.
Exemplos:
Exibindo os processo de todos os terminais, incluindo aqueles que não usam terminal, com o
nome de cada usuário responsável pelo processo:
#ps –aux
Os campos mais importantes desta saída de comando são:
%CPU – percentual de CPU consumido com o processo.

%MEM – percentual de memória consumida no processo.
STAT – Status do processo.
R : em execução.
S : aguardando outro evento para continuação.
D : dormindo permanentemente.
T : parado para que possa ser reiniciado depois.
X : morto.
Z : processo “zumbi”. Foi terminado mais ainda é procurado por seu PPID.
< : maior prioridade.
N : menu prioridade.
+ : em primeiro plano.
s : líder de sessão.
l : multi-thread.

#top
Exibe e gerencia processos. Mostra os processos mais atuais no topo.
O campo NI, que é mostrado, se refere ao Nice Number do processo. O Nice number padrão
para processos iniciados é o 0, ou seja: se um processo é iniciado sem que seja especificado o seu Nice
Number, ele, automaticamente, é 0 .
#kill
Gerencia os processos pelo PID deles.
Sintaxe:
#kill -<sinal> <PID>
Exemplos:
Exibindo todos os sinais que o sistema pode usar:

#kill –l
Terminando o processo de PID 913 com o sinal 15(TERM):

#kill -15 913
ou
#kill –TERM 913
ou
#kill 913
Terminando abruptamente o processo de PID 913 com o sinal 9(KILL):

#kill -9 913
ou
#kill –KILL 913
Deixando o processo de PID 913 pronto para ir para background:

#kill -20 913
ou
#kill –TSTP 913
Continuando o mesmo processo em background:

#kill -18 913
ou
#kill –CONT 913
Como pudemos perceber acima, o comando kill não serve apenas para ‘matar’ processos, como
o próprio nome sugere. Ele é um gerenciador de processos que envia o sinal necessário para eles via
linha de comando. Outro detalhe importante é que o sinal padrão do comando kill é 15, pois é o sinal
mais aconselhável para terminar uma tarefa, ou seja: terminar um processo com o comando kill sem
especificar qualquer argumento leva-o a terminar o processo com o sinal 15.
O próximo comando também gerencia processos, só que pelo nome, ao invés de pelo PID.
#killall
Gerencia processos pelos nomes deles.
Sintaxe:
#killall -<sinal> <nome_do_processo>
Exemplos:
Listando os nomes de todos os sinais disponíveis:

#killall -l
Terminando o processo executado pelo programa dd com o sinal 15:

#killall -15 dd
ou
#killall –TERM dd
ou
#killall dd
Encerrando abruptamente o processo executado pelo servidor X com o sinal 9:

#killall -9 Xorg
ou
#killall –KILL Xorg
#killall5
Termina todos os processos em execução.
Sintaxe:
#killall5
ou
#killall5 –o <PID> (para fazer um PID ser omitido).
#fuser
Fecha processos e seus arquivos.
Sintaxe:
#fuser <opções> <arquivo>
Opções:
-k : envia sinal -9 para o processo.
-M : se refere a um ponto de montagem a ser fechado.
-v : verbose.
-i : modo interativo.
Exemplo:
Fechando abruptamente o terminal remoto pts/0:

#fuser –k /dev/pts/0
Um processo pode ser enviado para background de várias formas diferentes, uma delas é
executar o comando sucedido por &. Ele receberá um ID, que será usado para manipulá-lo em
background. Um exemplo disso é a linha de comando abaixo, que envia uma verificação de badblocks
para segundo plano:
#badblocks /dev/sda5 &
#bg
Envia um processo parado com sinal 20 (CTRL+Z) para background.
Sintaxe:
#bg <num>
#fg
Trás um processo de volta para foreground (primeiro plano).
Sintaxe:
#fg <num>
#jobs
Mostra os processos que estão em background no terminal atual.
#nohup

Executa processos em background, tornando-os insensíveis a logout da sessão de usuário. A
saída do comando será enviada para o arquivo nohup.out.
Sintaxe:
#nohup <comando>
Exemplo:
Executando o backup dos logs do sistema com o nohup:

#nohup tar czf /root/logs.tgz /var/log
#nice
Executa um processo com prioridade específica.
Sintaxe:
#nice -<Nice Number> <comando>
Exemplos:
Clonando o disco /dev/sda em /dev/sdb com prioridade -15:

#nice --15 dd if=/dev/sda of=/dev/sdb
Fazendo backup compactado do diretório /home com prioridade 2:

#nice -2 tar cjvf /root/backup_users.tar.bz2 /home
Repare que o primeiro ‘-‘ faz parte da sintaxe do comando, portanto, não tem nada a ver com o
Nice Number a ser aplicado.
Devemos sempre lembrar também de que dar prioridade alta a um processo significa usar
melhores recursos de processamento do que se ele estivesse sendo executado em prioridade 0.
#renice
Modifica a prioridade de um processo já em execução.
Sintaxe:
#renice <Nice Number> <PID>
Exemplos:
Mudando a prioridade do processo de PID 1811 para -16:

#renice -16 1811
Mudando para 4 a prioridade do processo de PID 1902:

#renice 4 1902
Mudando a prioridade de todos os processos do usuário operador para -17:

#renice -17 –u operador

Processo INIT
O processo INIT é o primeiro a ser executado assim que o sistema é inicializado. A cadeia de
boot em Linux funciona da seguinte forma: o “boot loader” entrega o boot para a imagem do kernel, que
“chama” o processo INIT para inicializar todos os daemons (serviços/sevidores) referentes ao Runlevel
escolhido para boot que são executados na inicialização, como por exemplo, serviço de rede e servidor
Web.
SysVinit
Esta versão do processo INIT foi deixada de lado pela maioria das distribuições devido à
disparidade da ordem de execução com o poder de processamento dos sistemas de Hardware
disponíveis.
Para executar estes serviços, ele usa os seguintes diretórios:

/etc/init.d – é o diretório que contém os scripts que gerenciam os daemons do processo INIT no
Debian (e distribuições afins). Para que estes scripts sejam executados no boot, é preciso que eles
tenham link simbólico para os diretórios abaixo:
/etc/rc0.d – diretório de links simbólicos para scripts de Runlevel 0.
/etc/rc2.d – diretório de links simbólicos para scripts de Runlevel 2 (este é o Runlevel padrão
dos sistemas GNU/Linux em geral).
Em Red Hat o padrão muda um pouco, na verdade, o que passa a acontecer é que os diretórios
“rc” e o “init.d” ficam como subdiretório do diretório /etc/rc.d. Exemplos:
/etc/rc.d/rc2.d – diretório de links simbólicos de scripts de Runlevel 2.
/etc/rc.d/init.d – diretórios dos scripts de gerenciamento dos daemons.
Obs: é importante ressaltar que existe no Red Hat o link simbólico /etc/init.d, que aponta para o
diretório /etc/rc.d/init.d.
O gerenciamento desses daemons é feito com os comandos abaixo:
No Debian:
#/etc/init.d/<serviço> <ação>
ou
#invoke-rc.d <serviço> <ação>
No Red Hat:
#/etc/rc.d/init.d/<serviço> <ação>
ou
#services <serviço> <ação>
Ações:
start: inicia um daemon.
restart: reinicia um daemon.
reload : apenas relê o arquivo de configuração do daemon.
force-reload : força esta releitura do arquivo de configuração.
Exemplos:
Reiniciando o serviço de rede no Debian:

#/etc/init.d/networking restart

ou
Relendo o arquivo de configuração do samba para aplicar as alterações que foram feitas em um
servidor Red Hat:
#service smbd reload
Definir em qual Runlevel um daemon vai ser executado ou terminado é uma tarefa que pode ser
executada tanto criando links manualmente dos scripts do diretório “init.d” para o “rc” correspondente
quanto com o uso dos comandos abaixo:
#update-rc.d
Cria ou remove uma execução de script em um Runlevel específico. Ele cria os links simbólicos
necessários para que o daemon possa iniciar no Runlevel desejado.
Sintaxe:
#update-rc.d <daemon> <enable/disable/remove> <runlevel>
Exemplos:
Definindo que daemon winbind seja executado toda vez que o sistema iniciar em Runlevel 2:
#update-rc.d winbind enable 2
Removendo forçadamente os links do daemon rsync de todos os diretórios “rc”:

#update-rc.d –f rsync remove
#chkconfig
Faz o mesmo que o comando update-rc.d, porém este não é padrão da distro Debian e sim do
Red Hat:
Sintaxe:
#chkconfig <opção> <daemon> <runlevels> <on/off>
Opções:
--list : lista em quais Runlevels o daemon vai ser executado.
--level : especifica o Runlevel.
on : ativa execução do daemon em um Runlevel.
off: desativa execução do daemon em um Runlevel.
Exemplos:
Exibindo o status de todos os scripts de daemons no processo INIT:

#chkconfig –list
Ativando o daemon apache2 nos runlevels 2345:

#chkconfig --level 2345 apache2 on
O Runlevel padrão de um sistema pode ser modificado em um arquivo chamado /etc/inittab. É

preciso tocar cuidado ao fazê-lo, pois sistema tiver como Runlevel padrão o Runlevel 6, por exemplo, ele
ficará em um constante loop de reinicialização, que só poderá ser resolvido com o início forçado do
sistema em outro Runlevel, processo que só poderia ser feito no arquivo de configuração do boot loader.
A estrutura deste arquivo é constiuída da seguinte forma:

<ID>:<RUNLEVELS>:<AÇÃO>:<COMANDOS>
As ações mais importantes são:

Initdefault : define qual vai ser o runlevel padrão do sistema.

sysinit : define qual é o script principal de inicialização do processo INIT. Para Red Hat este
script é o /etc/rc.d/rc.sysinit, enquanto para Debian este script é o /etc/init.d/rcS, que, na verdade,
apenas aponta para outro script (/etc/init.d/rc). Este script é o responsável pela execução dos links
simbólicos que apontam para o diretório /etc/init.d ou /etc/rc.d/init (Red Hat).
wait : define que um programa inicia ou termina sempre após o de ordem anterior ser executado.
respawn : indica que quando terminar a execução de um processo, o mesmo será iniciado
novamente.
ctrlaltdel : define a qual comando a combinação de teclas CTRL+ALT+DEL irá corresponder.
#runlevel
Exibe o Runlevel atual do sistema.
#init
Troca o Runlevel do sistema.
Sintaxe:
#init <runlevel>
Exemplo:
Mudando o Runlevel atual para 1:

#init 1
SystemD
O sistema de supervisão e inicialização de serviços Systemd foi anunciado como o novo,

revolucionário e totalmente inovador substituto do SysVinit. De fato, na descrição teórica ele parece
ser muito poderoso, embora menos flexível do que uma série de scripts de shell.
Arquitetura do SystemD
O Systemd visa a agir nos dois principais pontos problemáticos do SysVinit: shell e
paralelismo.
Para eliminar o uso do shell, o Systemd realiza todas as chamadas redundantes — isto é,
aquelas presentes na maioria dos scripts — de forma embutida no binário /sbin/systemd.
Entre suas características especiais está o de garantir que determinado serviço foi parado e,
com ele, todos os processos filhos que este havia gerado. O subsistema que permite esse recurso é
conhecido como Cgroups (Control Groups, ou grupos de controle) e reside no kernel. Os Cgroups
permitem atribuir rótulos (ou tags) a cada processo que for iniciado no sistema, além de registrar tais
informações (processos e seus respectivos rótulos) num pseudo-sistema de arquivos, o que facilita
imensamenLoja0495te sua consulta por qualquer programa ou usuário.
Outra característica é em relação a montagem de sistemas de arquivos. O Systemd é dotado
de inteligência onde necessário. Ele lê o arquivo /etc/fstab durante a inicialização do sistema, e cria as
políticas de montagem automática dos sistemas de arquivos descritos no arquivo. O SystemD não
faz uso do serviço autofs. Ele utiliza o suporte do kernel ao autofs, mas implementa internamente as
montagens automáticas, de forma totalmente independente do serviço autofs.
Diretórios do Systemd
A estrutura de diretórios do Systemd é realmente peculiar e muito mais complexa que no

SysVinit. Os diretórios mais importantes são:
/lib/systemd – diretório base dos arquivos do Systemd. Na sua raiz estão os binários deste
sistema;
/lib/systemd/system – diretório que abriga os principais arquivos originais de configuração.

/etc/systemd – é onde o administrador deve inserir seus arquivos personalizados de
configuração para os serviços customizados. Exemplo: um serviço que restaura as regras do Iptables
no boot. Ou seja: não mexa no /lib/systemd/system/. Mexa somente em /etc/systemd/system/. Não se
espera que o diretório /lib/ tenha arquivos de configuração alterados pelo administrador. É sempre
bom seguir estes padrões para facilitar a documentação do sistema (boas práticas, por favor!).
É importante também ressaltar que neste diretório estão os links simbólicos para os 'confs'
originais do SystemD, localizados em /lib/systemd/system, como monstra o exemplo abaixo:
OK...mas em qual situação um determinado daemon é executado ou 'morto'? Então, aí é que

entram os chamdos targets . Os nomes são bem sugestivos, os mais importantes diretórios
correspondentes são:
poweroff.target.wants – serviços que serão executados no desligamento do sistema (Runlevel

0);
reboot.target.wants – serviços que serão executados no reboot (Runlevel 6);
multiuser.target.wants – seviços que serão executados em modo 'multi-user' (Runlevels2 e 3);
getty.target.wants – responsável por executar os terminais TTY;
Visão do diretório /etc/systemd/system/multi-user.target.wants:
Vejamos um exemplo de configuração:

#vim rsyslog.service
Neste arquivo temos a descrição do serviço, a dependência para que ele seja executado
(socket do syslog), o caminho de completo do binário que executa o serviço (daemon), a saída padrão
(null), o target onde ele vai ser executado (multi-user) e o alias dele.
A configuração destes arquivos é bem intuitiva, como podemos perceber.
Paralelismo
No SystemVinit a execução de programas era feita de forma ordenada, onde o processo 1 só

era executado após o 0 terminar. Justifica-se: na época em que foi desenvolvido não havia tanta
oferta de processadores dual core. Com o passar do tempo, tornou-se cada vez mais desnecessário
manter este tipo de execução de programas de boot, visto que os processadores já era capazes de
processar multiplas tarefas com performance satisfatória. O Systemd veio para resolver esta questão
em definitivo, visto que executa os processos de forma paralela, agilizando mais ainda o boot do
sistema (quem nunca teve problemas com o sendmail na inicialização, por exemplo, por exemplo?! )
Este gráfico mostra os detalhes da arquitetura do Systemd

Arquivos de serviços
Um fato muito positivo sobre o Systemd é que a documentação já está muito bem feita. O
pacote do Systemd já traz as páginas de manual de cada tipo de serviço. Experimente:
# man -k systemd
systemd.automount (5) - systemd automount configuration files
systemd.conf (5) - systemd manager configuration file
systemd.device (5) - systemd device configuration files
systemd.exec (5) - systemd execution environment configuration
systemd.mount (5) - systemd mount configuration files
systemd.path (5) - systemd path configuration files
systemd.service (5) - systemd service configuration files
systemd.snapshot (5) - systemd snapshot units
systemd.socket (5) - systemd socket configuration files
systemd.special (7) - special systemd units
systemd.swap (5) - systemd swap configuration files
systemd.target (5) - systemd target configuration files
systemd.timer (5) - systemd timer configuration files
systemd.unit (5) - systemd unit configuration files
Há uma página de manual para os arquivos de serviços (systemd.service), e é ela que

devemos consultar para entender ou desenvolver arquivos de serviços.
Gerenciar serviços com o comando “systemctl”:
#systemctl status irqbalance.service

Verifica o estado atual do serviço irqbalance.
#systemctl enable httpd.service

Habilita o serviço httpd.
#systemctl restart httpd.service

Reinicia o serviço httpd.
#systemctl stop httpd.service

Para o serviço httpd.
#systemctl disable telnet.service

Desativa o serviço telnet.
# systemctl list-units --type=service

Lista todos os serviços ativos.permitir o paralelismo, o Systemd abre sockets para
comunicação entre os serviços, de forma que todos os serviços marcados pelo administrador como
desejados possam iniciar em paralelo e, caso dependam de outros serviços, estes também sejam
iniciados sob demanda.

KERNEL
Como já foi visto de maneira resumida na introdução deste material, o Kernel é o responsável
por suportar e interagir com os recursos lógicos e físicos que podem ser oferecidos pelo sistema. Uma
placa de rede Wireless só funciona se o Kernel der suporte a ela, assim como também o protocolo ipv6
só funciona se o Kernel o suportar. Para saber das modificações que estão sendo feitas no código-fonte
do Kernel, basta observar a seção de Changelogs do site www.kernel.org .
Antes de configurar, compilar e instalar um novo Kernel, é preciso saber que tipo de Kernel o
administrador vai querer implementar. Os tipos são:
Kernel Monolítico
Este tipo de kernel deixa junto com a imagem de boot do Kernel todo e qualquer suporte
implementado a qualquer tipo de recurso, podendo tornar a inicialização do sistema um pouco mais
demorada.
Kernel Modular
Neste caso em específico, uma grande quantidade de recursos fica em módulos, que são
instalados a parte e não precisam serem carregados juntos com o sistema. Neste caso, há mais
facilidade em gerenciar recursos, uma vez que, se não quiser um recurso, basta adicioná-lo a uma
“blacklist” de módulos.
É importante destacar também que nem todos os recursos podem ser colocados em módulos,
alguns têm que ser “built-in” mesmo, por exigência do Kernel, sendo assim, nenhum Kernel é totalmente
modular.
Versões do Kernel
A sintaxe de versão do Kernel é:
<versão maior>. <versão menor> .<correção/patch/atualização>.<verso extra>
Antes do Kernel 2.4 ser lançado, as versões aumentavam de forma que uma versão menor que
fosse ímpar representava um Kernel instável ainda, enquanto uma versão menor que fosse par
significava em Kernel estável. Hoje isso não é mais uma realidade, uma vez que Linus Torvalds decidiu
que as alterações seriam feitas no terceiro campo. A versão menor só será alterada se for uma mudança
muito brusca na estrutura do Kernel.
Exemplo:
Uma versão recompilada para dar suporte a Paravirtualização, no Kernel 2.6.35, teria a
nomenclatura:
2.6.35-Virt
Compilação de Kernel
A possibilidade de download, reconfiguração e reinstalação de um novo Kernel fascina os
administradores de sistemas Linux ao redor do mundo. Os motivos pelos quais um administrador pode
querer recompilar um Kernel são muito simples de se explicar: obter melhor performance de recursos de
hardware do sistema, como processador, memória RAM, placas de vídeo e rede, por exemplo; ter que
habilitar suporte a recursos adicionais, como paravirtualização e PAE (para sistemas de 32 bits poderem
reconhecer memórias RAM de mais de 4GB); personalizar uma distro para que ela possa ter um fim
específico, como uma distro exclusiva para Firewall, como o SmothWall, por exemplo, que tem suporte a
muitos adaptadores de rede mas não suporta placas aceleradoras gráficas funcionando em modo pleno,
já que o Kernel desta distro está compilad para ser um Firewall e não uma estação de jogos, ou de
edição gráfica.
O procedimento para a sua recompilação consiste em algumas etapas:
Configuração
Nesta etapa ocorre a escolha de quais recursos serão instalados. É preciso entender muito bem
de recursos como rede, discos, dispositivos e recursos de hardware, redes e de sistemas de arquivos,
pois as opções de configuração do Kernel são muitas e escolher a opção errada pode custar o não
reconhecimento de alguns recursos desejados.

Compilação
A compilação de um software qualquer consiste em converter os códigos-fonte dele para
arquivos binários (linguagem de máquina). Numa compilação de Kernel não é diferente, um vez que
existe a necessidade de os módulos e recursos “Built-in” interagirem com os hardwares de sistema.
Instalação
O conceito de instalação é a cópia de binários do um programa para um diretório de instalação.
Procedimentos para compilação de instalação de um novo Kernel
Para este procedimento, vamos utilizar a versão 2.6.35.4 do Kernel obtida em www.kernel.org.
Descompactar o diretório de código-fonte do Kernel em /usr/src:

#tar –xjf linux-2.6.35.4.tar.bz2 –C /usr/src
Criar um link simbólico do diretório de compilação (apenas para facilitar o procedimento):

#ln –s /usr/src/linux-2.6.35.4 /usr/src/Linux
Instalar programas necessários, entrar no diretório do código-fonte e começar a configuração do

Kernel:
#apt-get install libncurses5-dev gcc build-essential make -y
#cd /usr/src/linux
#make menuconfig
Os métodos de configuração de Kernel são os seguintes:

#make config : método de configuração em modo texto. Não tem menu nenhum e confirma
opção por opção, exigindo que o usuário diga obrigatoriamente a qual recurso ele não quer dar suporte.
#make menuconfig : esta opção conta com um menu para terminal que dinamiza muito mais a
escolha das opções, uma vez que o administrador só precisa configurar os recursos que ele quer.
#make oldconfig : restaura a configuração de um arquivo .config já pronto.
#make xconfig : configuração através de interface gráfica do servidor X.
É importante, antes de fazer a configuração do Kernel, definir qual vai ser a versão atual do
Kernel que está sendo reconfigurado, isto pode ser feito dentro do arquivo Makefile, como no exemplo da
figura a seguir:
Depois de configurada a versão do Kernel, vamos partir para a configuração do mesmo. A figura
abaixo é de uma configuração feita com o comando #make menuconfig. Após a conclusão deste
passo, Serpa gerado um arquivo chamado .config, que irá conter as escolhas feitas na configuração
realizada com o comando em questão.
Os recursos que podem ser adicionados como “Built-in” ou como “Modulares” estão com < >,
enquanto aqueles que só podem ser implementados em Built-in estão com [ ].
Resolvendo dependências antes de começar a compilação:

#make dep
No caso abaixo, todas as dependências estão satisfeitas, tornando assim o uso de make dep
desnecessário.
Removendo arquivos de compilações anteriores:

#make clean
Criando a imagem de boot do Kernel no diretório arch/<arquitetura_do_kernel>/boot:

#make bzImage
É importante lembrar que até este momento nenhuma ação foi tomada em relação aos módulos,
já que a imagem de boot é totalmente independente dos módulos do Kernel.

Este passo irá compilar a imagem do Kernel e criar um arquivo de imagem desta imagem, assim,
o gerenciador de boot poderá executar o boot por ela.
No caso, #make bzImage usa o agente compactador BZIP2 para comprimir a imagem, esta
imagem também pode ser carregada em memória estendida, enquanto #make zImage usa o agente
COMPRESS e só pode compactar imagens pequenas de Kernel (até 500KB). É justamente por causa
desta diferença que em grande maioria das compilações é escolhido o método #make bzImage.
Compilando os módulos:
#make modules
Instalando os módulos em /lib/modules/<versão do kernel>:

#make modules_install
Criando uma imagem INITRD dos módulos instalados:

#cd /lib/modules
#mkinitramfs -o /boot/initrd.img-2.6.35-VIRTUAL 2.6.35-VIRTUAL
Os módulos instalados não são carregados durante o boot, a não ser que eles sejam declarados
no arquivo /etc/modules ou que estejam dentro de uma imagem INITRD e que o boot loader aponte para
ela.
Copiar a imagem do Kernel para o diretório de boot:

#cp -p arch/<arquitetura do kernel>/boot/bzImage /boot/vmlinuz-2.6.35-VIRTUAL
Para manter o padrão de nomenclatura, deve-se copiar a imagem do Kernel para /boot com o
nome de vmlinuz-2.6.35-VIRTUAL.
Atualizar o boot loader GRUB:

#update-grub
Reiniciar o sistema:
#shutdown -r now
Comandos de Kernel
#uname
Exibe informações sobre o Kernel em execução.
Opções:
-a : exibe todas as informações sobre o Kernel instalado.
-n : exibe o hostname.
-r : exibe a versão do Kernel instalado.
-m : exibe a arquitetura do Kernel instalado.
-s : exibe o nome do Kernel instalado.
-p : exibe o processador do sistema.
-o : nome do sistema operacional.
#lsmod
Exibe módulos que foram carregados.
#modinfo
Exibibe informações detalhadas sobre um módulo específico, como informações sobre autoria,
versão, arquitetura, dependências, etc.
Sintaxe:
#modinfo <módulo>
Exemplo:

Obtendo informações sobre o módulo iptable_nat:
#modinfo iptable_nat
#depmod
Atualiza o aquivo de dependências de módulos em /lib/modules/<versão>/modules.dep com
novos módulos instalados.
#modprobe
Insere os módulos e suas depoendências no Kernel em execução. Também tem opções de
consulta e exclusão de módulos.
Sintaxe:
#modprobe <opções> <módulo>
Opções:
-l : lista localização dos módulos.
-t : indica o tipo dos módulos (seção de módulos).
Seções:
arch : módulos de arquitetura do Kernel.
crypto : módulos de criptografia.
drivers: módulos de drivers de dispositivos de hardware.
net: módulos de dispositivos de rede.
sound: módulos de recursos de som.
fs : módulos de filesystems.
lib : módulos de bibliotecas.
-r : remove um módulo.
Exemplos:
Inserindo o módulo tun no Kernel:

#modprobe tun
Removendo o módulo tun do Kernel:

#modprobe -r tun
Mostrando a localização do arquivo de módulo do módulo ip_conntrack:

#modprobe -l ip_conntrack
Mostrando os 10 primeiros arquivos de módulos da seção de drivers de dispositivos de rede:

#modprobe -l -t net | head -10
#insmod
Isere um módulo no Kernel em execução mas não resolve dependências de módulos.
Sintaxe:
#insmod <módulo>
#rmmod
Remove módulos de um Kernel em execução.
Sintaxe:
#rmmod <opção> <módulo>
Opções:
-a : remove todos os módulos que não estão sendo usados.
-f : força a remoção do módulo.

-v : verbose.
Comandos de Hardware
#lspci
Mostra os dispositivos de hardware que utilizam o barramento PCI.
#lsusb
Mostra todos os dispositivos conectados à porta USB.
#lshw
Este programa exibe toda a configuração de Hardware do sistema.

GERENCIADORES DE BOOT
Os carregadores de boot são peça fundamental em uma configuração de sevidor Linux, visto que
são eles que cuidam de tornar a imagem do Kernel inicializável e dizer qual a partição será usada como
sistema raiz. Os dois gerenciadores de boot padrões do Linux são o GRUB e o LILO, o primeiro é
amplamente utilizado pelos sistemas operacionais e o segundo está subutilizado pela maioria das distros
(está disponível na maioria dos repositóriosmas não é o padrão). Uma das únicas exceções é o
Slackware, que até hoje usa este boot loader.
Independente do boot loader, é importante saber que ele pode ser instalado em 2 lugares
diferentes:
Na partição ou no MBR (Master Boot Recording)?
Os primeiros 512 bytes do HD são destinados a um setor específico chamado Master Boot
Recording, que é onde se encontra, geralmente, o boot loader de um sistema operacional qualquer. No
caso de GRUB e LILO, gerenciadores de boot do Linux, o administrador ainda tem como escolher onde
eles serão instalados. Quando apenas um sistema operacional Linux for instalado no HD, o ideal é que
ele seja instalado no MBR.
Caso exista algum outro sistema operacional derenciando o boot pelo HD, o administrador pode
optar por instalar o boot loader em uma partição, e não no disco, lembrando que essa não é uma prática
comum em servidores, pois não há razão para “dual boot” em servidor, já que ele foi concebido para
prover alta disponibilidade de serviço.
LILO (Linux Loader)
Gerenciador de boot mais antigo do Linux, o LILO está em crescente desuso entre as distros em
geral, salvo algumas exceções, como o Slackware, por exemplo.
Por não ser o boot loader padrão do Debian, o LILO precisa ser instalado no mesmo:
#apt-get install lilo –y
O arquivo de configuração do LILO é o /etc/lilo.conf, para gerar o arquivo, o administrador pode

escolher editar linha por linha dele ou digitar o comando liloconfig:
#liloconfig
Neste exemplo acima, o LILO está sendo instalado no MBR (HD /dev/sda). Este comando
apenas cria o aquivo de configuração, mas não instala o LILO MBR, para tal, o administrador precisa
verificar a sintaxe do arquivo que foi gerado e depois instalar o lilo onde ele foi escolhido para ser
instalado:
#lilo

Uma das vantagens do LILO em termos de segurança é que ele depende de instalação manual
toda vez que é modificado, evitando assim que alguns acidentes, como edição errada do arquivo, por
exemplo, possam causar o constrangimento de o sistema ficar sem inicialização.
O arquivo de configuração do LILO (/etc/lilo.conf) é divido em duas seções: global e image. A

primeira vai tratar de assuntos genéricos do boot loader, enquanto a segunda vai tratar de questões
relacionadas às opções de boot pela imagem do Kernel.
Opções da seção global do arquivo:

boot : configura o disco ou partição onde vai ser instalado o LILO.
delay : tempo de espera por opção do usuário até que seja escolhida a primera imagem de boot.
timeout : tecnicamente, faz a mesma coisa que a opção acima. Detalhe: a unidade de medida
dos dois é o décimo de segundo, portanto, configurar timeout=100 significa esperar 10 segundos até
que o usuário decida por qual imagem ele vai inicializar, não ocorrendo isso, ele inicia com a primeira.
prompt : para que o prompt boot: seja exibido, é preciso que seja utilizada esta opção.
install : tipo de interface do menu do LILO. As opções podem ser:
text : boot em modo texto simples.
menu : menu básico.
bmp : imagem bitmap.
password : define uma senha de boot para o LILO.
vga : resolução de vídeo do terminal, elas são representadas por códigos. Os mais importantes
são:
normal : 640x480
788 : 800x600
791 : 1024x768
794 : 1280x1024
map : especifica o caminho do mapa de dispositivos.
Opções da seção image do arquivo:

label : especifica um rótulo para a opção de boot.
initrd : aponta para o caminho da imagem dos módulos que serão carregados no boot após a
imagem do Kernel ser descompactada.
read-only : configura descompactação do Kernel no boot como apenas leitura.
read-write : configura descompactação do Kernel no boot como leitura e gravação.
other : aponta para outro sistema operacional como uma das opções de boot (muito utilizado em
dual-boot com Windows).
Exemplo:
other=/dev/sda7
label=Windows
table=/dev/sda
table : aponta para o disco onde se encontra a tabela de partições do sistema operacional
estrangeiro.
Toda vez que alguma mudança for feita em /etc/lilo.conf, o LILO deve ser reinstalado e o sistema
deve ser reiniciado:
#lilo
#shutdown –r now
GRUB (Gran Unified Boot Loader) - Legacy

O GRUB é o boot loader usado pela maioria das distribuições para desktops e servers
justamente pelo fato de ele ser um gerenciador dinâmico (não precisa ser reinstalado após cada
mudança em seu arquivo de configuração) e cheio de recursos, como boot por diversos sistemas
operacionais e filesystems diferentes, por discos de qualquer tipo (inclusive ISCSI), por múltiplas
imagens, por ter um menu que disponibiliza o modo de comando (para emergências) e a possibilidade de
criptografação de senha se boot.

O grub também pode ser instalado no MBR ou na partição pelo comando grub-install.
Exemplo:
Instalando o GRUB no disco /dev/sdc:

#grub-install /dev/sdc
Os arquivos dos quais o GRUB precisa estão em /boot (imagem do Kernel, initrd, mapas de
dispositivos, etc), portanto, em cada alteração de conteúdo deste diretório, como em uma instalação de
um novo Kernel, não é necessário editar seu arquivo de configuração em /boot/grub/menu.lst, basta
executar o comando update-grub.
O arquivo de configuração do GRUB tem, em tese, opções parecidas com as do arquivo de
configuração do LILO, o que difere bastante é a sintaxe dessas opções. Os campos mais importantes
desse arquivo são:
default : configura qual vai ser a imagem de boot padrão. Geralmente este número é 1.
timeout : configura o tempo de espera (em segundos) por uma escolha de boot por parte do
usuário. Se esta escolha não for feita, o boot loader irá iniciar pela primeira imagem de boot que estiver
listada no menu.
color : permite escolher cores para o menu do GRUB.
password : especifica uma senha para o caso de o administrador tantar acesso de edição pelo
menu do GRUB. Esta é uma ótima prática de segurança, principalmente se o acesso físico ao servidor
por múltiplos usuários é inevitável.
hiddenmenu : esta opção esconde o menu do GRUB até que o usuário presione <ESC>, dentro
do limite de tempo (timeout). Caso isto não seja feito, o boot será feito com a imagem escolhida na opção
default.
root : especifica por qual partição será o sistema raiz do sistema.
makeactive : aplicar o flag inicializável à partição.
chainloader : entrega a responsabilidade de iniciar um outro sistema operacional ao seu boot
loader instalado. Esta opção é muito utilizada em dual-boots Linux/Windows.
kernel : configurações de boot pela imagem do Kernel. Nesta seção, é configurada a resolução
de vídeo, seguindo o padrão vga=<código>, sendo os mesmos códigos que são utilizados no LILO.
Também, e principalmente, é referenciado o local da imagem de boot do Kernel, se o mesmo vai ser
iniciado em ro(read only) ou rw(read and write). Também podem ser passados alguns parâmetros
especiais, como o boot forçado por um runlevel específico e a inicialização direta pelo Shell BASH, para
caso de ter que “pular” o processo INIT e fazer login como root (sem senha alguma).
title : especifica um rótulo para a opção de boot.
initrd ; aponta o caminho da imagem INITRD que vai carregar os módulos na inicialização do
sistema.
Outro detalhe a ser observado é a declaração de nomenclarura de discos e partições no GRUB é
bem particular, tornando-se uma preocupação para quem não domina o assunto e é obrigado a
configurá-lo. Esta nomenclatura segue a seguinte sintaxe, com a contagem de discos começando de
zero:
(HD<num_disco>,<num_part>)
Exemplos:
/dev/sda (HD0)
/dev/sda2 (HD0,1)
/dev/sdb5 (HD1,4)
/dev/sdb7 (HD1,6)
Criando e usando a criptografia no GRUB

Como foi dito anteriormente, a passagem de parâmetros no menu do GRUB deve ser controlada
ao máximo para que não aconteçam desastres, como um usuário comum com acesso físico ao servidor
conseguir entrar no sistema direto pelo Shell Bash e não precisar de senha de root para acesso ao
terminal. Uma grande estratégia de proteção contra esta ameaça de segurança é criar uma senha para
passagens de parâmetros no boot do GRUB. Para isso, vamos criar uma senha primeiro e redirecionar a
sua criotografia para o arquivo se configuração de boot:
#grub-md5-crypt | tee –a /boot/grub/menu.lst

Dentro do arquivo menu.lst, onde está a criptografia, a sintaxe para configurar este bloqueio deve
estar antes da primeira opção de boot se seguinte forma:
lock
passwd --md5 <chave criptografada>
Se, após o sistema reiniciado o usuário quiser editar o menu do GRUB, esta senha criptografada
será pedida a ele para que o procedimento possa ser realizado.

GRUB 2
Afim de adequar o boot manager aos novos padrões de hardware e fimware do mercado, o
GRUB2 surgiu modificando praticamente todos os padrões de configuração. O arquivo
/boot/grub/menu.lst já não existe mais nesta versão do boot manager. O recomendado é sempre fazer as
alterações dentro do arquivo /etc/default/grub e logo depois atualizar o grub.
Toda e qualquer alteração na configuração também pode ser feita diretamente em
/boot/grub/grub.cfg.
Visão do arquivo /etc/default/grub
O Grub2 não trabalha com o caminho completo fixo dos arquivos de Kernel e nem da Initrd, você
dentro deste arquivo só define as opções adicionais de boot do Kernel, como 'quiet', por exemplo.
Para adicionar uma nova imagem compilada de Kernel no Grub2 basta copiá-la para /boot e
depois executar update-grub como root. Todo o diretório /boot será lido e os arquivos dele inseridos no
menu do GRUB.

COMPILAÇÃO DE PACOTES E BIBLIOTECAS
A instalação de alguns pacotes pode ser feita também através de seu código-fonte
disponibilizado em alguma mídia de download. Este código-fonte geralmente vem compactado no
formato .tar.gz (ou .tgz, que dá no mesmo) ou em formato .tar.bz2 e é modo mais open-source possível
de instalação de pacote, visto que o código-fonte é a própria linguagem utilizada para a construção dos
programas que integram o pacote a ser instalado.
Compilação
O computador trabalha com interpretação de linguagem binária (“zeros” e “uns”) mas os
programas são construídos em linguagens mais compreensíveis para seres humanos: as linguagens de
programação (C, C#, C++, Java, Shell Script, etc). Por este motivo é que, depois antes de ser instalado,
um programa tem que ser compilado para linguagem binária, para que ele possa ser interpretado pelo
computador. Quando este pacote vem em formato .deb ou .rpm, ele já vem pré-compilado, só cabendo
aos gerenciadores de pacote instalá-lo (ou seja: copiá-lo para os diretórios que são destinos de
instalação).
Para que um pacote possa ser comipilado, é necessário um compilador de código fonte,
portanto, deve ser a primeira atitude a ser tomada pelo administrador instalar todos os softwares
necessários para este procedimento:
#apt-get install make gcc libncurses5 –y
Tendo em mãos o arquivo de pacote, o próximo passo é descompactá-lo, levando em
consideração que o nome do arquivo é aalib-1.4rc5.tar.gz :
#tar -xzvf aalib-1.4rc5.tar.gz
Todos os outros passos têm que ser executados de dentro do diretório do código-fonte, dentro
dele estará o arquivo Makefile assim que ele for criado por um script quase que genérico para todas as
compilações de pacotes, o configure, que também fica dentro do diretório do código-fonte:
Executando o script configure:
#./configure
O arquivo Makefile possui alguns campos que devem ser observados primordialmente:
prefix : é o local para onde vão ser copiados os arquivos todos os arquivos de instalação. A
maioria dos pacotes “tgz” utilizam /usr/local mas este diretório pode ser outro, se o administrador
modificar este campo ou executar o script configura coma s opções:
#./configure --prefix=<diretório>
bindir : indica qual será o diretório de arquivos binários comum a todos os usuários.
sbindir : indica qual será o diretório de arquivos binários de superusuários.
libdir : diretório de bibliotecas do pacote.
mandir : diretório de manuais do comando ‘man’.
infodir : diretório de manuais do comando ‘info’.
sysconfdir : diretório de arquivos de configuração do pacote
O próximo passo é a compilação do código-fonte:

#make
Agora, a instalação propriamente dita:

#make install

Após executada a instalação, o administrador deve se preocupar em saber se os comandos e
bibliotecas relativas ao pacote estão no path do usuário. Em relação aos binários, é só observar o valor
da variável PATH, se os diretórios de binários estiverem lá, o próximo passo será verificar se no path de
bibliotecas está o diretório de biliotecas do pacote. O aquivo de configuração de paths de bibliotecas é
o /etc/ld.so.conf, porém, o que ele faz é apenas um “include” para o diretório /etc/ld.so.conf.d/, onde
estão os arquivos de configuração individuais de path com extensão .conf, sendo assim, todo arquivo
com esta extensão dentro desse diretório será um arquivo de configuração de path de biblioteca, basta
incluir em seu interior o caminho de path desejado.
#ldconfig
Este comando aplica as modificações feitas em todos os arquivos de configuração de paths. Ele
grava estas mudanças em /etc/ld.so.cache, que é o aquivo que armazena estas informações de busca.
#ldd <programa>
Lista de quais bibliotecas compartilhadas pelo sistema um programa depende, geralmente estas
bibliotecas estarão em /lib, pois este é o diretório de bibliotecas do sistema.
O resultado deste comando utilizado contra o binário /usr/local/bin/aafire é o da figura abaixo:

SHELL SCRIPT
A linguagem de programação Shell é um kit de ferramentas versáteis e de grande utilidade para

o administrador, pois esta linguagem utiliza como interpretador de comando o próprio Shell do sistema e,
sendo assim, pode executar todos os comandos de um terminal do Linux ou do Unix e ainda mais as
suas próprias estruturas de análises lógicas, seus comandos próprios, interfaces gráficas, etc. Estas
características todas fazem de um programa de Shell uma parte integrante do próprio sistema em si,
uma vez que diversas rotinas administrativas podem ser interfaceadas por ele, como backups, regras de
firewall, criação e administração de usuários em demanda, etc. Enfim, o Shell Script é totalmente
aplicável a sistema.
Antes de produzir o primeiro script, algumas ferramentas devem ser conhecidas:
Aliases
Os aliases substituem comandos ou parte de linhas de comandos. Eles são armazenados em

memória e removidos dela no momento em que o usuário não está mais usando o terminal (logoff), por
causa disto, para que haja persistência dos aliases, é preciso declará-los em algum arquivo de script de
login de usuário, como foi visto em capítulo anterior.
A sintaxe de criação de um alias é esta abaixo:
#alias <nome do alias>=’comandos’
Para remover um alias:
#unalias <nome do alias>
Para executar o alias, basta digitar o nome dele como um comando, que pode, sem problemas
ter argumentos também:
#<nome do alias>
Exemplos:
Criando e executando o alias backup para fazer backup de todo o diretório /var/log para um
aquivo chamado /backups/backup-var.tar.gz:
#alias backup=’tar -czvf /backups/backup-var.tar.gz /var/log’
#backup
Criando um alias para tornar padrão o modo interativo do comando rm quando ele for digitado:
#alias rm=’rm –i’
Neste caso, quando o comando for executado com qualquer que seja a opção, será perguntado
ao usuário se ele quer mesmo excluir o objeto.
Funções
Ao contrário dos aliases, as funções só conseguem armazenar comandos completos, ou seja:

não aceitam argumentos na hora da execução.
As duas sintaxes possíveis para uma função são:
#function <nome> { comandos; };
ou
#<nome> () { comandos; };
É preciso tomar muito cuidado com os espaços entre as chaves e os outros caracteres, pois se
esta sintaxe não for mantida à risca, a função não funcionará.

Exemplos:
Criando e executando uma função para atualizar a base de dados do APT, instalar o pacote
squid e depos limpar o cache:
#function instala_squid { apt-get update; apt-get install squid; apt-get clean; };
#instala_squid
Para excluir uma função, basta usar o comando unset:

#unset <função>
Para exibir todas as funções criadas:

#declare –f
Variáveis de Shell
O Shell do sistema trabalha o tempo inteiro lendo e gravando variáveis que vão ajudá-lo a
interpretar melhor os comandos e as configurações existentes. Um exemplo sismples é a variável HOME
do usuário, que é lida pela linha de comando cd ~ para que seja possível entender que ‘ ~ ‘ é o homedir
do usuário em sessão, a cada vez que um usuário faz logon é criada esta variável com o caminho do
diretório pessoal dele (independente de qual seja este usuário).Existem dois tipos de variáveis no Linux:
Variáveis Globais
São as variáveis que não dependem de sessão de usuário para existirem. Estas variáveis podem
ser consultadas através do comando set.
Exemplos:
LANG : variável que recebe o idioma do sistema e a codificação de caracteres.
LANGUAGE: variável de idiomas de teclado.
HOSTNAME : hostname da máquina.
Variáveis de ambiente
São aquelas que dependem do usuário para serem criadas, pois, dependendo de quem seja o
usuário, a variável não será a mesma, como as variáveis abaixo:
PATH : indica o caminho de busca dos comandos que são digitados pelo usuário. A variável
PATH do usuário root contém os diretórios “sbin”, que a mesma variável para um usuário comum não
tem, por padrão, pois os programas contidos em dietórios “sbin” são de uso exclusivo de root.
SHELL : aponta para a localização do arquivo binário do Shell do usuário.

PWD : diretório atual do usuário.
OLDPWD : diretório acessado anteriormente pelo usuário.
HOME : diretório pessoal do usuário.
A lista de variáveis de ambiente pode ser obtida com o comando env.

Criação e manipulação de variáveis
Dependendo do motivo do script, o usuário vai precisar que a variável que ele esteja usando não
sirva apenas para o seu próprio programa, mas seja também uma variável exportada para o sistema,
então, a primeira providência que deve ser tomada é exportar esta variável com o comando abaixo:
#export <variável>=<valor>
Este processo também pode ser feito em duas etapas: a criação e depois a exportação da
variável. Para isso, podemos usar as seguintes linhas de comando:
#<variável>=<valor>
#export <variável>
Toda vez que uma variável for utilizada, o $ deve vir antes do nome dela, como no exemplo
abaixo:
#export LOGS=/var/log
#cd $LOGS
Outro exemplo de manipulação de variável é a adição do diretório /programas na variável PATH

do usuário para que comandos que estejam neste diretório possam ser executados de forma mais
simples por ele:
#export PATH=$PATH:/programas
Mostrando o valor da variável:
#echo $PATH
Para excluir uma variável que foi criada, basta utilizar também o comando unset, como no
exemplo abaixo:
#unset LOGS

Criação de scripts de Shell
Um aquivo de script é um arquivo comum de texto e pode ser executado com qualquer extensão
(.txt,.mp3,.ppt, etc..), até porque as extensões em Linux não têm funcionalidade nenhuma para execução
ou leitura ou gravação em arquivos. Ainda que não utilizemos as extensões, para que o script de Shell
possa ser lido pelo edito vim com cores de sintaxe é preciso que o arquivo de script tenha alguma
extensão, mais especificamente a extensão .sh.
Como os scripts de Shell serão utilizados em administração de sistema Linux como caixa de
ferramentas, vamos já começar aplicando o seu uso para este fim, com o primeiro script abaixo, que será
um programa para criar usuários:
#vim ~/cria_users.sh
Neste script, já se podem notar algumas características de Shell Script, como a inserção de
comentários, que pode ser feita com o ‘#’. Eles são primordiais para a boa documentação dos scripts
criados, pois podem ser usados para marcar a versão do script, as datas de criação e última
modificação, o autor e a descrição do script que está sendo criado, como foi feito no exemplo acima.
É importante também que a informação de qual Shell vai interpretar os comandos esteja no
cabeçalho com a seguinte sintaxe: #!<caminho do Shell>. No exemplo acima foi utilizado o Shell
BASH, cujo binário está em /bin/bash. Poderia ter sido utilizado outro Shell disponível em /etc/shells, sem
nenhum problema, mas como o BASH é o Shell padrão para comandos no Linux, é sempre melhor
utilizá-lo como interpretador para os comandos que vão ser usados.
Alguns outros recursos usados acima serão analisados agora:
#echo
Este comando é responsável por produzir tanto STDIN (saída padrão de comando) como
STDERR (saída de erros de comando). Suas sintaxes são:
#echo <valor de variável, saída de comando ou texto>
#echo ”<valor de variável, saída de comando ou texto>”
#echo ‘<texto>’
Exemplos:
Produzindo como saída o valor da variável SHELL:

#echo $SHELL
ou
#echo “$SHELL”
Produzindo o texto $SHELL:

#echo ‘$SHELL’
Outro detalhe importante sobre o comando echo são as opções de posicionamento do texto,
utilizadas em conjunto com o parâmetro -e do mesmo:
\\n : insere nova linha.
\\t : insere tabulação horizontal (padrão para documentos de texto em geral).
\\v : insere tabulação vertical.
\\b : insere um backspace.
\\a : emite um sinal de “bip” do speaker.

Exemplos:
Exibir o texto de seguinte forma:

Linux
System
Administrator
#echo -e “Linux \\nSystem \\nAdministrator”
Exibir o mesmo texto, só que com as linhas tabuladas horizontalmente:

#echo -e “\\tLinux \\n\\tSystem\\n\\tAdministrator”
Agora, o mesmo tabulado horizontalmente e verticalmente (espeçamento entre linhas):

#echo -e “\\v\\tLinux \\n\\v\\tSystem \\n\\v\\tAdministrator”
#read
Atribui a uma variável o valor digitado pelo usuário.
Exemplos:
Lendo o valor da variável IP, que será lançado como 172.16.0.1 pelo usuário, e exportando a
variável:
#read IP; export IP
Lendo, exportando e exibindo o valor da variável DSK_BKP com mensagem para o usuário:
#read -p “Digite o disco desejado para backup:” DSK_BKP
#export DSK_BKP
#echo $DSK_BKP
É lógico que o uso do read só é viável para um script, pois é a única forma de pedir para que o
usuário lance um valor para uma variável.
Sub-Shells
Quando a saída desejada para STDOUT, STDIN ou STDERR é o resultado de um comando, o
ideal é utilizar um Sub-Shell, que é uma forma de um comando utilizar a saída de um outro comando ou
de uma variável receber um resultado de comando. Um Sub-Shell pode ser representado por $
(comando) ou por `comando`, como nos exemplos abaixo:
Fazendo backup de uma lista em um arquivo chaamado lista.txt:
#tar -cjvf /backups/bkp-lista.tar.bz2 `cat lista.txt`
Execução de um script
É importante que um script tenha permissão de execução para o usuário que o quer utilizar, pois
desta forma, ele pode ser executado se for informado o seu caminho completo ou se ele for copiado (ou
se tiver um link) para um diretório do path do usuário é só executá-lo como um comando qualquer,
apenas digitando o seu nome.
Outras formas de execução:
#sh <script> (neste caso, o script não precisa ter permissão de execução).
#. <script>
#./<script>
#source <script>
#bash <script>
Exemplos:
Executando o script cria_users.sh criado acima como um comando no path do usuário:

#chmod +x ~/cria_users.sh && ln -s /root/cria_uses.sh /sbin/cria_users
#cria_users

Executando ~/cria_users.sh, que não está no path do usuário:
#sh ~/cria_users.sh
Estruturas de análise lógica
As estruturas funcionam no Shell Script como na maioria das linguagens de programação, só

que com sintaxes diferentes. É sempre recomendável para um programador Shell conheça pelo menos
um pouco de algoritmos (o máximo possível), pois é preciso antes de implementar uma estrutura dessas,
saber muito bem qual será o intuito, uma análise condicional, uma execução com “n” passos, uma
estrutura de repetição ou uma análise de caso para um menu, por exemplo.
O uso de cada uma dessas estruturas é bem didático e bem simples, mesmo para o
administrador de sistema Linux que nunca teve contato com lógica de programação.
Antes de conhecer cada uma das estruturas, é importante conhecer o comando abaixo:
test
Testa arquivos, diretórios, números e strings (textos).
Testes numéricos:
-eq : igual a.
-lt : menor que.
-le : menor ou igual.
-gt : maior que.
-ge : maior ou igual.
-ne : diferente de.
Testes em strings:
= : igual a.
!= : diferente de.
-z : vazia.
-n : não-vazia.
Testes em aquivos:
-d : é um diretório.
-f : é um arquivo.
-s : é um aquivo e não é vazio.
-ef : é o mesmo arquivo.
-nt : arquivo mais novo.
-ot : arquivo mais velho.

Estrutura if (condicional)
Analisa uma condição verdadeira e, para ela, executa uma série de comandos. Também é
possível adicionar uma condição para se teste for falso (else), mas esta não é imprescindível.
Sintaxe1:
if <condição verdadeira>
then <comandos>
fi
Onde fi finaliza a estrutura.
Sintaxe2:
then <comandos>
else <comandos>
fi
Sintaxe3:
then <comandos>
else if <condição verdadeira>
then <comandos>
fi
fi
No modelo de sintaxe acima, temos uma estrutura if composta, onde a análise de condição falsa
(else) pode receber uma outra estrutura if. Outro detalhe é que, como foram utilizadas 2 estruturas if,
foram também finalizadas as duas com fi.
Exemplo1:
No caso acima, o script acim testa a existência do arquivo /etc/nologin. Caso este exista, a
mensagem ‘O login não será possível agora!!’ será exibida, caso contrário, a mensagem ‘Login liberado’
será exibida.

Exemplo2:
No
caso acima, mais uma condição foi analisada: a de existir /etc/nologin, mas ele ser um diretório, e não um
arquivo, neste caso, a mensagem ‘/etc/nologin é um diretório, não um arquivo’ será exibida.
Estruturas while e until

Estras estruturas têm sintaxes diferentes, porém têm a mesma função: a de executar tarefas em
repetição (loop) mediante a um teste satisfeito.
Estrutura while:
while <teste verdadeiro>
do <comandos>
done
Estrutura until:
until <teste falso>
do <comandos>
done
No caso de uma estrutura while, serão repetidos comandos enquanto aquele teste for
verdadeiro, enquanto que na estrutura until é justamente o contrário: apenas quando o teste falso for
satisfeito a repetição dos comandos vai parar de ser realizada.
Exemplos:
No caso acima, foi criado um “loop” de criação de diretórios onde, cada vez que este loop for
executado, ele vai verificar se a variável qtd (quantidade de diretórios) ainda é maior que cont (um
contador que foi criado para servir de referência), caso seja, cont vai ter o seu valor acrescido de 1 e vai
servir de rótulo para a criação de um diretório com o nome dir-$cont, quando cont for igual à qtd, o loop
acaba.

Neste script foram utilizados operadores matemáticos. Os operadores para Shell Script são:
+ : soma
- : subtração.
* : multiplicação.
/ : divisão.
** : exponenciação.
Para o caso de precisar fazer alguma operação aritmética, ela deve ser deve ser realizada entre
(( )) ou $(( )), como foi mostrado no exemplos acima.
Neste caso acima, foi utilizada a estrutura de repetição until, que testou o valor da variável qtd
até que ele fosse igual ao valor da variável cont, que, na verdade, agiu como uma constante neste script,
já que o seu valor apenas serviu como parâmetro de comparação para a variável qtd, que permaneceu
sendo subtraída de 1 a cada “loop” desses.
Estrutura for
A estrutura for atribui para uma variável um valor de uma lista por vez. Para cada passo dessa
lista serão executados comandos que estiverem abaixo de “do”. Esta é uma ferramenta importantíssima
para programas que precisam executar passos em sequência.
Sintaxe:
for <variável> in <lista>
do
<comandos>
done
Exemplo:
No programa acima, para cada diretório da lista extraída do arquivo /etc/passwd foi criado um
arquivo de backup. Supondo que haja 20 usuários nesta lista, os comandos serão executados 20 vezes,
portanto teremos 20 arquivos de backup, um para cada homedir de usuário, pois a cada passo desses, a
variável home receberá um desses diretórios como valor.
O uso de for em scripts é útil também para criação de diretórios ou arquivos em demanda,
utilizando o comando seq.
#seq
Exibe uma sequência numérica.
Exemplos:
Exibir de 1 até 100:

#seq 100
Exibir de 10 até 100:

#seq 10 100
Exibir de 10 até 100 com intervalo de 5:

#seq 10 5 100

Exemplo de uso do seq na estrutura for:
#vim ~/criadir_for.sh
Toda vez que é digitado um parâmetro para qualquer comando, este parâmetro é guardado na
variável 1, por isso ela foi analisada sem ser solicitada pelo comando read.
No programa acima, a variável qtd, utilizada pela estrutura for, recebe cada um desses números
que foram resultado do comando seq de cada vez e, para cada um deles, cria um arquivo. Detalhe: tudo
foi feito com apenas 5 linhas de script (contando com o comentário).
Vamos à execução do script (que vai criar 10 arquivos):

#chmod +x ~/criaarq_for.sh
#ln -s ~/criaarq_for.sh /sbin/criaarq_for
#criaarq_for 10
Estrutura case
Analisa se a variável se encontra em cada caso e, para cada um, executa os comandos
escolhidos pelo programador. Esta estrutura é muito útil na criação de programas com menu e também
na criação de comandos que possuem argumentos.
Sintaxe:
case <variável> in
<opção1>) <comandos> ;;
<opção2>) <comandos> ;;
<opção3>) <comandos>
esac
Em tese, este estrutura é uma ferramenta de substituição à estrutura if em análises muito

grandes, como uma que precisasse de 10 condições, com o if este código ficaria enorme e, em qualquer
linguagem de programação, é primordial que o programador prime pela boa organização de seu scripts,
estruturas cada vez menores mas que tenham funcionalidade completa.
Existe a necessidade de o programador providenciar que o script dele esteja bem documentado (com
comentários e, se necessário, manuais), bem indentado e com as versões bem atualizadas, levando em
consideração a freqüência com que elas são atualizadas para decidir se será uma versão com 2,3 ou até
4 dígitos.
Voltando à estrutura, cada opção do case deve ser separada da outra com ;; e o final da mesma
é marcado pelo esac.
O tratamento de erros em uma estrutura case é feito por * em uma das opções significando
“nenhuma das alternativas acima”.

Vamos ver um exemplo de case usado para analisar um menu de opções em um programa para
gerenciamento de pacotes:
A função menu, no caso deste script responde pelo menu e pela estrutura case inteira e, antes
de ela ser executada, os sinais 2(sinal INT) e 15 (TERM)foi capturado com o comando trap. Este
comando insensibiliza uma linha de comandos a sinais em específico, neste caso a função não terá como
ser interrompida com CTRL+C e nem poderá ser terminada com o sinal 15.
Quanto às opções, o | quer dizer “ou”, para o caso de o número ser digitado por extenso.

REDES EM LINUX
Ao longo dos anos, por conta de sua estabilidade, segurança, flexibilidade, escalabilidade, e
outras características, o Kernel Linux esteve assumindo o posto de excelente servidor de rede em muitas
aplicações, como serviços de LDAP, servidor de arquivos, firewall, DHCP, proxy, servidor de uma VPN,
etc. Por causa dessa vocação que o Linux tem para este mercado é que o seu administrador deve ter um
profundo conhecimento de técnicas de configuração, planejamento e manutenção de uma rede.
O servidor de rede Linux deve ser capaz de se manter disponível para que os clientes Linux e de
outras plataformas (Windows, Mac, Unix, BSD, etc) possam fazer uso dos recursos providos por ele.
Para que a alta disponibilidade aconteça, é preciso providenciar que o Hardware esteja condizente com
o serviço que será prestado, podemos citar como exemplo a diferença de espaço de armazenamento em
discos entre um servidor de logs e um firewall que apenas vai servir como roteador e vai fazer filtro de
pacotes que passarem dele para outra rede, é claro que o servidor de logs deverá contar com um espaço
em disco maior. Outra diferença que pode ser analisada é a existente entre o Hardware requerido para
um servidor de máquinas virtuais e o requerido para um servidor de arquivos apenas, neste caso, a
diferença maior fica por conta do tipo de CPU que terá que ser adotado: o primeiro usa instrução de
virtualização e o segundo não tem obrigação de ter tal tecnologia. É igualmente importante, é lógico,
atentar para o Hardware de rede a ser utilizado, com o advento de redes de até 1Gb/s de taxa de
transferência de dados, fica a cargo do administrador então apenas escolher os fabricantes e modelos
adequados para a estrutura (switches, patch chords, patch pannels, routers, access points, etc.).
Protocolos e portas
Protocolos de rede são conjuntos de regras de funcionamento que regem as conexões que vão
ser estabelecidas. Cada protocolo de rede tem a definição de seu padrão em um documento chamado de
RFC.
TCP/IP
De todos os protocolos, 2 se destacaram bastante no processo de difusão e desenvolvimento da
Internet, assim com das grandes LANs : TCP e IP, tanto que, na maioria dos casos, são pronunciados
juntos (TCP/IP). O primeiro é o Protocolo de Controle de Transferência (Transmission Control
Protocol), que é um protocolo que funciona na camada de transporte do modelo OSI (camada 4) e
recebe este nome porque ele garante a entrega de dados ao destinatário, tornando-se um protocolo
confiável, pois confere a integridade da informação antes de ela ser enviada. Este protocolo é utilizado
para serviços onde a entrega dos dados em perfeito estado é essencial, um grande exemplo é um
download de um arquivo: é lógico que nenhum usuário ficaria satisfeito de receber este arquivo com
vários pedaços faltando (pois, na maioria dos casos nem funcionaria) e, por isso, a transferência do
mesmo é feita no protocolo TCP por intermédio de alguma porta que possa prover o serviço de
transporte usado, como a porta 21 do serviço de FTP.
Para que os serviços possam ser criados e não haja conflitos entre as funcionalidades deles, são
designadas as portas para os mesmos. A lista de portas para serviços disponíveis para protocolo o TCP
estão em /etc/services. As mais comuns são:
20 e 21 : FTP
22 : SSH
23 : Telnet
25 : SMTP
53 : DNS
80 : HTTP(WWW)
110 : POP3
143: IMAP
443: HTTPS
465: SMTPS
995: POP3S

O Internet Protocol se preocupa somente com os critérios e as características de
conectividade dos sistemas. Ele garante que hosts que estejam em uma mesma rede tenham
conectividade direta e também que possam ser feitas várias segmentações dentro de uma rede só,
recurso chamado de sub-rede. A versão deste protocolo que vai ser analisada é a versão 4 (IPV4), que
conta com as seguintes características de endereçamento de hosts:
Endereço IP
Um endereço IP em IPV4 é constituído de 4 blocos de 8 bits no máximo cada um, sendo
chamado cada bloco de octeto, por causa disso. Em cada octeto desses, os bits são representados em
números decimais, pois assim fica mais humanamente possível de ser implementado. Os números
decimais disponíveis para compor esse modelo de endereçamento de rede vão de 0 a 255 (estando
disponíveis para uso 256 números, contando com o 0, é claro). Um exemplo de endereço IP é de um host
é 10.0.0.1.
O endereço IP também pode ser utilizado por ume rede, definido com ele quantos hosts poderão
integrar a mesma rede. Um exemplo de endereço IP de rede é 172.16.0.0/16, onde o primeiro critério de
conectividade plena entre hosts que façam parte desta rede será cada host estar na mesma classe, que
está sempre definida pelo primeiro octeto, o segundo critério será a igualdade do segundo octeto entre os
hosts: 16 é o que está definido no endereço de rede e ele deve ser mantido porque o octeto onde ele está
se encontra com os 8 bits “fechados” para alteração.
Os endereços IP estão divididos em classes:
Classe A : o primeiro octeto pode ir de 1 até 126.
Classe B : o primeiro octeto pode ir de 128 até 191 (obs: o 127 é reservado para o localhost).
Classe C : o primeiro octeto pode ir de 192 até 223.
Classe D : o primeiro octeto pode ir de 224 até 239.
As classes utilizadas para redes LAN e WAN são as A,B e C, pois a C é utilizada para
comunicação em multicast, onde múltiplos endereços recebem a mesma mensagem do host que enviou
(o chamado broadcast).
Exemplos de IPs:
125.0.2.25 é um IP de classe A.
155.200.0.20 é um IP de classe B.
219.1.5.2 é um IP de classe C.
Um refinamento dessas 3 classes foi criado para que os IPs de seus hosts não se confundissem
com IPs de servidores externos da grande rede mundial de computadores, ficando assim constituído o
termo “IP privado” para IPs de redes LAN. As classes de IP privado são:
Classe A: 10.0.0.0 até 10.255.255.255, tendo como representação CIDR 10.0.0.0/8.
Classe B: 172.16.0.0 até 176.31.255.255, tendo como representação CIDR 172.16.0.0/16.
Classe C: 192.168.0.0 até 192.168.255.255, tendo como representação CIDR 192.168.0.0/24.
A definição de quantos hosts uma rede pode suportar é feita com a seguinte fórmula:
32 - BITS DA REDE
Deste resultado acima iremos extrair a informação de quantos bits faltam para completar todos
os endereços dos octetos, o número 2 deve ser elevado a este número obtido e o resultado subtraído de
2 (que são os endereços de rede e broadcast, que não podem ser utilizados). Em uma rede
192.168.0.0/24 teríamos o seguinte cálculo:
32 - 24 = 8 (bits que faltam ser preenchidos)
2⁸ = 256 -2 = 254 hosts
Protocolo ARP (Address Resolution Protocol)

Este protocolo é encarregado de garantir a interpretação de um endereço físico de rede (MAC
address) através de um endereço lógico (IP). Endereço MAC é o endereço físico que toda interface de
rede possui, sendo único para todas elas espalhadas pelo mundo. Este endereço é construído com
números hexadecimais (números e letras) e é representado por 6 blocos de 2 números hexadecimais
cada um, sendo os 3 primeiros, geralmente, reservados à especificação do fabricante da interface.
Exemplo:
00:0f:e0:42:27:0d
Este protocolo é de extrema importância para aplicações de Firewall e servidores DHCP, que
serão explicados em capítulos posteriores.
O protocolo RARP faz justamente o contrário: resolve IP através de endereço MAC.

UDP (User Datagram Protocol)
O uso deste protocolo também é para tráfego de dados, porém ele não garante a entrega dos
mesmos, visto que é um protocolo de transporte simples. Ele pode ser utilizado para troca de dados que
não têm a obrigação de chegarem em perfeito estado mas precisam chegar o mais rápido possível,
como por exemplo a transmissão de uma rádio online, onde a qualidade sonora não seria mais
importante do que a velocidade de chegada da mensagem. Pelo fato de não garantir esta entrega dos
dados, o serviços SMTP e FTP não trabalham com este protocolo, porém, alguns serviços têm também
funcionalidade com o protocolo UDP, como HTTP, DNS e LDAP.
ICMP (Internet Control Massage Protocol)

Este protocolo é encarregado de emitir relatórios sobre a conectividade entre hosts na mesma
rede e entre hosts e roteadores. Os comandos ping e traceroute utilizam este protocolo para enviar
pacotes pequenos (geralmente 64 bytes) que “perguntam” o estado de uma conexão e recebem, na
mesma proporção, a resposta do destino ou gateway consultado, caso ocorra algum erro nesta
comunicação, este erro será reportado ao host que enviou a requisição, salvo em caso de bloqueio por
política DROP de um Firewall Iptables. É importante ressaltar que quando uma requisição so protocolo
ICMP é enviada, o MAC do remetente fica registrado na tabela ARP do destinatário, e vice-versa.
É imprescindível que um administrador de servidor Linux entenda os protocolos e as portas

disponíveis para uso no servidor. Estas duas informações estão dentro dos arquivos /etc/services e
/etc/protocols, como mostram as figuras abaixo:
Configuração de rede
As interfaces de rede no Linux seguem, geralmente, padrões de nomenclatura:

eth0 : 1ª interface de rede ethernet.
eth1 : 2ª interface de rede ethernet.
wlan0: 1ª interface de rede wireless.
wlan1: 2ª interface de rede wireless.
Os modos de configuração dos endereços IP para estas interfaces são diferentes para algumas
distros:
No Debian
O arquivo /etc/network/interfaces é o concentrador da configuração de endereço de rede de
todas as interfaces de rede presentes.

Onde auto é a flag que ativa a interface de rede assim que o serviço networking é iniciado (no
boot, por exemplo), a opção iface se refere à interface de rede em questão, inet é o tipo de endereço de
rede a ser utilizado: static para endereço IP definido manualmente e dhcp para IP dinâmico (que
depende de um servidor DHCP ativo na rede), address é o endereço IP, netmask a máscara de sub-
rede, gateway neste arquivo é o gateway padrão (um host pode ter apenas um default gateway). Vale
lembrar que, para uma definição de IP por dinâmico (por DHCP), nenhum campo de endereço deve ser
preenchido, já que o servidor ficará encarregado da função de fornecer o endereço.
No caso da figura apresentada, temos três interfaces de rede: lo com seu endereço de loopback
para o localhost (127.0.0.1), eth0 com IP estático e eth1 com IP dinâmico. A interface lo não deve ser
desabilitada em hipótese alguma, pois ela poderá servir para testes em Web Server, por exemplo.
Depois que toda alteração necessária é feita nesse arquivo, o serviço networking tem que ser
reiniciado para que as interfaces possam fazer uso da nova configuração:
No Red Hat
No caso desta distro, e das distros baseadas nela, existe, para cada interface de rede um
arquivo de configuração será criado assim que o Kernel reconhecer a interface, que pode ser encontrado
dentro do diretório /etc/sysconfig/network-scripts/. O nome de cada arquivo desse segue a sintaxe de
ifcfg-<interface>, como por exemplo o arquivo de uma interface de rede eth1 seria ifcfg-eth1. Vamos à
configuração:
#vim /etc/sysconfig/network-scripts/ifcfg-eth0
Onde:
DEVICE é o nome da interface de rede.
BOOTPROTO é tipo de endereço que essa interface vai ter.
IPADDR é o endereço IP para caso de escolha de endereço estático.
NETMASK é a máscara de sub-rede.
GATEWAY é o gateway padrão do host.
HWADDR é o endereço MAC da interface (que não deve ser modificado em hipótese alguma
neste arquivo).
ONBOOT é a flag que ativa (ou não, dependendo da resposta) a interface no boot.
Em comum, os dois sistemas operacionais têm a configuração de servidor de nomes (DNS), ela
pode ser feita no arquivo /etc/resolv.conf, como no exemplo abaixo:
#vim /etc/resolv.conf
Neste caso acima, temos o sistemas usando dois servidores DNS: 10.12.1.254 é o primário e
10.12.1.150 o secundário (que só é consultado caso o primeiro não responda). Este arquivo pode conter
os seguintes campos:
nameserver <IP>
É o campo onde deve ser declarado o IP do servidor DNS que vai responder às consultas de
nomes deste host.
domain <NOME>
É o nome de domínio local a ser usado pelo host. Se nada for definido, este nome fica
localhost.localdomain.
search <NOME> <NOME>
É a lista de domínios, separados por espaço, que podem também serem consultados na busca
por algum host. Quanto mais domínios forem escolhidos nesta opção, mais lenta vai ficar a busca por um
nome na rede.

Comandos de rede
Os comandos de rede que iremos abordar neste treinamento são:

#ifconfig
Exibe configuração IP de uma interface de rede e também modifica o seu endereço.
Sintaxe:
#ifconfig <opção> <interface> <opções>
Opções:
-a : exibe a configuração das interfaces ativas e desativadas.
up : ativa uma interface.
down : desativa uma interface.
netmask : define máscara de sub-rede para a interface.
Exemplos:
Listando o IP de todas as interfaces de rede ativas no host:

#ifconfig
Listando o IP de todas as interfaces de rede ativas ou inativas:

#ifconfig -a
Listando o IP apenas da interface de rede eth2:

#ifconfig eth2
Repare que o comando ifconfig, sem mais argumentos, é capaz de retornar o endereço MAC da
interface de rede.
Desativando a interface de rede eth0:

#ifconfig eth0 down
ou
#ifdown eth0
Ativando a interface de rede eth0:

#ifconfig eth0 up
ou
#ifup eth0
#ping
Faz teste de conectividade entre hosts através do protocolo ICMP.
Sintaxe:
#ping <opções> <host>
Opções:
-c : especifica quantas tentativas vão ser feitas. O padrão é testar continuamente.
-s : muda o tamanho do pacote a ser enviado (o padrão é 64 bytes).
-I :especifica a interface para o teste.
Exemplos:
Testando a conectividade com o host 10.12.1.254 com 5 tentativas, no máximo:

#ping -c5 10.12.1.254
Testando a conectividade com o host brunoodon.com.br através da interface eth2:

#ping -I eth2 brunoodon.com.br
#nmap
É um sacanner de portas de um servidor qualquer.
Exemplo:
Verificando o status das portas do host www.lpi.org:

#nmap -sT ead.howtoonline.com.br
As portas que estão marcadas como OPEN estão aptas a receberem os pacotes das portas e
protocolos listados, porém as portas que aparecem como FILTERED têm acesso negado por algum
firewall.
#lsof
Exibe a lista de arquivos abertos no sistema, inclusive os utilizados por serviços de rede.
#arp
Exibe informações sobre a tabela ARP.
Opções:
-v : modo verbose.
-n : ao invés de exibir nomes, exibe números IP.
-i : especifica a interface.
Exemplos:
Listando a tabela ARP de conexões ocorridas na interface de rede eth2 em modo numérico:
#arp -ni eth2
Esta tabela ARP é armazenada dentro do arquivo /proc/net/arp.
#hostname
Exibe ou modifica temporariamente o hostname do sistema. A modificação definitiva só pode ser
feita em /etc/hostname.
#netstat

Exibe o status das conexões de rede estabelecidas. Conexões STREAM são de protocolo TCP e
DGRAM são conexões de protocolo UDP.
Opções:
-n : exibe apenas hosts em modo numérico, não em nomes.
-l : mostra apenas sockets em escuta.
-r : mostra a tabela de roteamento.
-c : monitoramento contínuo de conexões.
Exemplo:
Verificando a tabela de roteamento (apenas IPs):
Interfaces de rede virtuais

Em uma interface de rede pode haver mais de um endereço IP configurado e isso só é possível
através da criação de interfaces de rede virtuais.
Elas podem ser criadas com os nomes seguindo a seguinte sintaxe: <interface>:<nome> e vão
responder normalmente às solicitações requeridas em uma rede. Quanto á performance, é preciso
analisar qual o tipo de serviço será prestado pelo host e se a interface física suportará toda a banda
requerida pelas interfaces virtuais adicionadas a ela. Este recurso é muito utilizado por servidores que
possuem um fluxo de dados mediano e precisam separar redes para utilizar, cada uma delas, serviços
diferentes. Exemplo: um servidor Web que tem o host tux.linux respondendo na rede 192.168.0.0/24 e
um servidor de arquivos que é disponibilizado para a rede 10.0.0.0/24, todos os dois no mesmo servidor
físico e na mesma interface física.
A definição de uma interface de rede virtual pode ser feita temporariamente através do comando
ifconfig ou pode também ser feita de forma permanente, dentro do arquivo /etc/network/interfaces, no
Debian. Vamos ver no exemplo abaixo a criação de uma interface de rede chamada eth2:virtual:
#ifconfig eth2:virtual 172.16.0.20/16
Neste exemplo, podemos ver a configuração definitiva de uma interface de rede virtual com o
mesmo endereço:

Rotas
Quando uma solicitação é feita por qualquer protocolo e ela não pode ser atendida na mesma
rede é preciso que a mesma seja encaminhada para um roteador, se o roteador foi encontrado e se ele
for o caminho correto para o destino, a solicitação terá sucesso, se não for, o protocolo ICMP se
encarregará de dar a mensagem de que não há rota para o host. O maior exemplo de uso de roteadores
é a Internet, pois antes de chegar a um site específico, o pacote passa por vários roteadores, que não se
responsabilizam por processar o pacote e sim encaminhá-lo para o destino que possa processá-lo ou
repassá-lo para outro roteador.
Existem 3 tipos de rotas que podem ser criadas para um host:
Rota padrão: o roteador padrão é chamado de default gateway e ele fica como opção
genérica de rota para todas as interfaces de rede (virtuais ou não). É sempre importante ressaltar que
pode existir apenas um default gateway em um servidor, pois o mesmo responde ao endereço de rede
0.0.0.0/0.0.0.0, ou seja: qualquer rede com qualquer máscara de sub-rede.
Rota para host: uma rota para um host ela é definida apenas para um IP, onde apenas
requisições daquele host irão ser roteadas.
Rota para rede: é o tipo de roteamento onde uma rede inteira é atendida.
#route
Verifica ou cria rotas em um servidor.
Opções do modo de consulta:

-n : exibe o resultado da tabela de roteamento em modo numérico (apenas IPs).
-v : modo verbose.
-C : exibe o cache de roteamento.
-F : exibe a tabela de roteamento (igual ao comando route sem argumento nenhum).
Exemplo:
Listando a tabela de roteamento em modo numérico e verbose:

#route -nv
No caso acima, podemos concluir que o único roteador existente é o 192.168.0.1, que é também
o default gateway, pois está respondendo ao destino 0.0.0.0 com máscara 0.0.0.0, ou seja: responde
como roteador de todos os outros IPs.
O campo opções da tabela de roteamento pode ser interpretado da seguinte forma:
U : roteador em uso.
! : a rota não foi aceita.
G : um gateway está sendo usado.
H : é uma rota para um host.
Opções do modo de alteração:

add : adiciona uma rota.
del : exclui uma rota.
-host : se refere a rota para um host.
-net : se refere a rota para uma rede.
netmask : especifica a máscara de sub-rede para uma rota de rede.
gw : especifica um roteador.
default : se refere a um default gateway, seria o mesmo que -net 0.0.0.0 netmask 0.0.0.0.

Exemplos:
Criando rota estática para o host 172.16.0.20 sair pelo roteador 172.16.0.1:
#route add -host 172.16.0.20 gw 172.16.0.1
Criando rota padrão para 172.16.0.1:

#route add default gw 172.16.0.1
Criando rota para a rede 172.16.0.0/16 sair pelo roteador 172.16.0.1:

#route add -net 172.16.0.0 netmask 255.255.0.0 gw 172.16.0.1
#traceroute
Verifica por quantos roteadores passa um pacote antes de chegar ao host destino. Este
comando também utiliza o protocolo ICMP para este tipo de teste.
Exemplo:
Verificando as rotas até o host brunoodon.com.br:

#traceroute brunoodon.com.br

CLIENTES DE SEVIDORES LINUX
Em muitos casos, os clientes de servidores Linux são distribuições Linux . Já vimos a

configuração de um cliente DNS, agora vamos ver como outras aplicações de cliente podem ser
utilizadas em distros GNU/Linux.
DHCP
O Dinamic Host Configuration Protocol, substituto do protocolo BOOTP, é o protocolo que provê
configurações automáticas de endereço de rede para os clientes que solicitarem, esta solicitação é feita
pelo cliente em broadcast por protocolo UDP e, sendo assim, o primeiro servidor que responder analisará
se o cliente se encaixa nos critérios que o próprio servidor estabeleceu. Um servidor DHCP pode
também fornecer, além do endereço IP e da máscara de sub-rede, o nome de domínio, o gateway e os
endereços IP dos servidores DNS a serem utilizados pelo cliente. Estas concessões de endereço têm um
tempo de duração determinado pelo servidor e, após este tempo ter se esgotado, será feita uma nova
negociação de endereço entre o MAC address da interface de rede do cliente e o servidor, podendo
assim, o cliente receber um endereço totalmente diferente do anterior.
É sempre importante lembrar que requisições DHCP sendo feitas em uma rede com muitos hosts
podem causar a queda de rendimento significativa, pois as requisições sempre são enviadas em
broadcast pelos clientes. Para o caso de redes de grande porte que precisem usar DHCP, é
recomendável utilizar um lease time (tempo de concessão) maior, para que os intervalos de solicitação
de IP possam ser cada vez maiores.
#dhclient
Este comando faz a requisição de endereço para um servidor DHCP qualquer em uma rede.
Sintaxe:
#dhclient <interface>
Exemplo:
Requisitando IP dinâmico para eth0:

#dhclient eth0
Para a configuração de uma interface de rede permanecer solicitando endereço IP

dinamicamente, é só editar o arquivo /etc/network/interfaces:
Neste caso acima, a interface de rede eth0 está configurada para automaticamente buscar em
broadcast suas configurações de endereço de rede.
FTP
O File Transfer Protocol, como o próprio nome já diz, é um protocolo desenvolvido para transferir
arquivos pela rede. Ele utiliza duas portas TCP para tal conexão: 20 e 21. Na maioria dos casos dos
servidores FTP espalhados pela Internet, o acesso ao servidor FTP é autenticado, porém, existem os
casos em que este login é feito de forma anônima. O acesso do cliente ao servidor FTP é feito através do
comando ftp:
Sintaxe:
#ftp <host>
Logo após o acesso, o usuário terá á sua disposição o prompt do ftp para digitar os comandos
(muito destes comandos são comandos de shell sh). Vamos ver alguns comandos de FTP:
ftp>lcd - exibe ou modifica o diretório local do usuário (diretório do cliente).
ftp>put - faz o upload de um arquivo apenas.

ftp>mput - faz o upload de múltiplos arquivos.
ftp>get - faz o download de um arquivos apenas.
ftp>mget - faz o download de múltiplos arquivos.
Exemplos:
Fazendo download do arquivo arq1.txt:

ftp>get arq1.txt
Mofificando o diretório atual para /dados:

ftp>lcd /dados
Fazendo upload de todos os arquivos do diretório local para o diretório atual no servidor:
ftp>mput *
DNS
O Domain Name System é o serviço TCP/UDP que resolve nomes de hosts para os clientes. É
pela atuação deste serviço que sites na Web podem ser acessados pelo nome, e não apenas por IP.
Geralmente, estes nomes de domínio são separados por pontos indicar subdivisões de um domínio ou
parametrizar tipos de segmentos ou localidades, exemplos:
.br : sites brasileiros.
.gov : sites do governo.
.mil : sites militares.
.edu : sites educacionais.
O servidor DNS mais utilizado pelo Linux é o BIND (Berkeley Internet Named), mas o que vamos
estudar neste material é o uso de um servidor DNS pelo cliente.
Ordem de consultas de nomes

Nem todo nome consultado pelo cliente virá de um serviço DNS. O cliente pode utilizar a
consulta aos arquivos /etc/hosts e /etc/networks. O primeiro define um nome para um IP específico e o
segundo define um nome para uma rede específica. É importante lembrar que essas configurações são
feitas por parte do cliente, ou seja, não valerão para a rede toda.
Vamos ver um exemplo de arquivo /etc/hosts:
No caso acima, o localhost (127.0.0.1) também responderá pelo nome de brunoodon e 10.12.1.1
responderá pelos nomes de SERVER1, DHCP, DNS ou SMB. Isso é muito útil para o usuário que vai
frequentemente acessar o mesmo servidor, o cliente poderá simplesmente substituir o IP do servidor em
qualquer solicitação pelo alias criado, neste caso, o sistema não vai procurar por um DNS para resolver
nomes, pois dentro do arquivo /etc/nsswitch.conf, a configuração da seção host (de busca por nomes na
rede) está indicando a prioridade de arquivos locais para esta tarefa e, só em caso de não achar o nome
em um dos arquivos, procurar um DNS configurado em /etc/resolv.conf:
O arquivo /etc/nsswitch.conf não serve apenas para determinar a ordem de busca de nomes
pela rede, ele também busca bibliotecas de consulta de usuários, senhas e grupos do sistema, esta
configuração pode tanto buscar um caminho local como uma autenticação por algum protocolo de rede
de que esteja em outro servidor, como é o caso de uma autenticação feita por um protocolo LDAP.
Com o arquivo /etc/networks acontece o mesmo que com o arquivo /etc/hosts, ele também pode
configurar nomes para redes.

Comandos de consulta de DNS
#host
Consulta o nome ou um IP de um servidor DNS.
Exemplo:
#host brunoodon.com.br
#dig
Consulta parâmetros de configuração de um servidor DNS.
Exemplo:
Consultar servidor www.lpi.org:

#dig lpi.org

#nslookup
Testa a consulta a um determinado nome do domínio e exibe qual servidor DNS foi utilizado na
pesquisa. Com ele o administrador também pode testar a resolução de nomes através de outros
servidores DNS não confugurados no /etc/resolv.conf .
Exemplo:
#nslookup brunoodon.com.br
#nslookup
>server 8.8.8.8
>howtoonline.com.br
#whois
Mostra detalhes de registro do Domínio.
Exemplo:
#whois brunoodon.com.br

SERVIDOR DE LOGS
Tão importante quanto instalar, configurar e incrementar serviços em um host é monitorar os logs
referentes aos eventos acontecidos nele. Também não menos importante que isso tudo está o fato de
que os logs devem ter uma política de rotatividade, para que não cresçam desordenadamente. Todos
esses ítens serão estudados neste capítulo.
Vejamos a lista de principais logs do sistema:
/var/log/messages : é o principal log do sistema, ele registra quase todos os eventos, não
sendo capaz de registrar eventos de autenticação, mudanças de senha e eventos de e-mail.
/var/log/syslog : é um log com a mesma função do /var/log/messages, com o diferencial de
registrar também os eventos na prioridade mais alta possível, ou seja: tudo sobre os eventos cobertos.
/var/log/auth.log : é o único log do sistema que registra detalhes sobre trocas de senha e
autenticação.
/var/log/dmesg : é o log que contém as mensagens produzidas pelo Kernel durante o boot.
/var/log/mail.log : log que registra eventos de servidor de e-mails.
Exemplo de monitoramento de log:
#tail -f /var/log/auth.log
Sucessor do Syslog, o Rsyslog é o servidor responsável por gerenciar os logs do sistema. O

daemon é o rsyslogd .
O arquivo de configuração do Syslog é o /etc/rsyslog.conf. A estrutura dele consiste nos
seguintes campos:
<facilidade>.<prioridade> <arquivo de log>
As principais facilidades são:
syslog : eventos gerais de log.
kern : eventos de Kernel.
auth : eventos de autenticação.
authpriv : eventos de trocas de senha.
security : auth + authpriv.
mail : eventos de servidor de e-mail.
cron : eventos de agendamentos.
lpr : eventos de impressão.
Além de definir qual tipo de evento o log irá registrar, é preciso informar qual nível de informação
será encontrada neste log, para isso existe a prioridade de um log. As prioridades existentes (em ordem)
são:
info : menor prioridade de todas. Registra poucos detalhes sobre um evento.
err : registra apenas em erros.
debug : além de registrar o erro, depura o mesmo.
warn,crit,alert : mensagens de alerta.
emerg : mensagens emergenciais.

Existe também a instrução para que uma determinada facilidade não seja registrada no log, é o
none, como no exemplo do arquivo abaixo em que o log /var/log/syslog está configurado para não
receber eventos de autenticação e de mudanças de senhas através da linha *.*;auth,authpriv.none
-/var/log/syslog (como no arquivo abaixo):
O syslog pode também ser configurado para enviar os logs para outro servidor ao invés de
mantê-los localmente, basta que, no lugar de um arquivo de log esteja a seguinte sintaxe: @<host>.
Rotatividade dos logs

O programa que garante a rotatividade dos logs do sistema é o logrotate, cujo diretório que
contém os arquivos de configuração dos serviços a serem cobertos é /etc/logrotate.d/. Vamos analisar o
arquivos de configuração de rotatividade do log do BIND:
#vim /etc/logrotate.d/bind
Onde:
daily, mounthly ou weekly : são unidades de tempo de rotação.
compress : significa que o log vai ser compactado um novo vazio será criado a cada unidade de
tempo dessa.
delaycompress : mantém mais uma cópia do log além do log compactado com nome de
<log>.0.
rotate : a quantidade de logs que ele vai manter.
missingok : caso o log não exista, nenhum aviso será gerado para o administrador, é o oposto
de nomissingok.
create : Cria um novo arquivo de log sem sobrescrever o antigo.

sharedscripts : habilita o uso de scripts. Geralmente é utilizado para recarregar o daemon após
o rotacionamento.
postrotate : executar script após rotacionar.
#logger
O comando logger tem a função de enviar saídas de comandos para logs.
Sintaxe:
#logger ”mensagem” opções
Opções:
-s : envia mensagem também para STDOUT.
-p ; especifica a prioridade para a mansagem.
-i : mostra o PID do evento criado.
-f : ao invés de enviar uma mensagem, envia o conteúdo de um arquivo.
Exemplo:
Enviar o conteúdo do arquivo /proc/swaps para os arquivos de log com prioridade warn:
#logger -f /proc/swaps -s -p warn
Um dos logs que atende na prioridade warn foi verificado em suas últimas 2 linhas para verificar
se o comando funcionou.

SUPERSERVIDORES
Os Superdaemons, como são tecnicamente chamados, existem para que vários serviços
possam ser gerenciados através de apenas um daemon, porém, nem todo serviço pode ser incluído em
um Superdaemon.
Inetd
O Inetd é o Superservidor nativo do Linux. Ele proporciona a vantagem de o serviço apenas ser
alocado em memória quando for solicitado. Sua configuração é feita dentro do arquivo /etc/inetd.conf. A
sintaxe do arquivo em questão é:
<nome do serviço> <socket utilizado> <protocolo> <opção> <usuário> <localização dos
daemons necessários>
Xinetd
Este é a evolução do Inetd, possui mais recursos de controle que o anterior e as sintaxes de seus
arquivos de configuração são totalmente diferentes. Seu arquivo de configuração é o /etc/xinetd.conf,
mas ele permite que arquivos de configuração independentes dentro de /etc/xinetd.d gerenciem os
serviços. Vamos ver um exemplo de configuração do arquivo /etc/xintetd.conf:
Entendendo os campos do arquivo:

service : nome do seviço em /etc/services.
disable : configura se o serviço vai ser desabilitado no ato da inicialização do Superdaemon. É o
oposto de enable, ou seja: enable = yes equivale a disable = no.
id : é um nome de identificação do serviço. É muito útil para casos em que o mesmo serviço
possui duas configurações: uma para TCP e outra para UDP, como no caso acima.
socket_type : tipo de socket a ser utilizado.
protocol : tipo de protocolo a ser utilizado.
user : usuário que controla o daemon.
wait : é o oposto de nowait, seguindo o mesmo conceito deste campo do servidor Inetd.
nowait=yes equivale a wait=no.

TCP WRAPPERS
O TCP Wrappers existe para configurar filtros de acesso de entrada de pacotes que usam o
protocolo TCP e fazer com que essa configuração possa ser a mais simples possível, tanto que a
configuração do daemon tcpd pode feita com a configuração de apenas 2 arquivos:
/etc/hosts.deny
Este é o arquivo de configuração de negação de acesso à entrada de pacotes dos seviços e
hosts especificados. Sua sintaxe de configuração funciona da seguinte forma:
<serviço>: <hosts>
Onde a configuração desses campos com as opções ALL: PARANOID fará com que o sevidor
não aceite nenhum tipo de conexão TCP onde o nome do servidor não confira com o seu IP e ALL: ALL
fará o bloqueio total de todos os serviços para todos os hosts. Para adicionar alguma execeção de
acesso para o campo de serviços basta escolher a regra EXCEPT, como no exemplo abaixo:
ALL EXCEPT sshd: 10.12.1.150
Neste caso acima, todos os seviços TCP, exceto o sshd (sevidor ssh), serão negados quando
vindos do host 10.12.1.150.
/etc/hosts.allow
Este arquivo só tem razão de estar com alguma configuração válida caso exista alguma negação
feita em /etc/hosts.deny, pois o /etc/hots.allow é a lista de exceção de bloqueios de pacotes TCP de
entrada no servidor.

SSH
O Secure Shell, como o próprio nome já diz, é o shell que proporciona um nível alto de
segurança para clientes e servidores em acessos remotos. Ele usa para conexão um terminal
/dev/pts/<num>, mesmo tipo de terminal utilizado para emuladores de terminal de interface gráfica, como
o xterm. Algumas partes deste serviço, que trabalha com os protocolos TCP e UDP, serão estudadas
neste material:
ssh : cliente de acesso remoto.
ssh-keygen : criador de chave de criptografia.
scp : aplicação de cópias remotas via SSH.
Os arquivos de configuração do serviço são /etc/ssh/ssh_config para o cliente SSH e

/etc/ssh/sshd_config para o servidor SSHD.
Comandos
#ssh
Acessa um host através do serviço SSH.
Sintaxe:
#ssh <host>
Exemplo:
Acessando o host 10.4.1.1:

#ssh 10.4.1.1
#ssh-keygen
Gera chaves com criptografia RSA ou DSA para autenticação de usuários em um servidor. Com
a execução deste comando, são criados 2 arquivos: id_<tipo> e id_<tipo>.pub, o primeiro de chave
privada e o segundo de chave pública.
Exemplos:
Criando chaves com algotítmo de criptografia RSA:

#ssh-keygen -t rsa
Criando chaves com algorítmo de criptografia DSA:

#ssh-keygen -t dsa
Para fazer uso da chave pública, é preciso que ela seja copiada para dentro do arquivo
~/.ssh/authorized_keys do usuário que se quer utilizar a chave, no servidor. Para tal, podemos utilizar a
seguinte linha de comando:
#ssh-copy-id -i <arquivo de chave> <usuário>@<host>:
Exemplo:
Copiando a chave pública para o servidor 10.5.1.150 para o login do usuário operador:
#ssh-copy-id -i ~/.ssh/id_rsa.pub operador@10.5.1.150:
#scp
Faz cópia de arquivos e diretórios pela rede via SSH.
Sintaxe:
#scp <opções> <origem> <destino>

Opções:
-r : modo recursivo.
-C: ativa a compactação do conteúdo durante a cópia.
Exemplos:
Copiando o arquivo backup.tgz para o diretório /tmp do host 10.0.2.2 usando para este cópia o
login do usuário user1:
#scp backup.tgz user1@10.0.2.2:/tmp
Copiando o diretório /dados do servidor 10.0.2.2 para o diretório local /root usando o login do
usuário user1:
#scp -r user1@10.0.2.2:/dados /root

SINCRONIZAÇÃO DE DATA E HORA
O Network Time Protocol é o seviço responsável por manter a data e a hora do sevidor
sincronizadas com servidores mundiais. A lista de servidores NTP está em www.pool.ntp.org.
O arquivo de configuração do cliente NTP é o /etc/ntp.conf.
Na seção server é definido qual vai ser o servidor NTP a ser utilizado para a sincronização de
data e hora, neste caso o servidor é ntp.ubuntu.com, mas o administrador pode recorrer a sevidores NTP
de qualquer parte do mundo. A seção statsdir configura um diretório onde serão armazenados os
arquivos de estatísticas de uso do servidor (logs), mais abaixo, statistics está configurando os tipos de
estatísticas que serão armazenadas nos logs. A seção driftfile aponta para o arquivo que vai servir
como indicador de oscilação do relógio local: o arquivo /var/lib/ntp/ntp.drift.
Além do ntpd, deamon do NTP, o cliente ntpdate pode ser utilizado para sincronismo de data e
hora com servidores NTP, a única providência que deve ser tomada antes é para o serviço do NTP, pois
não podem haver dois serviços de sincronização de data e hora funcionando ao mesmo tempo no
servidor.
#invoke-rc.d ntp stop
Sincronizando data e hora com o servidor ntp.ubuntu.com:
#ntpdate ntp.ubuntu.com
Importante também para a manutenção de data e hora corretas no servidor é configurar

corretamente o timezone do mesmo, para que ele possa ter e hora conforme o seu fuso horário, pois um
servidor em Buenos Aires nunca pode ter a mesma hora que um na África do Sul. O servidor NTP
sempre vai enviar para os clientes a informação do UTC (Tempo Univeral Coordenado), este informação
será cruzada com o timezone do cliente e aí este saberá quantas horas a mais ou a menos serão
necessárias para se chagar à hora relativa ao seu fuso horário. A modificação do timezone pode ser
feita no arquivo /etc/timezone, veja um exemplo de um:
Para modificar o timezone, o administrador pode editar o arquivo /etc/timezone ou utlilzar os

programas tzconfig e tzselect, ou ainda (para o Debian) dpkg-reconfigure tzdata.
#tzselect

#dpkg-reconfigure tzdata
#hwclock
Sincroniza data e hora do Hardware com o sistema e vice-versa.
Opções:
--hctosys : toma como referência a data e hora do BIOS para acertar a data e hora do sistema.
--systohc : toma como referência a data e hora do sistema para acertar a data e hora do BIOS.

SERVIDOR X
As distribuições open-source têm cada vez mais desenvolvido sistemas operacionais para
usuário final (desktops) de alto nível por todo o mundo, mas, muito antes de isso tudo acontecer, já
existiam esforços para desenvolver plataformas gráficas que fossem beneficiar tanto clientes como
servidores, visto que aplicações gráficas para servidores são cada vez mais comuns hoje em dia, um
grande exemplo é o Wireshark (antigo Ethereal), que é uma ferramenta muito útil como analisador de
rede para administradores.
A plataforma gráfica disponível para distros Linux é o Servidor X (ou Xorg), ela suporta as
aplicações gráficas disponíveis para Linux, como gerenciadores de desktop, gerenciadores de logins,
jogos, aplicações de escritório e editores de imagens.
O Xorg é totalmente free e também segue as regras de licenciamento da GPL, podendo o
administrador instalá-lo na distro que quiser.
Assim que o servidor X é instalado, é importante verificar e modificar (se este for o caso) o seu
arquivo de configuração, que é o /etc/X11/XF86Config ou, em algumas distros (como o Debian),
/etc/X11/xorg.conf. Este arquivo é dividido em seções e sub-seções, vejamos algumas seções dele:
“InputDevice”
Esta seção é responsável pela configuração de opções de teclado, como layout, idioma e driver
e também de configuração de mouse.
“Files”
Configura o local onde estão armazenadas as fontes do servidor X. O local padrão é
/usr/share/fonts.
“Device”
Configura opções da placa de vídeo, como driver e o nome do fabricante também.
“Monitor”
Opções de monitor, como frequências horizontal e vertical, modelo e fabricante.
“Screen”
Esta seção se refere à configuração da visualização da interface gráfica. É, por exemplo, nesta
seção que as resoluções de vídeo podem ser configuradas através da SubSection “Display”, como no
exemplo abaixo:
É uma prática muito comum, para que o usuário possa fazer uso do melhor de seu Hardware nas
aplicações gráficas, a geração de um novo arquivo xorg.conf, isto pode ser providenciado pela linha de
comando X -configure -a, este comando vai gerar um arquivo ~/xorg.conf.new, que vai conter as
configurações atualizadas de Hardware e deve ser copiado para o diretório /etc/X11, depois de ser feito
um backup do arquivo original, é claro.
O maior benefício de criar um novo arquivo de configuração, sem dúvida, é o reconhecimento do

driver de vídeo original, o que habilita o uso de todos os recursos gráficos do adaptador de vídeo.

A variável DISPLAY
Com certeza, parte integrante de alta importância do servidor X é a definição do valor da variável
DISPLAY. Esta variável é responsável por direcionar aplicações gráficas para o display correto e é muito
comum de ela ser personalizada em caso de vários monitores serem utilizados, neste caso, a variável
display pode definir para qual deles a aplicação gráfica será enviada. Em caso de programas de acesso
remoto, como VNC, por exemplo, utilizarem o acesso assistido à interface gráfica, é preciso que o cliente
determine qual display ele vai acessar. Vamos à sintaxe dessa variável:
DISPLAY=<host>:<display>.<tela>
Onde, para enviar o wireshark para o primeiro “screen” do segundo monitor do host brunoodon,
deve-se utilizar a seguinte linha de comando:
#export DISPLAY=brunoodon:1.0 && wireshark
O host padrão é o localhost e o uso de ‘:’ é obrigatório nesta variável, portanto, se o que o
usuário quer é enviar o resultado das requisições gráficas para o display e tela padrão do mesmo host,
basta atribuir valor :0.0 à variável da seguinte forma:
#export DISPLAY=:0.0
Gerenciadores de Desktop
Assim que o Xorg é instalado, para acessar uma sessão gráfica é preciso utilizar o seguinte
comando:
#startx
Ao iniciar uma sessão gráfica apenas com o xorg instalado, o usuário vai contar apenas com um
terminal para que ele possa, por ele, executar aplicações gráficas. Isso com certeza não atende as
necessidades de um usuário final, é necessário que o Xorg também possar contar com um gerenciador
de desktop, pois este gerenciador vai ser o responsável pelos menus, janelas, temas e efeitos de
interface gráfica. Os sistemas Linux contam com uma grande variedade de gerenciadores de desktop
disponíveis para a instalação, alguns exemplos são:
GNOME
KDE
XFCE4
LXDE
BLACKBOX
FLUXBOX
OPENBOX
AFTERSTEP
É possível determinar qual vai ser o gerenciador de desktop padrão do usuário criando o arquivo
~/.xinitrc ou ~/.xsession, que deverá ter como conteúdo a expressão exec <sessão do desktop
manager>. Desta forma, se o usuário user1 quiser utilizar o gnome, ele deve configurar este arquivo
(com qualquer um dos nomes acima) da seguinte forma:
#vim ~/.xsession
exec openbox
No caso acima, o gerenciador de desktops OpenBox será iniciado cada vez que o usuário
executar o script startx ou fizer logon no gerenciador de login escolhido. Como a maioria das distros
conta com a possibilidade de instalação de vários gerenciadores de desktop, este recurso pode ser
utilizado para que cada usuário trabalhe com o gerenciador que quiser.

Gerenciadores de login
Até agora percebemos que Servidor X e gerenciador de desktop são duas coisas totalmente
diferentes, a pesar de o segundo depender da existência do primeiro para funcionar, mas em caso de o
sistema precisar iniciar já em uma interface gráfica direto sem a necessidade de executar o programa
startx, como pode ser feito? É aí que entram os gerenciadores de login, eles atuam como serviços do
processo INIT e, portanto, podem ser ativados logo após o boot do sistema. Um gerenciador de login
autentica o usuário para que possa ser iniciada uma sessão por ele. É expressamente não recomendável
o login com usuário root na interface gráfica e, por este motivo, a maioria dos gerenciadores de login vem
com o login pelo root desabilitado.
A troca do gerenciador de login padrão pode ocorrer manualmente pelo arquivo ou também pode
ser feita pela linha de comando abaixo:
#dpkg-reconfigure gdm (ou kdm ou xdm)
Se o sistema tem algum gerenciador de login mas o administrador não quer que o sistema
inicialize por ele, é só remover os links simbólicos do GDM/KDM/XDM de dentro dos diretórios
/etc/rc<runlevel>.d, o método mais fácil de se fazer isso seria:
#update-rc.d -f gdm remove
Desta forma, o GDM fica ainda instalado, porém não é carregado pelo processo INIT.
XDM
O XDM é o gerenciador de login padrão para distros Linux, ele vem com um conjunto
interessante de de arquivos de configuração que vão incrementar o uso do servidor X.
Outra característica interessante deste gerenciador de login é que ele trabalha nativamente com
o protocolo XDMCP, este protocolo possibilita conexões remotas de hosts da rede em um servidor X
qualquer. Conexões remotas feitas por SSH podem ser redirecionadas para o servidor X através deste
protocolo, mas para que isso aconteça é preciso configurar o servidor SSH para aceitar
redirecionamento para servidor X em seu arquivo de configuração /etc/ssh/sshd_config. É possível
também que um usuário remoto envie uma aplicação gráfica para o display de um servidor
Os arquivos de configuração deste serviço, assim que ele for instalado, serão copiados para
/etc/X11/xdm. Os arquivos mais importantes são:
Xresources : este arquivo configura parâmetros de aparência do gerenciador de login.
Xsession : define qual gerenciador de janelas vai ser ativado após a autenticação pelo XDM,
este script só deve ser utilizado caso o servidor X conte com mais de um gerenciador de janelas e o
administrador queira definir um window manager padrão para todos os usuários, caso contrário, o
arquivo .xsession deve ser criado dentro do diretório home do usuário contendo o seu gerenciador de
janelas (o ~/.xinitrc terá o mesmo efeito .
Xaccess: define conexões recebidas de hosts ao servidor X.
Xservers : faz o controle e a associação de displays a hosts específicos. Para acessos via
SSH, a opção “-nolisten tcp” não deve ser removida, pois o SSH não usa o protocolo TCP para
direcionar conexões ao servidor X.
xdm-config : arquivo de configuração de arquivos e programas utilizados palo XDM para
interação com o usuário, como por exemplo, o arquivo de log de erro de login e o arquivo de pid do
processo.

SERVIÇO DE IMPRESSÃO
O servidor padrão para impressão em distros Linux ou Unix é o CUPS (Common Unix Print
Server). Ele usa o serviço IPP (Internet Print Protocol), na porta 631 TCP/UDP para conexões. O pacote
de instalação do CUPS é o cupsys e os pacotes foomatic-* são importantes nesta composição, pois
trazem alguns programas que vão facilitar a administração do servidor.
Os drivers para impressoras no CUPS têm extensão .PPD e praticamente todos os fabricantes
já contam com drivers de suas impressoras também na versão Linux (o servidorjá vem com muitos deles
em modo nativo).
É possível também que usuário do Windows utilizem impressoras compartilhadas pelo CUPS, o
que torna o servidor multi-plataforma.
Vamos à implementação:
#apt-get install cupsys foomatic-* -y
Após a instalação, é preciso incluir as impressoras no arquivo /etc/cups/printers.conf, este
procedimento pode ser feito através do assistente, que pode ser acessado por qualquer Web Browser
através do endereço http://localhost:631 (a interface lo deve estar ativa).
Algumas opções ao lado podem ser utilizadas também, como compartilhamento de todas as
impressoras criadas pelo host, administração remota, aceitar impressão pela rede, usar autenticação
Kerberos, etc. O arquivo de configuração do CUPS é o /etc/cups/cupsd.conf.
Vamos ter uma visão geral do arquivo /etc/cups/printers.conf:
No exemplo do arquivo acima, o nome da impressora é IMPRESSORA_LINUX e ela pode ser

encontrada na URI ipp://10.12.1.1/LINUX_PRINTER, na linha 16, a expressão Shared Yes indica que
ela está compartilhada na rede, o que proporciona aos clientes Linux o mapeamento automático da
impressora, sem precisar de intervenção manual. Este arquivo proporciona ainda a limitação de
impressão por páginas, por tamanho e por tempo.
Comandos de impressão
Linux BSD Apliacação

lp lpr Imprime um arquivo em uma impressora
lpstat lpq Mostra a fila de impressão de uma impressora
cancel lprm Exclui um trabalho da fila de impressão
Exemplos:
Imprimindo o arquivo /etc/passwd na impressora IMPRESSORA_LINUX:
#lp /etc/passwd -d IMPRESSORA_LINUX
Verificando a fila:
#lpstat
Excluindo o job nº1:

#cancel 1

LINGUAGEM SQL
Esta é uma das linguagens de manipulação de bancos de dados mais populares do mundo e
conta com uma sintaxe simples para qualquer um programador que queira se aventurar. O banco de
dados que vamos utilizar é o MYSQL-SERVER, mas o Debian também conta em seus repositórios com o
PostgreeSQL, que também é um ótimo banco de dados. Vamos à instalação do MySQL:
#apt-get install mysql-server -y
Para acessar o servidor MySQL, é preciso utilizar o comando mysql, especificando qual usuário
vai acessar com o parâmetro -u e pedindo senha com o parâmetro -p (para sessões autenticadas) :
#mysql -u root -p
Após este comando, um prompt de comandos do servidor MySQL vai ser disponibilizado para
que o usuário possa digitar os comandos:
mysql>
Toda linha de comando que for digitada neste prompt deve ser finalizada apenas quando o ‘;’ for
digitado ao fim do mesmo.
Comandos SQL
O SQL é case insensitive, ou seja: não faz diferença alguma digitar os comandos em caixa alta
ou baixa. Vamos aos comandos:
SHOW DATABASES
Exibe os bancos de dados existentes.
CREATE DATABASE <NOME>

Cria um banco de dados
DROP DATABASE <NOME>

Remove um banco de dados.
USE <BANCO>
Acessa um banco de dados.
CREATE TABLE <NOME> (<CAMPO1> <TIPO>, <CAMPO2> <TIPO>)

Cria uma tabela dentro de um banco de dados.
SHOW TABLES
Exibe todas as tabelas de um banco.
DROP TABLE <NOME>

Remove uma tabela existente.
DESCRIBE <TABELA>
Descreve os tipos de campos de uma tabela.
INSERT INTO <TABELA> (<CAMPO1>, <CAMPO2>) VALUES (<VALOR1>, <VALOR2>)

Insere registros em uma tabela especificando campos específicos.
SELECT <CAMPOS> FROM <TABELA> WHERE <CONDIÇÂO>

Seleciona campos de uma tabela específica onde os registros atendam à condição imposta pelo
WHERE. O WHERE não será necessário se o caso for exibir todos os registros da tabela.
UPDATE <TABELA> SET <RELAÇÂO CAMPO/VALOR> WHERE <CONDIÇÂO>

Atualiza campos de uma tabela que se encaixem nas condições impostas pelo WHERE. Neste
caso, o WHERE também não vai ser necessário se o programador quiser atualizar todos os campos da
tabela.
DELETE FROM <TABELA> WHERE <CONDIÇÂO>

Apaga registros de uma tabela segundo uma condição imposta pelo WHERE. Se o programador
for excluir todos os registros, basta não especificar condição alguma.
Exemplos:
Acessar o MySQL e criar o banco de dados LPI:

#mysql -u root -p
mysql>CREATE DATABASE LPI;
Acessar o banco LPI e criar uma tabela chamada LPI101:

mysql>USE LPI;
mysql>CREATE TABLE LPI101 (id INTEGER AUTO_INCREMENT NOT NULL PRIMARY
KEY, nome VARCHAR(40), nota NUMERIC);
Descrever os campos da tabela LPI101:

mysql>DESCRIBE LPI101;
No caso acima, a tabela LPI101 tem como chave primária o campo id, que é também de
preenchimento automático e um número inteiro, ou seja: este campo não precisará ser preenchido.
Quanto ao campo nome, o tipo VARCHAR significa que ele é um campo de, no máximo 255 caracteres.
Inserindo valores nos campos nome e NOTA da tabela LPI101 e selecionando de todos os
campos apenas o valor que for maior que 500:
mysql>INSERT INTO LPI101 (nome, NOTA) VALUES (‘Linus Torvalds’, ‘800’);
mysql>INSERT INTO LPI101 (nome, NOTA) VALUES (‘Goonie’, ‘450’);
mysql>SELECT * FROM WHERE NOTA >= 500;
Acrescentar 50 pontos aos candidatos que tiverem nota menor que 500:
mysql>UPDATE LPI101 SET NOTA = NOTA+50 WHERE NOTA < 500;
mysql>SELECT * FROM LPI101;
Excluir registros da tabela LPI101 que tenham nota menor que 600:
mysql>DELETE FROM LPI101 WHERE NOTA < 600;
mysql>SELECT * FROM LPI101;
É importante que o administrador saiba que o diretório onde ficam localizados os bancos de
dados do servidor MySQL-Server é o /var/lib/mysql e é importantíssimo que haja políticas de backup e
arranjos de discos que possibilitem disponibilidade e flexibilidade aos bancos.

MTA
Um Message Transmition Agent tem a incumbência de enviar mensagens de correio
eletrônico, bem como garantir que elas cheguem ao destinatário e, para tal tarefa, utiliza o protocolo
SMTP, cuja porta é 25 e, por ter que garantir a entrega de mensagens, só trabalha com o protocolo TCP.
Caso uma mensagem não possa ser enviada por algum motivo, ela será enviada para a fila de e-mails e,
assim que for resolvido o problema, será re-enviada. Também há casos em que o SMTP utiliza a porta
465, isto acontece por causa do incremento do SSL neste protocolo, para dar mais segurança à
conexão. Existem vários MTAs disponíveis em ambiente open-source mas alguns se destacam, como
Exim4, Postfix, Sendmail e Qmail. Com certeza, o mais utilizado dos 4 é o Postfix, pela baixa
complexidade dos arquivos de configuração e constante evolução com o passar do tempo.
Um serviço de e-mail completo possui três agentes: MTA, MDA e MUA e vamos tratar aqui
também, de forma introdutória, os outros 2 não mencionados:
Message Delivery Agent é o responsável por receber os e-mails e os encaminhar aos
diretórios corretos. Os protocolos que trabalham para que esta função seja possível são POP3 e IMAP,
nas portas 110 e 143, respectivamente. O MDA também é responsável por autenticar o usuário, assim
como o SMTP faz se for solicitado. A destacar como servidores MDA, o Sendmail, o Dovecot e o Postfix.
Message User Agent é a parte cliente da história toda, ou seja: a ferramenta utilizada para
leitura e envio de e-mails por parte dos usuários. Este componente de serviço de e-mails pode ser um
Web Mail ou um cliente de e-mails como Thunderbird e Evolution, por exemplo.
Sendmail
Um dos mais antigos MTAs do mundo open-source, o Sendmail tem como arquivo de
configuração o /etc/mail/sendmail.cf, que é um tanto quanto hostil a qualquer administrador que não tem
o conhecimento do mesmo. Com certeza um legado muito bom do Sendmail é o arquivo /etc/aliases, que
funciona como um mapeamento de diversos endereços para um “alias”, podendo servir para a criação
de um novo grupo de distribuição de mensagens como também servir para que um usuário ao invés de
receber mensagens, ele seja apenas um alias para o usuário administrador.
Quando um novo alias é criado, não há nenhuma necessidade de o daemon do MTA ser
reiniciado ou seu arquivo de configuração ser carregado novamente, basta que o comando newaliases
seja executado.
*Obs: A linha de comando sendmail -bi também reinicia um banco de dados de aliases, assim
como o comando newalises.
Postfix
Um dos mais respeitados servidores de e-mail é também o de mais fácil compreensão para o
administrador. Seu arquivo de configuração é o /etc/postfix/main.cf.
O arquivo de configuração do Postfix possui algumas variáveis que ajudam a entender o

funcionamento do mesmo:
myhostname : nome do host de do servidor, no caso do arquivo acima, ele é o hostname do
sevidor mas na maioria dos casos, este campo recebe o nome de domínio designado pelo servidor DNS.
mydestination : locais para onde as mensagens podem ser enviadas.
relayhost : este campo é de extrema importância pois ele configura quais hosts pode enviar e-
mails através dele, possibilitando assim o uso de clientes SMTP.
alias_database : configura qual o banco de dados de aliases, geralmente o postfix usa o
/etc/aliases.
mynetworks : área de atuação do servidor. Caso o localhost não seja um componente desta
variável, o servidor não será capaz de enviar e-mails para o localhost.
No ato da instalação do postfix o administrador vai se deparar com uma pergunta bem
interessante:

É importante que o smarthost esteja ativado, pois este tipo de host inteligente permite que o
MTA não precise de um DNS para servir como origem de e-mails, podendo ser o próprio hostname do
servidor o nome do host de origem para a mensagem.
O diretório padrão de recebimento de e-mails comum a todos os usuários é o /var/mail, onde as
mensagens serão encontradas em modo de arquivos com os nomes dos usuários destinatários.
O arquivo ~/.forward
Este arquivo, que deverá estar dentro do diretório pessoal do usuário, pode conter uma lista de
endereços para onde todo e-mail enviado pelo usuário vai ser redirecionado. Esta medida é bem comum
em servidores de e-mail onde os e-mails dos usuários precisam ser monitorados por pessoas de outros
departamentos.
Comandos de MTA
#mail
Envia e-mais em linha de comando.
Opções:
-s : “subject” - é o assunto do e-mail.
-c : com cópia.
-b : “blind copy” - cópia oculta.
No caso do comando mail, tanto uma mensagem quanto um conteúdo de um arquivo podem ser
enviados por e-mail. Seguem os exemplos:
Neste caso acima, o e-mail vai ser enviado para aluno@brunoodon.com.br, com cópia para
bruno@brunoodon.com.br e o corpo da mensagem vai ser o texto MTA sendmail. O fim da mensagem é
marcado pelo ‘.’ (ponto) na última linha.
Neste caso acima, uma das grandes utilidades deste comando: o envio de conteúdo de arquivos
de texto por e-mail, o que pode facilitar muito a criação de rotinas que possam disparar e-mails em caso
de situações adversas para o servidor, como alguns usuários estourando as suas cotas de
armazenamento.
#mailq
Consulta a fila de e-mails do MTA. O uso deste comando é o mesmo que o uso da linha de
comando sendmail -bp.

LPIC1 - Guia de Estudo PDF

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

LPIC1 - Guia de Estudo PDF

Enviado por

Direitos autorais:

Formatos disponíveis

ÍNDICE

Guia de Estudo para LPIC1 - Bruno Odon - howtoonline.com.br 1

Guia de Estudo para LPIC1 - Bruno Odon - howtoonline.com.br 2

Guia de Estudo para LPIC1 - Bruno Odon - howtoonline.com.br 3

O Linux Professional Institute , com sede em Ontário (Canadá), tem a

✔ A prova é composta de questões de múltipla escolha e também de discursivas (geralmente

✔ O aluno tem 90 minutos para a conclusão da prova;

Passos para certificar-se

Guia de Estudo para LPIC1 - Bruno Odon - howtoonline.com.br 4

Este projeto surgiu em 1983 (criado por Richard

Execução do software(liberdade nº 0);

Open Source x Free

Guia de Estudo para LPIC1 - Bruno Odon - howtoonline.com.br 5

O Ubuntu há muito tempo já conquistou a confiança de usuários e empresas

Guia de Estudo para LPIC1 - Bruno Odon - howtoonline.com.br 6

O Debian já é um sistema operacional muito mais focado em

Guia de Estudo para LPIC1 - Bruno Odon - howtoonline.com.br 7

Um kernel pode ser classificado de 2 formas:

Monolítico: carrega todos os recursos de que precisa na

Guia de Estudo para LPIC1 - Bruno Odon - howtoonline.com.br 8

Um terminal nada mais é do que a interface de interação entre o sistema operacional e o

/dev/tty1 Modo de comandos CTRL+ALT+F1

/dev/tty2 Modo de comandos CTRL+ALT+F2

/dev/tty3 Modo de comandos CTRL+ALT+F3

/dev/tty4 Modo de comandos CTRL+ALT+F4

/dev/tty5 Modo de comandos CTRL+ALT+F5

/dev/tty6 Modo de comandos CTRL+ALT+F6

/dev/tty7 Interface Gráfica CTRL+ALT+F7

Guia de Estudo para LPIC1 - Bruno Odon - howtoonline.com.br 9

/etc/securetty : é o arquivo onde se encontram todos os terminais suportados pela distribuição.

PROGRAMAS E COMANDO BÁSICOS

Guia de Estudo para LPIC1 - Bruno Odon - howtoonline.com.br 10

As outras colunas são:

Guia de Estudo para LPIC1 - Bruno Odon - howtoonline.com.br 11

Criando os diretótios linux/debian/ubuntu de uma só vez e exibindo a saída do comando:

Guia de Estudo para LPIC1 - Bruno Odon - howtoonline.com.br 12

#cp -vp /etc/network/* /tmp

Apenas copia o arquivo /etc/passwd se houver alguma modificação do original em relação ao

Guia de Estudo para LPIC1 - Bruno Odon - howtoonline.com.br 13

Exibindo o espaço ocupado pela partição /dev/sda5, que está montada:

Mostrando informações sobre a reserva de inodes da partição montada /dev/sda5:

Guia de Estudo para LPIC1 - Bruno Odon - howtoonline.com.br 14

Modifica a data para 27/07/2016 e hora para 08:31.

3 Formas diferentes de representação de data:

Guia de Estudo para LPIC1 - Bruno Odon - howtoonline.com.br 15

Exibindo o tamanho total de memória ocupado em MB:

Exibindo em tempo real (executando o comando de 1 em 1 segundo) o uso de RAM + Swap:

Agenda desligamento do sistema para 23:30.

Simula desligamento imediato enviando mensagem para os terminais ativos:

Guia de Estudo para LPIC1 - Bruno Odon - howtoonline.com.br 16

#vim <arquivo> – edita arquivo.

Opções internas do editor:

<insert> – modo de inserção de texto.

Outro recurso importantíssimo do VIM é a manutenção de um arquivo de backup para cada

Guia de Estudo para LPIC1 - Bruno Odon - howtoonline.com.br 17

Guia de Estudo para LPIC1 - Bruno Odon - howtoonline.com.br 18

/dev/hda – Primary Master.

NOTA: o conceito de Primário, Secundário, Mestre ou Escravo é genérico para qualquer

Guia de Estudo para LPIC1 - Bruno Odon - howtoonline.com.br 19

De 1 a 4 : simbolizam partições primárias ou extendidas.

No caso acima, vamos analisar a tabela de particionamento de /dev/sda:

Guia de Estudo para LPIC1 - Bruno Odon - howtoonline.com.br 20

O Filesystem Hierarchy Standard (Padrão Hierárquico de Sistema de Arquivos) é mantido pela