Primeiro precisamos instalar o servidor de backup rsync

apt-get install rsync

Depois insira as configurações abaixo em /etc/rsyncd.conf

vim /etc/rsyncd.conf
# user/group de execução do daemon
uid = user
gid = user
log file = /var/log/rsyncd.log
# módulo de backup
[modname]
# diretório do backup, se necessário crie outros módulos
path = /home/user/backup
# usuários autorizados para o backup
auth users = user
# arquivo de usuário e senha
secrets file = /etc/rsyncd.secrets
# permite gravação
read only = false
# evita que as sessões de backup sejam listadas para outros usuários
list = false
hosts allow = 192.168.0.0/24
transfer logging = yes
log format = %t: host %h (%a) %o %f (%l bytes). Total %b bytes.
# eof

Depois de finalizada as confs, é necessário criar usuário e senha.

vim /etc/rsyncd.secrets
user:senha
chmod 600 /etc/rsyncd.secrets
chmod 600 /etc/rsync.conf

E por último habilite a inicialização do servidor rsync

vim /etc/default/rsync
RSYNC_ENABLE=true

Basta apenas inicializar o seu servidor de backup

/etc/init.d/rsyncd start

Para o rsync client não é necessário realizar nenhuma configuração, crie um arquivo com a senha do usuário de backup no rsync server

vim /etc/rsync.secrets
senha
chmod 600 /etc/rsync.secrets

Depois execute o comando para backup

rsync -Cravzp –delete –password-file=/etc/rsync.secrets /backupdir user@host::modname/

OBS.:

* Para cliente rsync Windows pode-se utilizar o DeltaCopy

* É possívelo realizar as criações de mais diretórios de backup, crie mais uma sessão no seu arquivo de configuração com por exemplo “[modname2]” e realize pequenas alterações como diretório para backup, usuário e senha. Não sendo necessário a criação de outro arquivo rsyncd.secrets, pois os usuários serão controlados através da permissões de acesso e da diretiva “auth users”.

* Também é possível realizar cópias com o rsync através do ssh com o seguinte comando:

rsync -Cravzp /diretorio_origem sshuser@host:/diretorio/destino

* É por útimo podemos também sincronizar diretórios locais

rsync -Cravzp /diretorio/current /diretorio/sync

O primeiro passo dever ser baixa a versão necessária para sua aplicação ou a versão current do Java em http://java.com.

Hoje a versão mais recenter é jre-6u3-linux-i586-rpm.bin

Depois de feito um download crie o seguinte diretório

mkdir /usr/java

Extraia o pacote java

mv jre-6u3-linux-i586-rpm.bin /usr/java
chmod 755 /usr/java/jre-6u3-linux-i586-rpm.bin
cd /usr/java
./jre-6u3-linux-i586-rpm.bin

Leia toda a licença e aceite o termo “yes”, será extraído um pacote rpm.

Instale o pacote rpm

rpm -ivh jre-6u3-linux-i586.rpm

Pronto seu Java JRE se encontra instalado eu seu servidor.

AIX 5L habilita a instalação do kernel de 64 bits, bem como os anteriormente disponíveis como o kernel de 32 bits durante a instalação.

Antes de realizar a instalação do kernel de 64 bits é necessário verificar qual o bit mode do hardware, sendo o mesmo de 32 bits não é possível realizar a instalação do kernel de 64 bits.

Caso o seu hardware seja de 64 bits o AIX permite que o kernel de 64 bits seja instalado durante a instalação.

Mas caso isto não foi feito durante a instalação vamos ao processos para instalar o kernel de 64 bits.

Primeiro verificar o bit mode do hardware

bootinfo -y

Depois verificamos o bit mode do kernel

bootinfo -K

Se a saída foi 64-bits podemos realizar a instalação do kernel de 64 bits (caso o mesmo tenho retornado 32-bits), de acordo com os procedimentos abaixo:

# ln -sf /usr/lib/boot/unix_64 /unix
# ln -sf /usr/lib/boot/unix_64 /usr/lib/boot/unix
# smitty load64bit
-> Select Enable/Disable at System Restart
->> Choose Yes and press ENTER (quit smitty).
# lslv -m hd5
# bosboot -ad /dev/ipldevice
# shutdown -Fr
# bootinfo -K (should now show 64)

Após o reboot o sistema já estará sendo executado em 64 bits

Caso necessário alterar de 64-bits para 32-bits

# ln -sf /usr/lib/boot/unix_mp /unix
# ln -sf /usr/lib/boot/unix_mp /usr/lib/boot/unix
# smitty load64bit
-> Select Enable/Disable at System Restart
->> Choose No and press ENTER (quit smitty).
# lslv -m hd5
# bosboot -ad /dev/ipldevice
# shutdown -Fr
# bootinfo -K (should now show 32)

OBS.: Com o sistema rodando um kernel de 64 bits, o tipo do file system recomenda-se ser JFS2.

O comando getconf retorma informações sobre as configuraçoes do sistema, informações como memória, tamanho do disco, útimo boot, checagem do hardware e alguns paramêtros do kernel.

* para verificar bit mode do kernel

getconf KERNEL_BITMODE
64

* para verificar bit mode do hardware

getconf HARDWARE_BITMODE
64

* para verificar tamanho do disco (MB)

getconf DISK_SIZE /dev/hdisk0
8678

OBS.: Para mais parâmetros utilize a tabela abaixo.

A iniciliazação automática de daemons no Redhat Linux pode ser feita de duas maneiras, pela inittab ou pelo /etc/rc.d utilizando script de execução.

Para isto basta adicionar a seguinte entrada em /etc/inittab

vi /etc/inittab
# Start automático daemonname
daemonname::once:/caminho/para/bin/daemon >/dev/null 2>&1

A segunda forma é através do /etc/init.d script

Criamos um script de inicialização em /etc/init.d/startdaemon

Com o contéudo abaixo:

#!/bin/bash
#
# chkconfig: – 91 35
# description: Starts and stops vncserver/integradorTXT

# Source function library.
. /etc/init.d/functions

# Source networking configuration.
. /etc/sysconfig/network

# Check that networking is up.
[ ${NETWORKING} = "no" ] && exit 0

[ -f /caminho/para/bin/startdaemon ] || exit 0

prog=”startdaemon”

export DAEMON_DIR=/caminho/para/bin
export DAEMON_CONFIG=/caminho/para/conf/startdaemon.conf # somente se necessário

start() {
echo -n $”Starting $prog: ”
cd $DAEMON_DIR
daemon $DAEMON_DIR/startdaemon
RETVAL=$?
[ $RETVAL -eq 0 ] && touch /var/lock/subsys/startdaemon
return $RETVAL
}

stop() {
if test “x`pidof startdaemon`” != x; then
echo -n $”Stopping $prog: ”
killproc startdaemon
echo
fi
RETVAL=$?
[ $RETVAL -eq 0 ] && rm -f /var/lock/subsys/startdaemon
return $RETVAL
}

case “$1″ in
start)
start
;;

stop)
stop
;;

status)
status startdaemon
;;
restart)
stop
start
;;
condrestart)
if test “x`pidof startdaemon`” != x; then
stop
start
fi
;;

*)
echo $”Usage: $0 {start|stop|restart|condrestart|status}”
exit 1

esac

exit 0

# eof

Depois setamos as permissões de execução

chmod 744 /etc/init.d/startdaemon

Agora colocamos o nosso serviço no inialização automática, isto pode ser feito manualmente ou automaticamente.

Se automaticamente:

/sbin/chkconfig –add startdaemon
/sbin/chkconfig –level 35 startdaemon on
/sbin/chkconfig –list startdaemon

