Compartilhando arquivos em rede usando NFS.

O NFS (Network File System) foi projetado para compartilhar partições ou arquivos em rede, sendo que os compartilhamentos remotos se comportam como se fossem locais.

Basicamente para montar um servidor NFS é preciso configurar três arquivos:

/etc/exports

/etc/hosts.allow

/etc/hosts.deny

•  /etc/exports 

Neste arquivo contêm a lista de entradas de compartilhamento, nele define o volume que será compartilhado, a lista de hosts ou rede que tera acesso, e as permissões de acesso.

Sua estrutura segue a seguinte forma:

/compartilhamento host1(opcao1, opcao2) host2(opcao1, opcao2)

Onde:

/compartilhamento é o arquivo que será exportado para a rede.

Host1 e host2 são os endereços das máquina que terão acesso ao compartilhamento. Podendo ser descriminadas por nome ou endereço IP.

            Opcao1 e opcao2 são as permissões que cada host terá sobre o arquivo. 

Tipos de permissões:

ro:  O Host tem permissão somente  de leitura.

rw: Leitura e gravação.

no_root_squash: Esta opção define que os níveis de acesso do host remoto sejam os mesmos que o níveis locais, caso essa opção não seja especificada o host remoto terá acesso ao compartilhamento como root.

no_subtree_check: Desabilita a checagem do bloco quando é feita a solicitação de um arquivo, essa opções quando marcada pode melhorar o desempenho do serviço NFS sobre a rede.

sync : Por padrão a forma de gravação é assíncrona, ou seja a gravação e feita no servidor depois que o arquivo é terminado pelo cliente. Essa forma de gravação pode ocasionar arquivos corrompidos e a opção sync evita isso.

Supondo que queremos compartilhar o diretório /home e /usr/local, a configuração do arquivo /etc/exports  ficaria da seguinte forma:

#cat /etc/exports

/usr/local 10.0.0.1(ro) 10.0.0.2(ro)

/home 10.0.0.1(rw) 10.0.0.2(rw)

Neste caso o diretório /usr/local está compartilhado para as máquinas com endereço 10.0.0.1 e 10.0.0.2 com o nível de acesso somente leitura (ro) read only. Já o diretório /home está compartilhado para as máquinas  como leitura e escrita (rw) read and write .

É possível compartilhar usando a faixa de ips da rede, por exemplo :

Rede 10.0.0.0/24

O arquivo ficaria da seguinte forma:

#cat /etc/exports

/usr/local 10.0.0.0/255.255.255.0(ro)

/home 10.0.0.0/255.255.255.0(rw)

Resumindo o arquivo /etc/exports possue a seguinte estrutura:

<volume> [host/rede]<opções>

• /etc/hosts.deny 
  
  

 o arquivo /etc/hosts.deny define os hosts ou rede que não terão acesso ao compartilhamento.

Sua estrutura segue a seguinte forma:

<serviço>:[host/rede]<opções>

#cat /etc/hosts.deny 

ALL:ALL

Neste caso foi negado os o acesso de qualquer serviço e de qualquer host ou rede. Iremos definir as permissões de acessos no arquivo /etc/hosts.allow

• /etc/hosts.allow

O arquivo /etc/hosts.allow define os serviços liberados que serão liberados para acesso e quais hosts ou rede terão acesso a esses serviços:

#cat /etc/hosts.allow 

ALL : 10.0.0.0/24

Netse caso, foi liberado o acesso a todos os serviços que usam tcpd (tcp  wrapper) ou sshd , inclusive o NFS para a rede 10.0.0.0/24 .

É possível liberar somente os serviços exclusivos, também é possível adicionar exceções as regras, como por exemplo o sistema NFS necessita apenas de alguns serviços, vejamos como ficaria o arquivo /etc/hosts.allow:

#cat /etc/hosts.allow

portmap: 10.0.0.0/24 EXCEPT 10.0.0.1

lockd: 10.0.0.0/24 EXCEPT 10.0.0.1

