Backup/restauração local apenas (para um hd externo), usa o rsync para fazer o trabalho.

O script armazena as configurações do dispositivo, nome do usuário entre outras em um arquivo oculto chamado .backup.txt. Se o arquivo não existe,
o script faz as perguntas ao usuário, cria  arquivo no home do usuário e carrega o arquivo, se já existe então não pergunta mais a não ser que o usuário delete o arquivo.

O script está "irritavelmente" comentado (acho eu), mas é apenas o meu segundo script, então foi para meu beneficio, para não me perder. Peço desculpas se não está nos padrões aí dos programadores profissionais aí do VOL, mas, bem, um dia há-de melhorar...

Espero que seja útil para alguém.

• Download 7000.sync_local
• Enviar nova versão

Versão 2 - Enviado por Pedro Fernandes em 15/09/2019

Changelog: 1- Troquei os "sleep 10" e etc nos "testamentos" por "enter para continuar:" e "read pausa", pego de um script do Morimoto lá do hardware.com.br, porque nem sabia que se podia usar algo assim como "read pausa". Pois nenhum ser humano normal consegue ler os textos que excrevi no script em tempo hábil, (a não ser que seja o Dr. Spencer Reid do Criminal Minds!!).
2 - Quase todos os comandos são mostrados na tela, exemplo: echo -e "\umount /dev/etc..", para o usuário ver tudo o que o script faz, se é que alguém vai usar esta porcaria de script.
É isso!!!

Download 1568583264.sync_local

Esconder código-fonte