Este comando criar todos os simbólicos links automáticamentes de acordo com os runlevels escolhidos.

Se manualmente:

cd /etc/rc.d/rc3.d
ln -s ../init.d/startdaemon S91startdaemon

cd /etc/rc.d/rc5.d
ln -s ../init.d/startdaemon S91startdaemon

cd /etc/rc.d/rc0.d
ln -s ../init.d/startdaemon K35startdaemon

cd /etc/rc.d/rc6.d
ln -s ../init.d/startdaemon K35startdaemon

cd /etc/rc.d/rc1.d
ln -s ../init.d/startdaemon K35startdaemon

Para testar as configurações digitamos os seguintes comandos:

* para start do daemon manualmente

service startdaemon start

* para stop do daemon manualmente

service startdaemon stop

* para restart do daemon manualmente

service startdaemon restart

* para verificar o status do daemon

service startdaemon status

ou

ps -ef | grep startdaemon

OBS.: Para que o start funcione durante do boot que init level do sistema assuma como default 3 ou 5.

cat /etc/inittab | grep initdefault
id:5:initdefault

Os blocos no filesystem são utilizados para duas diferentes finalidades.

Muitos blocos armazenam dados dos usuários

E alguns blocos em todos os filesystem armazem filesystem metadata, que é basicamente a descrição da estrutura do filesystem.

Onde cada filesystem contém um superblock que contém informações como tipo do filesystem, tamanho, status, estruturas de metadados e etc.

Isto é muito importante pois em uma situação de emergência é possível utilizar o backup superblock para recuperar o primário.

O camando abaixo exibe localização do primário e backup superblock

dump2fs /dev/sda3 | grep -i superblock

Quando você utiliza um filesystem em falha você pode corromper toda a estrutura de dados do filesystem.

Você pode corrigir este problema da seguinte forma (assumindo que a partiço /dev/sda3 é o filesystem /home)

umount /home
e2fsck -f /dev/sda3

Supondo que o comando não encontrou e superblock e retornou um erro, é possível contornar este problema utilizando o backup superblock. A localização do backup superblock denpende do tamanho dos blocos do filesystem.

=> 1K blocksize, no bloco 8193
=> 2K blocksize, no bloco 16384
=> 4k blocksize, no bloco 32768

Também podemos tentar localizar a localização do backup superblock com o comando

mk2fs -n /dev/sda3

ou

dump2fs /dev/sda3 | grep -i superblock

Para reparar o filesystem através do backup superblock utilizamos o seguinte comando

e2fsck -f -b 8193 /dev/sda3

OBS.: é recomendado que se faça um backup do filesystem antes de utilizar o e2fsck.

dd if=/dev/sda3 of=/opt/backupsda3.img

A partição ramdisk é utilizada para leitura e gravação de dados, mas lembrado que a mesma é volátil (utiliza como gravação a memória RAM). Os dados contidos nesta partição ficam gravados enquando o sistem não é reiniciado.

Este tipo de partição é bastante útil caso você tenha apenas uma partição no seu Linux e precise de realizar backup de alguns arquivos porque o seu filesystem se encontra em read-only.

Primeiro passo criamos um device de 10MB

dd if=/dev/zero of=/dev/ram0 bs=1k count=10240
mk2fs -v -m 0 /dev/ram0 10240
mount -t ext3 /dev/ram0 /mnt

Assim teremos um ramdisk de 10MB e montando no /mnt como read-write

OBS.: Não desmonte o seu filesystem até que tenha realizado o backup dos dados necessário.

Esta imagem pode ser criada de dua formas.

Primeira via dd

dd if=/dev/sda1 of=/tmp/backupsda1.img

Segunda utilizando cp

cp /dev/sda1 /tmp/partition
mkdir /mnt/espelho
mount -t ext3 -o loop /tmp/partition /mnt/espelho

Isto garante que você tenho um backup completo da sua partição, caso aconteça algum imprevisto com o seu filesystem.