rquotad: 10.0.0.0/24 EXCEPT 10.0.0.1

mountd: 10.0.0.0/24 EXCEPT 10.0.0.1

statd: 10.0.0.0/24 EXCEPT 10.0.0.1

Com essa configuração, foi liberado apenas os serviços portmap, lockd, rquotad,mountd e statd para rede 10.0.0.0/24 exceto para o host 10.0.0.1 .

Além dos arquivos exports, hosts.deny e hosts.allow que ficam localizados dentro de /etc estarem devidamente configurados,  alguns processos devem estar em execução:

/etc/init.d/portmap start

/etc/init.d/nfs start

Foi usado aqui a distribuição CentOS kernel  2.6.18-194.el5.

Para configurar os serviços para executarem na inicialização, basta executar o comando ntsysv e marcar as opções:

#ntsysv 

[X] nfs

[X] portmap

Após a configuração do servidor, é necessário montar o compartilhamento no cliente que é exportado pelo servidor:

root@client:~# mkdir /mnt/nfs

Obs: Iremos montar o diretório /home exportado pelo servidor em /mnt/nfs no cliente:

root@cliet:~# mount -t nfs servidornfs.net:/home /mnt/nfs

Após a montagem, para que não seja perdida após reiniciar o cliente, basta adicionar a linha de comando acima no arquivo /etc/fstab .

root@cliet:~# vi /etc/fstab

servidornfs.net:/home /mnt/nfs nfs rw 0 0

Segue a sintaxe:

[endereço do servidor:/arquivoexportado] <arquivolocal> <fs-type> <opções> [dump] [fsckoder]

Source: http://nfs.sourceforge.net/nfs-howto/

Estilo MacGyver: Consertando o teclado do notebook.

Veja como é fácil e prático consertar o teclado de seu notebook.

http://sqlshow.wordpress.com/category/oficina-do-macgyver/

By: Cleyton

Copiando arquivos entre hosts usando scp.

O SCP (Secury Copy) assim como o RCP, são ferramenta para fazer cópias de arquivos entre hosts. A diferença entre as duas ferramentas é que o RCP faz a transferência dos dados de forma plana , já o SCP faz a cifragem dos dados durante a cópia, garantindo a segurança caso ocorra de um sniffer na rede querer extrair informações dos pacotes.
O SCP em si não faz nenhum tipo de autenticação, responsabiliza apenas pela transferência do arquivo, a segurança é garantida pelo protocolo SSH, que é utilizado pelo SCP .

Cópia do host local para o host remoto:
$scp ArquivoFonte usuário@host:/ArquivoAlvo

Cópia do host remoto para o host local:
$scp usuário@host:/ArquivoFonte /ArquivoAlvo

Para fazer cópias recursivas deve-se ser acrescentado a opção -r .
Exemplo :

root@localhost tmp# scp -r /tmp root@192.168.0.1:/tmp/

Foi feito a cópia de todos os arquivos que estavam em localhost:/tmp para 192.168.0.1:/tmp/

:)

Fazendo backup agendado de bancos do SGBD MySQL com shell script.

O SGBD MySQL possue uma ferramenta chamada mysqldump, que da a possibilidade de fazer cópias de segurança.

O Funcionamento do mysqldump é bem simples, é um cliente que cria arquivos ou scripts com todo conteúdo do DB, ou o conteúdo de uma banco, ou tabelas de uma banco. Neste caso iremos fazer o backup de um banco do SGBD MySQL.

Crie um arquivo com o seguinte conteúdo:

$vim backupbd.sh

#!/bin/sh

#backupbd.sh

##################################

#####     Definindo as variaveis           

##################################

DATA="`date +%d-%m-%Y-%H%M`"

NOME="/caminhodobackup"

BACKUPDIR="cd /caminhodobackup"

HOST="enderecodoBD"

USER="usuarioBD"

PASSWORD="senhaBD"

DATABASE="nomedobanco"

################################################

#####     Realizando o backup da base de dados                    

################################################

$BACKUPDIR

