Backup com rsync, dúvida como automatizar a remoção dos mais antigos?

Bom dia/tarde/noite pessoal!

Estou precisando de uma ajuda, tenho um servidor improvisado(maquina comum antiga que instalei o ubuntu server nela, para agir como servidor).

Neste “servidor” tenho dois HDs, 1 é utilizado pelos clientes da rede onde eles colocam suas coisas do dia a dia ex: planilhas, pastas da empresa etc etc etc…

o segundo HD, serve para guardar os backups diários que faço utilizando o rsync, até ai tudo bem, nada anormal(tirando a parte que o servidor não é um servidor mas sim um pc comum).

No meu script de backup, eu crio uma pasta chamada backup-$data_:hora, para saber de qual dia é este backup.

image

Então está tudo funcionando normal, mas chegará o dia, em que não haverá espaço mais no disco, então terei que manualmente apagar os mais antigos, e sim, usando o find também consigo fazer um script para apagar os mais antigos.

A parte que não sei, é como automatizar, de forma que, quando o rsync for fazer o backup, e perceber que o disco está cheio, como posso fazer para automaticamente os backups mais antigos sejam apagados?

De forma que eu não precise ir manualmente apagar, alguém poderia me dar uma ajuda?

Tenho certeza, que não só ajudaria a mim, como também muitos que devem ter a mesma dúvida.

1 curtida

caiosnom,

Olá caro amigo, será que poderia me passar esse script?
Por enquanto não posso lhe ajudar com a sua dúvida, mas poderia me ajudar no meu começo.

Valeu e obrigado.

1 curtida

Boa noite amigo.

Acredito que você está usando a ferramenta certa para o trabalho errado.

Há diversas questões que precisam ser respondidas para bolar um esquema de backup funcional. Muito provavelmente todas as ferramentas que você precisa já foram criadas, precisa apenas colocá-las em funcionamento. O esquema de backups incrementais existe justamente para esse tipo de situação. Deve haver dezenas de softwares e scripts (até mesmo usando rsync) para criar backups apenas dos arquivos diferentes.

Mais ainda: há sistemas de arquivos que podem manter o histórico de alterações em arquivos através dos famosos snapshots, que são semelhantes a backups incrementais.

Se há dois discos, melhor ainda que eles funcionem em RAID 1 com o próprio sistema se encarregando de copiar os dados entre os discos.

Certamente há muita coisa para aprender até conseguir o setup funcional, mas uma vez que esteja funcionando é a solução definitiva.


Mas se você não quer esquentar a cabeça e resolver definitivamente, apenas resolver da forma mais rápida possível?
Eu criaria uma tarefa no cron daily (ou via systemd timers) para apagar os arquivos de backup mais antigos que determinada data. Assim você manterá um número fixo desses backups inteiros. Pesquisando achei essa dica de como mover arquivos não modificados em determinado tempo para uma outra pasta. Seria semelhante a essa linha para colocar no cron @daily (após testar movendo, pode mudar para removê-los)

Reprodução da página https://www.vivaolinux.com.br/dica/Listando-arquivos-pela-data :
[4] Comentário enviado por ricardoolonca em 15/12/2016 - 11:26h

find /opt/dados -type f -ctime +210 -exec mv {} /lugar_novo \:

Explicação:
Procure (find), partindo da pasta /opt/dados, arquivos (-type f) criados a mais de 210 dias (7 meses) (-ctime +210) e para cada arquivos encontrado execute (-exec) o comando mv arquivo_encontrado (é substituído de {}) para a pasta /luga_novo

2 curtidas

Depende do tipo de backup, diferencial por exemplo eu posso afirmar que nunca, integral, pode apagar do dia anterior para trás… tô sem tempo agora mas é isso, depende do tipo de backuo

1 curtida

Seu caso é um belo exemplo de onde o ostree deveria ser usado, você tem o deploy (HD principal) e outro onde ficaria o repositório ostree (HD backup)

1 curtida

Apenas lembrando que OSTree, RAID 1 e snapshot por si não devem ser tratados como backups, o primeiro é redundância de hardware , o segundo é apenas versionamento, ambos estão sujeitos a perdas por n motivos.

