Documente Academic
Documente Profesional
Documente Cultură
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
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
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.
Antes de começar a administrar sistemas operacionais Linux, é preciso ter alguns conceitos bem
fundamentados:
O projeto 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:
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.
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 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.
Como desktop manager, o Ubuntu utiliza o Unity, que traz um layout que favorece o uso do
sistema por dipositivos com touch screen.
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 é 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.
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.
Exemplos:
/dev/pts/0 – um terminal emulado por xterm.
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 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.
#file
Mostra qual o tipo de arquivo em questão.
Sintaxe:
#file <objeto>
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 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}
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:
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:
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:
Sintaxe:
#free <opçoes>
Opções:
-k : em KB.
-m : em MB.
-g : em GB.
-t : exibe RAM+Swap.
Exemplos:
*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
Editor de texto sucessor do VI, que possui compatibilidade com qualquer sistema Linux.
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.
#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
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:
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.
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:
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
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 projeto inicial foi aproveitado porém personalizado pela maioria das distros, a maioria delas
aproveita o formato original do FHS em 80%.
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.
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:
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.
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.
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.
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>
Exemplo:
#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
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>
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>
Exemplos:
#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:
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.
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).
Conferindo a conectividade:
#ifconfig
#ping 10.23.1.1
Conferindo rotas:
#route -n
Configurando DNS:
#vim /etc/resolv.conf
nameserver <ip do servidor>
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
/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.
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
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
2 Chamadas de sistema
3 Chamadas de bibliotecas
5 Arquivos de configuração
6 Games
7 Miscelânea
8 Comandos de root.
#<comando> --help
Exibe informações reduzidas sobre opções de comando, geralmente.
Exemplo:
#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 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.
#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>
Sintaxe:
#head <opção> <arquivo>
Opções:
-c : mostra os primeiros bytes de um arquivo.
-n : especifica o número de linhas.
Exemplos:
#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:
#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>
Sintaxe:
#wc <opções> <arquivo>
Opções:
-l : número de linhas do arquivo.
-w : palavras contidas no arquivo.
-c : quantidade de caracteres.
Exemplo:
#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 linhas que contenham apenas 0 como valor absoluto:
#grep -w 0 /etc/passwd
#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:
#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:
#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:
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:
#<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.
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
Sintaxe:
#diff <arquivo1> <arquivo2>
Exemplo:
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
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”.
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
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:
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
#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.
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
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.
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.
É 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.
#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.
*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:
#addgroup
Também consulta /etc/adduser.conf, mas só que para criar grupos.
Exemplo:
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 :
#chfn
Modifica o campo de descrição do usuário.
Sintaxe:
#chfn <usuário>
Exemplo:
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:
#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:
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:
#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
#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 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
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.
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, 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
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:
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.
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.
Sintaxe:
#fdisk <opções> <disco>
Exemplos:
Particionando /dev/sda:
#fdisk /dev/sdb
#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:
#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:
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:
*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:
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
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
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.
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:
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
É 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
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/sdb2, que é ext3, em /backup como leitura e gravação, sem verbose:
#mount –t ext3 –w /dev/sdb2 /backup
#umount
Desmonta sistemas de arquivos.
Sintaxe:
#umount <opções> <volume/ponto de montagem>
Exemplos:
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.
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:
#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:
#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:
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)
RAID1 (Mirroring)
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.
RAID6
Instalando o programa:
#apt-get install mdadm –y
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).
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.
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.
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
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.
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.
Exemplos:
#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.
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
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:
#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:
Descompactar o arquivo:
#bzip2 –d disco.iso.bz2
ou
#bunzip2 disco.iso.bz2
Testando a integridade do arquivo:
#bzip2 –t disco.iso.bz2
Sintaxe:
#zip <arquivo zip> <origem>
Exemplos:
#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:
Diretórios importantes
#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:
Os formatos de data e hora podem ser diferentes, como nos exemplos abaixo:
#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.
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.
/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
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.
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.
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}
#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:
#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:
#quotaoff
Desativa as cotas em sistemas de arquivos:
Sintaxe:
#quotaoff <opção> <volume>
Exemplos:
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
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.
#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
#kill
Gerencia os processos pelo PID deles.
Sintaxe:
#kill -<sinal> <PID>
Exemplos:
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:
#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:
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
Sintaxe:
#nohup <comando>
Exemplo:
#nice
Executa um processo com prioridade específica.
Sintaxe:
#nice -<Nice Number> <comando>
Exemplos:
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:
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.
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.
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:
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
#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:
#runlevel
Exibe o Runlevel atual do sistema.
#init
Troca o Runlevel do sistema.
Sintaxe:
#init <runlevel>
Exemplo:
SystemD
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
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
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
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.
Instalação
O conceito de instalação é a cópia de binários do um programa para um diretório de instalação.
Para este procedimento, vamos utilizar a versão 2.6.35.4 do Kernel obtida em www.kernel.org.
É 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 [ ].
É 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.
Compilando os módulos:
#make modules
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:
#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:
#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.
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.
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.
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
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
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
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)
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.
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
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
#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:
Aliases
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
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
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.
#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
Para excluir uma variável que foi criada, basta utilizar também o comando unset, como no
exemplo abaixo:
#unset LOGS
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:
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.
#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:
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.
Sintaxe1:
if <condição verdadeira>
then <comandos>
fi
Onde fi finaliza a estrutura.
Sintaxe2:
if <condição verdadeira>
then <comandos>
else <comandos>
fi
Sintaxe3:
if <condição verdadeira>
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.
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.
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 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:
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).
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
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.
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
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
Configuração de rede
No Debian
O arquivo /etc/network/interfaces é o concentrador da configuração de endereço de rede de
todas as interfaces de rede presentes.
#vim /etc/network/interfaces
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.
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:
Repare que o comando ifconfig, sem mais argumentos, é capaz de retornar o endereço MAC da
interface de rede.
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:
#nmap
É um sacanner de portas de um servidor qualquer.
Exemplo:
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
#hostname
Exibe ou modifica temporariamente o hostname do sistema. A modificação definitiva só pode ser
feita em /etc/hostname.
#netstat
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:
Neste exemplo, podemos ver a configuração definitiva de uma interface de rede virtual com o
mesmo endereço:
#vim /etc/network/interfaces
Exemplo:
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.
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
#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:
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:
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.
Exemplos:
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.
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.
#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:
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
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.
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>.
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.
#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.
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:
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.
Comandos
#ssh
Acessa um host através do serviço SSH.
Sintaxe:
#ssh <host>
Exemplo:
#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:
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>
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
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
#tzselect
#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.
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.
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.
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.
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:
Comandos de impressão
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.
USE <BANCO>
Acessa um banco de dados.
SHOW TABLES
Exibe todas as tabelas de um banco.
DESCRIBE <TABELA>
Descreve os tipos de campos de uma tabela.
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.
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 ~/.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.