Neste artigo mostrarei como monitorar as Interfaces de Rede e também os clientes de um roteador linux utilizando o MRTG. Neste exemplo estou utilizando um Servidor Lunux Ubuntu com regras de NAT, mas pode ser adaptado facilmente para outras distribuições ou necessidades.

Também utizaremos o IPFM que fará a contabilização do tráfego utilizado pelos IPs que passam pelo roteador linux.

Instalando Programas necessários:

# apt-get install mrtg ipfm

Configurando o MRTG

# mkdir /etc/mrtg
# mkdir /etc/mrtg/scripts
# mkdir /var/www/mrtg

O primeiro é o diretório onde fica guardado o arquivo de configuração (normalmente mrtg.cfg). O segundo é onde ficarão os scripts necessários para o monitoramento e o terceiro diretório é onde estarão as páginas criadas para a visualização dos gráficos.

Criando os Scripts

IFVMON.SH (para monitorar os IPs de clientes)
# vi /etc/mrtg/scripts/ifvmon.sh

# Script Feito por Jefferson Aranha Dos Santos
# Jefferson.aranha@gmail.com
# Passando como 1º parâmetro o caminho completo do log do ipfm e 2º
# parâmetro um ip
#!/bin/bash
cat "$1" | grep "$2 " > /dev/null
if [ "$?" -ne 0 ]
then
echo 0
echo 0
else
cat "$1" | grep "$2 " | awk '{print $2"\n"$3}'
fi

MRTG.CFG

Language: brazilian
EnableIPv6: no
RunAsDaemon: Yes
Interval: 5
WorkDir:/var/www/mrtg
Logdir: /var/log/mrtg
Options[_]: bits,growright
#
Target[eth0]:`/etc/mrtg/scripts/ifmon.sh eth0`
Title[eth0]:"Trafego Internet - eth0"
Maxbytes[eth0]:1400000
PageTop[eth0]:<h1>Trafego Internet - eth0</h1>
Options[eth0]: growright,bits,noinfo
#
Target[eth1]:`/etc/mrtg/scripts/ifmon.sh eth1`
Title[eth1]:"Trafego Clientes - eth1"
Maxbytes[eth1]:1400000
PageTop[eth1]:<h1>Trafego Clientes - eth1</h1>
Options[eth1]: growright,bits,noinfo
#
Target[loopback]:`/etc/mrtg/scripts/ifmon.sh lo`
Title[loopback]:"Trafego da Loopback - lo"
Maxbytes[loopback]:1400000
PageTop[loopback]:<h1>Trafego da Loopback - lo</h1>
Options[loopback]: growright,bits,noinfo
#
Target[192.168.1.100]:`/etc/mrtg/scripts/ifvmon.sh /var/log/ipfm/subnet/ipfm.log 192.168.1.100`
Title[192.168.1.100]:"Trafego do IP - 192.168.1.100"
Maxbytes[192.168.1.100]:1400000
PageTop[192.168.1.100]:<h1>Trafego do IP - 192.168.1.100</h1>
Options[192.168.1.100]: growright,bits,noinfo

Salvo se eu tenha esquecido de alguma coisa, o MRTG agora está pronto para funcionar, portanto vamos às finalizações:

Executando o IPFM

# ipfm -c /etc/ipfm.conf

Gerando a página que mostrará os gráficos

# indexmaker –output=/var/www/mrtg/index.html /etc/mrtg/mrtg.cfg

Executando o MRTG

# env LANG=C /usr/bin/mrtg /etc/mrtg/mrtg.cfg –logging /var/log/mrtg.log

Deixem suas dicas e sugestões nos comentários.
Eduardo Supertrix

Se você está usando um desktop Ubuntu, pode ter se deparado com alguns problemas na hora de configurar programas de rede como Webmin e outros. O que acontece é que o NetworkManager; programa que cuida das configurações automáticas; é instalado e ativado na instalação padrão do Ubuntu Desktop.

Existe algumas maneiras de desabilitar este programa, mas acredito que a mais fácil é utilizar o programa rcconf:

# aptget install rcconf
# rcconf

Provavelmente o NetwordManager está na primeira posição da fila. Basta desabilita-lo e reiniciar a máquina. Em seguida, tudo que você vai precisar é configurar a rede na unha:

Edite o arquivo /etc/network/interfaces: (segue abaixo um exemplo)

