Linux: Compactação e Arquivamento

tar -czf projeto.tar.gz \
    --exclude=node_modules \
    --exclude=.git \
    --exclude=__pycache__ \
    projeto/

# Criar arquivo tar
tar -cf arquivo.tar arquivo1 arquivo2 dir/    # Apenas arquiva
tar -czf arquivo.tar.gz dir/            # Arquiva + compacta com gzip

> 💡 Dica: Mnemônico das opções `tar -czf` — `c` (create, criar), `z` (gzip, compactar com gzip), `f` (file, indicar o nome do arquivo). Esta é a combinação mais comum; o `.tar.gz` resultante é o formato padrão de distribuição no mundo Linux. Para extrair, basta trocar o `c` por `x` (extract): `tar -xzf`.
tar -cjf arquivo.tar.bz2 dir/           # Arquiva + compacta com bzip2
tar -cJf arquivo.tar.xz dir/            # Arquiva + compacta com xz

# Extrair
tar -xf arquivo.tar                     # Extrai (detecta o formato automaticamente)
tar -xzf arquivo.tar.gz                 # Extrai .tar.gz
tar -xf arquivo.tar -C /destino/        # Extrai para um diretório específico

# Listar conteúdo
tar -tf arquivo.tar.gz                  # Pré-visualiza a lista de arquivos dentro do arquivo

> ⚠️ Atenção: Antes de extrair um arquivo tar, use `tar -tf` para pré-visualizar a lista de arquivos — confirme que não há "bombas" (por exemplo, arquivos que explodem em uma quantidade absurda de arquivos pequenos, ou caminhos começando com `/`, indicando caminhos absolutos), para evitar sobrescrever arquivos do sistema ou lotar o disco.

# Excluir
tar -czf backup.tar.gz --exclude="*.log" --exclude=node_modules dir/

# Compactar
zip -r projeto.zip projeto/             # Compacta diretório recursivamente
zip -r projeto.zip projeto/ -x "*.git*" # Exclui .git
zip -r projeto.zip projeto/ -P senha    # Criptografa

# Extrair
unzip projeto.zip                       # Extrai no diretório atual
unzip projeto.zip -d /destino/          # Extrai no diretório indicado
unzip -l projeto.zip                    # Vê o conteúdo sem extrair

# Vantagem do zip: suportado nativamente em todos os sistemas operacionais

# Uso básico
rsync -av origem/ destino/               # Sincronização local (recursivo + preserva atributos)
rsync -av --delete origem/ destino/      # Sincroniza e apaga no destino o que não está na origem

> ℹ️ Nota: `rsync --delete` faz o destino ficar idêntico à origem — arquivos no destino que não existem na origem serão apagados. Se você errar (por exemplo, caminho de origem errado), pode acabar apagando muitos dados do destino. Sempre rode com `--dry-run` antes para pré-visualizar a operação.
rsync -avz origem/ usuario@host:/destino/     # Sincronização remota (com compactação)
rsync -avz -e "ssh -p 2222" origem/ host:/destino/  # Indica a porta SSH

# Excluir
rsync -av --exclude="node_modules" --exclude=".git" origem/ destino/

# Backup incremental (com hard links)
rsync -av --link-dest=../backup-ontem/ origem/ backup-hoje/

# Compacta o diretório projects dentro de home
tar -czf projects-backup.tar.gz ~/projects/

# Vê o conteúdo do arquivo
tar -tf projects-backup.tar.gz | head -10

# Extrai em /tmp
tar -xzf projects-backup.tar.gz -C /tmp/

# Com saída detalhada
tar -czvf meu-backup.tar.gz --exclude="*.log" /var/log/