Um backup de qualidade deve poder sobreviver a falhas humanas, bugs de software ou hardware, falhas de rede elétrica, desastres, etc… Realmente não é fácil, mas um bom backup teria:

  1. Múltiplas cópias armazenadas em locais diferentes (partição, Hardware, localidade).
  2. Pelo menos uma cópia offline (desconectada da rede em mídia física).
  3. O máximo de garantias de imutabilidade (modo apenas leitura, mídia permanente, etc).

Snapshots podem vir a se tornar backups, se replicados em outras partições/máquinas/locais, em modo apenas leitura ou em mídia permanente.

De resto, como o @Deleterium falou… Existe uma infinidade de ferramentas por ai, (timeshift, borg, deja dup, btrbk(btrfs), snapper(btrfs), etc) que podem ajudar com a parte mais dinâmica do seu backup e que serão infinitamente melhores e mais confiáveis.

1 curtida

Obrigado pelo feedback, segue o script:

#!/bin/bash

declarando a variável para coletar a data e hora.

INICIO=date +%d-%m-%y_%H:%M:%S

#declarando a variável que armazena os dados do LOG.

LOG=/var/log/BACKUP_MMADVOCACIA/BACKUP-$INICIO-LOG_rsync.txt

#espaçadores de inicio

echo " " >> $LOG
echo " " >> $LOG
echo “====================================================” >>$LOG
echo “Sincronização iniciada em $INICIO” >>$LOG
echo “====================================================” >>$LOG

#comando para executar o backup.
rsync -Cravzpt /mnt/MMADVOCACIA/ /mnt/BACKUP_MMADVOCACIA/BACKUP-$INICIO >>$LOG

#variável final para mostrar o tempo final do LOG.

FINAL=date +%d-%m-%y_%H:%M:%S

#Espaçadores de final
echo “====================================================” >>$LOG
echo “Sincronização finalizada em $FINAL” >>$LOG
echo “====================================================” >>$LOG
echo " " >> $LOG
echo " " >> $LOG

1 curtida

Amigos obrigado pelo feedback de vocês, o scritp que botei acima, eu o coloquei no contab para executar todos os dias a meia noite, e também fico comando find para apagar os arquivos de mais de 10 dias.

Mas ainda assim não está redondinho como eu desejo, por que?

Suponhamos que meu cliente sendo usuário, coloque arquivos gigantes, vamos criar a teoria da conspiração a qual meu cliente baixou filmes pra dentro do servidor e cada dia chegou a 100GB.

nessa situação em menos de 10 dias ja terá lotado o HD de backup.

Ai que ta, como eu posso fazer, para que na hora que o rsync for roda, e ver que o HD está lotado, automaticamente ele apague os mais antigos até que seja possível copiar os arquivos novos, acho que ai seria necessário programação.

Mas ai que ta, meu conhecimento em linux é bem básico, qualquer pessoa me recomendaria a nem usar linux como servidor por não dominar, mas eu gosto do desafio e da aventura.

Fora que com windows eu não conseguiria rodar a mesma coisa com o hardware tão pobre.

Pentium E 2.0GHZ
4gb de Ram DDR2 800mhz
2 hdS de 500.

O hd de backup com ostree serve pra ter um deduplicação de arquivos no backup,a nível software já é um bom uso, o Google Docs usa algo parecido

Esses outros passos são adicionais ao git para binários

Então meu caro, isso costuma acontecer bastante na nossa vida como um todo. É uma bola de neve:

  • Temos um problema
  • Resolvemos o problema de forma rápida e incompleta
  • A solução anterior criou outro problema.
  • Fica mais difícil de solucionar o segundo problema. Novamente resolve-se com a forma rápida e incompleta
  • Assim sucessivamente até:
  • O problema é tão grande que pra solucionar precisa começar de novo do zero e fazer do jeito “difícil mas definitivo” que não foi feito da primeira vez.

Exemplos são muitos: Consertar uma peça com cola em vez de trocar a peça. Arrumar a casa colocando tudo num “quartinho da bagunça”.


Ideia para seu script:

  1. Estimar o espaço que será ocupado pelo backup, através da verificação do tamanho da pasta a ser feita o backup: comando du -d0 /mnt/origem
  2. Verificar espaço livre do ponto de montagem de backup: df /mnt/destino
  3. Comparar espaço livre com tamanho de backup
    1. Se tiver espaço, faça backup, senão libere espaço