O fundamental conceito de Linux filesystem é que cada objeto no filesystem é representado por um inode.

Onde os objetos apresentam atributos como: tipo de arquivo, tamanho de arquivo, permissões, ACLs e etc.

Todas estas informações estão guardadas no inode do arquivo, onde cada inode é identificado por um inode number no filesystem (este número é único, por isto index node).

Para visualizar o inode number de um determinado objeto

ls -i /var/log/syslog

Saída:

21250 /var/log/syslog

Pode também utlizar o comando stat para verificar o inode number e os atributos do objeto.

stat /var/log/syslog

Saída

File: `/var/log/syslog`
Size: 34520 Blocks: 20 IO Block: 4096 regular file
Divece: 341h/833d Inode: 21250 Links: 0
Access: (0644/-rw-r–r–) Uid: ( 0/ root) Gid: ( 0/ root)
Access: 2007-10-10 00:30:02. 000000000 +530
Modify: 2007-10-10 00:30:03. 000000000 +530
Change: 2007-10-10 00:30:03. 000000000 +530

Exemplo de utilização:

touch /tmp/\”teste*

Você não vai conseguir remover este tipo de arquivo, pois em seu nome contém caractes de controle e também caractes especiais.

Removendo este arquivo:

ls -il /tmp

Saída:

695523 -rw-r–r– 1 root root 0 2007-10-10 00:35 “teste*

Usaremos o comando find para excluir por inode number

find . -inum 695523 -exec rm -i { } \;

OBS.:

Também é possível utilizar \ antes de um caracter especial para utilizar o comando rm normalmente.

rm “\”teste\*”

Também é possível recuperar um arquivo excluído pelo seu inode number utilizando o comando debugfs da seguinte forma:

Execute o comando apontando para a partição onde se encontrava o arquivo excluído.

debugfs /dev/sda3

Se desejar modificar os inodes diretamente utilize

debugfs -w /dev/sda3

Listando os inodes apagados

debugfs: lsdel

Como a saída será muito grande é necessário grava em algum arquivo

debugfs: quit
# echo lsdel | debufs /dev/sda3 > /tmp/inode.out

Para visualizar uma melhor descrição do inode desejado utilize

debugfs: stat <695523>

Caso possua muitos arquivos para verificar utilize:

cut -c1-6 /tmp/inode.out | grep “[0-9]” | tr -d ” ” > /tmp/inode.number

Para visualizar os detalhes de cada inode number:

sed ‘/^.*$/stat <\0>/’inode.number | debugfs /dev/sda3 > /tmp/inodes.detail

Agora sabendo quais inodes queremos vamos recupar os arquivos

debugfs: start <695523>
debugfs: dump <695523> /tmp/inodefile.out

Se por acaso ficou algum lixo no arquivo podemos, recupera-lo da seguinte maneira.

dd if=/tmp/inodefile.out of=/tmp/inodefileresize.out bs=6050 count=1

OBS.:

O valor do bs no comando dd, corresponde ao valor contido no campo Size: na saída do comando dubugfs: dump <695523>.

Os inodes se aplicam a todos os sistemas Linux e Unix.

Para criar um novo sistema de arquivos em uma partição

newfs /dev/rdsk/c0t1d0s6

Pressione y para confirmar

Este comando criar as estruturas necessárias para o novo sistema de arquivos na partição do disco, incluindo o diretório lost+found.

Assim que criado o file system para montar o mesmo devemos editar o arquivo vfstab, e adionar o novo file system

vi /etc/vfstab
/dev/dsk/c0t1d0s6 /dev/rdsk/c0t1d0s6 /dados ufs 2 yes -

Para montagem do novo file system

mkdir /dados
mount /dados

Para visualizar o novo file system

df -k

OBS.: O Solaris permite somente 8 partições por disco, númeradas de 0 a 7.