Na falta de um roadmap formal, apontamos quatro incrementos que você pode esperar ver no sistema este ano, já em discussão na comunidade de desenvolvedores.

O último ano foi muito emocionante para o Linux. O que começou como passatempo, na Finlândia, completou 20 anos e dominou quase tudo, desde dispositivos móveis a supercomputadores.  E tudo leva a crer que 2012 ainda será um ano interessante para o sistema operacional.

O Linux não chega a ter um roadmap. O desenvolvimento é resultado da colaboração entre centenas de desenvolvedores de muitas empresas. Não existe ninguém elaborando uma lista de recursos a serem adicionados e direcionando desenvolvedores a trabalharem nela, ou em melhorias no kernel. Mas se você prestar atenção nas discussões da comunidade Linux, poderá ter uma ideia razoavelmente boa do que vai acontecer no futuro próximo.

Aqui estão algumas coisas que você pode esperar ver no Linux em 2012.

1 – Melhorias no Btrfs

Uma das grandes contribuições da Oracle para o kernel do Linux é o Btrfs, o sistema de arquivos que adiciona muitas características que as empresas gostariam de ver no OS. Por exemplo, o Btrfs suporta uma série de recursos e benefícios ausentes em outros sistemas para Linux, como pooling, instantâneos de estado do disco, soma de verificação, spanning integral de múltiplos dispositivos, uma maior integridade dos dados através da soma de verificação, instantâneos do sistema inteiro de arquivos antes de qualquer grande mudança, melhor gerenciamento de volume e RAID.

No entanto, faltam ao Btrfs algumas características- principalmente, a ferramenta fsck – que muita gente gostaria de ver implementada antes de colocá-lo em produção. A previsão era a de qu a ferramenta fsck estivesse diponível no fim de 2011. É provável que esteja pronta ainda no início de 2012, o que deve acelerar a adoção do Btrfs por algumas das distribuições Linux muito rapidamente.

Se eu tivesse que fazer uma previsão, diria que o Btrfs acabará por suplantar o Ext4 como sistema de arquivos padrão para a maioria das principais distribuições Linux. Mas não espere ver uso generalizado em ambientes de produção antes de meados de 2013.

2 – Android, alinhamento com plataforma ARM e foco nos sistemas embarcados

O Linux em sistemas embarcados vai continuar a ser um dos principais focos em 2012. Isso inclui tudo, desde set-top boxes, o Roku para telefones Android e tablets, e até sistemas para impressoras e qualquer outra coisa que você possa pensar.

Há muito barulho na imprensa especializada em TI sobre o fato do Android ser uma “ramificação” do Linux. Aqui está algo sobre o qual você não deve ter ouvido falar muito a respeito: o pessoal do kernel Linux e o do Android tem trabalhado duro para sincronizar o kernel principal e o kernel do Android.

Com o kernel 3.3, a maioria das funcionalidades do Android deve estar presente no kernel principal. Não tudo, mas progressos estão sendo feitos muito rapidamente. Se tudo correr bem, os usuários devem ser capazes de executar Android em cima de um vanilla kernel (kernel reduzido) até o fim do ano.

Note que este tipo de inclusão assíncrona não é incomum, e não há nenhuma razão para pânico. O Xen esteve fora do kernel padrão durante anos, enquanto sua equipe aprendia a trabalhar com a comunidade responsável pelo kernel (e vice-versa). A Red Hat e outras distribuições de Linux têm incluído patches para recursos ou dispositivos constantemente. É algom comum à plataforma.

Ao mesmo tempo, o pessoal do kernel continua a tentar domar o “oeste selvagem” da arquitetura ARM. Em um dado momento, havia cerca de 70 sub-arquiteturas ARM na árvore do kernel. Compare isso com outras arquiteturas, e você verá um problema aí. A boa notícia é que você também verá um esforço maior este ano para a resolução do problema.

Parte dele é o suporte a longo prazo da árvore do kernel para os fornecedores de eletrônicos de consumo. A Long Term Stable Kernel Initiative (LTSI) é focada na produção de um kernel estável, que estará disponível por aproximadamente a mesma quantidade de tempo de vida da maioria dos dispositivos eletrônicos de consumo (2 a 3 anos). O fato de muitos fornecedores estarem trabalhando juntos em um único núcleo deve fornecer uma série de benefícios.

A Canonical também anunciou na CES que está trabalhando em um Linux para set top boxes e DVRs. Será interessante ver a receptividade dos principais fabricantes desses dispositivos. Sou cético sobre suas chances de sucesso, a menos que consigam emplacar em algum dispositivo de uma grande marca, que o torne atraente para os usuários.

3 – Melhor ajuste e provisionamento

O cgroups é um recurso do Kernel do Linux, desde a versão 2.6.24, que tem como finalidade limitar, contabilizar e isolar o uso de recursos. Continua a evoluir e permitir um controle mais refinado do sistema. Por exemplo, no Linux 3.2 (lançado em 04 de janeiro) temos um novo recurso chamado CPU bandwidth control que permite que os administradores definam quanto tempo de CPU um grupo de processos pode usar.

A versão 3.2 acrescentou também ajustes finos de provisionamento ao Linux Device Mapper, que permite que administradores possam controlar o excesso de oferta de cotas de armazenamento para cada usuário. Isso pode parecer duvidoso, mas se você tiver algumas centenas de usuários em um sistema, será necessário definir um limite superior para a quantidade de armazenamento que poderão usar. Claro que, se configurado corretamente, a maioria dos usuários não se aproximará desse valor. Então você provavelmente não precisará de armazenamento suficiente para dar a cada usuário sua quota máxima.

Você pode esperar ver a melhoria contínua do cgroups e de outras áreas no kernel para permitir que os administradores de TI possam definir limites de recursos e outras formas de afinar seus sistemas ainda mais. As melhorias podem deixar de estar presentes em futuras versões do Linux por alguns ciclos, mas estão a caminho. Suspeito que o SUSE Enterprise Linux será lançado com um kernel 3.0 em 2013.

4 -Crescimento do OpenStack

Finalmente, esperamos ver o OpenStack sendo implantado até o fim de 2012 ou início de 2013. O projeto foi anunciado em 2010 e já atraiu mais de 140 empresas e organizações. É também a pilha de IaaS para o SUSE Linux e o Ubuntu. A partir das minhas conversas com membros da comunidade OpenStack, SUSE e Rackspace, digo, sem medo de errar, que o OpenStack terá um grande impulso em meados do ano.

Basicamente, o Linux vai continuar a melhorar para uso nas empresas e nas plataforma móveis. Com o Kindle Fire e o Nook, da Barnes & Noble, acho que veremos mais e mais tablets Android ganhando mercado. E, a não ser que algo drástico aconteça, o Android continuará a manter uma liderança firme no mercado de telefonia. O único lugar em que o Linux continuará a definhar será no desktop. Mas não se pode ter tudo, certo?

Fonte:

Joe Brockmeier, CIO/EUA

Publicada em 13 de janeiro de 2012

http://cio.uol.com.br/

Hoje em um servidor, seja ele web, de arquivos, ou qualquer outro serviço essencial para o dia-a-dia a ele denominado é primordial que um administrador possua alguma rotina de backup imposta sobre o mesmo.

É fato que esse trabalho é crítico pois no mundo da informação o que não queremos é perde-la, pois se isto acontecer poderá colocar os seus negócios no fio da navalha e certamente cabeças irão rolar. 

É complexo colocar nesta postagem um backup que resolva tudo, mas vou colocar e explicar como executar em um servidor web um backup das contas de usuários de sites hospedados e seus respectivos bancos de dados, ainda duplicando o backup efetuado como segurança para outro servidor. É claro que o conteúdo aqui proposto pode ser adaptado por você para executar rotinas de backup expecíficas.

O arquivo em shell script pode ser obtido neste link: backup-shell.sh (3)

Você pode fazer o download e colocar na “crontab” do seu sistema para que o mesmo efetue o backup na hora que melhor lhe convir.

Funcionamento

No início do arquivo shell script do link citado acima, teremos declarações de variaveis de controle do fluxo do programa.

O que vemos acima são variaveis de controle, como nome de usuário e senha do mysql, nomes de pastas para o armazenamento dos arquivos e diretórios capturados da origem, lista de exclusão de diretórios que não queremos que seja efetuado o backup e lista de servidores que queremos duplicar o backup ocorrido, ainda temos uma lista de e-mail para informar os responsáveis da ação efetuada pelo nosso backup.

Neste trecho é gerado uma lista de todos os bancos de dados existentes no Servidor MySQL excluindo as bases de dados da instalação básica do servidor como “information_schema” e “mysql” utilizando o comando “mysql” para efetuar o login e executar a ação.

Com o comando “mysqldump” efetuamos o backup das bases de dados existentes na lista capturada no comando anterior e salvamos a saida do resultado para um arquivo em disco contendo as informaçãoes como criação da base de dados, tabela e inserções de registros.

Aqui é executado o backup da pasta public_html de cada usuário existente, repare ainda que na sincronia podemos excluir diretórios utilizando a opção –exclude do comando rsync.

Com a lista de servidor(es) efetuamos um loop e sincronizamos os dados do diretório de backup efetuado com o comando anterior.

E por fim geramos um arquivo de log com as informações obtidas de cada comando efetuado no backup e enviamos para a lista de e-mail.

Claro que este backup pode ser melhorado e adaptado para outras situações que fogem do escopo desta postagem. A Idéia aqui é dar uma luz para aqueles que não a possui, espero que tenha ajudado.

Fonte:  http://www.nacaolivre.com.br

Você que tem IP Dinamico e não sabe como fazer para bloquear o acesso ao seu servidor, vai uma dica de regra de IPTables, onde você manipula a liberação de seu acesso com telnet.

Com a grande facilidade de se ter um servidor Cloud, Decidado ou outros, e o mesmo ficar aberto para a internet as portas de acesso como portas de SSH (22), FTP (21), Banco de Dados (mysql=3306); (postgres=5432) entre outros serviços, muitas vezes somos obrigados a mudar as portas para ter um pouco mais de segurança, com uma simples regra de firewall irei exemplificar uma forma de mudar isto, vamos a ela.

1- Crie um arquivo /etc/init.d/firewall ;

2- Setar permissão de execução chmod +x /etc/init.d/firewall ;

3- Adicionar o conteúdo abaixo neste arquivo (/etc/init.d/firewall);

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

#!/bin/bash

# chkconfig: – 55 45
# description: Firewall IPTables
# Autor: Flávio Silva
# E-mail: contato@flaviosilva.net.br
# Site: http://www.deserv.com.br / http://blog.deserv.info
# probe: false

# Define o caminho do comando iptables
IPTABLES=`which iptables`
function OK() {
echo -e “\\033[1;39m [ \\033[1;32mOK\\033[1;39m ]\\033[1;0m"
}

function FALHOU() {
echo -e "\\033[1;39m [ \\033[1;31mFALHOU\\033[1;39m ]\\033[1;0m”
}

function STOP(){

###############################################################
# Flushing filter #
###############################################################
$IPTABLES -F
$IPTABLES -P INPUT ACCEPT
$IPTABLES -P OUTPUT ACCEPT
$IPTABLES -X
OK
}

function START(){
###############################################################
# Default Policies #
###############################################################
$IPTABLES -P INPUT DROP
$IPTABLES -P OUTPUT ACCEPT

###################
# Stateful Input #
###################
$IPTABLES -A INPUT -m state –state ESTABLISHED,RELATED -j ACCEPT

#######################################
# REGRA DE ACESSO DINAMICO SSH #
#######################################

HOST_IP=”0.0.0.0/0.0.0.0″

$IPTABLES -A INPUT -p tcp –dport 12345 -m recent –set –name SSH-ACCESS
$IPTABLES -A INPUT -p tcp -s $HOST_IP –dport 22 -m recent –rcheck –seconds 3600 –name SSH-ACCESS -j ACCEPT
$IPTABLES -A INPUT -m state –state NEW -m tcp -p tcp –dport 123456 -m recent –name SSH-ACCESS –remove

####################
# Loopback traffic #
####################
$IPTABLES -A INPUT -s 127.0.0.1 -i lo -j ACCEPT

##########################
# ICMP Filtering #
# and TRACEROUTE INPUT #
##########################
$IPTABLES -A INPUT -p icmp -j ACCEPT
$IPTABLES -A INPUT -p udp –dport 33434:33523 -j ACCEPT

#######################
# Drop stealth scans #
#######################
$IPTABLES -I INPUT -p tcp -m tcp –tcp-flags FIN,SYN,RST,PSH,ACK,URG NONE -j DROP
$IPTABLES -I INPUT -p tcp -m tcp –tcp-flags FIN,SYN FIN,SYN -j DROP
$IPTABLES -I INPUT -p tcp -m tcp –tcp-flags SYN,RST SYN,RST -j DROP
$IPTABLES -I INPUT -p tcp -m tcp –tcp-flags FIN,RST FIN,RST -j DROP
$IPTABLES -I INPUT -p tcp -m tcp –tcp-flags FIN,ACK FIN -j DROP
$IPTABLES -I INPUT -p tcp -m tcp –tcp-flags ACK,URG URG -j DROP
$IPTABLES -I INPUT -p tcp -m tcp –tcp-flags PSH,ACK PSH -j DROP

#################################
# Regras de Gerenciamento INPUT #
#################################

$IPTABLES -A INPUT -s XXX.XXX.XXX.XX -j ACCEPT #CASO TENHA ALGUM IP FIXO LIBERE ELE AQUI, SE NAO COMENTE ESTA LINHA COM “#”

#################################
# Fechando conexoes SSH OUTPUT #
#################################
$IPTABLES -A OUTPUT -p tcp –dport 22 -j DROP

#################################
# Regras de Clientes INPUT #
#################################
$IPTABLES -A INPUT -p tcp –dport 80 -j ACCEPT # HTTP
$IPTABLES -A INPUT -p tcp –dport 443 -j ACCEPT # HTTPS
$IPTABLES -A INPUT -p tcp –dport 3306 -j ACCEPT # MYSQL
$IPTABLES -A INPUT -p tcp –dport 21 -j ACCEPT # FTP

OK
}
#FW options

case $1 in
start)
echo “Carregando Modulo de firewall…”
START
;;

stop)
echo “Parando Modulo de firewall…”
STOP
;;

restart)
echo “Restartando Modulo de firewall…”
STOP
START
;;

*)

echo -e “Tente $0 {start|stop|restart}”
;;
Esac

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

OBS: Veja que a porta “12345″ indicada no bloco de “REGRAS DE ACESSO DINAMICO SSH”, foi configurada para efetuar a liberação da porta 22 neste exemplo, e a porta “123456″, para o bloqueio do acesso, abaixo efetuaremos os devidos testes.

4- Adicionar os modulos de Firewall a serem carregados

touch /etc/rc.modules
chmod 755 /etc/rc.modules

Conteudo do arquivo /etc/rc.modules

/sbin/modprobe ip_conntrack

source /etc/rc.modules <- Carrega o conteudo do arquivo

5- Execute o Arquivo de Firewall

OBS.: ANTES DE EXECUTAR O FIREWALL TENHA ALGUMA FORMA ALTERNATIVA DE ACESSO AO SERVIDOR PARA PODER EFETUAR OS DEVIDOS TESTES, POIS AO SUBIR O FIREWALL VOCÊ PODERÁ PERDER O ACESSO AO SERVIDOR

/etc/init.d/firewall start/stop/restart

6- Efetuando teste de acesso:
Com o Firewall habilitado, efetue o telnet na porta que você definiu para a abertura do SSH, no nosso exemplo a porta 12345:

telnet xxx.xxx.xxx.xxx 12345

Feito o telnet, seu IP será liberado no arquivo “/proc/net/ipt_recent/SSH-ACCESS” e o acesso é liberado para acessar o servidor diretamente na porta 22

O arquivo lhe mostrará o IP da seguinte forma: “src=xxx.xxx.xxx.xxx ttl: 61 last_seen: 523542876 oldest_pkt: 2 523539875, 523542876″

Para bloquear o acesso a porta 22 novamente, basta efetuar o telnet na porta de fechamento, no nosso caso a porta 123456.

telnet xxx.xxx.xxx.xxx 123456

Configurando um cliente NFS

Inicialmente é necessário ter um kernel com o suporte a sistemas de arquivo NFS compilado ou como um módulo. Isso deve ser configurado antes da compilação do kernel. Caso não se tenha feito isto, por favor verifique o Como Fazer – Kernel para instruções sobre como proceder. Caso se esteja utilizando uma distribuição muito boa (como o Conectiva Linux) e nunca se tenha lidado com o kernel ou módulos, nfs está magicamente à sua disposição. 

Pode-se agora, na linha de comandos do superusuário, informar o comando de montagem apropriado e o sistema de arquivos estará disponível. Continuando com nosso exemplo anterior, desejamos montar /mn/parolin/local a partir de parolin. Isso deve ser feito através do seguinte comando:

mount -o rsize=1024,wsize=1024 parolin:/mn/parolin/local /mnt

(Retornaremos posteriormente às opções rsize e wsize). O sistema de arquivos está agora disponível sob /mnt e pode-se acessá-lo através do comando cd, assim como verificar o seu conteúdo através do comando ls, e observar os arquivo individualmente. Pode-se perceber que ele não é tão rápido quando um sistema local, mas muito mais amigável que o uso do ftp. Se, ao invés de montar um sistema de arquivos, o comando mount apresente uma mensagem de erro comomount:parolin:/mn/parolin/local falhou, razão fornecida pelo servidor: Permissão negada, então o arquivo exports contém algum erro. Caso ele informe mount clntudp_create: RPC: Programa não registrado isso significa que os programas nfsd ou mountd não estão sendo executados no servidor.

Para desmontar o sistema de arquivos basta comandar:

umount /mnt

Para que um sistema de arquivos nfs seja montado na inicialização do sistema operacional, deve-se editar o arquivo /etc/fstab da forma usual. No caso de nosso exemplo, deve-se adicioar a seguinte linha:

# dispositivo  pto.montagem tipo_sist_arqs  opções           dump ordem verif.

…

parolin:/mn/parolin/local  /mnt    nfs  rsize=1024,wsize=1024 0    0

…

Bem, parece tudo. Quase. Continue a leitura por favor.

Opções de Montagem

Há algumas opções que devem ser consideradas. Eles definem a forma como o cliente NFS lida com uma queda do servidor ou da rede. Um dos aspectos mais interessantes sobre NFS é que ele lida com estas situações com elegância, desde que o cliente esteja corretamente configurado. Há dois tipos distintos de parâmetros de tratamento de falhas:

soft

O cliente NFS reporta um erro ao processar o acesso a um arquivo localizado em um sistema de arquivos montado via NFS. Alguns programas podem lidar com isto com compostura, outros não. Esta opção não é recomendada.

hard

O programa que acessa um arquivo em um sistema de arquivos montado via NFS irá travar sempre que o servidor não responder. O processo não pode ser interrompido ou finalizado a menos que se tenha especificado intr. Quando o servidor NFS esteja novamente ativo, o programa irá continuar a partir do ponto onde tenha parado. Isso é provavelmente o que se deseje. Recomendamos o uso do parâmetro hard,intr em todos os sistemas de arquivos montados via NFS.

A partir do exemplo anterior, esta seria a entrada no arquivo fstab:

# dispositivo  pto.montagem tipo_sist_arqs  opções           dump ordem verif.

…

parolin:/mn/parolin/local  /mnt    nfs  rsize=1024,wsize=1024,hard,intr 0 0

…

Otimizando o NFS

Normalmente, caso as opções rsize e wsize seja especificados, o NFS irá ler e gravar blocos de 4096 e 8172 bytes. Algumas combinações de kernel do Linux e placas de rede não podem lidar com blocos grandes e não podem ser otimizados. Então vamos tentar descobrir como encontrar os parâmetros rsize e wsize que funcionem da maneira mais otimizada possível. É possível testar a velocidade das opções com um simples comando. Dado o comando mount conforme descrito acima, logo temos acesso de gravação ao disco, podendo executar um teste de performance de gravação seqüencial:

time dd if=/dev/zero of=/mnt/testfile bs=16k count=4096

Este comando criará um arquivo de 64 Mb de bytes zerados (que deve ser grande o suficiente para que o cache não altere significativamente a performance. Pode ser usado um arquivo maior caso o sistema local tenha muita memória). Isso pode ser feito algumas vezes (5-10?), para que se possa ter uma média bem fundamentada. Neste casos, o importante é medir o tempo de “relógio” e o tempo efetivamente gasto na conexão. Após, pode-se testar a performance da leitura ao se ler o arquivo de volta:

time dd if=/mnt/testfile of=/dev/null bs=16k

Isso pode ser feito algumas vezes. Após deve-se executar o comando mount e umount novamente com tamanhos maiores em rsize e wsize. Eles devem ser provavelmente múltiplos de 1024, e não maior que 16384 visto que este é o tamanho máximo do NFS versão 2. Exatamente após a montagem de um tamanho maior, acesse o sistema de arquivos montado através do comando cd e explore-o através do comando ls, para estar seguro que ele está funcionando perfeitamente. Caso os parâmetros rsize/wsize sejam muito grandes, os sintomas não são muito óbvios. Um típico sintoma é uma lista incompleta dos arquivos produzida pelo comando ls e nenhuma mensagem de erro. Ou ao se ler um arquivo ele falha misteriosamente, sem mensagens de erro. Após definir que os parâmetros rsize/wsize funcionam perfeitamente deve-se executar os testes de performance. SunOS e Solaris tem a reputação de funcionar muito melhor com blocos de 4096 bytes.

kernels mais recentes do Linux (desde o 1.3) executam a leitura antecipada para rsizes maiores ou iguais ao tamanho de página da máquina. Em máquinas Intel o tamanho de página é de 4.096 bytes. A leitura adiantada aumenta significativamente a performance de leitura do NFS. Ou seja, sempre que possível deve-se usar o rsize de 4.096 bytes em máquinas Intel.

Lembre-se de editar o arquivo /etc/fstab com os valores de rsize/wsize encontrados.

Uma sugestão para incrementar a performance de gravação do NFS é desabilitar o sincronismo de gravação do servidor. A especificação NFS indica que a gravação NFS solicitada não pode ser considerada finalizadas antes dos dados serem gravados em um meio não volátil (normalmente o disco rígido). Isso restringe a performance de gravação de alguma forma, enquanto que gravações assíncronas irão aumentar a velocidade do NFS. O servidor Linux nfsd nunca faz gravações síncronas uma que a própria implementação do sistema de arquivos não o faz, mas em servidores em sistemas operacionais diferentes isso pode aumentar a performance através do seguinte parâmetro no arquivo exports:

/dir    -async,access=linuxbox

ou algo similar. Por favor verifique a página de manual online da máquina em questão. Cabe salientar que esta opção aumenta o risco de perda de dados no caso de algum problema ocorrer antes da efetiva gravação dos dados.

Fonte: http://www.magnux.org

PREENCHIMENTO DE ARQUIVOS:

 # duplicar o tamanho de um arquivo
 sed G

 # duplicar o tamanho de um arquivo que jah contém linhas em branco.
 # O arquivo de saída deve conter não mais que uma linha branca
 # entre linhas de texto
 sed '/^$/d;G'

 # triplicar o tamanho de um arquivo
 sed 'G;G'

 # desfazer a duplicação de tamanho (assume que as linhas de numeração par
 # estejam em branco)
 sed 'n;d'

 # insere uma linha em branco acima de cada linha que contem "regex"
 sed '/regex/{x;p;x;}'

 # insere uma linha em branco abaixo de cada linha que contem "regex"
 sed '/regex/G'

 # insere uma linha em branco acima e abaixo de cada linha que contem "regex"
 sed '/regex/{x;p;x;G;}'

