Comando Route

Definindo rotas estáticas no Linux com route

Para implementar rotas no Linux existem diversos softwares livres e de código aberto que possibilitam a manipulação de tabelas de roteamento IP do kernel. Seu principal ofício é configurar rotas estáticas para os hosts que compõem determinada faixa de rede, por intermédio de uma interface propriamente configurada. O software route é padrão nos sistemas Linux, foi originalmente desenvolvido por Fred N. Van Kempen e posteriormente modificado por Johannes Stille e Linus Torvalds. O suporte a irtt (compartilhamento com netstat) foi adicionado por Bernd Eckenfels.

Outras funções importantes que foram adicionadas são mss e windows, implementadas por Alan Cox. O brasileiro Arnaldo Carvalho de Melo contribuiu na tradução do manual para a língua portuguesa.

A inserção de rotas pode ser iniciada pelo comando "route" seguido de parâmetros que validam os conceitos de rotas que foram descritas no início deste documento. Abaixo segue a tabela 1 contendo todos os parâmetros.

Tabela 1: Parâmetros do route

Parâmetro	Especificação
-v	Lista detalhada
--version	Mostra a versão e outras informações.
-n	Mostra as rotas definidas, sem resolver nomes
-e	Mostra a tabela de roteamento no formato Netstat
-ee	Mostra uma imensa linha contendo todos os parâmetros da tabela de roteamento
-net	Refere-se ao endereço de uma rede, encontrado no arquivo /etc/networks
-host	Refere-se ao endereço de uma máquina
del	Remove uma rota
add	Adiciona uma rota
netmask	Opção para adicionar máscara de rede da rota a ser adicionada
gw	Adiciona o gateway, onde qualquer pacote destino será roteado através do gateway específico
metric	Configura o campo métrico da tabela de roteamento, porém não é usado por kernels mais recentes, somente daemons de roteamento a utilizam
mss	Especifica o tamanho máximo do segmento TCP em bytes (MSS) para conexões TCP através desta rota
window	Especifica o tamanho da janela TCP para conexões TCP através desta rota. Tipicamente somente usado para redes AX.25 e em drivers incapazes de de tratar frames back to back
irtt	Tempo de ida e volta de conexões TCP desta rota
reject	Bloqueia rota antes do uso da rota default
mod, dyn, reinstate	Instala rotas modificadas ou dinâmicas, são usadas por daemons de roteamento
dev	Refere-se ao dispositivo - eth0, eth1
dev If	Força o uso do dispositivo indicado, pois o kernel pode determinar o dispositivo por conta própria

O comando route pode ser usado de diversas formas, pode-se encontrar diversos documentos pela internet com exemplos de configuração diferentes, portanto abordaremos uma forma não convencional para fazer a inserção de rotas no sistema, esse sendo um padrão sugerido pelos desenvolvedores desse software. É importante ressaltar que para se usar o route é necessário que, ao menos uma interface esteja configurada. Podemos adicionar entradas na interface loopback usando a máscara 255.0.0.0 e associá-la ao dispositivo lo (local).

# route add -net 127.0.0.0 netmask 255.0.0.0 dev lo

Para adicionar uma rota padrão que permita a saída do tráfego da rede é necessário indicar na sintaxe do comando default e indicar em qual interface os pacotes serão roteados. Caso não defina a interface no comando, o kernel irá definir uma interface para adicionar o gateway, naturalmente poderá vir a ser o primeiro dispositivo.

# route add default gw 192.168.0.1 dev eth0

Pode-se configurar o arquivo /etc/hosts para usar nomes de máquinas, para que não seja necessário colocar número de IP sempre que for adicionar uma rota ou rejeitar uma rota para determinada faixa de rede. Por esse motivo é importante que o arquivo fique legível, usando-se comentários indicando se é nome atribuído a máquina ou o dispositivo de rede.

Exemplo 1: Arquivo /etc/hosts

## Local
127.0.0.1                localhost
## device eth0
192.168.0.1             androide-gw
## device eth1
192.168.1.1             curupira-gw
## maquina
192.168.2.1             javali-gw
## maquina
192.168.3.1             torresmo-gw

É possível adicionar uma rota para uma máquina da rede através de uma interface e assumir que a máquina é a própria interface. Com isso podemos permitir que uma rede possa ser alcançada através dessa máquina ou definir rota para toda uma classe de rede. Nos comandos seguintes podemos validar essa afirmação.