# Prepara dados de teste
mkdir -p /tmp/compress-test
cp -r /usr/share/doc/* /tmp/compress-test/ 2>/dev/null

# gzip
time tar -czf test.tar.gz -C /tmp compress-test
ls -lh test.tar.gz

# bzip2
time tar -cjf test.tar.bz2 -C /tmp compress-test
ls -lh test.tar.bz2

# xz
time tar -cJf test.tar.xz -C /tmp compress-test
ls -lh test.tar.xz

# Resultado da comparação
# Em geral: test.tar.gz é o maior mas o mais rápido, test.tar.xz é o menor mas o mais lento

# Arquiva o projeto (excluindo diretórios desnecessários)
cd ~/projects
zip -r myapp.zip myapp/ -x "myapp/node_modules/*" "myapp/.git/*" "myapp/__pycache__/*"

# Vê o conteúdo
unzip -l myapp.zip | head -20

# Criptografa o arquivo
zip -r -e segredo.zip confidencial/    # Vai pedir uma senha

# Backup local
rsync -av --delete ~/projects/ /backup/projects/

# Backup remoto em um servidor
rsync -avz -e "ssh -i ~/.ssh/minhachave" \
    --exclude="node_modules" \
    --progress \
    ~/projects/ usuario@servidor-backup:/backups/

# Backup incremental (usando hard links)
# Dia 1
rsync -av /data/ /backup/2026-07-07/

# Dia 2 (guarda só as alterações)
rsync -av --link-dest=/backup/2026-07-07/ /data/ /backup/2026-07-08/

#!/bin/bash
# auto-backup.sh - Backup automatizado de diretórios críticos

BACKUP_ROOT="/backup"
DATE=$(date +%Y%m%d)
RETENTION_DAYS=30

# Diretórios a fazer backup
declare -A DIRS
DIRS["projects"]="$HOME/projects"
DIRS["configs"]="/etc"
DIRS["notes"]="$HOME/notes"

echo "=== Starting backup: $DATE ==="

# Cria o diretório de backup
mkdir -p "$BACKUP_ROOT/$DATE"

for name in "${!DIRS[@]}"; do
    src="${DIRS[$name]}"
    dest="$BACKUP_ROOT/$DATE/$name.tar.gz"

    if [ -d "$src" ]; then
        echo "Backing up $src → $dest"
        tar -czf "$dest" \
            --exclude="node_modules" \
            --exclude=".git" \
            --exclude="*.log" \
            "$src" 2>/dev/null
        echo "  ✅ $(du -h "$dest" | cut -f1)"
    else
        echo "  ⚠️ Directory does not exist: $src"
    fi
done

# Apaga backups expirados
echo ""
echo "Cleaning backups older than $RETENTION_DAYS days..."
find "$BACKUP_ROOT" -maxdepth 1 -type d -mtime +$RETENTION_DAYS -exec rm -rf {} \;

echo "=== Backup complete ==="

#!/bin/bash
# rsync-backup.sh - Backup incremental usando rsync

SOURCE="$HOME/projects/webapp"
DEST_USER="backup"
DEST_HOST="backup.example.com"
DEST_PATH="/backups/webapp"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
LOGFILE="/var/log/backup.log"

log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOGFILE"
}

log "Starting backup of $SOURCE..."

# Executa o backup incremental remoto com rsync
rsync -avz \
    --delete \
    --partial \
    --progress \
    --exclude="node_modules" \
    --exclude=".git" \
    --exclude=".env" \
    --exclude="tmp/" \
    -e "ssh -i ~/.ssh/backup_key -p 22" \
    "$SOURCE/" \
    "${DEST_USER}@${DEST_HOST}:${DEST_PATH}/current/" >> "$LOGFILE" 2>&1

if [ $? -eq 0 ]; then
    log "✅ Backup succeeded"
    # Cria um snapshot com timestamp
    ssh -i ~/.ssh/backup_key "${DEST_USER}@${DEST_HOST}" \
        "cp -al ${DEST_PATH}/current ${DEST_PATH}/${TIMESTAMP}"
    log "✅ Snapshot created: $TIMESTAMP"
else
    log "❌ Backup failed (exit code: $?)"
    exit 1
fi