NUMERACÃO:

 # numera cada linha de um arquivo (com alinhamento simples a esquerda). Usar
 # uma tabulação em vez do espaço vai preservar as margens. (veja a observação
 # sobre o '\t' no final desse arquivo)
 sed = arquivo | sed 'N;s/\n/\t/'

 # numera cada linha de um arquivo (números a esquerda, alinhados a direita)
 sed = arquivo | sed 'N; s/^/     /; s/ *\(.\{6,\}\)\n/\1  /'

 # numera cada linha de um arquivo, mas só imprime os números se a linha não
 # estiver em branco
 sed '/./=' arquivo | sed '/./N; s/\n/ /'

 # conta as linhas (emula o "wc -l")
 sed -n '$='

CONVERSÃO DE TEXTO E SUBSTITUIÇÃO:

 # EM AMBIENTE UNIX: converte o caractere de linha nova do DOS (CR/LF) para o
 # formato Unix
 sed 's/.$//'            # assume que todas as linhas terminam com CR/LF
 sed 's/^M$//'           # no bash/tcsh, pressione Ctrl-V depois Ctrl-M
 sed 's/\x0D$//'         # gsed 3.02.80, mas os scripts acima sao mais simples

 # EM AMBIENTE UNIX: converte o caractere de linha nova do Unix (LF) para
 # o formato DOS
 sed "s/$/`echo -e \\\r`/"            # comando usado com o ksh
 sed 's/$'"/`echo \\\r`/"             # comando usado com o bash
 sed "s/$/`echo \\\r`/"               # comando usado com o zsh
 sed 's/$/\r/'                        # gsed 3.02.80

 # EM AMBIENTE DOS: converte o caractere de linha nova do Unix (LF) para
 # o formato DOS
 sed "s/$//"                          # método 1
 sed -n p                             # método 2

 # EM AMBIENTE DOS: converte o caractere de linha nova do DOS (CR/LF) para
 # o formato Unix. Só pode ser feito com o sed UnxUtils, versão 4.0.7
 # ou maior. A versão do UnxUtils pode ser identificada pelo parâmetro padrão
 # "--text" que aparece quando o "--help" é usado. De outra forma, mudar
 # os caracteres de linha nova do DOS para o formato Unix não pode ser
 # feito em um ambiente DOS. Use o "tr" para isso.
 sed "s/\r//" arquivo_entrada >arquivo_saida         # sed UnxUtils versão v4.0.7 ou maior
 tr -d \r <arquivo_entrada >arquivo_saida            # tr GNU versão 1.22 ou maior

 # apaga o espaço em branco inicial (espaços, tabulações) do começo
 # de cada linha, puxando o texto para a esquerda
 sed 's/^[ \t]*//'                    # veja a nota sobre o '\t' no final
                                      # deste arquivo

 # apaga o espaço em branco final (espaços, tabulações) do final de cada linha
 sed 's/[ \t]*$//'                    # veja a nota sobre o '\t' no final
                                      # deste arquivo

 # deleta AMBOS os espaços em branco final e inicial de cada linha
 sed 's/^[ \t]*//;s/[ \t]*$//'

 # insere 5 espaços em branco no ínicio de cada linha (faz o offset da página)
 sed 's/^/     /'

 # alinha tudo a direita, numa coluna de 79 caracteres de largura
 sed -e :a -e 's/^.\{1,78\}$/ &/;ta'  # definido como 78 mais 1 espaço

 # centraliza todo o texto no meio de uma coluna de 79 caracteres de
 # largura. No método 1, os espaços no começo da linha são significativos,
 # e espaços em branco são anexados ao final de cada linha. No método 2,
 # os espaços no início de cada linha são descartados ao centralizar
 # a linha e não é adicionado nenhum espaço no final de cada linha.
 sed  -e :a -e 's/^.\{1,77\}$/ & /;ta'                     # método 1
 sed  -e :a -e 's/^.\{1,77\}$/ &/;ta' -e 's/\( *\)\1/\1/'  # método 2

 # substituir (achar e trocar) "foo" por "bar" em cada linha
 sed 's/foo/bar/'             # troca somente a 1a instância de uma linha
 sed 's/foo/bar/4'            # troca somente a 4a instância de uma linha
 sed 's/foo/bar/g'            # troca TODAS as instâncias de uma linha
 sed 's/\(.*\)foo\(.*foo\)/\1bar\2/' # troca o 'próximo-para-último'
 sed 's/\(.*\)foo/\1bar/'     # troca somente a última occorrência

 # substitui "foo" por "bar" SOMENTE nas linhas que contem "baz"
 sed '/baz/s/foo/bar/g'

 # substitui "foo" por "bar" EXCETO nas linhas que contem "baz"
 sed '/baz/!s/foo/bar/g'

 # troca "scarlet" ou "ruby" ou "pucy" para "red"
 sed 's/scarlet/red/g;s/ruby/red/g;s/puce/red/g'   # na maioria dos seds
 gsed 's/scarlet\|ruby\|puce/red/g'                # somente no GNU sed 

 # reverter a ordem das linhas (emula o "tac")
 # um bug/função do HHsed v1.5 fazia com que as linhas em branco fossem deletadas
 sed '1!G;h;$!d'              # método 1
 sed -n '1!G;h;$p'            # método 2

 # reverte cada caractere em cada linha (emula o "rev")
 sed '/\n/!G;s/\(.\)\(.*\n\)/&\2\1/;//D;s/.//'

 # une pares de linhas lado a lado (como o "paste")
 sed '$!N;s/\n/ /'

 # se uma linha termina com uma barra invertida, a próxima linha é
 # anexada a ela
 sed -e :a -e '/\\$/N; s/\\\n//; ta'

 # se uma linha termina com um sinal de igual, ela é anexada a linha
 # anterior e o sinal de "=" é substituído por um espaco simples.
 sed -e :a -e '$!N;s/\n=/ /;ta' -e 'P;D'

 # adiciona vírgulas a strings numéricos, mudando "1234567" para "1,234,567"
 gsed ':a;s/\B[0-9]\{3\}\>/,&/;ta'                     # GNU sed
 sed -e :a -e 's/\(.*[0-9]\)\([0-9]\{3\}\)/\1,\2/;ta'  # outros seds

 # adiciona vírgulas em números com pontos decimais e sinais de negativo (GNU sed)
 gsed -r ':a;s/(^|[^0-9.])([0-9]+)([0-9]{3})/\1\2,\3/g;ta'

 # adiciona uma linha em branco a cada 5 linhas (após as linhas 5, 10, 15, 20, etc.)
 gsed '0~5G'                  # somente no GNU sed
 sed 'n;n;n;n;G;'             # outros seds

IMPRESSÃO SELETIVA DE CERTAS LINHAS:

 # imprime as primeiras 10 linhas de um arquivo (emula o comportamento do "head")
 sed 10q

 # imprime a primeira linha de um arquivo (emula o "head -1")
 sed q

 # imprime as últimas 10 linhas de um arquivo (emula o "tail")
 sed -e :a -e '$q;N;11,$D;ba'

 # imprime as 2 últimas linhas de um arquivo (emula o "tail -2")
 sed '$!N;$!D'

 # imprime somente a última linha de um arquivo (emula o "tail -1")
 sed '$!d'                    # método 1
 sed -n '$p'                  # método 2

 # imprime somente as linhas que se encaixam na expressão regular
 # (emula o "grep")
 sed -n '/regexp/p'           # método 1
 sed '/regexp/!d'             # método 2

 # imprime somente as linhas que NÃO se encaixam na regexp (emula o "grep -v")
 sed -n '/regexp/!p'          # método 1, corresponde ao descrito acima
 sed '/regexp/d'              # método 2, sintaxe mais simples

 # imprime a linha imediatamente anterior a expressão regular, mas
 # não a linha contendo a expressão
 sed -n '/regexp/{g;1!p;};h'

 # imprime a linha imediatamente posterior a expressão regular, mas
 # não a linha contendo a expressão
 sed -n '/regexp/{n;p;}'

 # imprime uma linha de contexto antes e depois da expressão regular,
 # com o número da linha indicando onde a expressão regular
 # aparece (similar ao "grep -A1 -B1")
 sed -n -e '/regexp/{=;x;1!p;g;$!N;p;D;}' -e h

 # procura e imprime por AAA e BBB e CCC (em qualquer ordem)
 sed '/AAA/!d; /BBB/!d; /CCC/!d'

 # procura e imprime por AAA e BBB e CCC (nessa ordem)
 sed '/AAA.*BBB.*CCC/!d'

 # procura e imprime por AAA ou BBB ou CCC (emula o "egrep")
 sed -e '/AAA/b' -e '/BBB/b' -e '/CCC/b' -e d    # maioria dos seds
 gsed '/AAA\|BBB\|CCC/!d'                        # somente com o sed GNU

 # imprime um parágrafo se ele possuir AAA (linhas vazias separam os parágrafos).
 # Com o HHsed v1.5 deve ser inserido o 'G;' apos o 'x;', nos 3 scripts abaixo
 sed -e '/./{H;$!d;}' -e 'x;/AAA/!d;'

 # imprime um parágrafo se ele possuir AAA e BBB e CCC (em qualquer ordem)
 sed -e '/./{H;$!d;}' -e 'x;/AAA/!d;/BBB/!d;/CCC/!d'

 # imprime o parágrafo inteiro se ele possuir AAA ou BBB ou CCC
 sed -e '/./{H;$!d;}' -e 'x;/AAA/b' -e '/BBB/b' -e '/CCC/b' -e d
 gsed '/./{H;$!d;};x;/AAA\|BBB\|CCC/b;d'         # somente com o GNU sed

 # imprime somente as linhas com 65 caracteres ou mais
 sed -n '/^.\{65\}/p'

 # imprime somente as linhas com menos que 65 caracteres
 sed -n '/^.\{65\}/!p'        # método 1, corresponde ao descrito acima
 sed '/^.\{65\}/d'            # método 2, sintaxe mais simples

 # imprime uma parte do arquivo que vai da expressão regular até
 # o final do mesmo
 sed -n '/regexp/,$p'

 # imprime uma parte do arquivo baseada nos números das linhas (linhas 8-12,
 # inclusive)
 sed -n '8,12p'               # método 1
 sed '8,12!d'                 # método 2

 # imprime a linha de número 52
 sed -n '52p'                 # método 1
 sed '52!d'                   # método 2
 sed '52q;d'                  # método 3, eficiente com arquivos grandes

 # começando na linha 3, imprime cada sétima linha
 gsed -n '3~7p'               # somente o GNU sed
 sed -n '3,${p;n;n;n;n;n;n;}' # outros seds

 # imprime um pedaço de arquivo que está entre as duas
 # expressões regulares (inclusive)
 sed -n '/Iowa/,/Montana/p'             # é case sensitive

DELEÇÃO SELETIVA DE CERTAS LINHAS:

 # imprime todo o arquivo EXCETO a parte entre 2 expressões regulares
 sed '/Iowa/,/Montana/d'

 # deleta linhas duplicadas consecutivas de um arquivo (emula o "uniq"). A primeira
 # linha de um conjunto de linhas duplicadas é mantida, o resto é deletada
 sed '$!N; /^\(.*\)\n\1$/!P; D'

 # deleta linhas duplicadas não consecutivas. Tome cuidado para nao estourar
 # o tamanho do buffer do espaco de reserva (hold space), ou então use o sed GNU.
 sed -n 'G; s/\n/&&/; /^\([ -~]*\n\).*\n\1/d; s/\n//; h; P'

 # deleta todas as linhas exceto as linhas duplicadas (emula o "uniq -d").
 sed '$!N; s/^\(.*\)\n\1$/\1/; t; D'

 # deleta as 10 primeiras linhas de um arquivo
 sed '1,10d'

 # deleta a última linha de um arquivo
 sed'$d'

 # deleta as 2 últimas linhas de um arquivo
 sed 'N;$!P;$!D;$d'

 # deleta as 10 últimas linhas de um arquivo
 sed -e :a -e '$d;N;2,10ba' -e 'P;D'   # método 1
 sed -n -e :a -e '1,10!{P;N;D;};N;ba'  # método 2

 # deleta cada oitava linha
 gsed '0~8d'                           # somente no GNU sed
 sed 'n;n;n;n;n;n;n;d;'                # outros seds

 # deleta as linhas que combinarem com padrão
 sed '/padrao/d'

 # deleta TODAS as linhas em branco de um arquivo (o mesmo que "grep '.' ")
 sed '/^$/d'                           # método 1
 sed '/./!d'                           # método 2

 # deleta todas as linhas brancas CONSECUTIVAS de um arquivo exceto a primeira;
 # ainda deleta todas as linhas em branco do início e fim do arquivo (emula o
 # "cat -s")
 sed '/./,/^$/!d'          # método 1, permite 0 brancos no topo, 1 no
                           # final do arquivo
 sed '/^$/N;/\n$/D'        # método 2, permite 1 branco no top, 0 no
                           # final do arquivo

 # deleta todas as linhas em branco CONSECUTIVAS do arquivo, exceto as 2 primeiras:
 sed '/^$/N;/\n$/N;//D'

 # deleta todas as linhas em branco iniciais, no início do arquivo
 sed '/./,$!d'

 # deleta todas as linhas em branco finais, no final do arquivo
 sed -e :a -e '/^\n*$/{$d;N;ba' -e '}'  # funciona com todos os sed
 sed -e :a -e '/^\n*$/N;/\n$/ba'        # o mesmo, exceto gsed 3.02*

 # deleta a última linha de cada parágrafo
 sed -n '/^$/{p;h;};/./{x;/./p;}'

APLICAÇÕES ESPECIAIS:

 # remove overstrikes nroff (caracter, backspace) das man pages. O comando
 # 'echo' pode precisar da opção -e se você usar Unix System V ou uma
 # shell bash
 sed "s/.`echo \\\b`//g"    # as aspas duplas são necessárias em ambiente Unix
 sed 's/.^H//g'             # no bash/tcsh, pressione Ctrl-V e depois Ctrl-H
 sed 's/.\x08//g'           # expressão hexadecimal para o sed v1.5

 # mostra as mensagens de cabeçalho de um Usenet/e-mail
 sed '/^$/q'                # deleta tudo após a primeira linha em branco

 # mostra o corpo da mensagem de um Usenet/e-mail
 sed '1,/^$/d'              # deleta tudo até a primeira linha em branco

 # mostra o cabeçalho Subject, mas remove a porção inicial "Subject :"
 sed '/^Subject: */!d; s///;q'

 # pega o cabeçalho de endereço de resposta
 sed '/^Reply-To:/q; /^From:/h; /./d;g;q'

 # verifica o endereço de maneira correta. Pega o endereço de e-mail
 # através da 1a linha do cabeçalho de endereço de retorno (veja
 # o script acima)
 sed 's/ *(.*)//; s/>.*//; s/.*[:<] *//'

 # adiciona um sinal de maior com um espaço a cada linha (citação de uma
 # mensagem)
 sed 's/^/> /'

 # deleta o sinal de maior e o espaço de cada linha (remove a
 # citação de uma mensagem)
 sed 's/^> //'

 # remove a maioria das tags HTML (acomoda tags de múltiplas linhas)
 sed -e :a -e 's/<[^>]*>//g;/</N;//ba'

 # extrai binários uuencoded com múltiplos pedaços, removendo informações
 # estranhas/extras, fazendo com que só a parte uuencoded permaneça. Os
 # arquivos devem ser passados ao sed na ordem correta. A versão 1 pode
 # ser executada a partir da linha de comando; a versão 2 pode ser
 # executada a partir de um shell script Unix. (Modificado de um
 # script criado por Rahul Dhesi.)
 sed '/^end/,/^begin/d' arquivo1 arquivo2 ... arquivoX | uudecode   # vers. 1
 sed '/^end/,/^begin/d' $* | uudecode                      # vers. 2

 # Ordena parágrafos de arquivos alfabeticamente. Parágrafos são separados
 # por linhas em branco. O GNU sed usa o \v como tabulação vertical, ou qualquer
 # caracter único serve.
 sed '/./{H;d;};x;s/\n/={NL}=/g' file | sort | sed '1s/={NL}=//;s/={NL}=/\n/g'
 gsed '/./{H;d};x;y/\n/\v/' file | sort | sed '1s/\v//;y/\v/\n/'

 # zipa cada arquivo .TXT individualmente, deletando o arquivo fonte
 # e definindo o nome de cada .ZIP para o nome base do arquivo .TXT.
 # (no DOS: o comando "dir /b" retorna nomes de arquivo reduzidos e em caixa alta).
 echo @echo off >zipup.bat
 dir /b *.txt | sed "s/^\(.*\)\.TXT/pkzip -mo \1 \1.TXT/" >>zipup.bat

USO TÍPICO: O sed pega um ou mais comandos de edição e aplica todos eles,
em sequência, a cada linha de entrada. Após todos os comandos terem sido
aplicados a primeira linha de entrada, ela é jogada para a saída e a
segunda linha de entrada começa a ser processada, recomeçando o ciclo.
Os exemplos acima assumem que a entrada venha do dispositivo padrão  (por exemplo,
o console, onde  normalmente a entrada é via pipe). Um ou mais nomes de
arquivo podem ser passados na linha de comando se a entrada não vier da
entrada padrão. A saída é mandada para a saída padrão (a tela). Assim:

 cat arquivo | sed '10q'        # usa a entrada via pipe
 sed '10q' arquivo              # tem o mesmo efeito, mas evita o uso do "cat"
 sed '10q' arquivo > novo-arquivo    # redireciona a saída para o disco