#!/bin/bash
#
#
#####################################################################
#
# Título: sync_local
#
# Autor: Pedro Fernandes
#
# Email: pedrobfernandes32@protonmail.com
#
# Descrição: Script de backup/restauração local apenas, (para um hd externo),
# por exemplo, que usa o rsync para fazer o trabalho.
# O script armazena as configurações do dispositivo, nome do usuário entre
# outras em um arquivo oculto chamado .backup.txt. Se o arquivo não existe,
# o script faz as perguntas ao usuário e cria  arquivo no home do usuário e
# carrega o arquivo, se já existe então não pergunta mais a não ser que o
# usuário delete o arquivo.
#
#####################################################################
#
#####################################################################
# Constantes
PRESENTE="$(which rsync)"
MONTAGEM=/media/BKP
DIR_HOME=" "
RAIZ=" "
EXT_BKP_DIR=" "
#
######################################################################
#
######################################################################
# Funções
#
# Função para verificar a presença do rsync. Deve ser padrão em qualquer distribuição, mas
# não mata por verificar....
rsync_presente () {

   if [[ -z "$PRESENTE" ]]; then
      echo -e "\nEste script precisa de ter o rsync instalado.
Por favor procure o rsync no site "https://rsync.samba.org/", ou
no repsitórido da sua distribuição.
Terminando por aqui." >&2
      sleep 3
      exit 1
   else
      return
   fi
}
#
# Já tem o arquivo de configuração ou não? Se não criamo lo no final da função,
# se tem, então carregamos e retornamos ao restante do script.
# Vamos também verificar se o dispositivo tem sistema de arquivos do windows.
# Se tiver vamos dar a opção de abortar o script e escolher outro dispositivo.
# A função que verifica se é sistema de arquivos do Windows, não tenho certeza se
# deteta mesmo sistema de arquivos FAT, pois não tenho nenhum para testar, mas sei
# que deteta se é NTFS.
# Ela começa com a declaração da variável "winfs".
# Vamos garantir também que o usuário escreve o dispositivo como /dev/sd?,
# se ele não escrever vamos abortar.
arquivo () {
   if [[ "$(id -u $usuario)" -eq 0 ]]; then
      DIR_HOME=/root
      RAIZ=/
   else
      DIR_HOME=/home/$usuario
      RAIZ=/home
   fi

   EXT_BKP_DIR=$MONTAGEM/sync_$usuario

   if [[ -e "$DIR_HOME/.backup.txt" ]]; then
      echo -e "\nCarregando a configuração salva no arquivo $DIR_HOME/.backup.txt"
      . $DIR_HOME/.backup.txt
      return
   else
      echo -e "\nVocê ainda não tem um arquivo de configuração criado.
Iremos criar um agora."
      sleep 3
      clear
      echo -e "\n Digite o dispositivo que vai usar para fazer os backups.
ATENTÇÃO: tome cuidado para não escolher o dispositivo errado!!!!; e digite corretamente.
Exemplo: /dev/sdb1 e não /dev/sdb1/ nem sdb1 nem dev/sdb......."
      read -p "Dispositivo: >" dispositivo
         if [[ "$dispositivo" =~ ^/{1}dev{1}/{1}sd{1}[a-z]{1}[1-9]{1}$ ]]; then
               clear
               if ! fdisk -l | grep $dispositivo &>/dev/null; then
                  echo -e "\nDispositivo não encontrado.
Certifique -se de que digitou corretamente.
Abortando o script......" >&2
                  sleep 2
                  exit 1
               fi

               disco="$(findmnt -D | grep $dispositivo | cut -c 1-8)"
               winfs="$(fdisk -l | grep $dispositivo | grep -E "NTFS|FAT*")"
               if [[ -n "$winfs" ]]; then
                  clear
                  echo -e "\nO seu dispositivo parece estar com sistema de arquivos do Windows.
As permissões dos seus arquivos não serão preservadas neste caso.
Deseja continuar assim mesmo, ou deseja saír do script e escolher outro dispositivo?"
                  read -p "Digite [1] para saír ou [2] para continuar assim mesmo: >"
                     if [[ "$REPLY" =~ ^[1-2]$ ]]; then
                        if [[ "$REPLY" == 1 ]]; then
                           echo -e "\nAbortando o script....."
                           umount $dispositivo
                           sleep 2
                           udisks --detach $disco
                           sleep 2
                           echo -e "\nJá pode desplugar o dispositivo."
                           exit
                        else
                           clear
                           echo -e "\nContinuando.......
Não se esqueca de restaurar as permissões dos arquivos para as permissões padrão
da sua distribuição, quando posteriormente quiser restaurar o backup."
                           sleep 6
                           clear
                        fi
                     else
                        echo -e "\n Digitou uma opção inválida.
Vamos presumir a opção [1], saír do script." >&2
                        umount $dispositivo
                        sleep 2
                        udisks --detach $disco
                        sleep 2
                        echo -e "\nJá pode desplugar o dispositivo."
                        exit 1
                     fi
               fi
         else
            echo -e "\nDigitou um dispositivo inválido.
Lembre-se: tem que ser algo como /dev/sdb1........
Abortando o script......." >&2
            sleep 3
            umount $dispositivo
            sleep 2
            udisks --detach $disco
            sleep 2
            echo -e "\n Já pode desplugar o dispositivo"
            exit 1
         fi

      short="$(findmnt -D | grep $dispositivo | cut -c 6-9)"
      ident="$(ls -l /dev/disk/by-uuid/ | grep $short | rev | cut -d " " -f 3 | rev)"
      echo "name=$usuario" > $DIR_HOME/.backup.txt
      echo "idnt=$ident" >> $DIR_HOME/.backup.txt
      echo "particao=$dispositivo" >> $DIR_HOME/.backup.txt
      echo "raw=$disco" >> $DIR_HOME/.backup.txt
      echo "short=$short" >> $DIR_HOME/.backup.txt
      echo "local_dir=$DIR_HOME" >> $DIR_HOME/.backup.txt
      echo "ext_dir=$EXT_BKP_DIR" >> $DIR_HOME/.backup.txt
      echo "dir_pai=$RAIZ" >> $DIR_HOME/.backup.txt
      sleep 2
      echo -e "\nConfiguração criada e armazenada em $DIR_HOME/.backup.txt.
Se quiser usar outro dispositivo, delete primeiro este arquivo, que de seguida armazenaremos
as novas configurações. Se por outro lado, quiser fazer backup no nome de outro usuário,
então basta no inicio do script digitar o nome do usuário que faremos as perguntas de novo
e armazenaremos as configurações na pasta do usuário digitado."
      . $DIR_HOME/.backup.txt
      sleep 10
      clear
      return
   fi
}
# Função para criar ponto de montagem só para o script.
# Pode ser desnecessário pois monta automaticamente,
# mas prefiro assim pois pelo menos sei que não erro....
monta () {
   if [[ ! -d "$MONTAGEM" ]]; then
      echo -e "\nCriando ponto de montagem........."
      mkdir "$MONTAGEM"
      sleep 3
      return
   else
      return
   fi
}
#
# Desmonta partição do lugar onde foi montada automaticamente.
# Monta a partição no ponto criado pelo script, usando o uuid.
# Se não der erro, aborta o script.
# Também, verifica se diretório para armazenar os backups
# está criado. Se não estiver, então cria e muda a propriedade
# para o usuário informado no arquivo de configuração.
dspt () {
   umount $particao 2>/dev/null
   sleep 2
   mount --uuid $idnt $MONTAGEM 2>/dev/null
   if [[ "$?" != 0 ]]; then
      echo -e "\nDispositivo não encontrado.
Por segurança, vamos abortar o script." >&2
      sleep 2
      exit 1
   else
      if [[ ! -d "$EXT_BKP_DIR" ]]; then
         echo -e "\nCriando diretório para armazenar os backups........"
         mkdir $EXT_BKP_DIR
         chown -R $name: $EXT_BKP_DIR
         sleep 2
         return
      else
         return
      fi
   fi
}
#
# Se depois do backup quer usar o dispositivo, apenas desmonta
desmonta () {
   echo -e "\nAguarde enquanto desmontamos o dispositivo......"
   umount $particao
   sleep 2
   echo -e "\nVocê já pode usar o dispositivo novamente.
Para usar, basta montar de novo."
   exit
}
#
# Se por outro lado quer remover, então desliga.
# "raw", vai achar o /dev/sd? ao invés de /dev/sd??,
# para puder usar o udisks e desligar o disco.
desliga () {
   echo -e "\nDesligando o dispositivo............"
   umount $particao
   sleep 2
   udisks --detach $raw
   sleep 2
   echo -e "\nDispositivo desligado.
Pode remover agora."
   exit
}
#
# Função para saber se continua usando ou se desliga o disco
decide () {
   echo -e "\nQuer desligar e remover o dispositivo,
ou pretende continuar a usar?"
      read -p "Escolha [1] para desligar, ou [2] para continuar a usar: >"
         if [[ "$REPLY" =~ ^[1-2]$ ]]; then
            if [[ "$REPLY" == 1 ]]; then
               desliga
            else
               desmonta
            fi
         else
            echo -e "\nDigitou algo errado. Presumindo opção [1], desligar....." >&2
            sleep 2
            desliga
         fi
}
#
# Função para fazer backup.
salva_root () {
   while true; do
      clear
      echo "

Escolha uma opção de backup:

1. $DIR_HOME
2. /etc
3. /usr/local
4. completo ($DIR_HOME, /etc /usr/local)
0. saír
"
         read -p "Escolha [0-4]: >"
            case "$REPLY" in
               1)   rsync -av $DIR_HOME $EXT_BKP_DIR 2>/dev/null
                  sync
                  echo -e "\nFinalizado."
                  sleep 2
                  continue
                  ;;
               2)   rsync -av /etc $EXT_BKP_DIR 2>/dev/null
                  sync
                  echo -e "\nFinalizado."
                  sleep 2
                  continue
                  ;;
               3)   rsync -av /usr/local $EXT_BKP_DIR 2>/dev/null
                  sync
                  echo -e "\nFinalizado."
                  sleep 2
                  continue
                  ;;
               4)   rsync -av $DIR_HOME $EXT_BKP_DIR 2>/dev/null
                  rsync -av /etc $EXT_BKP_DIR 2>/dev/null
                  rsync -av /usr/local $EXT_BKP_DIR 2>/dev/null
                  sync
                  echo -e "\nFinalizado."
                  sleep 2
                  continue
                  ;;
               0)   decide
                  break
                  ;;
               *)   echo -e "\nVocê digitou uma opção inválida. Abortando o script......" >&2
                  desliga
                  break
                  ;;
            esac
   done
}
#
# Função para restaurar.
restaura_root () {
   while true; do
      clear
      echo "

Escolha uma opção de restauro:

1. $name
2. etc
3. local
4. completo ($name, etc, local)
0. saír
"

         read -p "Escolha [0-4]: >"
            case "$REPLY" in
               1)   rsync -av $EXT_BKP_DIR/$name $RAIZ 2>/dev/null
                  sync
                  echo -e "\nFinalizado."
                  sleep 2
                  continue
                  ;;
               2)   rsync -av $EXT_BKP_DIR/etc / 2>/dev/null
                  sync
                  echo -e "\nFinalizado"
                  sleep 2
                  continue
                  ;;
               3)   rsync -av $EXT_BKP_DIR/local /usr 2>/dev/null
                  sync
                  echo -e "\nFinalizado"
                  sleep 2
                  continue
                  ;;
               4)   rsync -av $EXT_BKP_DIR/$name $RAIZ 2>/dev/null
                  rsync -av $EXT_BKP_DIR/etc / 2>/dev/null
                  rsync -av $EXT_BKP_DIR/local /usr 2>/dev/null
                  sync
                  echo -e "\nFinalizado."
                  sleep 2
                  continue
                  ;;
               0)   decide
                  break
                  ;;
               *)   echo -e "\nVocê digitou uma opção inválida. Abortando o script......" >&2
                  desliga
                  break
                  ;;
            esac
   done
}
#
# Função para salvar o diretorio /home/usuario
# ou uma pasta apenas dentro do diretorio /home.
salva () {
   while true; do
      clear
      echo "

Escolha uma opção de backup:

1. $DIR_HOME
2. pasta no seu diretório /home
0. saír
"

         read -p "Escolha [0-2]: >"
            case "$REPLY" in
               1)   rsync -av $DIR_HOME $EXT_BKP_DIR 2>/dev/null
                  sync
                  echo -e "\nFinalizado."
                  sleep 2
                  continue
                  ;;
               2)   read -p "Digite a pasta: >" pasta
                  if [[ "$pasta" =~ [^-_A-Za-z0-9] ]]; then
                     echo -e "\nVocê digitou errado. Saíndo do script......" >&2
                     sleep 2
                     desliga
                     break
                  else
                     local existe="$(find $DIR_HOME -type d -name $pasta 2>/dev/null)"
                     if [[ -z "$existe" ]]; then
                        echo -e "\nPasta não encontrada. Saíndo do script." >&2
                        sleep 2
                        desliga
                        break
                     else
                        rsync -av $DIR_HOME/$pasta $EXT_BKP_DIR
                        sync
                        echo -e "\nFinalizado."
                        sleep 2
                        continue
                     fi
                  fi
                  ;;
               0)   decide
                  break
                  ;;
               *)   echo -e "\nVocê digitou uma opção inválida. Abortando o script......" >&2
                  desliga
                  break
                  ;;
            esac
   done
}
#
# Função para restaurar o /home do usuario
# ou uma pasta apenas
restaura () {
   while true; do
      clear
      echo "

Escolha uma opção de restauro:

1. $name
2. uma pasta fora do seu diretório $name
0. saír
"

         read -p "Escolha [0-2]: >"
            case "$REPLY" in
               1)   rsync -av $EXT_BKP_DIR/$name $RAIZ 2>/dev/null
                  sync
                  echo -e "\Finalizado."
                  sleep 2
                  continue
                  ;;
               2)   echo -e "\nA pasta pode estar fora do seu diretório $name,