Liberar espaço:

  1. Criar um array com os arquivos de backup ordenados por data ls --sort=time --reverse /mnt/destino
  2. Apagar o arquivo backup mais antigo rm
  3. Verificar espaço livre do ponto de montagem do backup df /mnt/destino
  4. Comparar espaço livre com tamanho de backup
    1. Se tiver espaço, faça backup, senão libere espaço

Fazer backup:

  1. comando que você já usa. rsync
2 curtidas

Obrigado pela resposta amigo, isso é exatamente o que estou querendo aplicar.

O algoritmo verificar espaço livre e comparar com o tamanho do backup.

o que eu não sei, é como botar isso em prática, porque meu conhecimento é bem limitado.

A linguagem de programação em shell é cheia de detalhes, o que a torna difícil. Eu já usei bastante, mas mesmo hoje em dia ainda corro atrás de exemplos e folhas de resumo (cheat sheet). Um script que use saídas de programas como insumo de decisões lógicas já é algo avançado! Você precisará de um manual ou apostila de bash para conseguir implementar a lógica acima.

1 curtida

Sim, apenas toquei no assunto pois pode ter gente que vai vir ler e entender que versionar no HD original pode ser uma forma de backup, acontece, na cabeça das pessoas versões e redundância soam como cópia logo backup.

@caiosnom não é uma questão de conhecimento, é uma questão de praticidade e boas praticas, por isso foi indicado para você que não “reinvente a roda”. Provavelmente a melhor solução para você seria usar BTRFS e snapper + btrbk.

Você vai poder comprimir toda a partição, os snapshots terão deduplicação a nível de bloco de sistema, estarão sempre acessíveis, serão criados/removidos e se disponíveis na mesma partição restaurados instantaneamente quando precisar, você terá garantias ACID para ações como envio de subvolumes para outras partições e poderá fazer transferências diferenciais assim como remover versões anteriores sem quebrar o histórico e ainda controlar a remoção de backups a depender do tamanho dos snapshots, separar os espaços dos clientes e controlar o tamanho de seus volumes. Enfim, existem vários benefícios únicos desse setup.

Inclusive acabei de configurar o samba para usar os snapshots do snapper em um subvolume BTRFS para mostrar aos usuários windows como “versões anteriores”. Fiquei meio enrolado mas depois que descobri ficou fácil!

1 curtida

Sim vfs_shadow_copy2 pode ser usado com BTRFS, LVM, etc. Usar ferramentas como BTRFS, Snapper e integrar com samba, etc, É mais fácil e seguro que montar sua própria “gambiarra”. :joy: No máximo você vai ter de modificar alguns arquivos de configuração e ler a documentação.

Apenas lembrando desta vez que “versões anteriores” não é uma funcionalidade de backup nem versionamento (sem resolução de conflitos, etc).

caraca, vou ter que comer muito arroz e feijão pra aprender esssas coisas mirabolantes que vocês fazem hahsaushasuas

Esse forum é ótimo.

Valeu mesmo todas as opiniões.
Vou implementar um backup simples e verificar o resultado.
Obrigado.

Obrigado pelo script.
Vou adaptá-lo as minhas necessidades.

Eu fiz um script relativamente simples:

#!/usr/bin/env bash

#diretório para fazer backup.
DIRTOBACKUP=’/home/user/file’

#Device para medir espaço livre.
DEVICEBACKUP=’/dev/loop12’

#Ponto de montagem do backup
MOUNTBACKUP=’/home/user/test’

#Medir tamando do backup em bytes.
tamanhobackup=$(du -bc $DIRTOBACKUP 2> /dev/null | grep -i total | awk ‘{print $1}’)

#Medir espaço livre do device em bytes.
spacelivre=$(echo “$(df | grep -i $DEVICEBACKUP | awk ‘{ print $4 }’) * 1024” | bc)

#Entra no ponto da montagem do backup.
cd $MOUNTBACKUP

while [ $tamanhobackup -gt $spacelivre ];
do

#Remove o arquivo mais antigo
rm -vf “$(ls -1ptr $MOUNTBACKUP | grep -v / | head -1)”

#Recalcula o espaço livre.
spacelivre=$(echo “$(df | grep -i $DEVICEBACKUP | awk ‘{ print $4 }’) * 1024” | bc)

done

#Faz o backup.
rsync -Cravzpt $DIRTOBACKUP $MOUNTBACKUP

2 curtidas