Para instruções de sintaxe adicionais, incluindo a maneira de aplicar
comandos de edição a partir de um arquivo no disco, ao invés da linha
de comando, consulte "sed & awk, 2nd Edition," por Dale Dougherty e
Arnold Robbins (O'Reilly, 1997; http://www.ora.com), "UNIX Text
Processing," por Dale Dougherty e Tim O'Reilly (Hayden Books, 1987)
ou os tutoriais do Mike Arst distribuídos como U-SEDIT2.ZIP (em vários
sites). Para explorar totalmente o poder do sed, deve-se entender
as "expressões regulares". Para isso, veja "Mastering Regular Expressions"
de Jeffrey Friedl (O'Reilly, 1997). As páginas de manual ("man pages")
dos sistemas Unix podem ser úteis (tente "man sed", "man regexp", ou
a subseção sobre expressões regulares no "man ed"), mas as páginas
de manual são notadamente mais difíceis de se compreender. Elas
não são escritas para ensinar o uso do sed ou das expressões
regulares para usuários iniciantes, mas como texto de referência
para aqueles que já tem certa experiência com as duas ferramentas.

SINTAXE DAS ASPAS: Os exemplos acima utilizam as aspas simples ('...')
ao invés das aspas duplas ("...") para agrupar comandos de edição,
visto que o sed é comumente utilizado em plataformas Unix. As
aspas simples impedem que a shell Unix interprete o cifrão ($)
e a crase (`...`), os quais seriam expandidos pela shell se estivessem
dentro das aspas duplas. Usuários da shell "csh" e derivadas
ainda precisarão utilizar a barra invertida (\) antes do sinal de
exclamação (por exemplo \!) para conseguir rodar os exemplos acima, mesmo
usando as aspas simples. Versões do sed escritas para o DOS
invariavelmente necessitam das aspas duplas ("...") ao invés das
aspas simples para agrupar os comandos de edição.

USO DO '\t' NOS SCRIPTS SED: Para maior clareza na documentação, nós
utilizamos a expressão '\t' para indicar o caractere de tabulação
(0x09) nos scripts sed. Porém, a maioria das versões do sed não reconhece
a abreviação '\t', logo, quando for executar estes scripts via linha
de comando, você deve apertar a tecla TAB. A abreviação '\t' só
é reconhecida como um metacaractere nas expressões regulares no
awk, perl, HHsed, sedmod, e o GNU sed v3.02.80.

VERSÕES DO SED: As versões do sed diferem entre si, logo, algumas
variações na sintaxe são esperadas. Em particular, a maioria
não suporta o uso de rótulos (:nome) ou instruções ramificadas
(b,t) na edição dos comandos, exceto no final dos mesmos. Nós utilizamos
uma sintaxe que seria portável para a maioria dos usuários do sed,
mesmo sabendo que a popular versão GNU do sed permite uma sintaxe
mais sucinta. Quando o leitor vê um comando comprido como esse:

   sed -e '/AAA/b' -e '/BBB/b' -e '/CCC/b' -e d

é importante que ele saiba que o GNU sed permite uma redução, como:

   sed '/AAA/b;/BBB/b;/CCC/b;d'		# ou mesmo
   sed '/AAA\|BBB\|CCC/b;d'

Lembre-se ainda que, apesar de muitas versões do sed aceitarem comandos
como "/one/ s/RE1/RE2/", algumas não permitem o uso de "/one/! s/RE1/RE2/",
a qual contém um espaço antes do 's'. Omita o espaço quando for digitar
o comando.

OTIMIZANDO PARA MAIOR VELOCIDADE: Se a velocidade de execução precisa
aumentar (em virtude de grandes arquivos de entrada ou de processadores
e discos rígidos lentos), a substituição será executada mais rapidamente
se a expressão de "procura" é especificada antes da instrução
"s/.../.../". Assim:

   sed 's/foo/bar/g' arquivo         # comando de substituição padrão
   sed '/foo/ s/foo/bar/g' arquivo   # executa de forma mais rápida
   sed '/foo/ s//bar/g' arquivo      # sintaxe mais sucinta

Na seleção ou remoção de linhas nas quais você somente precisa
ver uma primeira parte de um arquivo, o comando "quit" (q) no script
irá reduzir drasticamente o tempo de processamento para arquivos
grandes. Assim:

   sed -n '45,50p' arquivo           # imprime as linhas 45-50
   sed -n '51q;45,50p' arquivo       # mesma coisa, mas faz muito mais
                                     # rapidamente

Fonte: http://sed.sourceforge.net/

Port knocking funciona como um cadeado de segredo para ter acesso ao servidor, onde o usuário ou invasor terá que “bater” em um determinado número de portas com um limite de tempo também determinado para fazer a sequência para só assim liberar o ip que ele estiver usando também por um determinado tempo. O acesso a porta que queremos aqui no caso é a 22 (ssh).  

Vamos construir um cenário onde você queira primeiro liberar o acesso direto a alguns IPs sem precisar passar pelo segredo das portas, depois liberaremos todos os IPs (ou alguma rede específica) somente se acertarem a sequência das portas e por último bloquearemos todo o resto.

A configuração a seguir pode ser adicionada a seu script de firewall.

Como este é o primeiro tutorial que escrevo, tentarei ser o mais claro possível (espero que me perdoem se não conseguir):

Testando:

A forma mais fácil que eu acho para testar é utilizando o telnet. Por ex.:

$ telnet IP_SERVIDOR 100
$ telnet IP_SERVIDOR 200
$ telnet IP_SERVIDOR 300
$ telnet IP_SERVIDOR 400

e agora é só entrar com ssh normalmente.

Por: Leandro Lanini
Fonte: http://www.vivaolinux.com.br

Roteadores ou equipamentos que interligam duas ou mais redes são chamados de Gateways. A necessidade de configurarmos rotas estáticas surge à medida que possuímos mais de um gateway na rede, sendo assim, configuramos as máquinas da rede 1, por exemplo, de forma que: quando quiser acessar a rede 2 saia pelo gateway A e quando for acessar as redes 3,4,5… saia pelo gateway B.

Traduzindo isso para o TCP/IP ficaria:

Suponha que

  rede 1 = 192.168.1.0 / 255.255.255.0
  rede 2 = 192.168.0.0 / 255.255.0.0
  rede 3 = 10.100.1.0 / 255.255.255.0
  rede 4 = 10.100.2.0 / 255.255.255.0
  rede 5 = 10.100.3.0 / 255.255.255.0
  ....
  ubuntu#> route add -net 192.168.0.0/16 gw 192.168.10.1
  ubuntu#> route add -net 10.100.0.0/16 gw 192.168.10.10

Com isso a tabela de roteamento da máquina que estamos configurando ficaria assim:

  ubuntu#> route
  Tabela de Roteamento IP do Kernel
  Destino         Roteador        MáscaraGen.    Opções Métrica Ref   Uso Iface
  192.168.1.0     *               255.255.255.0   U     0      0        0 eth0
  192.168.0.0     192.168.10.1    255.255.0.0     UG    0      0        0 eth0
  10.100.0.0      192.168.10.10   255.255.0.0     UG    0      0        0 eth0

Note que a primeira linha foi adicionada automaticamente quando configuramos o endereço IP da própria máquina.

Uma maneira de melhorarmos isso é trabalhando com default gateway, ou seja, ao adicionarmos um gateway default, ele será adicionado na última linha da tabela de roteamento, de forma que todo IP com destino a uma rede que não se encaixa nas definições iniciais da tabela de roteamento serão mandadas para o default gateway (que por isso está na última linha).

Mas o escopo dessa dica é como transformar as rotas estáticas, que até aqui foram adicionadas manualmente, em configurações adicionadas automaticamente sempre que ligamos a máquina.

Já vi várias formas de adicionarmos estas rotas, desde comandos adicionados no script de inicialização do usuário, o /etc/init.d/rc.local até scripts executados ao iniciar o ambiente gráfico (arghhhh!!!), porém o mais adequado é utilizarmos os recursos que o sistema oferece para isso que são:

No Ubuntu (debian em geral): basta adicionarmos no arquivo /etc/network/interfaces as seguintes linhas:

  post-up route add -net 192.168.0.0/16 gw 192.168.10.1
  post-up route add -net 10.100.0.0/16 gw 192.168.10.10

Já em sistemas como o RedHat devemos criar o arquivo /etc/sysconfig/network-scripts/route-eth0 contendo:

  GATEWAY0=192.168.10.1
  NETMASK0=255.255.0.0
  ADDRESS0=192.168.0.0

  GATEWAY1=10.100.0.0
  NETMASK1=255.255.0.0
  ADDRESS1=192.168.10.10

Sendo assim toda vez que o serviço de rede subir estas rotas estáticas serão adicionadas automaticamente na tabela de roteamento de sua máquina.

Fonte: http://www.dicas-l.com.br

O Guia de Administração do Sistema do Red Hat Enterprise Linux é parte do compromisso crescente da Red Hat em oferecer suporte útil e oportuno para usuários do Red Hat Enterprise Linux. De acordo com o lançamento de novas ferramentas e aplicações, este manual será expandido para incluí-las.

rhel-sag(PT_BR)-3-HTML-RHI (2003-07-25T17:10)

Integrando o Apache com o TOMCAT para que as páginas estáticas sejam executadas pelo Apache e as em JSP pelo contêiner TOMCAT, além do direcionamento das aplicações via APACHE, sendo o WebServer de acesso para as aplicações que estão no TOMCAT.

O sistema de autodetecção do Slax não é tão desenvolvido quanto o de distribuições como o Ubuntu, Knoppix ou Mandriva, mas ajuda bastante.

Você pode baixar a última versão no: http://slax.linux-live.org/.

Além do “Slax Standard Edition”, que é a versão principal, que abordo aqui, estão disponíveis algumas versões específicas, como o KillBill (que vem com o wine pré-instalado) e o PopCorn (uma versão reduzida, que pode ser instalado num pendrive de 128 MB).

O Slax configura o vídeo durante o boot, mas não abre o modo gráfico automaticamente. Na tela de login, você deve se logar como root, senha toor e rodar o comando “startx” para abrir o KDE. Você pode também usar a opção “slax gui” na tela de boot, para que ele abra o KDE automaticamente, como no Kurumin.

Embora seja raro, existem casos em que o sistema trava na hora do boot por causa de problemas com a detecção de algum periférico. Nestes casos, você pode experimentar as opções “slax noagp”, “slax nopcmcia”, “slax nodma” ou “slax acpi=off”.

Ao abrir o modo gráfico, você verá uma versão personalizada do KDE, com um visual simpático e um menu limpo, com poucos programas instalados por padrão. Devido à simplicidade, o tempo de boot também é perceptivelmente mais baixo.

Para configurar o som, use o comando “alsaconf”, e para configurar a rede, use o “netconfig” (o mesmo script usado no Slackware). Se você acessa via ADSL com autenticação (PPPoE), use o comando “adsl-setup” para configurar a conexão e depois o “adsl-start” para conectar. Estes dois comandos podem ser encontrados também no Mandriva, Fedora e em outras distribuições derivadas do Red Hat.

{mospagebreak}

O Slax não inclui suporte a nenhum softmodem, mas se por acaso você utilizar um hardmodem, pode conectar usando o Kppp, como em outras distribuições.

O suporte a placas wireless também não conta com todos os drivers disponíveis mas ele já vem com o Ndiswrapper pré-instalado, que permite configurar muitas placas usando os drivers do Windows. Você pode ver dicas de como configurar sua placa usando o Ndiswrapper no Guia Modems e placas wireless no Linux: http://www.guiadohardware.net/guias/05/

Em resumo, você primeiro carrega o arquivo .inf do driver do Windows XP, com o comando “ndiswrapper -i”, como em:

# ndiswrapper -i neti2220.inf

… e, em seguida, ativa o Ndiswrapper usando o comando:

# modprobe ndiswrapper

Com a placa ativa, você pode configurar os parâmetros da rede wireless e monitorar a conexão através do Kwifimanager, que está dentro do menu internet.

O Slax não oferece nenhuma opção de alterar o particionamento durante a instalação. Você precisa criar as partições previamente, usando o cfdisk e formatá-las através do comando “mkreiserfs”, como em “mkreiserfs /dev/hda2″. Outra opção, é particionar usando um CD do Kurumin, ou o CD de instalação do Mandriva e voltar ao Slax para instalar. Mesmo ao particionar a partir do próprio Slax, usando o cfdisk, é sempre necessário reiniciar, para que o instalador detecte as alterações.

O instalador está disponível no “Iniciar > System > Slax Installer”. Ele é provavelmente o instalador mais simples de todas as distribuições que já vi. Você precisa apenas indicar a partição onde o sistema será instalado e no MBR de qual drive o lilo será gravado (caso tenha mais de um). Não existe a opção de instalar o lilo na partição, caso você esteja instalando-o em dual boot com o Windows ou outra distribuição. Ele sempre se gravará na MBR e você precisará configurar o “/etc/lilo.conf” para que ele lhe dê a opção de inicializar os outros sistemas instalados.

{mospagebreak}

Existem duas formas de instalação. A opção “Live” simplesmente copia o conteúdo do CD para a partição, ocupando apenas 200 MB. Esta opção é mais uma opção para poder dar boot sem usar o CD-ROM do que uma instalação propriamente dita, algo similar a usar a opção “tohd” no Kurumin. A opção “Real” ocupa quase o triplo de espaço, pois nela os arquivos são realmente descompactados, criando uma instalação real do sistema, onde você pode instalar novos programas e fazer qualquer tipo de alteração.

Mesmo depois de instalado, o Slax continua usando o root como usuário padrão. Enquanto você estiver brincando e explorando o sistema isto é até interessante, pois permite que você mexa onde quiser, sem ser perturbado por problemas com as permissões. Se alguma coisa der errado, basta reinstalar e começar de novo.

Mas, a partir do momento em que você resolver navegar na web ou fazer qualquer trabalho mais sério, o uso do root torna-se um grave problema de segurança por dois motivos: como root você tem permissão para fazer tudo, então acaba sendo muito fácil destruir o sistema e, ao mesmo tempo, abrindo todos os programas como root, fica muito mais fácil explorar brechas de seguranças nos programas para obter acesso à sua máquina remotamente. Esta segunda possibilidade não é tão grande assim, mas vale a pena evitar.

{mospagebreak}

Você pode criar um novo usuário usando o comando adduser, como em:

# adduser tux

São feitas muitas perguntas, que permitem incluir informações diversas no cadastro do usuário (que seriam úteis numa grande rede), mas, no caso de um humilde desktop, as únicas que realmente interessam são o nome em si (login) e a senha.

Depois de instalado, o Slax nada mais é do que uma versão customizada do Slackware. O que você aprender a fazer no Slax pode ser feito também no Slackware e vice-versa.

Um dos grandes atrativos do Slax é ser um sistema bem simples e limpo, com poucos programas instalados por padrão. Isto é uma faca de dois gumes, pois também significa que ao usar o sistema por mais tempo, você acabará precisando investir mais tempo baixando e instalando programas adicionais.

O Slax é compatível com os pacotes da versão correspondente do Slackware. O Slax 5.06, por exemplo, usa os pacotes do Slackware 10.2. Normalmente, a última versão do Slax usa os pacotes da última versão do Slackware.

Você pode instalar programas adicionais a partir dos CDs de instalação (do Slackware) ou ir baixando individualmente os programas desejados a partir de um dos mirrors listados no http://www.slackware.com/getslack/.

Para instalar o suporte a português do Brasil no KDE, por exemplo, baixe o pacote kde-i18n-pt_BR, que está disponível na pasta “slackware/kdei/” do CD ou mirror. Os pacotes do Slackware usam a extensão “.tgz”. Junto com cada pacote, existe sempre um arquivo “.txt”, com uma descrição curta e um arquivo “.asc”, usado pelo instalador para verificar a integridade do pacote principal.

Para instalar o pacote baixado, use o comando “installpkg”, seguido pelo nome do pacote, como em:

# installpkg kde-i18n-pt_BR-3.4.2-noarch-1.tgz

Use a tecla TAB para completar o nome do arquivo depois de digitar as primeiras letras. O installpkg é uma ferramenta simples de instalação, que funciona de uma forma similar ao “dpkg -i” do Debian. Ele permite instalar pacotes que você já baixou, mas não é capaz de baixar os pacotes por si só, como o apt-get. O installpkg também não checa dependências ao instalar os pacotes: mesmo que exista algum problema, você só saberá depois de tentar abri-lo.

Esta forma simplificada de instalar programas é a principal característica do Slackware. A vantagem é que você literalmente pode fazer o que quiser, sem que ele te perturbe com mensagens de erro e dependências desencontradas. A desvantagem é que ele não faz nada sozinho; a única maneira de descobrir que o pacote x precisa do pacote y para funcionar é pesquisando.

Depois de instalado o pacote, acesse o Painel de Controle do KDE, Regional & Accessibility > Contry, Region & Language e, dentro dela marque a opção Add Language > Brazil Portuguese. Clique no “Apply” e reinicie o KDE para que os aplicativos passem a usar nossa língua.

{mospagebreak}

Para instalar o Gimp, baixe o pacote “gimp”, que está na pasta “slackware/xap”; para instalar o Firefox, baixe o pacote “mozilla-firefox” que está na mesma pasta; e assim por diante. O Slax já vem com o plugin do Flash pré-instalado; experimente instalar também o Java e Real Player, seguindo as instruções do capítulo 5 depois de instalar o Firefox.

Para instalar o OpenOffice 2.0, baixe o pacote para o Slackware, disponível no: http://www.openoffice.org.br/ e instale-o usando o comando:

# installpkg openoffice.org.br-2.0-i586-4.tgz

Depois de instalado, você pode completar a instalação do corretor ortográfico e usar as otimizações que vimos no capítulo 5.

O Slackware utiliza uma estrutura de scripts diferente da das outras distribuições. No Debian e na maioria das outras distribuições, você usaria o comando “/etc/init.d/ssh start” para inicializar o servidor SSH e permitir que sua máquina possa ser acessada a partir de outros micros da rede local. No Slackware, isso funciona de forma similar, mas os scripts mudam de lugar, vão na pasta “/etc/rc.d/”.

Para instalar o servidor SSH no Slax, por exemplo, instale o pacote “openssh-4.2p1-i486-1.tgz” que está dentro da pasta “slackware/n/” do CD ou mirror de instalação do Slackware. Ao instalar o pacote, será criado o arquivo “/etc/rc.d/rc.sshd”, o script que permite inicializá-lo. Para usá-lo, você precisa primeiro transformá-lo num executável, usando o comando:

# chmod +x /etc/rc.d/rc.sshd

E, em seguida, inicializar o servidor SSH, usando o comando:

# /etc/rc.d/rc.sshd

O fato de ser uma distribuição minimalista, com tamanho reduzido e rápida de instalar, faz com que o Slax seja uma forma muito prática de se familiarizar com o Slackware, já que você pode testar a instalação de vários programas, testar várias configurações e reinstalar o sistema rapidamente sempre que alguma coisa der errada.

Fonte: GuiadoHardware.net

Autor: Carlos E. Morimoto

Introdução

Neste tutorial eu irei ensinar como instalar um servidor de comunicação instatânea baseada no protocolo Jabber utilizando o mysql para autenticação, para ser usado dentro de empresas, grupos e etc.

A instalação é bem simples e se for bem seguida, você não terá problemas.

Então deixemos de conversa e vamos logo ao que interessa.

Sistema Operacional Utilizado

• Debian Linux Versão 3.1

Softwares necessários

• Jive Messenger versão 2.1.5 ou superior.
• Mysql 3.4 ou superior. Recomendado usar >= 4.1
• JRE 1.5 ou superior para linux. Pode ser adquirido no site da sun.

Instalação e Configuração

Mysql

Usando o apt-get ou através de mecanismos da sua distro faça o download e instalação do mysql. (Não irei ensinar a configurar e instalar o mysql, para isso existem vários tutoriais na net).

Crie um database chamado jabber.

Crie uma conta de usuário no mysql ou use a conta do root. Recomendado não usar o root. Esse usuário deverá ter permissões para se conectar de qualquer lugar, ou seja, “%”.

O motivo: durante a configuração do jabber o mesmo ira acusar erros caso o usuário que você especificar não estiver conforme eu descrevi.

Você pode tentar limitar o acesso desse usuário permitindo logon somente local após a instalação. Comigo não funcionou.

JRE 1.5

No site da Sun[1], baixe o arquivo .BIN do JRE-1.5 no diretório /usr/local. Aqui utilizei a jre-1_5_0_04-linux-i586.bin

Deixe o arquivo ser executavel.

# chmod +x jre-1_5_0_04-linux-i586.bin

Execute o arquivo digitando:

# ./jre-1_5_0_04-linux-i586.bin

Após concordar com os termos de licença, irá surgir uma pasta chamada jre1.5.0_04 no diretório corrente.

Servidor Jabber

Nesta instalação vamos usar o Jive versão 2.1.5.

Faça o download do jive no site http://www.jivemessenger.com

Descompacte-o arquivo no diretório /usr/local

# tar -zxvf jive_messenger_2_1_5.tar.gz

Feito isso é hora de criar uma variavel de ambiente utilizada pelo jive para identificar a localização da máquina virtual java.

# export INSTALL4J_JAVA_HOME=/usr/local/jre1.5.0_04/

Chegada a hora de iniciarmos o servidor. Digite:

# /usr/local/jive_messenger/bin/messenger start

Se tudo estiver correto o servidor estará funcional.

Abra um browser qualquer e aponte para o ip do servidor na porta 9090

Se tudo der certo você estará na área administrativa começando a configurar o servidor.

Preencha os campos que o sistema requer e vá avançando.

Após concluir a configuração, você deve alterar as permissões do usuário mysql que o jive usa, limitando elas.

A configuração do Jive é muito fácil e lembra os wizards do windows.

Após completar a configuração do servidor, é chegada a hora de baixar o client e testar. Recomendo o uso do Pandion e NeosMt (Meu preferido).

Instale o client do NeosMt[2]

Vá em criar nova conta. E onde ele pedir o servidor, você deverá colocar ip ou nome do servidor em que foi feita a instalação.

Criado a conta agora é só logar com o usuário@servidor e senha.

Conclusão

Pronto temos um servidor Jabber de comunicação Instantânea.

Até mais e abraços.

Autor

• ’1c3_m4n (iceman@underlinux.com.br)

Fonte: http://under-linux.org

Introdução

Apache é a implementação open source de um servidor HTTP. Ele é o webserver mais popular na Internet. Uma pesquisa realizada em 2005 pela NetCraft mostra que cerca de 70% dos sites na Internet rodam sobre o Apache.

Opções de Configuração em tempo de Compilação

Carrege apenas os módulos necessários

O servidor Apache é um programa modular onde o administrador pode escolher entre as funcinalidade que deseja incluir no servidor selecionando um pacote de módukis. Os módulos podem ser compilados estaticamente no binário httpd ou dinamicamente como DSOs(Dynamic Shared Objects). Módulos DSO podem ser compilados quando o servidor for compilado ou poem ser compilados utilizando o apxs para adicioná-los mais tarde. O modulo mod_so deve ser compilado estaticamente no Apache para que o suporte a DSO seja ativo.

Execute o apache apenas com os módulos necessários. Isto reduz o consumo de memória aumenta a performance do servidor. Compilar os módulos estaticamente irá reduzir o consumo de RAM que é utilizado para suportar módulos compilados dinamicamente, mas será necessário recompilar o apache toda vez que um módulo for adicionado ou removido. È aqui que o DSO se torna útil. Uma vez que o modulo mod_so seja compilado estaticamente, qualquer outro módulo pode ser inserido ou removido utilizando o comando LoadModule no arquivo httpd.conf – , mas você terá que compilar os módulos utilizando apxs se ele não foi compilado quando o servidor foi feito.

Escolha o MPM apropriado

O apache vem com uma selação de Módulos Multi-Processadores (MPMs) que são responsáveis por abrir as portas de rede na máquina, aceitando requisições, e despachando processos para cuidar das requisições. Apenas um MPM pode ser carregado por vez.

Escolher o MPM depende de vários fatores, por exemplo se o SO suporta threads, quanta memória está disponível, escalabilidade versus estabilidade, modulos externos,etc .. Sistemas Linux podem escolher entr utilizar um MPM com suporte (worker) a threads ou um prefork sem threads:

O MPM Worker utiliza múltiplos processos. Ele é multi-threaded com cada processo e cada thread cuidando de uma única conexão. Esté é mais rápido e mais escalável e a memória consumida e relativamente baixa. Funciona bem com múltiplos processadores. Porém, o worker é menos tolerante a módulos defeituosos, e threads defeituosas podem afetar todas as outras threads de um processo.

O MPM Prefork utiliza múltiplos processos filhos, cada filho cuidad de apenas uma conexão por vez. Prefork é muito bem gerenciada por processadores simples ou múlitplos, a velocidade é comparável ao worker e é mais tolerante a falhas em modulos e processos que terminam inesperadamente. Mas o consumo de memória é alto, mais tráfego leva a mais consumo de memória.

Opções de Configuração em Tempo de Execução

DNS lookup

A diretiva HostnameLookips habilita a consulta de DNS, então os hostnames podem ser logados ao invés de endereços IP. Isto adiciona latência em cada requisição desde que a consulta do DNS tem que ser completada antes que a requisição seja terminada. Esta opção é desabilitada por padrão no Apache 1.3 e superiores. Deixe isto inativo e utilize programas pós-processamento como o logresolve para determinar os IPs dos logs. Logresolve vem com Apache.

Quando utilizar as diretivas Allow from ou Deny from, utilize endereços IP ao invés de nomes de domínios. Caso contrário uma consulta dupla ao DNS será executada para ter certeza de que o domínio ou host não está sendo spoofado.

AllowOverride

Se o AllowOverride está setado para ‘None’, então o Apache irá tentar abrir o arquivo .htaccess (especificada pela diretiva AccessFileName) em cada diretório que for acessado. Por exemplo:

DocumentRoot /var/www/html
<Directory />
AllowOverride all
</Directory>

Se uma requisição for feita para acessar /index.html, o Apache irá tentar abrir /.htaccess, /var/.htaccess, /var/www/.htaccess, and /var/www/html/.htaccess. Estas tentativas aumentam a latência. Se o arquivo .htaccess for necessário para um diretório, habilite apenas para este diretório.

 FollowSymLinks e SymLinksIfOwnerMatch

Se a opção FollowSymLinks estiver setada, então o servidor permitirá que links simbólicos possam ser seguidos neste diretório. Se a opção SymLinksIfOwnerMatch estiver setada, então o servidor permitirá acessar o link apenas se o destino dele bater com o dono do link.

Se a opção SymLinksIfOwnerMatch estiver setada, então o Apache terá que realizar consultas adicionais ao sistema para verificar se os donos coincidem. Chamadas adicionais também são necessárias quando a opção FollowSymLinks NÃO está setada. Por exemplo:
DocumentRoot /vaw/www/html
<Directory />
Options SymLinksIfOwnerMatch
</Directory>
Para uma requisição feita para /index.html, o Apache irá executar lstat() em /var, /var/www, /var/www/html, and /var/www/html/index.html. Estas requisições adicionais também irão aumentar a lantência. Os resultados do lstat não são cacheados, então as consultas irão ocorrer em cada requisição.

Para uma máxima performance, sete FollowSymLinks em cada lugar e nunca sete SymLinksIfOwnerMatch. Ou então, se SymLinksIfOwnerMatch for necessário para um diretório, sete ele para apenas este diretório.

 Content Negotiation

Evite utilizar content negotiation para respostas mais rápidas. Se content negotiation é necessário para o site, utilize arquivos type-map ao invés da diretiva Options MultiViews. Com MultiViews, Apache precisa scanear o diretório em busca de arquivos, o que adiciona latência.

 MaxClients

O MaxClients seta o número máximo de clientes simultâneos que pode ser suportada por cada servidor. Nenhum processo além do que está definido será aberto. Ele não deve conter um número muito baixo já que as requisições serão colacadas em fila, o que eventualmente irá dar time-out e os recursos do servidor continuarão não utilizados. Setar este valor muito alto irá causar o início de swap e o tempo de resposta irá cair drasticamente. O valor apropriado para MaxClientes pode ser calculado por: MaxClientes = Total RAM / Tamanho Máximo de Processos . O tamanho dos processos para arquivos estáticos é de mais ou menos 2-3MB. Para dinâmicos como PHP, deve ser por volta de 15MB. A coluna RSS de:
# ps -ylC httpd --sort:rss
Mostra a memória física non-swapped utilizada pelos processos do Apache em kilo Bytes.

Se existem mais usuários concorrentes do que MaxClients, as requisições serão colocadas em fila até o número baseado na diretiva ListenBacklog. Aumente o ServerLimit para setar o MaxClients acima de 256.

 MinSpareServers, MaxSpareServers, e StartServers

MaxSpareServers e MinSpareServers determina quantos processos filhos devem ser mantidos rodando. Se MinSpareServers for muito baixo e muitas requisições forem iniciadas, então o Apache terá que abrir processos adicionais para atender as requisições. Criar processos filhos é relativamente caro. Se o servidor estiver ocupado criando processos, ele não estará disponível para servir as requisições imediatamente. MaxSpareServers não deve ser muito alto, ele pode causar problemas de recursos desde que cada processo consome os recursos da máquina.

Sete MinSpareServers e MaxSpareServers para um valor com que o Apache não precise frequentemente abrir mais de 4 processos por segundo. (O Apache pode abrir o máximo de 32 processos por segundo). Quando mais de 4 processos por segundo forem abertos, uma mensagem será logada no ErrorLog.

A diretiva StartServers define o número de processos criados na inicialização do Apache. O Apache irá continuar abrir os processos até que alcance o número de MinSpareServers. Não afeta muito a performance já que o servidor não é reiniciado frequentemente. Se existem muitas requisições e o Apache é reiniciado frequentemente, sete este valor para um número alto.

 MaxRequestsPerChild

A diretiva MaxRequestsPerChild definie o número de requisições que um processo do servidor irá gerenciar. Depois as requisições MaxRequestsPerChild irão morrer. É definido para 0 por padrão, o que significa que o processo não irá expirar nunca. É apropriado setar este valor para alguns milhares. Isto pode ajudar a previnir vazamento de memória desde que o processo morre depois de servir um número de requisições. Não sete este valor muito baixo, já que criar novos processos causa overhead.

 KeepAlive and KeepAliveTimeout

A diretiva KeepAilve permite que múltiplas requisições possam ser enviadas pela mesma conexão TCP. Isto é útil para páginas com muitas imagens. Se o KeepAlive estiver Off, então para cada imagem, uma nova conexão TCP precisa ser aberta.

KeepAliveTimeout determinada quanto tempo deve esperar até a próxima requisição. Sete para um valor baixo, por volta de 2 a 5 segundos. Se for setado para um valor muito alto, os processos ficam amarrados esperando pelo cliente quando eles poderiam ser utilizados para servir novos clientes.

 Compressão HTTP & Caching

O servidor utiliza os métodos gzip ou deflate para as respostas payload antes que ele seja enviado para os clientes. Então o cliente descompacta o payload. Não existe necessidade de instalar softwares adicionais no lado do cliente desde que a maioria dos navegadores suporta isto. Utilizar compressão irá economizar banda e irá aumentar o tempo de resposta, estudos mostram que em média o ganho da compressão é de 75%. A compressão pode ser habilitada utilizando módulo mod_deflate. O Payload é compactado apenas se o navegador requisitar a compactação, ou então o conteúdo descompactado será enviado. Um navegador capaz de utilizar o conteúdo compactado envia o seguinte cabeçalho na requisição: "Accept-Encoding: gzip,deflate". Então o servidor irá enviar o payload compactado e o cabeçalho da reposta é "Content-Encoding: gzip"

O exemplo a seguir utiliza o telnet para verificar os cabeçalhos de requisição e de resposta:
bash-3.00$ telnet www.webperformance.org 80
Trying 24.60.234.27...
Connected to www.webperformance.org (24.60.234.27).
Escape character is '^]'.
HEAD / HTTP/1.1
Host: www.webperformance.org
Accept-Encoding: gzip,deflate

HTTP/1.1 200 OK
Date: Sat, 31 Dec 2005 02:29:22 GMT
Server: Apache/2.0
X-Powered-By: PHP/5.1.1
Cache-Control: max-age=0
Expires: Sat, 31 Dec 2005 02:29:22 GMT
Vary: Accept-Encoding
Content-Encoding: gzip
Content-Length: 20
Content-Type: text/html; charset=ISO-8859-1 

O module mod_cache pode ser utilizado no lado do servidor, está em produção estável na versão 2.2 do Apache.
 Servidor separado para conteúdo estático e dinâmico

Processos do apache para conteúdo dinâmico consome cerca de 3-20MB de RAM. E cresce para acomodar o conteúdo e nunca diminui até que o processo termine. Digamos que um processo cresca até os 20MB para servir um conteúdo dinâmico. Depois de completar a requisição, ele está libre para servir outra requisição. Se vier uma requisição para uma imagem, então esses 20MB de processos está servindo um conteúdo estático que poderia ser executado por um processo de 1MB. A memória é utilizada ineficientemente.

Utilize uma pequena compilação do Apache (com o mínimo de módulos compilados estaticamente) como sendo o servidor front-end para servir conteúdos estáticos. As requisições para conteúdos dinâmicos serão encaminhadas para um apache robusto (compilado com todos os módulos necessários). Utilizar um servidor front-end leve tem a vantagem de que os conteúdos estáticos são enviados rapidamente sem o consumo alto de memória e apenas o conteúdo dinâmico é passado para o servidor robusto.

Encaminhamento de requisições pode ser implementado utilizando os módulos mod_proxy e mod_rewrite. Suponha que exista um servidor apache leve rodando na porta 80 e o robusto na porta 8088. Então a configuração a seguir pode ser utilizada no apache leve para encaminhar todas as requisições de conteúdo dinâmico para o servidor robusto.
ProxyPassReverse / http://%{HTTP_HOST}:8088/
RewriteEngine on
RewriteCond   %{REQUEST_URI} !.*\.(gif|png|jpg)$
RewriteRule ^/(.*) http://%{HTTP_HOST}:8088/$1 [P]
Todas as requisições, exceto as imagens serão encaminhadas para o apache robusto. As respostas são recebidas pelo servidor front-end que as encaminha para o cliente. Todas as respostas aparentam vir de um único servidor. 
 Conclusão

Configurar o Apache para obter o máximo de performance pode ser traiçoeiro, não existem regras rápidas. Entenda as necessidades do servidor web e experimente com várias opções. Utiliza ferramentas como ab e httperf para medir a performance do servidor. Servidores leves como tux, thttpd também podem ser utilizados como servidores front-end. Se um servidor de banco de dados é utilizado, tenha certeza de que ele está otimizado para que ele não crie nenhum gargalo. No caso do MySQL, mtop pode ser utilizado para monitorar querys lentas. Performance de scripts PHP pode ser melhorada utilizando produtos de cache como o Turck MMCache. Ele elimina o overhead da compilação realizando cache dos scripts em seu estado compilado. 
 Bibliografia

http://news.netcraft.com/archives/web_server_survey.html
http://httpd.apache.org/docs/2.2/dso.html
http://httpd.apache.org/docs/2.2/mpm.html
http://modperlbook.org/html/ch11_01.html
http://www.speedupyoursite.com/18/18-2t.html
http://www.xs4all.nl/~thomas/apachecon/PerformanceTuning.html
http://www.onlamp.com/pub/a/onlamp/2004/02/05/lamp_tuning.html
http://httpd.apache.org/docs/2.2/misc/perf-tuning.html
Linux Server Hacks by Rob Flickenger 
 Fonte

http://www.howtoforge.net/configuring_apache_for_maximum_performance
http://under-linux.org/wiki/

Ligando e Desligando a Máquina

Salvo orientação específica do hardware em uso, ligar uma máquina Unix não costuma envolver maiores detalhes do que o acionamento de um botão liga/desliga no console da máquina e uma eventual intervenção humana logo em seguida, solicitando o boot efetivo do sistema a partir de um menu de opções.

O boot costuma gerar uma razoável quantidade de mensagens que aparecem no console da máquina. Normalmente elas referem-se aos diferentes estágios do reconhecimento e inicialização do hardware. É interessante conhecê-las, não obstante, salvo contingências, podem ser ignoradas até que surja o prompt ou a janela de login.

O desligamento é um processo mais delicado. O Unix utiliza parte da memória principal como cache de disco, a fim de acelerar as operações de leitura e gravação de arquivos. Antes de se desligar a máquina, é necessário assegurar que os discos estejam sincronizados com o cache, o que é feito pelo comando sync, que deve ser precedido do encerramento de todos os processos, a fim de que não ocorra uma dessincronização em seguida. Todos esses passos são tomados pelo comando shutdown:

$ shutdown -y -g 1 -i 5 (Solaris)
$ shutdown -h now (Linux)

Em sistemas baseados em PC, o shutdown por vezes é acionável através do ctrl-alt-del.

Manipulando arquivos e diretórios

O shell é o programa que lê e executa os comandos que você passa a digitar logo após logar no sistema, como cd ou ls. Via de regra você estará usando o Bourne shell (sh), ou o C shell (csh), ou aperfeiçoamentos desses, como o Korn shell (ksh) ou o Bourne again shell (bash). Via de regra você poderá descobrir qual deles está usando ao executar um ps ou um finger com o seu username com argumento.

Obsoleta ou não, a interface de linha de comandos possui características ainda não suficientemente reproduzidas nas interfaces gráficas, como a possibilidade de uso remoto com baixa banda, e a programabilidade. No caso do Unix, há ainda a vantagem dela estar melhor estandardizada que as interfaces gráficas. Em boa parte dessas notas estaremos nos referindo à interface de linha de comandos, mas abordaremos também a interface gráfica ao final. Vejamos alguns típicos comandos dos sistemas Unix-like:

• cat [-r] arquivo1 arquivo2 ... 

  Concatena os vários arquivos, na ordem especificada, copiando o resultado para a saída padrão. Se não houver argumentos, copia a entrada padrão para a saída padrão.

• cd diretório

  Troca o diretório corrente para o diretório especificado, ou para o diretório home, se não houver argumento.

• cp [-r] argumento1 argumento2 ... 

  Copia um ou mais arquivos, trocando seu nome ou criando a cópia num outro diretório, conforme a quantidade e o tipo dos argumentos. Se o primeiro argumento for um diretório, faz uma cópia recursiva de toda a subárvore iniciada nele, desde que a opção -r (recursive) tiver sido especificada.

• chmod nnn argumento1 argumento2 ... 

  Troca os atributos do(s) argumento(s) para nnn (veja atributos de arquivos). Ao invés de nnn, a alteração pode ser especificada por exemplo como a+r ou g-w (a, g e o significam all, group e owner; + significa adicionar e - remover; r,w, x e s indicam respectivamente atributos de leitura, escrita, execução e setuid).

• ls [-la] diretório1 diretório2 ... 

  Lista o conteúdo do(s) diretório(s) especificado(s), ou do diretório corrente se não houver argumento. Opções principais:
  -a Inclui arquivos com nome iniciado por “.” (tais arquivos normalmente armazenam configurações de aplicativos).
  -l Formato longo (veja atributos de arquivos).
  

• ln -s argumento1 argumento2 

  Cria um link simbólico cujo nome é o primeiro argumento, apontando para o segundo argumento. A opção -s não pode ser omitida, ou o link criado será um hard link, ao invés de simbólico.

• man [-k] nome 

  Invoca a man-page associada ao nome, ou exibe uma lista das man pages associadas ao nome, no caso da opção -k (de key) ter sido especificada.

  As man pages Unix são referências técnicas sumárias por vezes difíceis de compreender. Elas são exibidas através do more ou de algum outro paginador semelhante, por isso os comandos do more indicados mais adiante valem para a leitura de man pages, e são úteis para ajudar a localizar informações dentro de uma man page.

  As man pages são divididas em seções, que tradicionalmente são referidas através de parênteses. Por exemplo, a man page shutdown(2) é a man page do system call chamado shutdown, ao passo que a man page shutdown(8) é a man page do comando administrativo shutdown. Além dessas, a seção 1 contém manuais de comandos comuns, a 3 contém manuais de serviços de bibliotecas, a 4 descreve device special files, a 5 descreve formatos de arquivos de configuração, a 6 os jogos eventualmente instalados, e a 7 contém tudo o mais que não couber nas anteriores.

• mkdir diretório1 diretório2 ... 

  Cria os diretório(s) especificado(s).

• more arquivo 

  Exibe de forma paginada o arquivo especificado, ou a entrada padrão no caso de não haver argumento. Aceita vários comandos, entre eles
  

  ESPAÇO, C-b / ?

  Avança/recua uma página. Busca. Exibe relação de comandos.

• mv argumento1 argumento2

  Renomeia o primeiro argumento, que pode ser um arquivo ou um diretório, para o nome dado como segundo argumento. Se ao tentar executar esse comando a mensagem de erro cannot move across filesystems for exibida, é porque a origem e o destino estão em filesystems diferentes. Nesse caso deve-se copiar a origem para o destino usando cp, e depois remover a origem com rm.

• rm [-r] argumento1 argumento2 ... 

  Remove os arquivo(s) especificado(s). Se um argumento for um diretório, remove toda a subárvore iniciada nele, desde que a opção -r (recursive) tenha sido especificada. Via de regra não há modo em sistemas Unix-like de recuperar (undelete) um arquivo removido.

• rmdir diretório1 diretório2 ... 

  Remove os diretório(s) especificado(s), desde que estejam vazios.

• vi arquivo 

  O vi é uma ferramenta obsoleta, mas está está presente em virtualmente qualquerr plataforma Unix-like, e constitui por vezes a única alternativa para edição de arquivos, por isso convém conhecê-lo ao menos de forma minimal. No uso quotidiano, entretanto, normalmente preferir-se-á outras ferramentas, como o emacs ou o pico ou outras.

  h, j, k, l C-f,C-b x,X [n]dd i,ESC a,A J :

  cursor para esquerda/baixo/cima/direita. Página seguinte/anterior. Remove caracter atual/anterior. Remove n linhas (default 1). Entra/sai do modo inserção. Insere após caracter atual/final da linha. Concatena linha seguinte à atual. entra comando, entre eles w (salva), q (sair) e / (busca).

• wc arquivo1 arquivo2 ... 

  Obtém o total de linhas, palavras e caracteres de cada um dos arquivos estipulados, ou da entrada padrão no caso de não haver argumentos.

Shell Scripts

Seqüências de comandos que se necessita repetir com grande frqüência podem ser colocados num arquivo que, ao ser “executado”, ocasiona o disparo de cada um dos comandos da seqüência, na ordem indicada. Um arquivo desses é um shell script, cujo equivalente no MS-DOS são os arquivos “.BAT”.

Mesmo que nunca se escreva nenhum, com certa freqüência é necessário analisar shell scripts a fim de elucidar o modo de uso de determinados comandos, ou de realizar diagnósticos. Suponhamos por exemplo que você não se lembre como usar um comando chamado xpatgen, mas esteja com um shell num diretório que contém scripts, que usam entre outros o xpatgen. Basta então buscar ocorrências dele nos scripts:

$ grep xpatgen *
patgen: xpatgen -cal_bl

Com isso sabemos que o script patgen executa o xpatgen, e relembramos o modo de executar esse comando, o que talvez já seja suficiente para a necessidade do momento.

Shell scripts utilizam com freqüência de variáveis de environment e de parâmetros de linha de comando. Assim, se ao analisar um script você se deparar com algo como $HOST, lembre-se de que nesse ponto será substituído o valor da variável HOST, e que $1 significa o primeiro parâmetro da linha de comandos, $2 o segundo, e assim por diante.

Variáveis de Environment

Além dos parâmetros de linha de comandos como -l ou outros, pode-se também passar parâmetros a um programa através do uso de variáveis de environment. As mais comuns são:

• PATH – Lista os diretórios (separados por “:”) onde os executáveis serão procurados, tipicamente /bin, /usr/bin e /usr/X11/bin, entre outros.
• TERM – Tipo do terminal, por exemplo xterm ou vt100 (veja Configurando o Terminal).
• DISPLAY – Display default para as aplicações Xwindows.

Para exibir o valor de uma delas pode-se usar echo, antepondo o operador $ ao nome da variável, por exemplo:

$ echo $TERM

Existem dois estilos de atribuição de valores a variáveis de environment, o do Bourne shell, usado pelo sh, ksh e bash:

$ TERM=vt100; export TERM

e o do C shell, usado pelo csh e pelo tcsh:

% setenv TERM vt100

Uso de Metacaracteres

O metacaracter mais utilizado provavelmente é o “*”. Por exemplo,

$ rm *

irá remover todos os arquivos do diretório corrente. É necessário prestar atenção a dois detalhes quando se usa metacaracteres:

1. O caracter “.” não tem o significado de separador entre nome e sufixo que possui no MS-DOS, por isso “*.*” significa todos os arquivos em cujo nome ocorre ao menos um ponto.

2. A expansão do metacaracter é feita pelo shell, e não pela aplicação, por isso o comando

   $ mv *.txt *.bak

   não irá surtir o efeito esperado de renomear todos os arquivos que terminam com “.txt” para “.bak” (para essa operação deve-se usar o comando for).

Os shells Unix aceitam também o metacaracter “?”, que significa qualquer caracter e tambem intervalos, como [0-9] (qualquer dígito decimal), entre outros.

Uso de Expressões Regulares

Aplicativos Unix via de regra aceitam expressões regulares como argumentos de busca. Os usos mais freqüentes delas são bem ilustrados através do aplicativo grep. Nos casos abaixo ele será utilizado para buscar uma dada expressão em todos os arquivos do diretório corrente:

1. Busca de ocorrências de algum dos anos da década de 80:

   $ grep "198[0-9]" * 

2. Busca de uma ocorrência da palavra “yellow” seguida de uma ocorrência da palavra “page”, separadas por zero ou mais caracteres quaisquer:

   $ grep -i "yellow.*page" * 

3. Busca de uma das palavras “roget” ou “thesaurus”:

   $ grep -i "roget\|thesaurus" * 

A sintaxe das expressões regulares pode variar um pouco, dependendo da plataforma e da ferramenta. Via de regra as diferenças consistem em proteger-se ou não alguns caracteres especiais, e nas extensões que algumas ferramentas introduzem. Note por exemplo, o uso do egrep, em comparação com o uso do grep acima:

$ egrep -i "roget|thesaurus" * 

Via de regra todas as ferramentas Unix que lidam com texto, como o more, o sed, e o vi, entre outros, aceitam expressões regulares como argumento de buscas.

Manipulando processos

Um processo é um programa em execução. Num computador que possui apenas uma cpu, na verdade apenas um processo pode estar sendo executado em cada instante. O que se faz é executar um processo durante uma fração fixa de segundo, congelá-lo e passar a executar um outro, e assim por diante, criando a ilusão de simultaneidade.

Através do comando ps pode-se examinar os processos correntes. Por exemplo:

$ ps
PID TTY STAT TIME COMMAND
45 v02 S 0:00 -bash
105 v02 R 0:00 ps

O ps em geral omite muitos processos a fim de exibir uma saída limpa. Através das opções a e x (ou e no Solaris), pode-se exibir todos os processos correntes. O número de um processo é usado, por exemplo quando é necessário interromper prematuramente a sua execução, através do comando kill.

A finalidade primária do comando kill não é matar um processo, mas enviar um sinal para ele. O Unix possui diversos sinais predefinidos, como SIGHUP, SIGPIPE, SIGTERM, etc. O atendimento a um sinal entretanto é responsabilidade do processo, ou do programador que fez o programa, e por isso a forma com que cada processo reagirá a cada sinal poderá variar. A fim de se interromper a execução de um processo, deve-se enviar para ele o sinal SIGKILL:

$ kill -SIGKILL 45
$ kill -9 45

As duas formas acima em geral são equivalentes (o número associado a cada sinal pode variar com a plataforma).

O caracter “&” colocado ao final da linha de comandos instrui o shell para disparar o comando em background, a fim de que se possa continuar usando o shell mesmo antes desse comando encerrar a sua execução.

O comando nice faz com que um processo seja disparado com baixa prioridade.

 $ nice gzip -9 *

O comando nohup faz com que o processo sendo disparado se torne imune ao sinal SIGHUP. Em combinação com o &, ele permite o disparo de programas que permanecerão em execução mesmo após o logout do usuário. Exemplos:

 $ nohup gzip -9 * &

Através do comando at pode-se programar a execução de um comando para um horário determinado. Por exemplo:

$ at now + 1 minute
ls
ctrl-d

O comando ls será dessa forma executado daqui a um minuto. Note que na linha seguinte do comando at o que se escreve é na verdade um shell script, terminado com control-d. Ao invés de digitá-lo, poder-se-ia lê-lo de um arquivo através do redirecionamento da entrada:

$ at now + 1 minute <meuscript 

A execução periódica de um comando se faz através do cron, que é disparado no boot do sistema e monitora as tabelas de execução periódica de comandos de todos os usuários (a cada usuário corresponde uma tabela). Uma tal tabela é chamada crontab. Através dela pode-se especificar que um comando seja executado a cada hora, ou diariamente, ou semanalmente, etc. A edição, inspeção e remoção da crontab de um usuário é feita através do comando crontab, e opções -e, -l e -d. Cada linha da crontab indica um comando e a periodicidade com que ele deve ser executado (minutos, horas, dias do mês, meses e dias da semana). Por exemplo:

$ crontab -l
40 07 * * * updatedb
0 22 5 * * pagamento
0 6,12,15,18 * * * fetch
0 0 * * 6 backup

No caso a crontab contém três comandos. O updatedb deverá ser executado todos os dias às 7:40. O comando pagamento deverá ser executado às 22:00 do dia 5 de cada mês, e o backup será executado à zero hora de cada sábado.

Note que a crontab é um arquivo texto simples, e quando se executa o comando crontab com a opção -e, entra-se num editor de textos para editá-la. O editor de textos utilizado normalmente será o vi, ou aquele especificado na variável de environment EDITOR.

Configurando o terminal

O terminal pode ser um terminal no sentido estrito do termo, conectado ao computador por uma linha serial, ou então o próprio console da máquina, ou uma aplicação como o xterm emulando um terminal dentro do Xwindows,

A configuração do terminal é necessária para executar aplicativos como editores de texto visuais, ou para os comandos de teclado como backspace serem corretamente reconhecidos. Essa configuração envolve a configuração do driver do sistema, feita através do comando stty e o informe da aplicação, normalmente feito através da variável TERM. Vejamos exemplos de situações onde uma delas ou ambas são necessárias, e como realizá-la:

1. Ao pressionar a tecla backspace, ao invés de ser apagado o caracter anterior, surge na tela os caracteres “^H”. Solução:

   $ stty erase ^H

2. Ao executar o more ou o vi, algumas linhas permanecem escondidas, ou o scroll comporta-se de forma errática. Solução: cheque quantas linhas (vamos supor: 24) e quantas colunas (vamos supor: 80) o seu terminal/emulador possui e execute

   $ stty rows 24 cols 80

3. Após o uso de alguma aplicação, os caracteres aparecem trocados ou o eco deixou de funcionar, ou quando pressiono enter o cursor permanece na mesma linha. Tentativa de solução:

   $ stty sane

4. Ao tentar executar uma aplicação, a mensagem de erro terminal capability cm required, ou Terminal type is not defined, ou Terminal type is not powerful enough, ou outra semelhante foi exibida. Solução: cheque o tipo de terminal que você está usando ou emulando (dificilmente será algo diferente de xterm ou vt100) e atribua para a variável de environment TERM esse valor.

Diretórios Principais do Sistema

No Unix não há o conceito de nomes de drives, como C:, mas todos os paths partem de uma raiz comum, o root directory “/”. Quando a máquina possui vários discos diferentes (ou ao menos várias partições diferentes de um mesmo disco), cada uma delas em geral corresponderá a uma subárvore do filesystem, como /usr, /var ou ainda nomes não standard como /disco2, que são chamados de seus pontos de montagem. O comando mount executado sem parâmetros listará os diferentes dispositivos físicos montados (discos locais e remotos e suas partições) e a subárvore correspondente a cada um deles. A tabela que indica todas essas montagens é o arquivo /etc/fstab. Apesar de algumas pequenas diferenças de plataforma para plataforma, os diretórios principais do sistema são:

O termo básico aplicado acima aos diretórios /bin e /lib quer significar principalmente essenciais para o boot e operação mínima do sistema. A separação desses elementos básicos, em contraposição aos que são deixados no /usr, deve-se a razões práticas, principalmente para facilitar a organização de redes de máquinas compartilhando subárvores de diretório. De fato, é comum que o diretório /usr ao invés de estar replicado em todas as máquina da rede esteja residindo fisicamente num único disco, e sendo compartilhado por todas as máquinas.

Atributos e Nomes de Arquivos

No Unix cada arquivo (inclusive diretórios, que são casos particulares de arquivos), conta com um conjunto de atributos de leitura, escrita e execução, que são setáveis através do comando chmod, e podem ser exibidos pelo comando ls -l:

$ ls -l /bin/cat
-rwxr-xr-x 1 root root 16584 Dec 16 20:09 /bin/cat

A string -rwxr-xr-x representa os atributos do arquivo /bin/cat. O primeiro caracter (-) significa que se trata de um arquivo regular, em contraposição aos diretórios (d), device special files (c) e links simbólicos (l). Os 9 caracteres restantes informam as permissões de leitura, escrita e execução desse arquivo relativas ao seu proprietário, ao seu grupo, e a todos os demais. O proprietário e o grupo são informados logo à direita, e no caso são o usuário root e o grupo root.

Note que no Unix não existem os atributos de arquivo oculto (“hidden”) e do sistema (“system”), suportados no MS-DOS. Não obstante, arquivos cujo primeiro caractere é ponto (“.”) normalmente são omitidos pelo ls, a não ser que se utilize a opção -a (de “all”), conforme comentamos no início.

Um atributo importantíssimo existente no Unix é o chamado setuid, através do qual um processo adquire ao ser executado os privilégios do owner do arquivo. Isso é frequentemente utilizado por programas que são disparados por usuários não privilegiados mas que por algum motivo necessitam dos privilégios do superusuário, por exemplo:

$ ls -l /usr/sbin/pppd
-rwsr-xr-x 1 root bin 104876 Apr 27 1998 /usr/sbin/pppd

Sem os privilégios de superusuário, um usuário comum não conseguiria configurar a interface ppp e nem alterar a tabela de rotas do sistema, no momento em que se conecta ao provedor Internet. Assim, o pppd, ao ser executado, requisitará os privilégios do owner do arquivo, que no caso é o superusuário, e dessa forma ele poderá realizar essas operações.

No Unix via de regra são suportados nomes “longos” (até 64 ou às vezes até 256 caracteres), e o “.” não é um separador entre o nome do arquivo e sua extensão, mas um caracter como os outros. Não obstante, a noção de “sufixo” é utilizada informalmente para facilitar a identificação de alguns formatos de arquivos, por exemplo:

Archives (o termo não tem correspondente em português) são concatenações de vários arquivos ou de subárvores inteiras num único arquivo. Em Unix, tipicamente são produzidos com tar:

$ tar cvf /tmp/etc.tar /etc
$ tar tvf /tmp/etc.tar /etc
$ cd  /tmp; tar xvf etc.tar

O primeiro comando irá criar o archive /tmp/etc.tar, composto por toda a subárvore /etc. O segundo exibirá o conteúdo desse archive. O terceiro irá extrair todo o seu conteúdo dentro do diretório /tmp, ou seja, recriará aquela mesma subárvore como uma subárvore do diretório /tmp.

Intercambiando Disquetes com o MS-DOS

Via de regra as plataformas Unix-like oferecem ferramentas para lidar com disquetes “formatados” no MS-DOS (ou, mais precisamente, disquetes que usam FAT). Um set de ferramentas bastante popular é o mtools, que oferece clones das ferramentas do MS-DOS. Exemplos de uso:

$ mformat a:
$ mcopy a:relat.txt .
$ mdir a:

Versões recentes dessas ferramentas lidam também com o VFAT do Windows 95, que permite nomes de arquivos “longos”.

O intercâmbio de arquivos texto entre Unix e MS-DOS deve ser feito com cuidado. Por herança das antigas impressoras, o fim-de-linha no MS_DOS é codificado através de dois caracteres (CR e LF), enquanto no Unix há apenas um (o LF), além do que o final do arquivo é sinalizado no MS-DOS por um CTRL-Z. O mcopy possui a opção -t para realizar essas conversões quando copia de ou para disquetes.

O Kernel

O Kernel do Unix (e de virtualmente qualquer outro sistema operacional) possui um papel de que convém ter noções, a fim de se poder compreender melhor o funcionamento do sistema, realizar diagnósticos e procedimentos administrativos como adição de componentes de hardware. Algum conhecimento do papel do kernel é importante também para se ter uma noção mais clara do uso de arquivos especiais e do diretório /proc.

O Kernel ordinariamente reside no filesystem como um outro arquivo qualquer. No Linux, ele é em geral o arquivo /vmlinuz ou /boot/vmlinuz, ou ainda /boot/vmlinuz-2.0.36. Ele é um programa, ainda que um pouco diferente dos programas de aplicação como o /bin/ls. O kernel é carregado e posto em execução no boot da máquina, e a sua execução somente se encerra com o shutdown.

De forma simplificada, o seu papel é num primeiro momento reconhecer o hardware e inicializar os respectivos drivers. Em seguida ele entra num estado administrativo onde funciona como intermediário entre as aplicações e o hardware. Por exemplo, quando uma aplicação necessita alocar mais memória, ela solicita isso ao kernel. É o kernel que distribui o tempo de CPU aos vários processos ativos. É ele que habitualmente realiza a entrada e saída de dados nas diferentes portas de comunicação.

É por isso que a adição de hardware novo a uma máquina pode requerer a substituição ou ao menos a reconfiguração do kernel. Os kernels mais recentes do Linux oferecem vários mecanismos de configuração que os tornam sobremaneira flexíveis, a ponto de ser rara a necessidade de substituição do kernel. Os dois mecanismos fundamentais de se configurar a operação do kernel são a passagem de parâmetros no momento do boot (realizada pelo LILO) e a carga de módulos, feita manualmente ou por mecanismos automáticos como o kerneld.

O diálogo entre as aplicações e o kernel realiza-se fundamentalmente através dos system calls, que são serviços que o kernel oferece, como por exemplo read(2). Os device special files são maneiras de se referir ao kernel os dispositivos físicos ou lógicos com que se pretende operar, por exemplo a primeira porta serial ou a segunda unidade de fita, ou o disco principal do sistema. Neles, o importante não é o nome, mas sim os números de dispositivo, ou mais precisamente o major e o minor device numbers. Device special files são criados através do comando mknod, ou através de interfaces mais amigáveis, como o comando MAKEDEV.

Os sistemas Unix-like mais recentes oferecem um outro mecanismo de comunicação com o kernel, que é o filesystem /proc. As entradas desse filesystem são pseudo-arquivos cujo conteúdo reflete o estado atual de inúmeras estruturas de dados internas do kernel. Assim, um programa de aplicação passa a poder comunicar-se com o kernel através dos mecanismos ordinários de leitura e escrita de arquivos.

Em muitos casos a comunicação entre as aplicações e o kernel é intermediada por bibliotecas, principalmente a libc. Elas oferecem serviços de mais alto nível que os system calls do kernel, tornando mais simples o trabalho de programação.

Redirecionamento da Entrada e da Saída; Pipes

Processos num sistema Unix habitualmente possuem três dispositivos de I/O “padrões”, a “saída padrão”, a “entrada padrão” e a “saída de erros”. O Unix permite que esses dispositivos (e outros) sejam definidos no momento da execução, podendo escolher o console, um “pipe”, a impressora, um circuito virtual de rede conectando duas máquinas, uma linha física serial ou outras coisas.

Usuários de MS-DOS talvez já tenham feito coisas como

C> DIR >PRN:

para imprimir a saída de um comando. Essa sintaxe foi herdada do Unix daí a semelhança:

$ ls -l >/dev/lp1

Naturalmente tanto no MS-DOS quanto no Unix existem formas mais apropriadas para se imprimir algo, mas no momento esse exemplo convém. Shells do estilo “Bourne” (sh, ksh, bash) permitem redirecionamento da saída de erros através da seguinte sintaxe:

$ rm /bin/ls 2>/tmp/error

O “2” deve-se a que, internamente, a saída de erros corresponde ao descritor 2 (o 0 é a entrada padrão e o 1 é a saída padrão).

A entrada pode ser redirecionada de forma semelhante:

$ wc </tmp/error 

Os shells Unix oferecem um recurso para a ligação da saída padrão de um processo com a entrada padrão de outro, chamado pipe:

$ ls|wc

No exemplo a saída do ls está sendo usada como entrada do wc. Note que o shell dispara os dois processos ao mesmo tempo. Se o primeiro estiver produzindo saída numa taxa superior à que o segundo lê, o sistema operacional paralizará o primeiro sempre que o buffer que armazena o tráfego estiver cheio. Isso significa, por exemplo, que um pipe pode ser usado mesmo quando o volume total da saída do primeiro processo é extraordinariamente grande, por exemplo quando se tenta localizar informações de arquivos deletados através de um dump de todos os setores do disco.

Comunicação Serial e Paralela

O Unix apresenta as portas de comunicação seriais e paralelas na forma de arquivos especiais. Já vimos um exemplo do seu uso no ítem Redirecionamento da Entrada e da Saída, em que fizemos a impressão da saída de um comando.

Na comunicação entre dois computadores, utiliza-se freqüentemente portas seriais, e às vezes também as paralelas. Em muitos casos, quando a distância entre os dois é grande, haverá uso de modems, e eventualmente também de uma linha telefônica. Através de três exemplos práticos pode-se ter um bom panorama do uso de comunicação serial no Unix. Como os procedimentos variam um pouco dependendo das plataformas em uso, só é possível indicá-los de forma genérica:

a) Adição de um terminal

1. Conectar a serial do terminal com a da máquina Unix.
2. Disparar no Unix a variante do getty disponível.
3. Logar no terminal.
4. Transferir arquivos se o terminal oferecer esse recurso.

b) Conexão a um sistema remoto