# The loopback network interface
auto lo
iface lo inet loopback
#
# The primary network interface
auto eth0
iface eth0 inet dhcp
#
# The secondary network interface
auto eth1
iface eth1 inet static
      address 192.168.1.1
      netmask 255.255.255.0
      network 192.168.1.0
      broadcast 192.168.1.255

Veja mais itens de configuração em Cibercity.biz

Requerimentos:

• Um servidor que permita você logar via  SSH.
• O servidor precisa permitir que você rode scripts shell scripts e tenha acesso ao mysql via linha de comando.

Definindo as variáveis:

 
#!/usr/bin/bash
 
#Variables
sr="localhost"                    #remote server
lg="nome_do_usuario_do_mysql"     #login name
pw="senha"                        #password
hs="all"                          #file name to store sql file
bk="$HOME/dbackup"                #path to store backup files
nw=$(date "+%Y%m%d")              #get date as string
nb=60                             #maximum number of files that will be keep

A primeira linha é o caminho do interpretador do shell script. Varia conforme a configuração do servidor. Este que aparece é para a Dreamhost.

Você vai precisar editar, colocando os seus valores nas seguintes variáveis:

• sr: nome do seu servidor, normalmente “localhost”, mas para a Dreamhost é sempre “mysql.dominio.com.br”
• lg: nome do seu usuário do servidor mysql
• pw: senha do seu usuário do servidor mysql

Se quiser, mude estas aqui com os seus valores:

• hs: nome do arquivo temporário mysql
• bk: nome do diretório onde ficarão armazenados as cópias do banco de dados. A variável $HOME deve ser mantida.
• nb: número de cópias do banco de dados. Como a Dreamhost me dá mais de 20 gigas de espaço em disco, e todos os meus bancos somados e compactados ficam em 10 Mb, eu armazeno 60 cópias, uma para cada dia de dois meses.

Agora, a funçao:

 
function backup()
{
  echo "Getting data from mysql server"
  mysqldump -u$lg -p$pw -h$sr --add-drop-table --quote-names --all-databases --add-drop-database > "$HOME/$hs.sql"
  echo "Compressing $fn.sql.gz file ..."
  gzip -f "$HOME/"$fn.sql
  if [ -d $bk ]; then
    continue
  else
    mkdir $bk
  fi
  cp -f "$HOME/"$hs.sql.gz "$bk/$nw.sql.gz"
 
  a=0
  b=$(ls -t $bk)
  c=$nb
 
  for arq in $b; do
    a=$(($a+1))
    if [ "$a" -gt $c ];  then
      rm -f "$bk/$arq"
    fi
  done
}

O comando mais importante aqui é o mysqldump. Com estes parâmetros, ele vai pegar todos os bancos de dados que estão no servidor definido na variável “sr”.

 
mysqldump -u$lg -p$pw -h$sr --add-drop-table --quote-names --all-databases --add-drop-database > "$HOME/$hs.sql"

O próximo comando compacta o arquivo sql gerado no diretório definido pela variável $HOME.

gzip -f "$HOME/"$fn.sql

O comando a seguir é quase cosmético. Ele cria o diretório para você automaticamente, caso ele não exista:

 
if [ -d $bk ]; then
  continue
else
  mkdir $bk
fi

Então, ele copia o arquivo gzipado para o diretório de backup, usando a data do sistema para gerar o nome, no formato AAAAMMDD.sql.gz. Ex: 20080603.sql.gz:

 cp -f "$HOME/"$hs.sql.gz "$bk/$nw.sql.gz"

E como não queremos estourar o limite do nosso espaço no servidor, o trecho a seguir faz a limpeza, deletando o arquivo de backup número $nb + 1, isto é, o arquivo mais velho criado anteriormente e de número maior do que o que você definiu na variável nb, ou seja, o 61 neste caso.

 
a=0
b=$(ls -t $bk)
c=$nb
for arq in $b; do
  a=$(($a+1))
  if [ "$a" -gt $c ];  then
      rm -f "$bk/$arq"
  fi
done

E para terminar, coloque na ultima linha do script:

 
backup

Salve em um arquivo, exemplo backup.sh, em formato texto puro, em formato UNIX (LF). Um editor gratuito que faz isto é o PSPAD.

Agora acesse o shell do seu servidor e rode o crontab.

crontab -e

E coloque no final do arquivo a linha:

0 6 * * * sh /home/user/backup.sh