mas ao ser restaurada para a sua máquina, ela será restaurada para dentro do seu diretório $DIR_HOME."
                  read -p "Digite a pasta: >" restaura_pasta
                  if [[ "$restaura_pasta" =~ [^-_A-Za-z0-9] ]]; then
                     echo -e "\nVocê digitou errado. Saíndo do script......" >&2
                     sleep 2
                     desliga
                     break
                  else
                     local existe="$(find $EXT_BKP_DIR -type d -name $restaura_pasta 2>/dev/null)"
                     if [[ -z "$existe" ]]; then
                        echo -e "\nPasta não encontrada. Saíndo do script." >&2
                        sleep 2
                        desliga
                        break
                     else
                        rsync -av $existe $DIR_HOME
                        sync
                        echo -e "\nFinalizado."
                        sleep 2
                        continue
                     fi
                  fi
                  ;;
               0)   decide
                  break
                  ;;
               *)   echo -e "\nVocê digitou uma opção inválida. Abortando o script......" >&2
                  desliga
                  break
                  ;;
            esac
   done
}
#
# Apresentando
sobre () {
        clear
   echo -e "\nScript de backup/restauração que usa o programa rsync
para fazer o trabalho pesado. Você digita as opções numéricas dos menus
para fazer backup/restauro das opções apresentadas.
Se escolher fazer o backup/restauro em nome do usuário root, terá as opções
de salvar/restaurar as pastas /root, /etc e /usr/local.
Se escolher fazer em nome de um usuário comum, então terá apenas a opção
de fazer backup/restauro da pasta /home/usuário e de pastas soltas dentro do
/home/usuario, ou de pastas no dispositivo externo que pertençam ao usuário
para dentro do /home/usuário."
   desliga
}
#
######################################################################
#
######################################################################
#
# Verificações de segurança
#
# Tem que ser root né??!!
if [[ "$(id -u)" -ne 0 ]]; then
   echo "Tem que ser root. Saindo"
   sleep 2
   exit 1