1. Disparar algum emulador de terminal disponível.
2. Selecionar a serial em que o modem está conectado.
3. Configurar o modo de operação da serial (velocidade, bits).
4. Configurar o modem através de comandos AT, se necessário.
5. Instruir o modem para discar, com ATD
6. Aguardar a negociação.
7. Logar.

c) Estabelecimento de um link ppp

1. Executar a conexão ao sistema remoto como indicada acima.
2. Iniciar o ppp no sistema remoto.
3. Disparar o pppd localmente.

Em PCs, os conectores externos das portas seriais são conectores DB-9 ou DB-25 macho, e os das paralelas são DB-25 fêmea.

Configuração do TCP/IP

Numa rede TCP/IP, a cada máquina está associado um número IP, que é um inteiro de 32 bits, normalmente escrito na forma de octetos, como 192.168.0.5. A cada máquina está associado um nome, como por exemplo marte ou pimenta.

A atribuição tanto do número quanto do nome é feita durante o processo de boot, a partir da especificação deles feita através da edição manual de arquivos de configuração e/ou do uso de aplicativos de gerenciamento do sistema específicos de cada plataforma.

Na verdade, o número IP não está associado à máquina, mas a uma determinada interface dela. Via de regra, a interface envolvida é a ethernet. Tanto para exibir quanto para setar manualmente o número IP de uma interface usa-se o comando ifconfig. Por exemplo, o comando:

$ ifconfig -a

irá listar todas as interfaces com informações de cada uma. A interface ethernet costuma chamar-se le0 (Solaris) ou eth0 (Linux). Além do ethernet, é comum usar-se portas seriais para criar interfaces TCP/IP, principalmente para criar links com linhas telefônicas. As placas ethernet costuma oferecer dois ou mais tipos de conectores. Ela pode ou não descobrir automaticamente qual está em uso. Em caso negativo, você deverá informá-la, o que habitualmente é feito através de um software de configuração que acompanha a placa.

O passo seguinte é a configuração das rotas. Através delas a máquina sabe por onde enviar datagramas a fim de que eles cheguem em seus destinos. Equivale de certa forma à sinalização do tráfego urbano, com placas indicativas da direção a tomar para atingir cada destino (Ponte do Limão à esquerda, ou Avenida Bandeirantes em frente, etc).

Cada rota envolve um destino, uma máscara, um gateway e uma interface. Pode-se exibir todas elas através do comando netstat:

$ netstat -r
Destination Gateway Genmask Iface
192.168.1.0 * 255.255.255.0 eth0
127.0.0.0 * 255.0.0.0 lo
default 192.168.1.1 0.0.0.0 eth0

Suponha que você deseja atingir a máquina 192.168.1.7. A aplicação da tabela de rotas indica, através de uma operação e bit-a-bit entre 192.168.1.7 e a máscara 255.255.255.0, que deve ser usada a primeira rota. Como não há gateway, a comunicação será feita diretamente através do ethernet.

Se o destino agora for 200.136.35.65, as duas primeiras rotas não nos servirão (experimente aplicar o e como no caso anterior). Portanto será usada a rota default, e como ela especifica um gateway, a comunicação terá que ser feita através dele. Assim, toda vez que se pretender enviar alguma informação para o 200.136.35.65, esta será enviada antes para o gateway 192.168.1.1, na esperança de que este consiga roteá-la para o seu destino.

Serviços TCP/IP

Atualmente é comum as pessoas confundirem Internet com a teia mundial WWW, entretanto muito antes de surgir a teia, a Internet já usava um sem-número de serviços construídos a partir dos protocolos de transporte TCP e UDP.

Um circuito TCP entre duas máquinas equivale a um pipe duplo entre dois processos, cada um rodando em uma das máquinas. O telnet é um típico serviço que se utiliza desse recurso, a fim de criar sessões remotas. Pode-se exibir todas os circuitos TCP ativos através do comando netstat:

$ netstat -t

O FTP, por sua vez, cria dois circuitos, utilizando um para envio de comandos e outro de dados. Através do uso de alguns comandos simples, permite transferir arquivos de ou para uma máquina remota. Os principais comandos do FTP são:

Disparo do Xwindows e das suas aplicações

O disparo do X é desnecessário quando o sistema opera num runmode em que o X está permanentemente ativo. Nesse caso, o próprio login é feito numa janela, ao invés de no console no modo texto.

Quando for necessário disparar o X manualmente, via de regra haverá dois ou três scripts já preparados para isso, como o startx ou o openwin. O que eles fazem basicamente é definir uma série de parâmetros e executar o xinit, que por sua vez dispara o Xserver e o Window Manager.

Convém não perder de vista que o Xwindows é um sistema cliente-servidor. O Xserver é o programa que conhece o hardware gráfico, é capaz de colocar o display no modo desejado, e desenhar nele. As aplicações conectam o Xserver através de um circuito TCP (por exemplo) e enviam a ele comandos através dos quais desenham as suas janelas e o conteúdo delas. O Window Manager é responsável por desenhar as molduras das janelas, criar menus de aplicações, e controlar o foco.

Assim, é natural que no disparo de cada aplicação seja necessário especificar qual é o server a ser utilizado. Isso normalmente se faz através da opção de linha de comando -display, ou através da variável de environment DISPLAY.

$ xterm -display 192.168.0.1:0.0
$ DISPLAY=192.168.0.1:0.0; export DISPLAY; xterm

Quando o Xserver está rodando numa máquina Unix, a permissão para um cliente usá-lo é dada através do comando xhost:

$ xhost +192.168.1.5 (autoriza o cliente 192.168.1.5)
$ xhost -192.168.1.5 (desautoriza o cliente 192.168.1.5)
$ xhost (lista os clientes autorizados)

Pode-se autorizar permanentemente um cliente a usar um determinado Xserver adicionando-o ao arquivo /etc/X0.hosts (um cliente por linha).

Ao longo dos anos foram sendo criados inúmeros Window Managers diferentes para o Xwindows. Algumas vezes além do window manager foram criadas também complexas bibliotecas oferecendo serviços de alto nível que além de simplificar o trabalho de programação tamém permitem estandardizar o aspecto visual e os recursos das janelas das aplicações. Um dos produtos mais conhecidos dessa linha é o Motif. O advento do Free Software criou outras opções, sendo as mais em voga atualmente o GTK e o QT, que são utilizados respectivamente pelo GNOME e pelo KDE.

Procedimentos de boot e o init

O boot do Unix consiste inicialmente na carga e execução do kernel. Em seguida, é disparado o processo init, que segue as instruções do arquivo /etc/inittab, que portanto é o ponto de partida para tudo o que se pretenda configurar a nível de disparo de processos ao longo do boot.

O inittab não é um script como o AUTOEXEC.BAT, mas uma lista de ações, algumas delas de valor permanente para todo o curso da operação do sistema. Cada linha válida representa um processo que o init deve disparar. O termo respawn significa que, além de disparar, o init deverá monitorar o processo e, se porventura ao longo da operação do sistema ele for encerrado, o init deverá redispará-lo.

Via de regra as linhas do inittab referem-se ou à chamada de scripts de configuração inicial do sistema, que são executados apenas uma vez, ou aos processos de controle de login no sistema, que são redisparados sempre que ocorre um logout. O inittab inclui ainda o conceito de runlevel, o que cria a flexibilidade de se poder inicializar a máquina em um de vários possíveis modos de operação. Na prática, costuma haver três modos principais, o single-user, utilizado para manutenção, um gráfico e um não gráfico.