mysqldump --host=$HOST --user=$USER --password=$PASSWORD --databases $DATABASE | gzip > $NOME/BACKUPDB-$DATA.sql.gz

###################################################

#####Ira compactar o arquivo no formato gzip com o             

#####  o nome BACKUPDB-dia-mes-ano-horaminuto.sql.gz   

###################################################

###Fim do aquivo

 Torne o arquivo executável:

$chmod u+x bacjupdb.sh

Após criar o arquivo e torná-lo executável, crie um agendamento no crontab inserindo a seguinte linha:

$vim /etc/crontab

01 00   * * *   root    /caminhodoarquivo/backupdb.sh

###Fim do arquivo.

Obs.: Neste caso o agendamento do backup é para todos os dias às 00:01, mas pode ser ajustado de acordo com a necessidade.

Como em toda boa estrutura é necessário pensar em um plano de contenção, ou oque fazer quando ocorrer o problema. Neste caso, se for necessário restaurar o banco, basta apenas descompactar o arquivo .gz e  redirecionar a entrada padrão do arquivo para o mysql:

$gunzib BACKUPDB-dia-mes-ano-horaminuto.sql.gz

$mysqldump --host=end.host --user=usuarioBD --password=senhaBD --databases nomedobanco < BACKUPDB-dia-mes-ano-horaminuto

Brincando com shell script .

Em uma aula de shell script fizemos uma agenda eletrônica, achei interessante e resolvi publicar.

Crie um arquivo com o seguinte código:

$vim agenda.sh

#!/bin/sh

while true;do

clear

echo

echo "Agenda Eletronica"

echo

echo "Menu"

echo

echo "1 - Inserir"

echo "2 - Pesquisar"

echo "3 - Listar"

echo "4 - Apagar"

echo "5 - Backup"

echo "6 - Sair"

echo

echo -n "Digite sua opcao:"

read OPCAO

case $OPCAO in

1)clear;

   echo "Inserir Dados";echo;

   echo -n "Nome: ";read NOME;

   echo -n "Tel: ";read TEL;

   echo "Confirma[s/n]?";read CON;

    if [ $CON = "s" ] || [ $CON = "S" ]

      then echo "$NOME - $TEL" >> /tmp/agenda

        echo "Dados Inseridos com Sucesso"

      else echo "Dados nao foram Incluidos"

    fi

;;

2)clear;echo "Pesquisar na Agenda";echo;

   echo -n "Digite a string p/ pesquisa: ";read DADO;

  cat /tmp/agenda | grep $DADO;;

3)clear;echo "Listagem da Agenda";echo;

   cat /tmp/agenda;;

4)clear;echo "Apagar Dados";echo;

   echo -n "Digite Nome p/ apagar: ";read NOME;

   cat /tmp/agenda | grep -v $NOME > /tmp/ag.tmp

   mv /tmp/ag.tmp /tmp/agenda;

   echo "Dado apagado com sucesso!!";;

5)clear;echo "Backup da Agenda ";echo;

   date "+%d%m-%H%M" >> /tmp/agenda.bk;

 cat /tmp/agenda >> /tmp/agenda.bk;

   echo "-----------------------" >> /tmp/agenda.bk;

   echo "Backup Realizado, olhar o arquivo /tmp/agenda.bk";;

6)exit;;

*)echo -n "Opcao invalida!";echo;;

esac

echo -n "Enter p/ continuar"

read A

done

################################################################

Após criar o arquivo é interessante torná-lo  executável:

$chmod u+x agenda.sh

Execute o arquivo:

$./agenda.sh

Pronto, já temos uma agenda eletrônica que além de inserir, pesquisar, listar, apagar, também realiza seu própio backup.  :)

Sobre coisas que eu já fiz e não me lembro.

Não poderia tirar o mérito da frase do grande mestre Estácio Cruz : "Coisas que eu já fiz e não me lembro."
Espero que não se importe com a cópia, mas estou apenas estendendo uma parte do trabalho de compartilhar o conhecimento que muitas vezes morre por não ter registros.  :)