Adicionar rota para máquina:

# route add curupira-gw eth0

Adicionar rota para uma rede:

# route add -net 192.168.2.0 netmask 255.255.255.0 gw curupira-gw

Adicionar rota para toda uma classe de rede (multcast):

# route add -net 192.168.0.0 netmask 255.255.0.0 dev eth0

Bloquear rota para rede privada:

# route add 10.0.0.0 netmask 255.0.0.0 reject

Outros comandos podem ser aplicados para a verificação do estado da tabela de roteamento, bem como informações de versões de software e exibição da tabela de roteamento. O comando route seguido da opção -V retornará como saída padrão a versão do software e módulos suportados pelo programa, já a opção -v mostra na saída padrão a tabela de roteamento de forma simplificada, porém se esta opção vier seguida de outros comandos terá a responsabilidade de jogar na saída padrão o processo sendo executado de forma detalhada.

O status da tabela de roteamento pode ser observada com a opção -n, onde serão exibidas 8 colunas (destino, roteador, MascaraGen, opções, métricas, Ref, Uso, Iface), a coluna opção relata o status de cada rota, se está habilitada, se está instalada por um daemon ou sendo rejeitada, entre outros. As possíveis situações referentes ao status das rotas podem ser apresentadas na tabela 2 abaixo.

Tabela 2: Opções

Opção	Especificação
U	Está habilitada
H	Refere-se que o alvo é uma máquina
G	Usa o roteador
R	Está apontando para um roteamento dinâmico
D	Rota instalada dinamicamente por redirecionamento
M	Modificada por redirecionamento
!	Rejeitada

Exemplo:

# route -n

Tabela de Roteamento IP do Kernel 
Destino       Roteador      MáscaraGen.    Opções Métrica Ref  Uso  Iface 
192.168.1.0   0.0.0.0       255.255.255.0  U      1       0    0    eth0 
192.168.2.0   0.0.0.0       255.255.0.0    U      1000    0    0    eth0 
0.0.0.0       192.168.1.1   0.0.0.0        UG     0       0    0    eth0

Outras opções podem ser aplicadas como o -e (--extend), para mostrar informações adicionais como por exemplo colunas com informações sobre tempo de ida e volta de pacotes e tamanho em máximo de segmento TCP/IP em bytes. Outra opção é usar o -F (--fib), que são informações de repasse. A opção route -C (--cache) joga na saída padrão o cache da tabela de roteamento que esteja registrada pelo kernel.

Basicamente podemos implementar rotas com esse software, embora existam formas, métricas mais eficientes, existem softwares que podem avançar mais nos conceitos de rotas, portanto no tópico seguinte há um aprofundamento na criação de rotas avançadas, que por sua vez pode restringir e controlar fluxo de tráfego e entre outros

Dicas para o SSH

#### Histórico de SSH ####

/var/log/auth.log


#### Para aparecer no SSH ####

* apt-get install linuxlogo
* cp /etc/motd /etc/motd-save
* /usr/bin/linux_logo > /etc/motd


#### Para colocar o SSH mais rapido para pedir a senha ####

sudo vi /etc/ssh/sshd_config

Port 2223
...
UseDNS no

-

Clonar HD com dd

Clone seu HD, compactando e visualizando a cópia em tempo real com o comando dd

Hoje precisei clonar um HD de um servidor (Sun Sparc Ultra10, rodando Debian), então vasculhei o Google buscando encontrar a melhor forma de fazer isso a partir de um terminal ssh, pois a máquina física está em produção em um datacenter, e não pode parar.

Encontrei várias matérias sobre como clonar HDs com o dd, inclusive aqui no VOL tem uma ótima. Porém todas que encontrei não falavam como executar o dd, acompanhando a evolução do processo de clonagem. Algumas matérias sugeriam outras soluções além do dd, mas no meu caso era impraticável, pois o servidor não tem acesso à internet para poder baixar nada. Então tinha que ser com o dd mesmo.

Outro problema foi que o HD secundário que armazenaria o clone tem tamanho inferior ao HD master, e desta forma eu teria que clonar compactando os dados simultaneamente.

Então mesclei várias informações de artigos diferentes, resultando numa eficiente dica de:

1. clonagem de hd a quente (com o sistema rodando)
2. compactação da imagem clonada simultaneamente
3. visualização da evolução da clonagem