Onde “home/user” é o caminho até seu arquivo backup.sh. Esta linha diz para seu servidor fazer uma cópia todo dia as 06:00 h. Se estiver usando o Nano como editor, tecle CRTL+o para salvar o arquivo, depois CRTL+x para sair.

Para restaurar o banco, primeiro descompate-o, depois rode o mysq.

 
gunzip -f "$HOME/dbbackup/nome_do_arquivo.sql.gz"
mysql -uusuario -psenha -hlocalhost < "$HOME/dbbackup/nome_do_arquivo.sql"

Importante: não coloque o script em um diretório que possa ser acessado pelo público, já que os dados de acesso ao banco estão nele.

Fonte: www.sgd.com.br

Este é um pequeno guia rápido para que você possa compactar, descompactar e visualizar arquivos no console do linux.

Introdução

GZIP e TAR são dois utilitários muito usados no Linux para a compactação de arquivos. Muitos dos programas e documentos disponíveis na Internet para Linux, se encontram nestes formatos. Este tutorial mostrará como usar os recursos básicos destas duas ferramentas.

GZIP: Arquivos do tipo .gz

O GZIP é um software de compressão criado para gerar uma cópia compactada de um arquivo. Ele não é capaz de compactar vários arquivos em um só. Mesmo compactando apenas um arquivo por vez, o GZIP o faz de maneira muito eficiente. Por isso é amplamente usado. Para usá-lo, a síntase é gzip [parâmetros] [arquivo], onde gzip é o nome do comando, parâmetros são opções para a operação (ver lista de parâmetros abaixo) e arquivo, obviamente, o arquivo que será compactado/descompactado. A seguir, é mostrado uma lista básica de parãmetros para a utilização do GZIP.

Parâmetros

A lista abaixo mostra alguns parâmetros que podem ser usados. É possível usar mais de um ao mesmo tempo:

c – mantém o arquivo original;
d – descompacta um arquivo comprimido;
l – lista o conteúdo de arquivos comprimidos;
v – exibe saída detalhada;
1 – compressão rápida;
9 – melhor compressão.

Abaixo, há exemplos, para os quais utilizaremos o arquivo arquivo.txt:

gzip arquivo.txt – compacta removendo o arquivo original e criando o arquivo arquivo.txt.gz;
gzip -c arquivo.ext – faz o mesmo que a operação acima, mas mantém o arquivo original;
gzip -9 nome.ext – faz uma compactação maior, removendo o arquivo original e criando o arquivo arquivo.txt.gz;
gzip -cv1 file1.txt file2.txt – compactação baixa, mantendo o arquivo original e criando os arquivos file1.txt.gz e file2.ext.gz. O parãmetro ‘v’ faz com que seja mostrado detalhes da operação;
gzip -l infowester.gz – lista o conteúdo do arquivo infowester.gz;
gzip -d arquivo.txt.gz – descompacta o arquivo arquivo.txt.gz.

TAR: Arquivos do tipo .tar e .tar.gz

O que o GZIP não consegue fazer, o TAR (Tape ARchives) faz. Ele é um aplicativo capaz de armazenar vários arquivos em um só. Porém, não é capaz de compactar os arquivos armazenados. Como é possível notar, o TAR serve de complemento para o GZIP e vice-versa. Por isso, foi criado um parâmetro no TAR para que ambos os programas possam trabalhar juntos. Assim, o TAR “junta” os arquivos em um só. Este arquivo, por sua vez, é então compactado pela GZIP. Quando ocorre o trabalho conjunto entre TAR e GZIP, o arquivo formado tem a extensão tar.gz.

O TAR também consegue gravar a propriedade e as permissões dos arquivos. Ainda, consegue manter a estrutura de diretórios original (se houve compactação com diretórios), assim como as ligações diretas e simbólicas.

Para utlizar o TAR, a síntaxe é tar [parâmetros] [-f arquivo] [-C diretório] [arquivos...]. Abaixo, segue a lista de parâmetros.

Parâmetros

-c – cria um novo arquivo tar;
-M – cria, lista ou extrai um arquivo multivolume;
-p – mantém as permissões originais do(s) arquivo(s);
-r – acrescenta arquivos a um arquivo tar;
-t – exibe o conteúdo de um arquivo tar;
-v – exibe detalhes da operação;
-w – pede confirmação antes de cada ação;
-x – extrai arquivos de um arquivo tar;
-z – comprime o arquivo tar resultante com o gzip;
-f – especifica o arquivo tar a ser usado;
-C – especifica o diretório dos arquivos a serem armazenados.