Quanto aos scripts de configuração (normalmente são os arquivos e/ou diretórios /etc/rc.*, dependendo da plataforma a mecânica de disparo deles pode ser bastante complexa. Note que cada runlevel pode disparar ou deixar de disparar alguns scripts, a fim de estabelecer o modo de operação desejado. Em quase todas as versões mais recentes do Linux essa mecânica segue o padrão dos diretórios /etc/rc.d/rcN.d, onde N é cada um dos runlevels. O conteúdo desses diretórios são links para cada um dos scripts de ativação ou desativação de serviços básicos (interfaces de rede, servidor de email, etc), com números embutidos nos nomes dos links, a fim de definir a ordem em que devem ser processados.

Referências

Virtualmente qualquer informação técnica sobre sistemas Unix-like pode ser obtida na Teia Mundial. Estou colocando aqui apenas um referência clássica (o Livro do Bach), e um link para uma lista de pontos de entrada de documentação sobre Linux.

[1] Bach, M. J. The Design of the Unix Operating System, Prentice-Hall, 1986.

[2] Alguns links de Linux, inclusive para materiais em português, estão disponíveis em http://www.ime.usp.br/~ueda/ldoc/links.html .

Fonte: http://www.ufrgs.br

O nome Linux surgiu da mistura de Linus + Unix. Linus é o nome do criador do Linux, Linus Torvalds. E Unix, é o nome de um sistema operacional de grande porte, no qual contaremos sua história agora, para que você entenda melhor a do Linux.

A origem do Unix tem ligação com o sistema operacional Multics, projetado na década de 1960. Esse projeto era realizado pelo Massachusets Institute of Technology (MIT), pela General Eletric (GE) e pelos laboratórios Bell (Bell Labs) e American Telephone na Telegraph (AT&T). A intenção era de que o Multics tivesse características de tempo compartilhado (vários usuários compartilhando os recursos de um único computador), sendo assim o sistema mais arrojado da época. Em 1969, já existia uma versão do Multics rodando num computador GE645. 

Ken Thompsom era um pesquisador do Multics e trabalhava na Bell Labs. No entanto, a empresa se retirou do projeto tempos depois, mas ele continuou seus estudos no sistema. Desde então, sua idéia não era continuar no Multics original e sim criar algo menor, mas que conservasse as idéias básicas do sistema. A partir daí, começa a saga do sistema Unix. Brian Kernighan, também pesquisador da Bell Labs, foi quem deu esse nome.

Em 1973, outro pesquisador da Bell Labs, Dennis Ritchie, rescreveu todo o sistema Unix numa linguagem de alto nível, chamada C, desenvolvida por ele mesmo. Por causa disso, o sistema passou a ter grande aceitação por usuários externos à Bell Labs.

Entre 1977 e 1981, a AT&T, alterou o Unix, fazendo algumas mudanças particulares e lançou o System III. Em 1983, após mais uma série de modificações, foi lançado o conhecido Unix System IV, que passou a ser vendido. Até hoje esse sistema é usado no mercado, tornando-se o padrão internacional do Unix. Esse sistema é comercializado por empresas como IBM, HP, Sun, etc. O Unix, é um sistema operacional muito caro e é usado em computadores poderosos (como mainframes) por diversas multinacionais.

Qual a relação entre o Unix e o Linux, ou melhor, entre o Unix e Linus Torvalds?

Para responder essa pergunta, é necessário falar de outro sistema operacional, o Minix. O Minix é uma versão do Unix, porém, gratuita e com o código fonte disponível. Isso significa que qualquer programador experiente pode fazer alterações nele. Ele foi criado originalmente para uso educacional, para quem quisesse estudar o Unix “em casa”. No entanto, vale citar que ele foi escrito do “zero” e apesar de ser uma versão do Unix, não contém nenhum código da AT&T e por isso pode ser distribuído gratuitamente.

A partir daí, “entra em cena” Linus Torvalds. Ele era um estudante de Ciências da Computação da Universidade de Helsinki, na Filândia e em 1991, por hobby, Linus decidiu desenvolver um sistema mais poderoso que o Minix. Para divulgar sua idéia, ele enviou uma mensagem a um grupo pela Usenet (uma espécie de antecessor da Internet). A mensagem pode ser vista no final deste artigo. No mesmo ano, ele disponibilizou a versão do kernel (núcleo dos sistemas operacionais) 0.02 e continuou trabalhando até que em 1994 disponibilizou a versão 1.0. Até o momento em que este artigo estava sendo escrito, a versão atual era a 2.6.

O Linux é um sistema operacional livre e é uma re-implementação das especificações POSIX (padronização da IEEE, Instituto de Engenharia Elétrica e Eletrônica) para sistemas com extensões System V e BSD. Isso signfica que o Linux é bem parecido com Unix, mas não vem do mesmo lugar e foi escrito de outra forma.

Mas por que o Linux é gratuito?

Linus Torvalds, quando desenvolveu o Linux, não tinha a inteção de ganhar dinheiro e sim fazer um sistema para seu uso pessoal, que atendesse suas necessidades. O estilo de desenvolvimento que foi adotado foi o de ajuda coletiva. Ou seja, ele coordena os esforços coletivos de um grupo para a melhoria do sistema que criou. Milhares de pessoas contribuem gratuitamente com o desenvolvimento do Linux, simplesmente pelo prazer de fazer um sistema operacional melhor.

Licença GPL

O Linux está sob a licença GPL, permite que qualquer um possa usar os programas que estão sob ela, com o compromisso de não tornar os programas fechados e comercializados. Ou seja, você pode alterar qualquer parte do Linux, modificá-lo e até comercialiazá-lo, mas você não pode fechá-lo (não permitir que outros usuários o modifiquem) e vendê-lo.

GNU

A história do Linux não termina aqui. É necessário saber também o que é GNU. GNU é um projeto que começou em 1984 com o objetivo de desenvolver um sistema operacional compatível com os de padrão Unix. O Linux em si, é só um kernel. Linus Torvalds, na mesma época que escrevia o código-fonte do kernel, começou a usar programas da GNU para fazer seu sistema. Gostando da idéia, resolveu deixar seu kernel dentro da mesma licença.

Mas, o kernel por si só, não é usável. O kernel é a parte mais importante, pois é o núcleo e serve de comunicador entre o usuário e o computador. Por isso, com o uso de variantes dos sistemas GNU junto com o kernel, o Linux se tornou um sistema operacional.

Mas você pode ter ficado confuso agora. O que é o Linux então? O que é GNU? Simplesmente, várias pessoas uma versões modificadas dos sistemas GNU, pensando que é o Linux em si. Os programadores que trabalham com ele, sabem que o Linux, é basicamente o kernel, conforme já foi dito, mas todos, chamam esse conjunto de Linux (há quem defenda o uso de GNU/Linux).

Finalizando, o projeto GNU é um dos responsáveis pelo sucesso do Linux, pois graças à �mistura� de seus programas com o kernel desenvolvido por Linus Torvalds, o Linux vem mostrando porque é um sistema operacional digno de habilidades insuperáveis por qualquer outro sistema.

Mensagem de Linus Torvalds na Usenet

Abaixo segue a mensagem publicada por Linus Torvalds via Usenet na divulgação de seu projeto. A tradução para português foi disponibilizada logo abaixo da mensagem em inglês. Ambas as mensagens foram retiradas deste link: http://www.rootlinux.com.br/documentos/downloads/Historia_do_Linux.txt.

De:Linus Benedict Torvalds (torvalds@klaava.Helsinki.FI)
Assunto:[comp.os.minix] Free minix-like kernel sources for 386-AT
Newsgroups:comp.archives
Data:1991-10-05 09:24:25 PST

Archive-name: auto/comp.os.minix/Free-minix-like-kernel-sources-for-386-AT

Do you pine for the nice days of minix-1.1, when men were men and wrote
their own device drivers? Are you without a nice project and just dying
to cut your teeth on a OS you can try to modify for your needs? Are you
finding it frustrating when everything works on minix? No more all-
nighters to get a nifty program working? Then this post might be just
for you

As I mentioned a month(?) ago, I’m working on a free version of a
minix-lookalike for AT-386 computers. It has finally reached the stage
where it’s even usable (though may not be depending on what you want),
and I am willing to put out the sources for wider distribution. It is
just version 0.02 (+1 (very small) patch already), but I’ve successfully
run bash/gcc/gnu-make/gnu-sed/compress etc under it.

Sources for this pet project of mine can be found at nic.funet.fi
(128.214.6.100) in the directory /pub/OS/Linux. The directory also
contains some README-file and a couple of binaries to work under linux
(bash, update and gcc, what more can you ask for . Full kernel
source is provided, as no minix code has been used. Library sources are
only partially free, so that cannot be distributed currently. The
system is able to compile “as-is” and has been known to work. Heh.
Sources to the binaries (bash and gcc) can be found at the same place in
/pub/gnu.

ALERT! WARNING! NOTE! These sources still need minix-386 to be compiled
(and gcc-1.40, possibly 1.37.1, haven’t tested), and you need minix to
set it up if you want to run it, so it is not yet a standalone system
for those of you without minix. I’m working on it. You also need to be
something of a hacker to set it up (?), so for those hoping for an
alternative to minix-386, please ignore me. It is currently meant for
hackers interested in operating systems and 386′s with access to minix.

The system needs an AT-compatible harddisk (IDE is fine) and EGA/VGA. If
you are still interested, please ftp the README/RELNOTES, and/or mail me
for additional info.

I can (well, almost) hear you asking yourselves “why?”. Hurd will be
out in a year (or two, or next month, who knows), and I’ve already got
minix. This is a program for hackers by a hacker. I’ve enjouyed doing
it, and somebody might enjoy looking at it and even modifying it for
their own needs. It is still small enough to understand, use and
modify, and I’m looking forward to any comments you might have.

I’m also interested in hearing from anybody who has written any of the
utilities/library functions for minix. If your efforts are freely
distributable (under copyright or even public domain), I’d like to hear
from you, so I can add them to the system. I’m using Earl Chews estdio
right now (thanks for a nice and working system Earl), and similar works
will be very wellcome. Your (C)’s will of course be left intact. Drop me
a line if you are willing to let me use your code.

Tradução para o português:

Você sente falta dos dias do Minix/1.1 quando homens eram homens e escre-
viam seus próprios drivers? Você está sem nenhum projeto legal e está
ansioso para mexer num sistema operacional que você possa modificar
para atender às suas necessidades? Você está achando chato quando tudo
funciona no minix? Não ficar mais a noite inteira tentando arrumar
um programa legal? Então esta mensagem pode ser para você.

Como eu disse há um mês (?) atrás, eu estou trabalhando numa versão
grátis dum similar para o Minix, para computadores AT-386. Ela
finalmente atingiu o estágio onde já é usável (apesar de talvez
não ser, dependendo do que você quer), e eu estou a fim de colocar
(online) o código fonte para uma distribuição melhor. É apenas a ver-
são 0.02 (com mais um patch) mas eu já rodei bash/gcc/gnu-make/gnu-sed/
compress dentro dela.

Códigos fontes para este hobby meu podem ser encontradas em nic.funet.fi
(128.214.6.100) no diretório /pub/OS/Linux. O diretório também contem
alguns arquivos README e um conjunto de arquivos para permitir
trabalho no Linux (bash, update e GCC, o que mais você queria? .
O código-fonte do kernel está disponível por inteiro, porque nenhum
do código do Minix foi usado. Os códigos-fontes das bibliotecas são
apenas parcialmente abertos, portanto não podem ser distribuidos. O
sistema pode compilar “como está” e é provado que funciona. (hehehe)
Código-fonte dos programas (bash e gcc) podem ser encontrados no mesmo FTP
em /pub/gnu.

PERIGO! AVISO! NOTA! Este código fonte ainda precisa do Minix/386 para
compilar (e o gcc-1.4.0, ou o 1.3.7, não testei) e você precisa do Minix
para configurá-lo, então ele ainda não é um sistema por si só para vocês
que não tem o Minix. Eu já estou trabalhando nisto. Você também precisa
ter um jeito hacker (?) para configurá-lo, então para aqueles torcendo
por uma alternativa ao Minix/386, me esqueçam. Ele é atualmente para
hackers com interesse no 386 e no Minix.

O sistema precisa de um monitor EGA/VGA e um disco rígido compatível (IDE
serve). Se você ainda está interessado, pegue no FTP o readme/relnotes
e/ou me mande um e-mail para saber mais.

Eu posso (bem, quase) ouvir vocês perguntando para si mesmos: porquê? O Hurd
vai sair em um ano (ou dois, ou em um mês, quem sabe), e eu já tenho o Minix.
Este é um programa feito por e para hackers. Eu gostei de fazer ele, e alguém
pode começar a olhá-lo e até mesmo modificá-lo às suas necessidades. Ele ainda é
pequeno para entender, usar e modificar, e eu estou otimista em relação a algum
comentário que vocês tenham a fazer.

Eu também estou interessado em alguém que tenha escrito alguns dos utilitários/
bibliotecas para o Minix. Se o seu trabalho pode ser distribuído publicamente
(registrado ou mesmo domínio público), eu gostaria de ouvir comentários de vocês,
e para que eu possa adicioná-los ao sistema. Eu estou usando o Earl Chews estdio
agora mesmo (obrigado, Earl, por um sistema que funciona), e trabalhos similares
seriam bem-vindos. Seus (C)’s obviamente serão mantidos. Me deixe uma mensagem
se você quer deixar que a gente use seu código.

Escrito por Emerson Alecrim

Fonte: http://www.infowester.com

Introdução
Independente de qual seja, todo sistema operacional possui um kernel. Trata-se de um item fundamental, que antes do Linux era conhecido apenas por estudantes de computação de grandes universidades ou por desenvolvedores da área. Após o surgimento do Linux, o termo kernel ficou mais conhecido e qualquer um que já tenha se aventurado no Linux provavelmente sabe de sua existência. Porém, os conceitos que envolvem o kernel não são claros a muita gente e, por isso, poucas pessoas sabem exatamente o que é kernel. O objetivo deste artigo é dar explicações sobre isso, mas com ênfase no kernel do Linux.

O que é kernel

Kernel pode ser entendido com uma série de arquivos escritos em linguagem C e em linguagem Assembly que constituem o núcleo do sistema operacional. É o kernel que controla todo o hardware do computador. Ele pode ser visto como uma interface entre os programas e todo o hardware. Cabe ao kernel as tarefas de permitir que todos os processos sejam executados pela CPU e permitir que estes consigam compartilhar a memória do computador.

O kernel do Linux

Para entender melhor tudo o que envolve o kernel do Linux é interessante ver um pouco da história do sistema (para conhecer a história completa, clique aqui). O kernel do Linux foi idealizado pelo finlandês Linus Torvalds, em 1991. Torvalds era um estudante de ciência da computação que, em seus estudos, teve a necessidade de criar uma nova versão do Minix, um sistema operacional baseado no Unix e desenvolvido por Andy Tannenbaum.

Linus começou a trabalhar nesse projeto e, quando desenvolveu algo concreto, enviou uma mensagem para um grupo de usuários do Minix na Usenet (a antecessora da internet). Na mensagem, Torvalds notificou sobre sua criação e avisou que disponibilizaria o código-fonte do que tinha desenvolvido a todos os interessados.

O que Linus Torvalds tinha criado, na verdade, era a primeira versão do kernel do Linux. Assim, falando grossamente, bastava juntar uma série de aplicativos com o kernel para que um sistema operacional fosse criado.

Linus Torvalds tinha vontade de ter um sistema operacional no qual fosse possível alterar conforme a necessidade. Ao criar a “nova versão” do Minix, Torvalds tinha desenvolvido um meio de usar o hardware de um computador por software e, portanto, restava agora a cada interessado adicionar os aplicativos e as funcionalidades desejadas, para assim constituir um sistema operacional. Em outras palavras, o “chassis” do sistema estava criado, bastava adicionar a “carroceria”.

O nome Linux é uma mistura de Linus com Unix. E como Linux é, na verdade, o nome de um kernel, talvez o InfoWester devesse dar o nome de “O kernel Linux” ao título deste artigo. Devido a essa questão – sobre o que de fato o nome Linux representa – o correto é dar o nome GNU/Linux a todas as distribuições desse sistema, uma vez que essas são constituídas pelo kernel – o Linux – mais uma coleção de programas e aplicativos, sendo que a quase totalidade desses softwares são baseados nos conceitos da GNU. No entanto, por questões de comodidade, convencionou-se a utilizar o nome Linux para toda e qualquer distribuição.

As versões do kernel

Periodicamente, novas versões do kernel do Linux são lançadas. Isso ocorre para prover melhorias em uma determinada função da versão anterior, para corrigir vulnerabilidades e para adicionar recursos ao kernel, principalmente compatibilidade com novos hardwares.

Cada versão do kernel é representada por 3 números distintos separados por pontos, sendo que um quarto número pode ser aplicado (você já saberá o porquê), por exemplo: 2.6.21.3. O primeiro número indica a versão do kernel. Note que esse número muda raramente: a última alteração (até o fechamento deste artigo) ocorreu em 1996, quando o kernel passou da versão 1 para a versão 2. O segundo número indica a última revisão feita até o momento naquela versão do kernel. O terceiro número, por sua vez, indica uma revisão menor, como se fosse uma “revisão da última revisão” do kernel. Note que o terceiro número pode ser acompanhado de pequenas siglas. Uma que costuma aparecer com freqüência é a sigla “rc” (release candidate), que indica a disponibilização de uma versão ainda não oficial, por exemplo: 2.6.22-rc1. Há siglas que apontam uma versão trabalhada por um desenvolvedor em específico, como a “mm”, que indica as alterações feitas por Andrew Morton.

Como já dito, um quarto número pode ser usado. Ele é aplicado quando uma falha grave no kernel foi descoberta, sendo, portanto, necessário atualizá-lo. Porém, não faz sentido lançar uma revisão completa apenas por causa de algumas correções, razão esta que levou à utilização de um quarto número.

É importante frisar que antes da série 2.6.x, o esquema de numeração do kernel tinha o seguinte esquema: se o segundo número da representação fosse ímpar, significava que aquela série ainda estava em desenvolvimento, ou seja, era uma versão instável e em fase de testes e aperfeiçoamentos. Se o número fosse par, significava que aquela série já tinha estabilidade para ser disponibilizada para uso.

Mais uma nota importante: você não precisa usar sempre a última versão do kernel. Só é recomendável fazer uma atualização em caso de necessidade de compatibilidade com novo hardware ou em casos de melhorias de recursos. Em alguns casos, principalmente com computadores antigos, o desempenho é melhor se usado um kernel antigo. Em situações simples, talvez seja melhor apenas aplicar um patch (uma correção para um problema) do que adicionar um kernel novo.

Compatibilidade

O kernel do Linux permite que o sistema operacional seja compatível com uma série de plataformas, desde palmtops até mainframes. Até mesmo nos computadores da Apple é possível instalar o Linux. As principais plataformas compatíveis são: Apple, Sun, Sparc, Alpha, PowerPC, i386 ( Intel), ARM, entre outras. A foto abaixo mostra o Linux rodando no videogame Nintendo DS:

Também existe compatibilidade com sistemas de arquivos. Acredite, apesar de não ser recomendável por questões de desempenho, é possível instalar o Linux até mesmo em partições FAT32. As principais compatibilidades neste aspecto são com os seguintes sistemas de arquivos: FAT, FAT32, ext2, ext3, ReiserFS, JFS, XFS, NTFS, entre outros.

Atuação do kernel

Obviamente, o kernel “começa a trabalhar” no processo de inicialização (boot) do sistema, a partir das instruções que são lidas na MBR (Master Boot Record), um recurso responsável por indicar ao BIOS do computador como e onde carregar o sistema operacional. Quando isso ocorre, o kernel começa a detectar os dispositivos de hardware essenciais do computador, como a placa de vídeo, por exemplo. Se até aí tudo ocorrer sem problemas, toda a imagem do kernel passa a ser carregada. Findo esse processo, o kernel checa a memória e a prepara para o uso através de uma função de paginação. As interrupções (IRQs), os discos, memória-cache, entre outros, são acionados em seguida.

Após realizar todas essas etapas, o sistema operacional está pronto para funcionar. O kernel carrega as funções responsáveis por checar o que deve ser inicializado em nível de software e processos, como, por exemplo, o conteúdo do arquivo /etc/init. Geralmente o que é carregado é a tela de login do usuário.

Usuário logado, sistema operacional trabalhando” O kernel agora executa suas funções, como a de controlar o uso da memória pelos programas ou a de atender a chamada de uma interrupção de hardware.

É interessante notar que as distribuições Linux montam o kernel com recursos e drivers básicos para hardware, afinal carregar o suporte a todo tipo de dispositivo é algo inviável. O kernel ficaria extremamente grande e somente os drivers relacionados ao hardware do computador em questão é que seriam usados. Para lidar com esse tipo de problema, os drivers são carregados como módulos após o kernel ser ativado. A questão é que carregar recursos por módulo gera uma queda de desempenho (pouco significativa em computadores rápidos) e, por isso, muitos usuários preferem recompilar o kernel de seus sistemas para que esse carregue os drivers junto com sua inicialização, ou seja, sem usar módulos.

Imagem do kernel carregando

Onde obter o kernel

Você pode baixar o código-fonte e o próprio kernel do Linux a partir do site www.kernel.org. Nesse endereço não só é possível baixar a última versão como também versões um pouco mais antigas. Por esse mesmo site também é possível obter informações, reportar bugs e participar de listas de discussão.

Finalizando

Aos que se interessam por esse tipo de estudo, entender o que é o kernel de um sistema operacional e como ele funciona é algo realmente fantástico. Talvez essa questão não seria tão conhecida entre os adeptos da computação se o Linux não fosse um sistema de código-fonte aberto. Graças a ele, qualquer pessoa pode tirar proveito do sistema operacional, ou melhor, do kernel, seja para estudar seu funcionamento, seja para usá-lo em seu cotidiano. O kernel é o núcleo de um sistema operacional e assim, não é errado dizer que o Linux é o coração das distribuições GNU/Linux. Mas isso é pouco. O Linux, mesmo que indiretamente, é um dos grandes responsáveis pela divulgação das filosofias que regem a cultura do software livre.

Escrito por Emerson Alecrim

Fonte: http://www.infowester.com

Introdução

Durante algum tempo procurei uma forma segura para acessar meu desktop Linux do trabalho remotamente, a fim de facilitar na administração da rede. Ora ou outra, principalmente a noite e nos fim de semana, surgem problemas nos servidores ou no processamento que precisam ser resolvidos imediatamente. Para tal, precisava me locomover de casa até o trabalho, sendo que na maioria das vezes eram problemas simples, que poderiam ser resolvidos com poucos comandos ou configurações, e eu perdia um enorme tempo somente com a locomoção. Adicione a isso vários outros administradores (que na verdade são programadores e que utilizam Windows), necessitando acessar essa mesma rede para correções de erros ou configurações em programas quando eventual problema acontecia. 

Pensando numa forma de facilitar na administração da nossa rede, de forma remota, ou seja, a partir de qualquer lugar e independente da plataforma operacional usada para acessar (Linux ou Windows), é que resolvi pesquisar e me aprofundar no assunto.

Achei diversas “receitas de bolos” que mostravam como fazer, mas encontrei nenhuma que me satisfizesse por completo, não queria apenas um nível de segurança, como acesso direto por ssh, como também gostaria de acessar meu desktop, afinal o ambiente da empresa é misto, ou seja, temos servidores com Linux, AIX e Windows, e para administrar os serviços Windows necessito de acesso ao seu desktop.

Enfim, após muita pesquisa e quebra-cabeça, descobri uma solução com OpenVPN + NxServer, sendo seus serviços disponibilizados numa máquina com Linux no meu trabalho. Neste computador temos instalado:

• Ambiente desktop (KDE)

Um pacote chamado rdesktop, que na verdade é uma implementação cliente- servidor do próprio protocolo rdesktop utilizado pela Microsoft para o serviço de Terminal Service (esse programa é que faz a ponte de conexão para os desktops Windows na nossa rede)

• O servidor de VPN: OpenVPN

Um programa que compartilha o desktop desta máquina (NxServer) que permite a conexão remota a partir da minha casa, independente do SO utilizado para me conectar (Linux ou Windows), ao desktop deste computador no trabalho.

• Servidor SSH

O OpenVPN é um dos vários pacotes para Linux desenvolvidos para a criação de VPN (Virtual Private Network), existem outros como OpenSwan e outras formas de fazer, como por exemplo usar Ipsec, que é uma implementação do protocolo IP com segurança ou criptografia, feita pelo próprio kernel do Linux. Utilizei o OpenVPN por ser fácil de configurar e pela extensa documentação que o acompanha.

O NxServer é um serviço de compartilha a área de trabalho de um computador com Linux, igual ao VNC, só que muito mais rápido e seguro, permitindo acesso a até dois usuários simultaneamente, cada um com uma sessão independente e onde todos os dados transmitidos são criptografados. Lembrando que o próprio protocolo X (XFree86 ou Xorg) oferece a possibilidade de acesso remoto seguro em cima do protocolo SSH, isto é exatamente o que o NxServer faz.

Desta forma, teremos dois níveis de segurança, sendo um criado pelo túnel VPN e o outro pela implementação de segurança do pacote Nx.

Exemplo do diagrama da VPN:

Baseando-se no diagrama acima, verifica-se que usando a internet a partir da minha casa, criamos um túnel seguro com OpenVPN para acessar um servidor na empresa, o qual tem seu desktop compartilhado pelo NxServer, e a partir deste, acessamos a área de trabalho de qualquer computador com Windows XP ou 2003 usando o protocolo rdesktop, que é nativo do Windows para aplicações de Terminal Server.

Configurando o servidor

Pré-requisitos

Todos os procedimentos de instalação foram feitos usando a distribuição Debian e kernel 2.6, sendo que suponho que você já tenha um ambiente gráfico instalado, no caso o KDE.

Utilizei o OpenVPN baseado no protocolo PTPpoint-to-point-tunneling-protocol), sendo que para funcionar é necessário o módulo TUN/TAP ativo no kernel.

1. Verifique em /lib/modules/versao-do-kernel/kernel/drivers/net/ se existe o arquivo tun.ko</p>
2. Se não existir, é necessário compilar este módulo no kernel e não explicarei nesta documentação como realizar tal procedimento.
3. Instale os pacotes openvpn, openssl, ssh e rdesktop

apt-get update
apt-get install openvpn openssl ssh rdesktop

4. Baixe os fontes *.deb do Nx no site www.nomachine.com

Por questão de dependência, é necessário baixar e instalar o nxclient, nxnode e nxserver, nessa ordem respectivamente.

dpkg -i nxclient_2.1.0-11_i386.deb

Configurando o OpenVpn

Existem vários modos de operação no OpenVpn, como Point-toPoint, Secret e TLS, estou utilizando o modo TLS, porque é o mais seguro. Não irei detalhar como funciona os outros modos citados acima. No caso do TLS, para utilizá-lo é preciso criar uma autoridade certificadora (ca), um certificado (cert), a chave privada (key) e a chave Diffie Hellman (dh) que são responsáveisl por autenticar a chave pública usada no cliente. Junto com o pacote openvpn vem alguns scripts que auxiliam na criação desses arquivos.

Copie a pasta /usr/share/doc/openvpn/examples/easy-rsa para /etc/openvpn/, então acesse /etc/openvpn/easy-rsa/2.0/

Edite o arquivo vars com as informações de país, estado e etc, então execute os comando abaixo preenchendo as informações necessárias:

• source ./vars # para carregar as varáveis editadas nesse arquivo

• ./clean-all # para limpar todos os certificados, se eles existirem

• ./build-ca # cria a autoridade certificadora

• ./build-key-server server # cria o certificado e chave privada do servidor com os nomes server.crt e server.key

• ./build-dh # cria a chave Diffie Hellman de 1024 bits

• ./build-key-pass cliente # cria a chave pública com senha que deverá ser utilizada pelo cliente, com os nomes cliente.crt e cliente.key.

Atenção: não esqueça essa senha, ela será usada para a conexão do cliente.

Todos as chaves e certificados criados serão gravados no diretório /etc/openvpn/easy-rsa/2.0/keys/. Se já não estiver, o faça, e permita que somente o root tenha acesso a esse diretório.

Copie esse diretório keys para /etc/openvpn/

Crie e edite o arquivo /etc/openvpn/openvpn.conf com o conteúdo abaixo:

#Arquivo de configuracao do servidor VP
#Interface virtual de rede utilizada
dev tun
# Modo de utilizacao da VPN
tls-server
# Arquivo de log e seu nivel
log /etc/openvpn/vpn.log
verb 3
# Faixa de rede que sera utilizada na VPN
# 20.0.0.1 # IP virtual do Servidor
# 20.0.0.2 # IP virtual do Cliente
ifconfig 20.0.0.1 20.0.0.2
# Certificados utilizados para autenticacao
ca /etc/openvpn/keys/ca.crt
cert /etc/openvpn/keys/server.crt
key /etc/openvpn/keys/server.key
dh /etc/openvpn/keys/dh1024.pem
# Porta padrao
port 1194
# Definindo o user padrao para executar o
# daemon “openvpn” para nobody
user nobody
group nobody
# Restringe o processo do openvpn somente ao diretorio /tmp
chroot /tmp
# Utilizando LZO como biblioteca de compreensao
comp-lzo
# Parametros utilizados para testar se a conexao
# continua “de pe” e para manter estabelecida em
# caso de firewall statefull
ping 15
# Evita que a interface virtual tun seja reiniciada e
# os arquivos de chaves relidos. Essencial quando
# se utiliza user nobody para execução do processo
persist-tun
persist-key

Reinicie o serviço openvpn: /etc/init.d/openvpn restart

Execute ifconfig e você verá que foi criada a interface virtual tun0 com IP 20.0.0.1, também será mostrado o IP original do computador (eth0). <p style=”text-indent: 26px;” align=”justify”> É interessante verificar também os logs do openvpn em /etc/openvpn/vpn.log

Configurando o NxServer

Os arquivos de configuração do nx são extensos e a princípio não há alterações a serem feitas, portanto apenas reinicie o serviço nxserver: /etc/init.d/nxserver restart.

Para quem quer se aventurar estejam a vontade para fuçar os arquivos de configuração.

Pronto, até aqui seu servidor já está pronto para autenticar a VPN e também com o desktop compartilhado.

Configurando o Firewall

Antes de passar para a configuração do cliente da VPN, se você possui um firewall, devemos fazer as devidas atualizações nas suas regras.

Como estamos falando em acessar um computador a partir da internet, é necessário que o mesmo possua um endereço IP válido para rotear na internet.

Ex: 200.175.x.y, pois do contrário você não conseguirá acessa-lo. Todo mundo que está conectado a internet já tem um IP válido, procure saber qual é, porque não entrarei nos méritos dessa questão.

No meu caso, possuo um firewall como barreira inicial para e da internet e quase todas as implementações de firewalls são feitas para realizarem “mascaramento” de endereços que vêem da internet, com destino as máquinas da rede interna. Portanto, para que a VPN possa funcionar é necessário que não haja esse mascaramento, ou seja, haverá apenas um redirect do nosso endereço de internet (200.175.x.y ou etc) para o destino na rede local (192.168.10.1, suponha que esse seja o IP original do servidor da VPN), só que neste caso, esse servidor da VPN vai estar numa DMZ.

Para quem já conhece, são os mesmos procedimentos tomados para acesso a um servidor Web. Tudo isto deve ser feito para que você possa autenticar a VPN a partir da sua usando um link ADSL ou mesmo internet discada.

Libere acesso no firewall da internet para o servidor VPN (192.168.10.1) na porta 1194 protocolo UDP.

No meu firewall, somente essas configurações foram necessárias. De acordo com a sua segmentação de rede, podem haver mais configurações.

Configurando o cliente

Vamos agora configurar o computador que fará o acesso à nossa VPN, ou nosso cliente.

Baixe e instale o cliente OpenVPN para Windows do site www.openvpn.org. Siga as instruções de instalação normalmente e você verá em Conexões de Rede que foi criado uma interface de rede virtual de nome TUN/TAP32.

Nas propriedades desse dispositivo adicione o IP 20.0.0.2 e máscara 255.0.0.0.

O arquivo de configuração dessa máquina cliente é quase idêntico ao do servidor, sendo adicionado somente a opção remote. Crie um arquivo em C:\Arquivos de programas\OpenVPN chamado cliente.ovpn com o conteúdo abaixo:

# will be pulling certain config file directives
# from the server.
client
# Use the same setting as you are using on
# the server. On most systems, the VPN will
# not function unless you partially or fully disable
# the firewall for the TUN/TAP interface.
dev tun
# Are we connecting to a TCP or
# UDP server? Use the same setting as
# on the server.
proto udp
# The hostname/IP and port of the server.
# You can have multiple remote entries
# to load balance between the servers.
Remote 200.175.x.y 1194 # esse será o IP e a porta usada pelo seu servidor VPN na internet.
ifconfig 20.0.0.2 20.0.0.1
# Keep trying indefinitely to resolve the
# host name of the OpenVPN server. Very useful
# on machines which are not permanently connected
# to the internet such as laptops.
resolv-retry infinite
# Most clients don’t need to bind to
# a specific local port number.
nobind
# Try to preserve some state across restarts.
persist-key
persist-tun
# SSL/TLS parms.
# See the server config file for more
# description. It’s best to use
# a separate .crt/.key file pair
# for each client. A single ca
# file can be used for all clients.
ca ca.crt
cert cliente.crt
key cliente.key
# Enable compression on the VPN link.
# Don’t enable this unless it is also
# enabled in the server config file.
comp-lzo
# Set log file verbosity.
Verb 3

Copie de forma segura (disquete, pendrive, etc) as chaves do cliente e o certificado que foram criados no Linux, e cole em C:\Arquivos de programas\OpenVPN. São eles:

• ca.crt
• cliente.crt
• cliente.key (somente)

Copie openvpn.exe e os dois arquivos *.dll que estão em C:\Arquivos de programas\OpenVPN\bin para C:\Arquivos de programas\OpenVPN\. <p style=”text-indent: 26px;” align=”justify”>Pronto, nossa VPN já pode ser levantada. Crie um arquivo vpn.bat com o conteúdo abaixo, ele iniciará o processo da VPN.

“C:\Arquivos de programas\OpenVPN\openvpn.exe” –config cliente.ovpn –tls-client

Confirme se o servidor OpenVPN está em execução na máquina com Linux. Execute vpn.bat. Será necessário fornecer a senha usada na criação da chave do cliente. Se tudo der certo você verá algumas informações repetidas de tentativa de adição de rotas (é normal, inclusive a mensagem de erro no final), deixe o prompt aberto, não o feche.

Abra outro prompt do DOS e tente pingar 20.0.0.1, se responder pronto, nossa VPN está funcionando.

Detalhe: o próprio Daemon do OpenVPN, tanto no Linux, como no Windows, já cria as rotas padrões para a conexão.

Baixe e instale o cliente NX para Windows do site www.nomachine.com

Abra esse cliente e crie uma nova sessão com um nome qualquer, host 20.0.0.1 porta 22 e escolha o método de acesso de acordo com sua conexão (Ex: ADSL).

Na próxima tela escolha Unix; KDE; a resolução que quer usar e o mais importante: habilite criptografia TLS para todo o tráfego. Assim, tudo que for transmitido para ambos os lados será criptografado. Perceba que teremos 2 níveis de segurança: um na VPN que já é criptografada e outro do próprio cliente NX, que também garante a segurança de todo o tráfego.

Crie um atalho no desktop e pronto.

Conecte-se com o cliente NX instalado e forneça usuário e senha. Esses são os mesmos que você utiliza para efetuar logon no Desktop KDE do Linux. Tudo certo, você verá no seu desktop Windows uma janela que mostra o desktop do servidor Linux, no caso o KDE.

Verifique os computadores com Windows XP ou servidores com 2000 ou 2003 (Terminal Server deve estar habilitado) os quais você irá querer fazer acesso remoto. No XP libere conexão ao Desktop a partir de Propriedades do Sistema. Pronto já podemos acessar o Windows. Preste atenção na ponte que será utilizada para esse acesso: Windows na minha casa → Servidor Linux no trabalho → Windows XP ou 2003 no trabalho.

Na tela do Linux (KDE) que você está vendo no seu Desktop Windows, abra um konsole e digite:

rdesktop ip_ou_nome_do_computador_que_quer_acessar &

rdesktop 192.168.10.20 &
rdesktop computador20 &

Pronto agora, de forma segura, você pode administrar qualquer computador da sua rede a partir da sua casa. Divirta-se!!!

Autor

• Bruno Roberto
• brunaocomanda@gmail.com

Fonte: http://under-linux.org/

Introdução

O que é?

A grosso modo podemos dizer que o NTP é um protocolo que visa manter os relógios dos diversos equipamentos de rede sincronizados.
http://pt.wikipedia.org/wiki/NTP

Para que relógios sincronizados?

Simples, em caso de ataques ou análise de logs é muito importante que todos os equipamentos estejam com os relógios acertados.

Imagine que você precise ver o que um usuário fez, primeiro você olha o firewall, horário de entrada 09:03:42, depois olha o servidor web, horário de acesso 09:02:07, depois o servidor de email, 09:15:48, cada maquina com um horário diferente e que foram acessadas praticamente ao mesmo tempo.

Ao verificar o relógio de cada maquina você vê uma diferença absurda em cada relógio, você pode fazer isso ai nas suas maquinas para constatar, nenhum terá o horário igual a outra, a diferença varias em minutos e não em segundos.

Isso é muito prejudicial, e no horário de verão? Ajustar o horário maquina por maquina?

Todos esse problemas podem ser resolvidos usando o NTP, por exemplo, para sincronizar uma maquina basta utilizar o comando.

ntpdate pcdsh05.on.br
13 Jun 11:16:45 ntpdate[1437]: adjust time server 200.20.186.75 offset -0.032176 sec

Com esse comando eu sincronizo o meu Linux com o servidor NTP pcdsh05.on.br, esse servidor é do Observatório Nacional

Essa solução é totalmente viável para apenas uma ou duas maquinas mas se você quiser sincronizar todas as maquina da rede isso fica um pouco complicado devido a trafego na Internet, o protocolo é bem compacto, usa UDP e cada troca de informação são usados poucos pacotes como podemos ver abaixo

11:22:28.967672 IP 10.10.1.7.123 > 10.10.1.1.123: NTPv4, Client, length 48
11:22:28.967888 IP 10.10.1.1.123 > 10.10.1.7.123: NTPv4, Server, length 48
11:22:28.968853 IP 10.10.1.7.123 > 10.10.1.1.123: NTPv4, Client, length 48
11:22:28.969001 IP 10.10.1.1.123 > 10.10.1.7.123: NTPv4, Server, length 48
11:22:28.969550 IP 10.10.1.7.123 > 10.10.1.1.123: NTPv4, Client, length 48
11:22:28.969684 IP 10.10.1.1.123 > 10.10.1.7.123: NTPv4, Server, length 48
11:22:28.970373 IP 10.10.1.7.123 > 10.10.1.1.123: NTPv4, Client, length 48
11:22:28.970516 IP 10.10.1.1.123 > 10.10.1.7.123: NTPv4, Server, length 48

Porem isso sendo feito por algunas centenas de maquina gera bastante trafego no seu link, para contornar isso irei mostrar como montar um servidor NTP em sua própria rede.

Maquina usada nos testes

cat /proc/cpuinfo
processor       : 0
vendor_id       : GenuineIntel
cpu family      : 6
model           : 7
model name      : Pentium III (Katmai)
stepping        : 3
cpu MHz         : 501.212
cache size      : 512 KB
fdiv_bug        : no
hlt_bug         : no
f00f_bug        : no
coma_bug        : no
fpu             : yes
fpu_exception   : yes
cpuid level     : 2
wp              : yes
bogomips        : 1004.19

free
             total       used       free     shared    buffers     cached
Mem:        254048     230196      23852          0      74748      63128
-/+ buffers/cache:      92320     161728
Swap:       522104         96     522008

cat /etc/fedora-release
Fedora Core release 4 (Stentz)

Softwares necessários

Para instalar usando o Fedora Core basta digitar o comando

yum install ntp

Com isso será instalado tanto os softwares clientes como o servidor.

Ou você pode baixar a ultima versão do site http://www.ntp.org/

Configurando o servidor

Para configurar o servidor basta editar apenas um arquivo /etc/ntp.conf essa é a copia do arquivo que estou usando atualmente.

Não vou me estender muito nas configuração que podem ser feitas no arquivo, para isso você pode ler o arquivo que está disponível no site da RPN em http://www.rnp.br/_arquivo/cais/manual_ntp_v1b.pdf essa documentação é muito boa, nesse arquivos irei centralizar na criação rápida e fácil de um servidor.

# Permite acesso ao servidor para sincronizar mas nao permite modificacoes no servico
restrict default nomodify notrap noquery

# Permite acesso complete para a interface local
restrict 127.0.0.1

# Libera acesso a minha rede local
restrict 10.10.1.0 mask 255.255.255.0 nomodify notrap
restrict 10.1.0.0 mask 255.255.0.0 nomodify notrap

# Servidor para sincronizar o relógio
# Será usado em ordem
# o pcdsh05.on.br e stratum 1 todos os outros são stratum 2
server pcdsh05.on.br
server ntp.cais.rnp.br
server ntp.puc-rio.br
server ntp1.pucpr.br
server ntp.pop-rs.rnp.br

Mais servidores podem ser vistos em http://www.rnp.br/ntp/ntp-stratum2.html

para ver como estão as suas permições use o comando ntpdc.

#  ntpdc -nc reslist
   address          mask            count        flags
=====================================================================
0.0.0.0         0.0.0.0             14147  noquery, nomodify, notrap
10.1.0.0        255.255.0.0          2199  nomodify, notrap
10.10.1.0       255.255.255.0       10519  nomodify, notrap
10.10.1.1       255.255.255.255         0  ntpport, interface, ignore
127.0.0.1       255.255.255.255         2  none
127.0.0.1       255.255.255.255         0  ntpport, interface, ignore

Outro comando util é o ntpq com ele é possivel ver como status dos servidores.

Com ele podemos ver o nivel na hierarquia que o servidor se encontra, o delay e outras informações.

# ntpq -p
     remote           refid      st t when poll reach   delay   offset  jitter
==============================================================================
*pcdsh05.on.br   .IRIG.           1 u  292 1024  377   45.989  -12.245   5.186
-titan.cais.rnp. 3.111.157.113    2 u  159 1024  377  180.385  -73.748 106.281
+139.82.34.11    200.143.193.3    3 u  208 1024  377   30.473  -15.311   0.586
+ntp.pucpr.br    192.5.41.209     2 u  249 1024  377   44.354  -23.184   1.113
-delta.pop-rs.rn 192.5.41.41      2 u  704 1024  377   69.726  -29.118   2.322
 LOCAL(0)        LOCAL(0)        10 l   63   64  377    0.000    0.000   0.004

Pronto agora que já configurou o arquivo basta iniciar o serviço

service ntpd start

e configurar para que ele seja iniciado todo vez que reiniciar a maquina

chkconfig ntpd on

Pronto seu servidor está configurado e funcionando, para isso vá em um cliente Linux e digite o comando.

ntpdate SERVIDOR

se você receber uma mensagem do tipo

13 Jun 12:13:51 ntpdate[6157]: no server suitable for synchronization found

Quer dizer que o seu servidor não está funcionando ainda, para saber o porque digite o comando

ntpdate -d SERVIDOR

para executar o ntpdate em modo debug

Looking for host SERVIDOR and service ntp
host found : SERVIDOR
transmit(10.10.1.7)
receive(10.10.1.7)
transmit(10.10.1.7)
receive(10.10.1.7)
transmit(10.10.1.7)
receive(10.10.1.7)
transmit(10.10.1.7)
receive(10.10.1.7)
transmit(10.10.1.7)
10.10.1.7: Server dropped: strata too high
server 10.10.1.7, port 123
stratum 16, precision -18, leap 11, trust 000
refid [10.10.1.7], delay 0.02612, dispersion 0.00000
transmitted 4, in filter 4
reference time:    00000000.00000000  Thu, Feb  7 2036  4:28:16.000
originate timestamp: c83954b4.4aeed890  Tue, Jun 13 2006 12:13:56.292
transmit timestamp:  c83954b4.4c0b45ae  Tue, Jun 13 2006 12:13:56.297
filter delay:  0.02629  0.02620  0.02617  0.02612
         0.00000  0.00000  0.00000  0.00000
filter offset: -0.00467 -0.00466 -0.00466 -0.00467
         0.000000 0.000000 0.000000 0.000000
delay 0.02612, dispersion 0.00000
offset -0.004673

13 Jun 12:13:56 ntpdate[6158]: no server suitable for synchronization found

Com isso podemos encontrar o problema na linha stratum 16, precision -18, leap 11, trust 000 essa linha fala que o nosso servidor está em stratum 16, esse é o stratum máximo de um servidor NTP, ou seja, ele está em um nível muito baixo e que não é confiável para ser usado para atualização de nossas maquinas.

Mas porque isso está acontecendo se tudo está configurado corretamente?

Fácil de responder, basta olhar no log do seu servidor.

tail /var/log/messages
Jun 13 12:13:16 SERVIDOR ntpd[1688]: ntpd 4.2.0a@1.1196-r Fri May 12 09:51:35 EDT 2006 (1)
Jun 13 12:13:17 SERVIDOR ntpd[1688]: precision = 3.000 usec
Jun 13 12:13:17 SERVIDOR ntpd[1688]: Listening on interface wildcard, 0.0.0.0#123
Jun 13 12:13:17 SERVIDOR ntpd[1688]: Listening on interface wildcard, ::#123
Jun 13 12:13:17 SERVIDOR ntpd[1688]: Listening on interface lo, 127.0.0.1#123
Jun 13 12:13:17 SERVIDOR ntpd[1688]: Listening on interface eth0, 10.10.1.7#123
Jun 13 12:13:17 SERVIDOR ntpd[1688]: kernel time sync status 0040
Jun 13 12:13:17 SERVIDOR ntpd[1688]: frequency initialized 0.000 PPM from /var/lib/ntp/drift

O servidor NTP foi iniciado só que ainda não fez nenhuma sincronização, aguarde um pouco até aparecer algo como.

Jun 13 12:16:33 SERVIDOR ntpd[1688]: synchronized to 200.20.186.75, stratum 1

Pronto, pelo que você pode verificar demorou cerca de três minutos para ele fazer a primeira sincronização, o seu pode demorar um pouco mais, isso é feito de forma automática por um algoritimo interno do servidor e não pode ser mudado, ele mesmo calcula quando deve buscar uma sincronização com o servidor de stratum superior.

Pronto agora você pode executar o ntpdate no cliente.

ntpdate SERVIDOR
13 Jun 12:22:23 ntpdate[6187]: adjust time server 10.10.1.7 offset -0.021264 sec

Pronto agora sim o nosso cliente foi sincronizado com sucesso, uma diferença de -0.021264 segundos, essa diferença varia muito.

Automatizando

Com ntpd

Essa configuração é mais recomendada pois o ntpd utiliza um algoritimo interno para determinar a quantidade de vezes que ele precisa sincronizar, diminuindo o trafego de pacotes ntpd em sua rede.

Para fazer uma configuração mais redonda você pode configurar o arquivo /etc/ntp.conf do cliente informando os seguintes parametros.

restrict default nomodify notrap noquery
restrict 127.0.0.1
server 10.10.1.1
server  127.127.1.0     # local clock
fudge   127.127.1.0 stratum 10
driftfile /var/lib/ntp/drift
broadcastdelay  0.008
keys            /etc/ntp/keys

Com esse simples arquivo de configuração o cliente irá manter o relógio sincronizado, porém somente a própria maquina poderá acessar a interface aonde o NTP está rodando.

Para ativar o serviço basta executar os seguintes comandos

# chkconfig ntpd on
# service ntpd start
Starting ntpd:                                             [  OK  ]

Com ntpdate

Para deixar as maquinas sincronizado a cada hora, basta criar um script no diretório /etc/cron.hourly/ chamado timesync com a seguinte linha.

#vi /etc/cron.hourly/timesync

#!/bin/sh
/usr/sbin/ntpdate -s 10.10.1.1

A opção -s server para ele não mostrar nada na saida padrão, o retorno será enviado para o syslog coloco ele como executável.

#chmod +x /etc/cron.hourly/timesync

Pronto desta forma a minha maquina será sincronizada toda hora.

O NTPDate está sendo descontinuado http://ntp.isc.org/bin/view/Dev/DeprecatingNtpdate, porém eu ainda utilizo ele para fazer os testes iniciais de funcionamento do servidor, essa informação foi passada pelo Marcos Vinicius Lazarini.

Horário de verão

Para evitar problemas com o horário de verão eu configuro os meus servidor para usarem o relógio de hardware em UTC, para fazer isso no Fedora sigo os seguintes passos

Edito o arquivo /etc/sysconfig/clock e altero a linha UTC=false para UTC=true, executo o comando.

hwclock --set --date="HH:MM" –utc

Para poder ajustar o relógio do hardware para UTC, três horas a menos que o nosso horário.

Como o NTP só configura relógio de software o relógio de hardware ficará com uma referência que pode ser entendida posteriormente.

Para verificar o horário de Greewich acesse http://www.timeanddate.com/worldclock/city.html?n=45

Cisco IOS

Para configurar o roteador Cisco para utilizar o servidor NTP é bem simples, acesso seu roteador e siga os comandos.

Router> enable
password: *********
Router# config t
Router(config)# ntp server 10.10.1.1
Router(config)# ntp server 10.10.1.2
Router(config)# exit
Router# wr mem

Maquinas com Microsoft Windows

Windows XP

Duplo clique o relógio na barra de tarefas
Clicar na aba horário na Internet
Marcar a opção sincronizar automaticamente e colocar o endereço do seu servidor e clicar em atualizar agora.
Pronto

É importante lembrar que o serviço Horário do Windows tem que estar iniciado

O Windows só atualiza o relógio a cada 10 dias e não funcionou corretamente em meus testes.

Windows 2000/2003

Colaboração de Marcos Vinicius Lazarini

No Windows 2000 em diante inclusive o Windows XP existe um serviço para sincronizar o relógio interno. para utiliza-lo você deve abrir o Prompt de Comand.

Clique em Inciar -> Executar.

Digite cmd e clique em OK.

No Prompt de Comando digite.

net stop w32time
net time /setsntp:SERVIDOR
net start w32time

Lembrando que o serviço Horário do Windows deve estar configurado como automático.

Outras versões do Windows

Você pode usar o programa SP_TimeSync, que eu uso, ou o About Time ambos são gratuitos e funcionam bem melhor que o do Windows XP por dois motivos, posso usar em outras versões do Windows e também posso especificar em que período de tempo deverá ocorrer os sincronismos do relógio.

FAQ

Meu horário esta sendo atualizado com 3 horas a mais do que o meu horário real

Quando instalei o fedora, coloquei como São Paulo e marquei a opção [X] UTC

Agora apenas entrei via setup e desmarquei esta opção UTC.

Agora quando executo o date, aparece BRT ao invés de UTC

Cristiano Borges Brasil

the NTP socket is in use, exiting

Esse problema que você está é porque o seu cliente Linux está rodando o daemon do NTP.

Para resolver esse problema é bem facil, basta parar o serviço do ntpd

service ntpd stop

Dai basta executar o ntpdate

Referências

• http://www.ntp.org/
• http://pt.wikipedia.org/wiki/NTP
• http://www.rnp.br/_arquivo/cais/manual_ntp_v1b.pdf
• http://www.rnp.br/ntp/ntp-hierarquia.html
• http://www.on.br/
• http://pcdsh01.on.br/
• http://www.rnp.br/ntp/ntp-stratum2.html
• http://www.timeanddate.com/worldclock/city.html?n=45
• http://www.arachnoid.com/abouttime/index.html
• http://www.spdialer.com/timesync/

Autor

Rodrigo Luis Silva é especialista em sistemas GNU/Linux com ampla experiência em diversas áreas, trabalha a mais de seis anos focado em desvendar os diversos recursos existentes nesse sistema operacional.

Fonte: http://www.dotsharp.com.br

Estamos procurando 1‘000‘000 pessoas que conhecem o Linux como uma plataforma e que cairam de amor com ele. Você é um deles? Basta registar-se no nosso site!

Esta página existe como uma apreciação para com o Linux e Open Source afim de torná-lo mais popular. É dificil compreender como o número de usuários Linux é baixo, chega a ser assustador. 

Esta não é uma página de contagem, o que significa que não estamos interessados em descobrir qual a melhor distribuição ou GUI. Nós só queremos saber quantas pessoas realmente usam uma plataforma de código aberto com toda a flexibilidade e que cairam de amor por ele. Muitos usuários podem pensar que estamos a tentando competir diretamente com o Linux Counter , mas, nós gostamos de pensar em nós mesmos como um site dedicado a todos os usuários no mundo que gostam e tem contribuído para tornar o Linux e Open Source um lugar melhor!

Efetue seu cadastro no link: http://1-million-tux.linux-befehle.org/indexpt.php

Obtendo e Instalando

Estive a algum tempo procurando e achei poucas coisas a respeito, achei apenas dois manuais que me ajudaram, porém não foram tão elucidativos.

Este arquivo será util para a configuração básica das seguintes ações em um servidor FTP:

   * instalação
   * downloads e uploads

ProFTPd

É um software que provê serviço de FTP de forma bastante eficiente e tem como característica a segurança e flexibilidade.

Dentre as vantagens do ProFTPd podemos citar as principais:

   * configuração fácil;
   * pode ser configurado em modo standalone ou através do inetd;
   * o PID é executado por um usuário desprivilegiado (nobody);
   * formato do arquivo de log extremamente configurável;
   * fácil administração do FTP, com relação a forma de restrição, acesso aos arquivos;
   * permite a configuração do número máximo de processos em execução, minimizando vulnerabilidades;

Onde Achar?

O download do ProFTPd poderá ser feito em:

   * http://www.proftpd.org
   * http://rpmfind.net

Pré-instalação

Caso você já tenha o WU-FTPd instalado, siga os seguintes passos:

 # rpm -q wu*
 ou
 # rpm -qa | grep wu*

Se a resposta for:

o pacote wu* não está instalado

Então prossiga para a instalação, porém se a resposta for:

 wu-ftp-*****

Isso significa que o WU-FTPd está instalado no seu sistema. Para desinstalá-lo digite o seguinte comando:

 # rpm -e wu-ftp

Instalando o ProFTPd

Uma vez que o WU-FTPd foi desinstalado, vá até o diretório em que você salvou o pacote do ProFTPd e digite:

Se ele for *.rpm:

 # rpm -ivh proftp*.rpm

É possível que o inetd (ou o xinetd) esteja com algumas configurações do WU-FTPd. Ao editar /etc/inetd.conf podemos ter:

 ftp stream tcp nowait root /usr/sbin/tcpd in.ftpd -l -a

Para eliminarmos o seu efeito devemos comentar esta linha colocando uma cerquilha (#) na frente da linha. Para que a modificação tenha efeito devemos iniciar o inetd:

 # killall -HUP inetd

Iniciamos agora o ProFTPd utilizando o seu initscript:

 # /etc/rc.d/init.d/proftpd start
 ou
 # /usr/local/sbin/./proftpd

Para verificar se o ProFTPd está rodando:

 # ps auwx | grep proftpd

Se obtiver esta linha como resposta é porque ele esta rodando e aceitando conexões:

 nobody     813  0.0  0.4  2264  556 ?        S    Sep15   0:00 [proftpd]

Se ele for .tar.bz2:

 # tar -jxpvf proftp*

No diretório em quem os arquivos foram descarregados digite:

 # ./configure --prefix=/usr/local/proftpd && make && make install

O uso do –prefix não é obrigatório, mas quem quiser está aí a configuração. Esse comando fará com que uma pasta com o nome de proftpd seja criada em /usr/local e dentro deverá conter os seguintes diretórios:

 /usr/local/proftpd/etc
 /usr/local/proftpd/bin
 /usr/local/proftpd/sbin
 /usr/local/proftpd/var
 /usr/local/proftpd/man

Para quem não usou o –prefix:

 /usr/local/etc
 /usr/local/bin
 /usr/local/sbin
 /usr/local/var
 /usr/local/man

Caso contenha a sua instalação foi feita com sucesso.

OBS: verificar se o sistema criou o usuário FTP, pois os arquivos ficarão no /home/ftp.

Entendendo a configuração do ProFTPd Como todo daemon, o ProFTPd é configurado através de um arquivo texto /etc/proftpd.conf. O ProFTPd lê o arquivo cada vez que é iniciado, portanto cada alteração feita neste arquivo só entrará em vigor após reiniciar o daemon.

No arquivo de configuração do ProFTPd é utilizado o conceito de contextos em sua configuração e em cada contexto temos as diretivas. Resumindo os contextos são opções globais de um comportamento e a diretiva seria um sub-comportamento.

Contextos

Os contextos são divididos em cinco categorias:

   * contexto principal: contém as configurações default utilizadas por outros contextos;
   * contexto <Directory DIR>: determina o comportamento do ProFTPd no diretório.
   * contexto <Anonymous DIR>: determina o comportamento do ProFTPd quando o usuário anonymous se loga a partir de qual diretório(DIR) ele será servido;
   * contexto <Limit AÇÃO>: determina as ações no ProFTPd que são:

     * LOGIN - usuário válido se logando. * READ - downloads de arquivos. * WRITE - uploads de arquivos. * STOR - upload de arquivos sem possibilidade de criação e deleção de diretórios.

   * contexto <VirtualHost IP>: define a criação de ftp's virtuais;

Exemplo de Configuração

Este FTP eu montei e está rodando em um Red Hat 9.0. O pacote usado foi proftpd-1.2.9rc1.tar.bz2.

Nessa configuração você poderá realizar o download de arquivos na pasta PUB e o upload na pasta incoming. A pasta incoming deverá ser criada.

Para a configuração do webmin para quem gosta do padrão Windows seguem os caminhos:

   * config file: /usr/local/"proftpd/"etc/proftpd.conf
   * executable: /usr/local/"proftpd/"sbin/proftpd
   * PID file: /usr/local/"proftpd/"var/proftpd.pid
   * ftpusers file: usr/local/"proftpd/"etc/ftpusers

“/”proftpd/” – é para quem usou o prefix la em cima na instalação.

proftpd.conf

 # This is a basic ProFTPD configuration file.
 # It establishes a single server and a single anonymous login.
 # It assumes that you have a user/group "nobody" and "ftp"
 # for normal/anonymous operation.

 ServerName                      "Nome do seu Servidor"
 ServerType                      standalone
 ServerAdmin                     seuemail@dominio.com.br
 ServerIdent                     off
 DefaultServer                   on
 RequireValidShell               off
 DefaultRoot                     ~
 AllowLogSymlinks                on
 IdentLookups                    off
 UseReverseDNS                   off

 # Port 21 is the standard FTP port.
 Port                            21
 # Umask 022 is a good standard umask to prevent new dirs and files
 # from being group and world writable.
 Umask                           022

 # To prevent DoS attacks, set the maximum number of child processes
 # to 30.  If you need to allow more than 30 concurrent connections
 # at once, simply increase this value.  Note that this ONLY works
 # in standalone mode, in inetd mode you should use an inetd server
 # that allows you to limit maximum number of processes per service
 # (such as xinetd)
 MaxInstances                    60

 # Set the user and group that the server normally runs at.
 User                            nobody
 Group                           nogroup

 # This next option is required for NIS or NIS+ to work properly:
 #PersistentPasswd off

 SystemLog                       /var/log/proftpd.log
 TransferLog                     /var/log/xferlog

 # Normally, we want files to be overwriteable.
 <Directory /*>
   AllowOverwrite                on
 </Directory>

 # A basic anonymous FTP server configuration.
 # To enable this, remove the user ftp from /etc/ftpusers.
 <Anonymous ~ftp>
 RequireValidShell             off
 User                          ftp
 Group                         ftp
 # We want clients to be able to login with "anonymous" as well as "ftp"
 UserAlias                     anonymous ftp

 # Limit the maximum number of anonymous logins
 MaxClients                    50

 # We want 'welcome.msg' displayed at login, and '.message' displayed
 # in each newly chdired directory.
 DisplayLogin                  welcome.msg
 DisplayFirstChdir             .message

 # Limit WRITE everywhere in the anonymous chroot
 <Limit WRITE>
   DenyAll
 </Limit>

 </Anonymous>

 <IfModule mod_tls.c>
       TLSEngine off
       TLSLog /var/log/proftpd-tls.log
       TLSProtocol TLSv1

       # Are clients required to use FTP over TLS when talking to this server?
       TLSRequired on

       # Server's certificate
       TLSRSACertificateFile /etc/ssl/server.crt
       TLSRSACertificateKeyFile /etc/ssl/server.key.unsecure

       # CA the server trusts
       TLSCACertificateFile /etc/ssl/ca.crt

       # Authenticate clients that want to use FTP over TLS?
       TLSVerifyClient off
 </IfModule>

Instalando um servidor FTP

O servidor de FTP mais usado no Linux é o Proftpd, disponível em quase todas as distribuições. O funcionamento do FTP é bem mais simples que o do Samba ou SSH, por isso ele é usado como uma forma simples de disponibilizar arquivos na internet ou mesmo dentro da rede local, sem muita segurança.

A principal limitação do protocolo FTP é que todas as informações são transmitidas de forma não encriptada, como texto puro, incluindo os logins e senhas. Ou seja, alguém capaz de sniffar a conexão, usando um programa como o Ethereal, veria tudo que está sendo transmitido. Para aplicações onde é necessário ter segurança na transmissão dos arquivos, é recomendável usar o SFTP, o módulo do SSH que permite transferir arquivos de forma encriptada. Apesar disso, se você quiser apenas criar um repositório com alguns arquivos para download ou manter um servidor público como o Ibiblio.org, então o FTP é mais interessante, por ser mais simples de usar.

O servidor aceita conexões remotas usando os logins dos usuários cadastrados na máquina. Lembre-se de que, para adicionar novos usuários, você pode usar o comando adduser ou algum utilitário de administração incluído na distribuição, como o system-config-users, o users-admin ou o kuser.

Não é difícil instalar o Proftpd, basta procurar pelo pacote “proftpd” na distribuição usada, como em:

 # apt-get install proftpd
 # yum install proftpd
 ou:
 # urpmi proftpd

No Debian, durante a instalação do pacote do Proftpd, geralmente são feitas algumas perguntas. A primeira é se você deseja deixar o servidor FTP ativo em modo standalone ou em modo inetd.

O standalone é mais seguro e mais rápido, enquanto o inetd faz com que ele fique ativo apenas quando acessado, economizando cerca de 400 KB de memória RAM (que fazem pouca diferença hoje em dia). O modo standalone é a opção recomendada.

Você terá também a opção de ativar o acesso anônimo, que permite acessos anônimos (somente leitura) na pasta “/home/ftp”, onde você pode disponibilizar alguns arquivos para acesso público. Nesse caso, os usuários fazem login no servidor usando a conta “anonymous” e um endereço de e-mail como senha. Caso prefira desativar o acesso anônimo, apenas usuários com login válido na máquina poderão acessar o FTP.

Depois de concluída a instalação, o servidor fica ativo por default, é inicializado automaticamente durante o boot e pode ser controlado manualmente através do serviço “proftpd”, como em “/etc/init.d/proftpd start”.

Você pode acessar outras máquinas da rede com servidores FTP ativos usando o GFTP, o Konqueror ou o próprio navegador. O FTP pode ser usado também como opção para transferência de arquivos na rede local. Uma das vantagens do FTP é que existem clientes para todas as plataformas, você pode baixar o Filezilla, um servidor e cliente de FTP for Windows, no http://filezilla.sourceforge.net/.

A configuração manual do servidor FTP é feita através do arquivo “/etc/proftpd/proftpd.conf”. Um arquivo configurado no CentOS pode ser usado no Mandriva (por exemplo), ou vice-versa; afinal, independentemente de estar usando o Debian, Fedora ou o Mandriva, o proftpd será sempre o mesmo.

Sempre que fizer alterações no arquivo, reinicie o servidor para que elas entrem em vigor. Para isso, use o comando “/etc/init.d/proftpd restart”.

No caso do Debian Etch e do Ubuntu 6.10 em diante, o servidor é configurado para utilizar endereços IPV6 por padrão, o que faz com que ele exiba uma mensagem de erro e aborte a inicialização caso você não tenha configurado a rede IPV6.

Para solucionar o problema, abra o arquivo “/etc/proftpd.conf” e substitua a linha:

UseIPv6 on

por:

UseIPv6 off

Uma das primeiras opções do arquivo é a opção Port, que permite alterar a porta usada pelo FTP. O padrão é usar a porta 21, mas muitos serviços de banda larga bloqueiam as portas 21 e 80 para que os usuários não rodem servidores. Nesse caso, você pode mudar para a porta 2121, por exemplo:

 # Port 21 is the standard FTP port.
 Port 2121

Ao mudar a porta padrão do servidor, os usuários precisarão indicar manualmente a porta no cliente de ftp ou navegador, como em: ftp://200.234.213.23:2121.

Em seguida, vem a opção MaxClients, que limita o número de conexões simultâneas ao servidor FTP. Esta opção trabalha em conjunto com a limitação de banda (veja a seguir). Você pode limitar os downloads de cada usuário a um máximo de 10 KB/s e limitar o servidor a 3 usuários simultâneos, por exemplo. Assim, o FTP consumirá um máximo de 30 KB/s do link do servidor.

 MaxClients 30

Se você quiser limitar o acesso dos usuários, prendendo-os em seus respectivos diretórios home, adicione a linha “DefaultRoot ~” no final do arquivo. Lembre-se de que no Linux o “~” é um curinga, que é automaticamente substituído pela pasta home do usuário que está logado:

 DefaultRoot ~

Para ativar a limitação de banda, adicione a linha “TransferRate RETR 8:10″, onde o “8″ pode ser substituído pela taxa desejada, em KB/s, por usuário:

 TransferRate RETR 8:10

A princípio, apenas os usuários que tiverem logins válidos no servidor poderão acessar o FTP. Caso você queira abrir um FTP público, adicione estas linhas no arquivo de configuração. Elas ficam comentadas no arquivo original:

 <Anonymous ~ftp>
 User ftp
 Group nogroup
 UserAlias anonymous ftp
 DirFakeUser on ftp
 DirFakeGroup on ftp
 RequireValidShell off
 MaxClients 20
 DisplayLogin welcome.msg
 DisplayFirstChdir .message
 <Directory *>
 <Limit WRITE>
 DenyAll
 </Limit>
 </Directory>

 <Directory incoming>
 Umask 022 022
 <Limit READ WRITE>
 DenyAll
 </Limit>

 <Limit STOR>
 AllowAll
 </Limit>
 </Directory>
 </Anonymous>

A linha “MaxClients” determina o número máximo de usuários anônimos que poderão se logar simultaneamente no servidor. Essa opção é separada da MaxClients principal, que limita o número de usuários com login válido. Você pode permitir 30 usuários válidos e mais 20 anônimos, por exemplo.

A opção “DisplayLogin welcome.msg” indica a mensagem de boas-vindas que é mostrada quando os usuários fazem login no FTP. Por padrão, é exibido o conteúdo do arquivo “/home/ftp/welcome.msg”.

Os usuários anônimos têm acesso apenas aos arquivos dentro da pasta “/home/ftp”, que é visto pelo cliente FTP como o diretório raiz do servidor. Graças a isso, eles não têm como ver, muito menos alterar outros arquivos do sistema.

A seção “Directory incoming” mais abaixo cria uma pasta de upload (por padrão a “/home/ftp/incoming”), onde os anônimos poderão dar upload de arquivos. A idéia é que você veja periodicamente o conteúdo da pasta e mova o que for útil para a pasta “/home/ftp”, para que o arquivo fique disponível para download.

Por padrão, os anônimos não podem ver o conteúdo da pasta incoming, podem apenas dar upload. Se necessário, crie a pasta incoming usando os comandos:

 # mkdir /home/ftp/incoming
 # chown nobody:nogroup /home/ftp/incoming

Para acessar o seu servidor, os clientes devem usar o login “anonymous” ou “ftp”, usando um endereço de e-mail qualquer como senha.

Uma medida comum ao ativar o upload para os usuários anônimos é usar uma partição separada para o FTP, para evitar que algum engraçadinho fique dando upload durante a madrugada até lotar o HD do servidor. Nesse caso, você precisa apenas adicionar uma linha no arquivo “/etc/fstab” para que a partição desejada seja montada durante o boot. Esta linha de exemplo montaria a partição /dev/hda3, formatada em ReiserFS na pasta /home/ftp:

 /dev/hda3 /home/ftp reiserfs defaults 0 2

Criando usuários e ajustando as permissões de acesso

Imagine agora que você quer uma configuração um pouco mais complexa, com vários usuários, cada um tendo acesso a apenas uma pasta específica. Esta configuração pode ser usada em conjunto com os virtual hosts do Apache (permitindo que os responsáveis possam atualizar os arquivos do site), ou em situações em que seu servidor hospeda arquivos de diversos usuários ou projetos diferentes.

O responsável pelo projeto1 pode dar upload para a pasta “/home/ftp/projeto1″ (por exemplo), mas não deve ter acesso a outras pastas nem a outros arquivos do sistema. Os usuários anônimos terão acesso às pastas de todos os projetos, mas, naturalmente, apenas para leitura.

A forma mais simples de fazer isso é criar os usuários que terão acesso ao FTP, colocando a pasta a que terão acesso como seu diretório home e bloqueando o uso do shell, para que eles não possam acessar o servidor remotamente através de outros meios (via ssh, por exemplo).

Vamos começar adicionando no arquivo a opção que prende os usuários nos seus diretórios home. Abra o arquivo “/etc/proftpd.conf” e adicione (no final do arquivo) a linha:

 DefaultRoot ~

Você vai precisar adicionar também a seção para liberar o acesso anônimo ao ftp, que vimos acima. Como queremos apenas que os mantenedores dos projetos possam dar upload de arquivos, remova a seção “<Directory incoming>”. A seção vai ficar:

 <Anonymous ~ftp>
 User ftp
 Group nogroup
 UserAlias anonymous ftp
 DirFakeUser on ftp
 DirFakeGroup on ftp
 RequireValidShell off
 MaxClients 20
 DisplayLogin welcome.msg
 DisplayFirstChdir .message
 <Directory *>
 <Limit WRITE>
 DenyAll
 </Limit>
 </Directory>
 </Anonymous>

O diretório padrão do FTP, onde os usuários anônimos terão acesso aos arquivos, é a “/home/ftp”. Em outras distribuições pode ser usada a pasta “/var/ftp”; dê uma olhada em como o arquivo vem configurado por padrão.

De volta à configuração, vamos começar criando subpastas para cada projeto:

 # mkdir /home/ftp/projeto1
 # mkdir /home/ftp/projeto2
 # mkdir /home/ftp/projeto3
 etc...

O próximo passo é ir adicionando os usuários no sistema, tendo o cuidado de fazer as alterações no diretório home e no shell padrão, para que eles tenham acesso somente via FTP e apenas à pasta desejada.

Para adicionar os usuários, use o comando “adduser”, como se estivesse criando uma conta normal:

 # adduser projeto1

 Acrescentando usuário projeto1...
 Acrescentando novo grupo projeto1 (1005).
 Acrescentando novo usuário projeto1 (1005) com grupo projeto1.
 Criando diretório pessoal /home/projeto1.
 Copiando arquivos de /etc/skel

 Enter new UNIX password:
 Retype new UNIX password:
 passwd: password updated successfully

Veja que por padrão ele cria a pasta “/home/projeto1″, que passa a ser o diretório home do usuário criado. Entretanto, neste caso queremos que o home seja a pasta “/home/ftp/projeto1″, onde ele dará upload dos arquivos.

Para alterar isso, abra o arquivo “/etc/passwd”, onde ficam guardadas as informações dos usuários. Na última linha do arquivo você verá:

 projeto1:x:1005:1005:,,,:/home/projeto1:/bin/bash

Vamos alterar o “/home/projeto1″ para “/home/ftp/projeto1″ (para trocar o home) e o “/bin/bash” para “/bin/false”, de forma a impedir que usuário tenha acesso ao shell do servidor e possa executar comandos (fazendo o que não deve no servidor). Se você preferir que, além do acesso via ftp, os usuários tenham acesso via ssh, então mantenha o “/bin/bash”. Depois das alterações, a linha ficará:

 projeto1:x:1005:1005:,,,:/home/ftp/projeto1:/bin/false

Você pode aproveitar para remover a pasta /home/projeto1, já que não precisaremos mais dela:

 # rm -rf /home/projeto1/

Na verdade, esse processo serve para que você entenda melhor o procedimento de criação destes usuários “falsos” no Linux. Estas alterações podem ser especificadas ao criar o usuário. Não é preciso sair editando todos os arquivos manualmente. O comando para criar o usuário “projeto1″, usando a pasta “/home/ftp/projeto1″ como home e o “/bin/false” como shell, seria:

 # adduser --home /home/ftp/projeto1 --shell /bin/false --no-create-home projeto1

Não esqueça de acertar as permissões da pasta /home/ftp/projeto1:

 # chown -R projeto1:projeto1 /home/ftp/projeto1/

Depois de concluir a configuração, falta só reiniciar o servidor FTP para que as configurações entrem em vigor:

 # /etc/init.d/proftpd restart

Em distribuições derivadas do Debian, você vai precisar adicionar a linha “/bin/false” no final do arquivo /etc/shells para que ele possa ser usado:

 # echo "/bin/false" >> /etc/shells

Feito isso, você já conseguirá se logar no servidor usando o login criado. O usuário não enxerga nada fora da pasta “/home/ftp/projeto1″ e todos os arquivos que ele der upload vão para lá.

A senha de acesso ao FTP é a mesma definida na hora de criar o usuário. O Proftpd simplesmente aproveita o sistema de autenticação do sistema. Se você precisar alterar a senha do usuário, use o comando “passwd projeto1″.

Para usar o Proftpd em conjunto com os virtual hosts do Apache, a configuração é a mesma, com exceção de que você não precisaria habilitar o acesso anônimo, já que o FTP seria usado apenas pelos webmasters dos sites hospedados.

Nesse caso, ao criar os usuários, use a pasta com os arquivos do site como home, como em:

 # adduser --home /var/www/joao --shell /bin/false --no-create-home joao

A opção “–no-create-home” evita que o sistema copie os arquivos do diretório “/etc/skel” (como os arquivos .bashrc, .bash_history e outros) para dentro da pasta de arquivos, “sujando” o diretório. Ao terminar, não se esqueça de alterar as permissões da pasta, de forma que o usuário tenha permissão de escrita:

 # chown -R joao:joao /var/www/joao

Graças ao uso da opção “DefaultRoot ~”, os usuários terão acesso apenas à pasta com os arquivos do site, sem acesso às pastas dos outros usuários ou às demais pastas do sistema. Esta é justamente a configuração usada na maioria dos serviços de shared hosting onde o acesso é feito via FTP. O sistema não é nada seguro e de vez em quando algumas das senhas são roubadas, mas, como ele é fácil de implementar e poucos usuários tem dificuldades em acessar as contas, a tradição continua.

FTP + TLS

É possível adicionar uma camada de segurança ao protocolo FTP ativando a encriptação via TLS. Nem todos os clientes de FTP suportam encriptação, de forma que a mudança criará dificuldades aos usuários menos técnicos, mas, por outro lado, elimina o grande risco do FTP, evitando que as senhas possam ser capturadas durante as conexões.

Presumindo que você já tenha instalado o pacote do Proftpd e feito a configuração básica, o próximo passo é instalar o pacote “openssl”. Ele é usado por diversos outros serviços, por isso é provável que já esteja instalado:

# apt-get install openssl

Em seguida, crie um diretório dentro da pasta “/etc/proftpd” para armazenar os certificados, como em:

# mkdir /etc/proftpd/cert

O próximo passo é gerar os certificados usando o comando “openssl”, como em:

# openssl req -new -x509 -days 3650 -nodes -out \
/etc/proftpd/cert/proftpd.cert.pem -keyout /etc/proftpd/cert/proftpd.key.pem

A opção “-days” especifica o tempo de validade do certificado. Nesse caso, estou gerando um certificado válido por 10 anos para evitar que os clientes passem a receber erros relacionados ao certificado caso ele expire antes que tenha tempo de atualizá-lo. Entretanto, do ponto de vista da segurança, o ideal é gerar certificados válidos por apenas um ano ou dois e substituí-los mais regularmente.

Depois de responder às perguntas feitas durante a geração do certificado (país, estado, cidade, nome da empresa, etc.), serão gerados os arquivos “proftpd.cert.pem” e “proftpd.key.pem” dentro da pasta “/etc/proftpd/cert”, que correspondem ao certificado.

O próximo passo é alterar a configuração do Proftpd de forma que ele ative o uso da encriptação. Abra o arquivo “/etc/proftpd/proftpd.conf” e procure pelas linhas:

<IfModule mod_tls.c>
TLSEngine off
</IfModule>

Para ativar o uso do TLS, você deve substituí-las por:

<IfModule mod_tls.c>
TLSEngine on
TLSLog /var/log/proftpd/tls.log
TLSProtocol SSLv23
TLSOptions NoCertRequest
TLSRSACertificateFile /etc/proftpd/cert/proftpd.cert.pem
TLSRSACertificateKeyFile /etc/proftpd/cert/proftpd.key.pem
TLSVerifyClient off
TLSRequired on
</IfModule>

Note que as opções “TLSRSACertificateFile” e “TLSRSACertificateKeyFile” indicam a localização dos dois arquivos com o certificado. Se você estiver usando uma pasta diferente da “/etc/proftpd/cert” para armazená-los, não esqueça de indicar a localização correta. Outra opção importante é a “TLSRequired”, que determina se o uso da encriptação será obrigatório ou não. Ao usar “TLSRequired on”, como no exemplo, apenas os clientes que tiverem ativado o uso do SSL poderão se conectar ao servidor, enquanto que ao usar “TLSRequired off” a encriptação passa a ser opcional.

Depois de salvar a configuração, reinicie o serviço:

# /etc/init.d/proftpd restart

Para ativar a encriptação no cliente, é necessário usar o protocolo “FTP over SSL”, em vez do protocolo FTP regular. No Filezilla, por exemplo, a opção aparece dentro do Site Manager, ao visualizar as propriedades da conexão:

Ao conectar a partir do cliente, você verá entradas similares a essas no arquivo “/var/log/proftpd/tls.log” (no servidor), sinal de que a encriptação está sendo usada:

Jun 30 12:54:46 mod_tls/2.1.1[2326]: TLSv1/SSLv3 connection accepted, using cipher DHE-RSA-AES256-SHA (256 bits) Jun 30 12:54:47 mod_tls/2.1.1[2326]: Protection set to Private Jun 30 12:54:47 mod_tls/2.1.1[2326]: starting TLS negotiation on data connection Jun 30 12:54:47 mod_tls/2.1.1[2326]: TLSv1/SSLv3 data connection accepted, using cipher DHE-RSA-AES256-SHA (256 bits) Jun 30 12:54:47 mod_tls/2.1.1[2325]: starting TLS negotiation on data connection

O grande problema é que o FTP over SSL não é suportado por todos os clientes de FTP, o que dificulta seu uso. Em geral, é mais fácil conseguir que os usuários migrem para o SFTP (veja detalhes sobre ele no capítulo sobre o SSH), que é suportado por um número maior de clientes de FTP do que conseguir fazer uma migração completa para o TLS.