fi
#
# Se usuário não existe, (ou digitou errado) dá erro e sai.
# Peço sempre no inicio o nome, para puder usar mais do que um
# arquivo de configuração.
# Se usuario é o root, Constantes DIR_HOME, RAIZ e EXT_BKP_DIR
# são configuradas para o root, se é usuario comum então são configuradas
# para o usuario.
read -p "Digite o usuário para o qual você fara o backup/restauro: >" usuario
if ! cat /etc/passwd | grep ^$usuario &>/dev/null; then
   echo -e "\nUsuário não encontrado.
Certifique-se de que não digitou errado.
Saíndo......" >&2
   sleep 3
   exit 1
fi
#
rsync_presente
arquivo
#
# Previnindo erros
if ! ls -l /dev/disk/by-uuid/ | grep $idnt &>/dev/null; then
   echo -e "\nErro. O seu dispositivo não parece estar plugado.
Abortando o script......" >&2
      sleep 2
      exit 1
fi
#
correto="$(ls -l /dev/disk/by-uuid/ | grep $idnt | rev | cut -c 1-4 | rev)"
dev="$(findmnt -D | grep $correto | cut -c 1-9)"
bruto="$(findmnt -D | grep $dev | cut -c 1-8)"

if [[ "$correto" != "$short" ]]; then
         echo -e "\nErro. Dispositivo encontrado de acordo com o uuid, mas parece