A seguir mostramos exemplos de utlização do TAR. Em alguns parâmetros o uso de ‘-’ (hífen) não é necessário. Desta vez, os comandos não serão explicados. Execute-os e descubra o que cada um faz. Repare na combinação de parâmetros e tente entendê-la. Assim, você saberá exatamente o que está fazendo. Bom aprendizado!

tar -c pasta > arq.tar
tar -cvf arq.tar arq1 arq2
tar -cvf /dev/fd0 /dir1/*
tar -cvMf /dev/fd0 /dir1 /dir2/subdir /dir3
tar -c -v -f arq.tar *.ext
tar cwf arq.tar pasta
tar -czvf /pasta/arq.tgz *
tar czwf arq.tar.gz -C /dir1 arq1 -C /dir2 arq2 arq3
tar -rf arq.tar arq*
tar -tf arq.tar
tar -xv -f arq.tar
tar xvMf /dev/fd0
tar xf arq.tar pasta/arq1
tar xzvf /pasta/subdir/arq.tar.gz
tar -xzwf arq.tgz

Outros Exemplos:

Para fazer os backups, utilizando o comando “tar”. Vamos primeiro criar um exemplo de arquivo de backup:

tar -cf maquina-backup-full-20030212.tar /etc /var/named /var/log
bzip2 maquina-backup-full-20030212.tar

O que fiz foi armazenar os arquivos dos diretórios “/etc”, “/var/named” e “/var/log” no arquivo maquina-backup-20030212.tar, e depois compactá-lo no formato bzip2 (uma compactação melhor, mas que requer mais processamento), gerando então o arquivo “maquina-backup-20030212.tar.bz2″. Este mesmo comando pode ser feito em uma linha só:

tar -jcf maquina-backup-full-20030212.tar.bz2 /etc /var/named /var/log

Agora o mesmo backup comoutra forma de compactação (utilizando o programa gzip ao invés do bzip2)

tar -zcf maquina-backup-full-20030212.tar.gz /etc /var/named /var/log

Agora vamos supor que eu alterei o conteúdo do diretório “/etc”, adicionando um arquivo chamado “teste” e modificando o arquivo “crontab”. Para não ter que fazer um backup total novamente, eu posso incrementar este backup somente com as modificações feitas. Para isso eu utilizo o seguinte comando:

find /etc /var/named /var/log -mtime -1 -type f -print | \
tar zcvf maquina-backup-incremental-20030212.tar.gz -T -

Aqui o Linux vai procurar por arquivos modificados numa faixa de 1 dia (usado para backups incrementais diários) e armazená-los no arquivo “maquina-backup-incremental-20030212.tar.gz”. Vejamos agora um backup feito com os arquivos modificados numa faixa de uma semana:

find /etc /var/named /var/log -mtime -7 -type f -print | \
tar zcvf maquina-backup-incremental-20030212.tar.gz -T -

Agora se você quiser automatizar, e poupar trabalho, use para a nomeação do arquivo o comando “date”, gerando assim a data no arquivo. Veja o exemplo dessa compactação:

# tar zcf backup-full-`date +%Y%m%d`.tar.gz /etc
# ls
backup-full-20030212.tar.gz

Agora que você já aprendeu a fazer os backups, vamos armazená-lo remotamente. Eu assumo que você já tenha configurado um servidor FTP em outra máquina, se você ainda não fez isso, faça. Depois adicione um usuário com uma certa senha para acessar este ftp. Aqui no tutorial vamos usar como usuário: “backup” e como senha: “segredo”. Utilize o seguinte script para automatizar o processo:

#!/bin/bash
#
DATA=`date +%Y_%m_%d`

# Dados do arquivo de backup
MAQUINA=”sakura”
ARQUIVO=”backup-full-$MAQUINA-$DATA.tar.gz”
DIRETORIOS=”/etc /var/log”

# Dados do servidor FTP
HOST_FTP=”192.168.0.1″
USUARIO_FTP=”backup”
SENHA_FTP=”segredo”

# A partir daqui não precisa mais editar.
# Cria o arquivo .tar.gz no /tmp (Temporário)
cd /tmp
tar zcf /tmp/$ARQUIVO $DIRETORIOS

# Acessa o FTP e coloca os arquivos
ftp -in <<EOF
open $HOST_FTP
user $USUARIO_FTP $SENHA_FTP
bin
lcd /tmp
dele $ARQUIVO
put $ARQUIVO
bye
EOF

# Remove os arquivos temporarios
rm -rf /tmp/$ARQUIVO

Pronto! Lembre-se de proteger este arquivo aos olhos alheios, porque a senha do usuário do FTP está visível. Este pequeno script shell cria um backup dos diretórios “/etc” e “/var/log”, conecta ao servidor FTP e envia o arquivo. Você só precisará alterar as variáveis do começo do arquivo para as suas necessidades.

Este guia descreve como gerar e usar um par de chave private/public para acessar um servidor remoto com SSH utilizando o programa PuTTY. PuTTY é um cliente de SSH que está disponível para Windowsw e Linux (embora é mais comum para sistemas Windows). Usando logins baseados em chaves, você pode desabilitar o procedimento normal de login por username/senha, tornando o seu acesso mais seguro.

Considerações iniciais: Neste tutorial eu usarei um desktop Windows para conectar um Servidor Linux (Debian Sarge, IP address: 192.168.0.100).

1. Instalação dos programas necessários para o Windows.
   Baixe os programas abaixo:
   http://the.earth.li/~sgtatham/putty/latest/x86/putty.exe
   http://the.earth.li/~sgtatham/putty/latest/x86/puttygen.exe
2. Crie um profile para o servidor a ser acessado.
   Vamos criar um profile para nosso servidor 192.168.0.100. Inicie o PuTTY. Especifique o endereço ou nome de host no campo Host Name (or IP address)

   Click em Connection -> Data e especifique o nome de usuário que você deseja entrar em seu servidor SSH no campo Auto-loginusername. Neste artigo eu usarei root.

   

   Volte para session novamente e insira um nome para este profile. Ex.: 192.168.0.100 ou Servidor. Coloque isso em Saved session. Em seguida click em Save.

   

   Em seu proximo login você pode simplesmente clicar 2x sobre o servidor que deseja abrir ou clicar em Load e Open.

3. Vamos acessar o servidor:

   Quando você se conecta ao servidor pela primeira vez, você recebe um aviso de segurança. Este informa que uma chave de acesso está sendo criada. Você deve aceita-la.

   

   Agora basta digitar a senha (quando solicitado) e você já estará dentro do servidor.
   Esta é a forma normal de acesso.

   

   Permaneça logado ao servidor para implantar a chave pública que você irá gerar.

4. Gerando as chaves públicas e privadas:
   Você pode usar o programa PuTTYgen para gerar as chaves pública/privada em seu desktop. Certifique-se selecionar SSH-2 RSA no tipo de chave e especificar 1024 no número de bits. Click em Generate.

   Após clicar em Generate, ele irá solicitar que você mova o mouse várias vezes por cima da área branca para gerar uma chave randômica.

   

   Agora uma chave pública/privada foram geradas. Em “Key comment” você pode deixar o seu email ou uma identificação desta chave. Opcionalmente você pode colocar uma senha em “Key passphrase” (não é a senha do root) que será solicitada sempre que você fizer o login (deixando em branco ele entrará direto).
   Em seguida click em “Save private key” para salvar sua chave privada (guarde-a em um local seguro no seu computador.

   

   Estamos quase lá! Agora você pode selecionar o texto que ficou em “Public key for pasting…” conforme acima, copiar (Ctrl+C) e cola-lo em um arquivo dentro de seu servidor chamado ~/.ssh/authorized_keys2.
   Caso ele não exista você pode cria-lo:

   mkdir ~/.ssh
   chmod 700 ~/.ssh
   vi ~/.ssh/authorized_keys2

   Cole o conteúdo que você tinha selecionado dentro desse arquivo (normalmente digitando “i”, para entrar no modo de insert, e clicando com o botão direito no mouse no centro da tela).

   Agora só falta colocar direitos sobre este arquivo somente para o root:

   chmod 600 ~/.ssh/authorized_keys2

5. Última configuração no programa PuTTY

   Altere as configurações conforme acima e coloque o local onde você salvou sua chave privada no campo “Private key file…”

   

   Volte para “Session” e salve as configurações.
   Pronto, sempre que você utilizar essa configuração salva, ele não pedirá mais a senha de root.

   

Introdução

Pode parecer estranho o título do tutorial. E é estranho mesmo. Mas pior seria o verdadeiro título como “rsync utilizando SSH sem que você tenha que digitar a senha de acesso todas as vezes que rodar o script”. Como este título seria muito grande, resolvi abreviar e explicar ao longo do tutorial.

Todos nós temos a necessidade de fazer cópias de segurança (ou backup) de informações, sejam estas entre estações e um servidor, entre servidores ou até mesmo entre estações. O Linux* conta com várias ferramentas interessantes para estas tarefas, sendo uma delas o rsync, um pequeno aplicativo que permite a cópia de arquivos de uma máquina para outra de forma segura.

Não estarei aqui discutindo como usar o rsync mas sim como permitir que um script acesse um servidor ou outra máquina sem que o usuário tenha que digitar a senha de acesso, podendo assim agendar o script para que seja executado de tempos em tempos.

Como fazer

Para que não seja necessário informar a senha todas as vezes que vamos fazer uma cópia dos arquivos de uma máquina é preciso exportá-la para a máquina remota. Com isso, a máquina local (que irá receber os arquivos), pode sem complicações fazer executar os comandos necessários para a operação.

Para exportar a senha, use os seguintes comandos:

# ssh-keygen -t dsa -f ~/.ssh/id_dsa
# cat ~/.ssh/id_dsa.pub | ssh root@maquina_remota 'cat - >> ~/.ssh/authorized_keys'
# cat ~/.ssh/id_dsa.pub >> ~/.ssh/authorized_keys

A primeira linha faz com que seja criada uma chave DSA e esta seja armazenada no arquivo id_dsa. Observe que neste caso está sendo usado o parâmetro DSA devido ao suporte ao SSH versão 2. Se seus sistemas somente suportam SSH versão 1, mude esta opção para rsa1.

As outras duas linhas colocam a chave criada dentro do arquivo de chaves autorizadas tanto na máquina que serve os arquivos quanto na que recebe. Na segunda linha troque maquina_remota pelo endereço IP da máquina que vai servir os arquivos.

Pronto! Agora podemos criar um script para fazer a cópia dos arquivos:

#!/bin/bash
#
# backup.sh
#Script para fazer copia de arquivos do servidor para a maquina de backup
#
# Criado por Paulino Michelazzo - paulino@michelazzo.com.br
# Versao 1.0 - marco/04
#
#

rsync -avz root@maquina_remota:/origem_dos_dados/ /destino_dos_dados/

E podemos agendar para que este script seja executado todas as madrugadas as 2 da manhã, colocando a seguinte linha dentro do arquivo /etc/crontab

0 2 * * * root /etc/backup.sh

Pronto! Agora todos os dias as 2 da manhã, os arquivos da máquina remota serão copiados, em suas últimas versões/alterações para a máquina de destino (ou local), permitindo que, em caso de qualquer problema, estes possam ser colocados novamente nos seus devidos lugares.

Incrementando o script

Uma reclamação existente é que não existe um arquivo de log para o acompanhamento do que foi feito pelo script. Mas este problema pode ser resolvido com um redirecionamento de saída de tela para um arquivo, da seguinte forma:

#!/bin/bash
#
# backup.sh
#Script para fazer copia de arquivos do servidor para a maquina de backup
#
# Criado por Paulino Michelazzo - paulino@michelazzo.com.br
# Versao 1.0 - marco/04
#
#

SYNC_LOG=/var/log/rsync.log # local onde o arquivo de log sera armazenado
# Delimitador de entrada de log
echo "******************************" >> $SYNC_LOG
date >> $SYNC_LOG
echo "Inicio da sincronizacao" >> $SYNC_LOG
rsync -avz root@maquina_remota:/origem_dos_dados/ /destino_dos_dados/ >> $SYNC_LOG

echo "Fim da sincronizacao" >> $SYNC_LOG
echo "******************************" >> $SYNC_LOG

Com as alterações acima propostas, todas as saídas do script serão redirecionadas para o arquivo /var/log/rsync/log, o qual poderá ser lido com qualquer editor de sua preferência, sendo que as informações relativas a execução do script ficam entre os comentários Início e Fim da sincronização.

Outras mudanças podem acontecer, tais como escolher somente alguns arquivos ou um a inclusão de vários outros diretórios no mesmo script para a operação de backup. Estas mudanças podem ser implementadas por qualquer um da forma que for mais conveniente para cada cenário.

* A grafia está abreviada para Linux, sendo o nome correto GNU/Linux”

Autor: Paulino Michelazzo, link

Email: paulino@michelazzo.com.br