Descrevo a solução abaixo (parte do princípio que a máquina tenha 2 HDs instalados):

Cenário:

• HD1 (hda) 120GB (só 20GB em uso)
• HD2 (hdc) 80GB

1. Primeiro vamos montar o HD slave no sistema (todos os comandos executados como root).

Criar uma pasta "imagem" no hd master para receber o ponto de montagem do hdc slave:

# mkdir imagem

Montar o hdc slave no sistema, na pasta "imagem":

# mount -t ext3 /dev/hdc1 imagem

Checando se a partição montou de acordo como esperado:

# df -h
/dev/hdc1        74G  270M   70G   1% /root/imagem

Se aparecer uma informação parecida com a linha acima, mostra que o hdc está montado no caminho /root/imagem, então está tudo bem, e nesse caso temos 70GB para uso. No meu caso, utilizei hdc1 pois é a partição ativa do meu HD slave. Se o seu for diferente, basta alterar o número. Vamos continuar como processo.

Comando para gerar a imagem-clone de hda para hdc compactando com o gzip:

# dd if=/dev/hda | gzip -9f | of=imagem/backup.iso bs=64k

No comando acima, dd if=/dev/hda significa a origem dos dados a serem clonados, no meu caso o hda. Entre dois pipes (|), o comando | gzip -9f| significa que ao mesmo tempo que o dd clona o hda ele compacta com o gzip no nível mais eficiente de compactação (que vai de 1 a 9), no caso o nível 9; o "f" significa forçar a compactação para evitar qualquer problema. O restante da linha de comando, of=imagem/backup.iso, significa a saída dos dados, o destino do clone.

No caso "imagem" é a pasta criada por mim para receber o arquivo-clone, e "backup.iso" é a imagem-clone propriamente dita, que ficará armazenada na pasta "imagem" que está montada com o hdc. O final do comando, bs=64k, é um comando extra para o dd, que fará a cópia-clone em blocos de 64k.

Com isso temos a linha de comando completa para fazer a imagem de hda para hdc.

Porém, o dd é um comando bem hard, e não tem um mostrador da evolução do clone. Dependendo da origem a ser clonada, pode demorar horas. Mas como vamos saber quando terminará?

Como eu já disse antes, esta foi uma das minha dificuldades. Então através de outro terminal ssh (ou se você estiver no console a máquina, pode abrir outro terminal com os comandos ALT+F2, ALTF3, ALTF4 etc, lembrando que você retorna para o terminal principal com ALT+F1).

Já no outro terminal ssh, digite os comandos abaixo.

Comando para descobrir o número do processo dd rodando:

# top
4839 root      25   0  2080  784  392 R 41.2  0.2  31:19.38 gzip

Na tabela mostrada pelo top, procure a coluna COMMAND (mais à direita) , a linha do dd executando. Identifique nesta linha o número do processo (PID - process ID), que fica mais à esquerda. No meu caso, o processo referente ao dd, como mostrado na linha acima, foi de PID 4839.

De posse deste número do PID, vamos executar o comando abaixo:

# watch kill -USR1 $44853; sleep 1;

Na linha de comando acima, o serviço "watch" mantém na tela ao vivo, em tempo real o que vem a seguir na linha de comando. O restante do comando, kill -USR1 é um recurso do comando dd que faz aparecer na tela a quantidade já executada da cópia-clone. E $44853 onde apenas 4853 é o número do PID descoberto como top. Altere este número para o do PID correspondente ao seu dd em execução. Ao final, sleep 1;, faz com que o processo de visualização ser finalizado. O watch faz o comando ser executado em loop, como se você tivesse várias vezes digitando ele no prompt.

Então você verá aparecer na tela a informação da clonagem a cada 2 segundos, conforme abaixo:

36090146+0 records in
336090145+0 records out
172078154240 bytes (172 GB) copied, 4686.54 seconds, 36.7 MB/s

336234848+0 records in
336234847+0 records out
172152241664 bytes (172 GB) copied, 4688.49 seconds, 36.7 MB/s

336395536+0 records in
336395536+0 records out
172234514432 bytes (172 GB) copied, 4690.53 seconds, 36.7 MB/s

336555610+0 records in
336555610+0 records out
172316472320 bytes (172 GB) copied, 4692.56 seconds, 36.7 MB/s

Pode observar que vai aumentando, linha após linha.

Espero que tenha ajudado.