que tem um nome de partição diferente do que está no arquivo de configuração.
Por segurança, não iremos prosseguir com o script.
Por favor, remova todos os dispositivos que estiverem plugados, e plugue somente
o seu dispositivo de backup, antes de rodar novamente este script." >&2
         sleep 5
         umount $dev
         sleep 2
         udisks --detach $bruto
         sleep 2
         echo -e "\nJá pode desplugar o dispositivo."
         exit 1
fi
#
# Tudo certo? Prossegue
monta
dspt
#
#######################################################################
#
#######################################################################
#
# Começa aqui
while true; do
   clear
   echo "

Escolha:

1. backup
2 .restaurar
3. sobre o script
0. saír
"

      read -p "Escolha [0-2]: >"
         case "$REPLY" in
            1)   if [[ "$(id -u $name)" -eq 0 ]]; then
                  salva_root
               else
                  salva
               fi
               break
               ;;
            2)   if [[ "$(id -u $name)" -eq 0 ]]; then
                  restaura_root
               else
                  restaura
               fi
               break
               ;;
            3)   sobre
               break
               ;;
            0)   desliga
               break
               ;;
            *)   echo -e "Digitou uma opção inválida." >&2
               sleep 2
               sobre
               desliga
               break
               ;;
         esac
done
#
######################################################################
#
######################################################################
#
exit
#
######################################################################

Backup de Máquina Virtual - XenServer

Backup incremental com montagem automática e e-mail

Backup Database MySQL Automatizado

Backup de Roteadores e Switches

Backup e envio do arquivo + md5sum para o FTP da escolha do usuário

Nenhum comentário foi encontrado.