Procedimentos - Projeto Empresa Livre

Ferramentas do usuário

Ferramentas do site

Visitou:
proxmox:prune-individual

Diferenças

Aqui você vê as diferenças entre duas revisões dessa página.

Link para esta página de comparações

Próxima revisão		Revisão anterior
proxmox:prune-individual [2026/09/27 18:00] – criada adminproxmox:prune-individual [2026/09/29 13:22] (atual) – admin
Linha 1: Linha 1:
-#!/usr/bin/env bash +====== PBS — Prune Individual por VM/CT ======
-# ============================================================================== +
-#  pbs-prune-setup — Assistente de prune individual por VM/CT no Proxmox Backup Server +
-# ------------------------------------------------------------------------------ +
-#  Autor   : Caio Monteiro +
-#  Site    : www.projetoempresalivre.com.br +
-#  Versão  : 1.0.0 (25/09/2026) +
-#  Licença : MIT +
-# +
-#  O PBS só faz prune por datastore/namespace. Este assistente: +
-#    1. coleta e valida os dados de conexão (host, datastore, token, fingerprint) +
-#    2. cria o token de API e a permissão automaticamente (quando roda no próprio PBS) +
-#    3. lista os grupos existentes e deixa você escolher VM/CT + quantos manter (keep-last) +
-#    4. simula (dry-run) antes de aplicar +
-#    5. instala o executor, a config, o agendamento (cron) e o logrotate +
-# +
-#  Uso: +
-#    pbs-prune-setup.sh              assistente interativo +
-#    pbs-prune-setup.sh --uninstall  remove tudo que foi instalado +
-#    pbs-prune-setup.sh --help +
-# +
-#  Arquivos instalados: +
-#    /usr/local/sbin/pbs-prune          executor (roda pelo cron ou manualmente) +
-#    /etc/pbs-prune/pbs-prune.conf      conexão e agendamento +
-#    /etc/pbs-prune/groups.conf         lista "grupo keep-last"  (ex.: vm/100 7) +
-#    /etc/pbs-prune/secret              secret do token (600) +
-#    /etc/cron.d/pbs-prune              agendamento +
-#    /etc/logrotate.d/pbs-prune         rotação do log +
-#    /var/log/pbs-prune.log             log de execução +
-# ==============================================================================+
  
-set -uo pipefail+Script para configurar políticas de retenção individuais por VM ou CT no Proxmox Backup Server.
  
-readonly VERSION="1.0.0" +Exemplo:
-readonly APP="pbs-prune" +
-readonly PREFIX="${PBS_PRUNE_PREFIX:-}"        # só para testes; em produção fica vazio +
-readonly CONF_DIR="${PREFIX}/etc/${APP}" +
-readonly CONF_FILE="${CONF_DIR}/${APP}.conf" +
-readonly GROUPS_FILE="${CONF_DIR}/groups.conf" +
-readonly SECRET_FILE="${CONF_DIR}/secret" +
-readonly RUNNER="${PREFIX}/usr/local/sbin/${APP}" +
-readonly CRON_FILE="${PREFIX}/etc/cron.d/${APP}" +
-readonly LOGROTATE_FILE="${PREFIX}/etc/logrotate.d/${APP}" +
-readonly LOG_FILE="${PREFIX}/var/log/${APP}.log" +
-readonly LOCK_FILE="${PREFIX}/run/${APP}.lock"+
  
-# ------------------------------------------------------------------ estado +<code> 
-PBS_HOST="" PBS_PORT="8007" DATASTORE="" NAMESPACE="" AUTH_ID="root@pam!prune" +vm/100   7 
-SECRET="" FINGERPRINT="" CRON_EXPR="" CRON_DESC="" +vm/101   15 
-G_NAMES=() G_KEEP=() AVAILABLE=() +ct/200   30 
-IS_LOCAL_PBS=0+</code>
  
-# ------------------------------------------------------------------ interface +Cada grupo pode possuir seu próprio ''keep-last''.
-if [[ -t 1 ]]; then +
-  C_0=$'\e[0m' C_B=$'\e[1m' C_DIM=$'\e[2m' C_R=$'\e[31m' C_G=$'\e[32m' C_Y=$'\e[33m' C_C=$'\e[36m' +
-else +
-  C_0="" C_B="" C_DIM="" C_R="" C_G="" C_Y="" C_C="" +
-fi+
  
-hr()   { printf '%s%s%s\n' "$C_DIM" "────────────────────────────────────────────────────────────" "$C_0"; } +===== Pré-requisitos =====
-info() { printf '  %s➜%s %s\n' "$C_C" "$C_0" "$*"; } +
-ok()   { printf '  %s✔%s %s\n' "$C_G" "$C_0" "$*"; } +
-warn() { printf '  %s⚠%s %s\n' "$C_Y" "$C_0" "$*" >&2; } +
-fail() { printf '  %s✖%s %s\n' "$C_R" "$C_0" "$*" >&2; } +
-die()  { fail "$*"; exit 1; } +
-tip()  { printf '  %s%s%s\n' "$C_DIM" "$*" "$C_0"; } +
-step() { printf '\n%s%s▌ %s%s\n' "$C_B" "$C_C" "$1" "$C_0"; hr; }+
  
-banner() { +Antes de executar:
-  printf '%s%s' "$C_B" "$C_C" +
-  cat <<'EOF'+
  
-  ╔════════════════════════════════════════════════════════╗ +  * Proxmox Backup Server acessível; 
-  ║   PBS Prune Individual — Assistente de configuração    ║ +  * ''proxmox-backup-client'' instalado; 
-  ║   Retenção por VM/CT no Proxmox Backup Server          ║ +  * acesso ''root'' ao servidor onde o script será instalado; 
-  ╚════════════════════════════════════════════════════════╝ +  * um usuário existente no PBS; 
-EOF +  * API Token associado a esse usuário; 
-  printf '%s  %sv%s · Projeto Empresa Livre%s\n' "$C_0" "$C_DIM" "$VERSION" "$C_0" +  * permissão no datastore que será utilizado.
-}+
  
-on_interrupt() { stty echo 2>/dev/null; printf '\n'; warn "Cancelado pelo usuário. Nenhuma alteração pendente foi aplicada."; exit 130; } +O API Token sempre pertence a um usuário existente.
-trap on_interrupt INT+
  
-# ask VAR "pergunta" "padrão" [validador] +Exemplos:
-ask() { +
-  local __var=$1 __prompt=$2 __def=${3-} __val=${4:-v_nonempty} __ans +
-  while :; do +
-    read -rp "  ${__prompt}${__def:+ ${C_DIM}[${__def}]${C_0}}: " __ans || die "Entrada encerrada." +
-    __ans=${__ans:-$__def} +
-    if "$__val" "$__ans"; then printf -v "$__var" '%s' "$__ans"; return 0; fi +
-  done +
-}+
  
-ask_secret() { +<code> 
-  local __var=$1 __prompt=$2 __ans +root@pam!prune 
-  while :; do +backup@pbs!prune 
-    read -rsp "  ${__prompt}: " __ans || die "Entrada encerrada."; printf '\n' +</code>
-    [[ -n $__ans ]] && { printf -v "$__var" '%s' "$__ans"; return 0; } +
-    warn "Campo obrigatório." +
-  done +
-}+
  
-# confirm "pergunta" [S|N]  -> 0 = sim +A permissão deve ser aplicada no datastore utilizado:
-confirm() { +
-  local def=${2:-N} ans hint +
-  [[ $def == S ]] && hint="S/n" || hint="s/N" +
-  read -rp "  $1 ${C_DIM}[${hint}]${C_0}: " ans || die "Entrada encerrada." +
-  ans=${ans:-$def} +
-  [[ ${ans,,} =~ ^(s|sim|y|yes)$ ]] +
-}+
  
-# choose VAR "título" "opção 1" "opção 2" ...   -> VAR recebe o número escolhido +<code bash> 
-choose() { +proxmox-backup-manager acl update /datastore/backup DatastoreAdmin --auth-id 'backup@pbs!prune' 
-  local __var=$1 __title=$2; shift 2 +</code>
-  local __i=1 __opt __ans +
-  printf '  %s%s%s\n' "$C_B" "$__title" "$C_0" +
-  for __opt in "$@"; do printf '   %s%2d)%s %s\n' "$C_C" "$__i" "$C_0" "$__opt"; __i=$((__i+1)); done +
-  while :; do +
-    read -rp "  Opção: " __ans || die "Entrada encerrada." +
-    if [[ $__ans =~ ^[0-9]+$ ]] && (( __ans >= 1 && __ans <= $# )); then printf -v "$__var" '%s' "$__ans"; return 0; fi +
-    warn "Escolha um número entre 1 e $#." +
-  done +
-}+
  
-# ------------------------------------------------------------------ validadores +Substitua ''backup'' pelo nome do seu datastore e utilize o usuário/token criado no seu ambiente.
-v_nonempty() { [[ -n $1 ]] || { warn "Campo obrigatório."; return 1; }; } +
-v_any()      { return 0; } +
-v_host()     { [[ $1 =~ ^[A-Za-z0-9._-]+$ ]] || { warn "Host/IP inválido (use nome DNS ou IPv4)."; return 1; }; } +
-v_port()     { [[ $1 =~ ^[0-9]+$ ]] && (( $1 >= 1 && $1 <= 65535 )) || { warn "Porta inválida (1-65535)."; return 1; }; } +
-v_name()     { [[ $1 =~ ^[A-Za-z0-9._-]+$ ]] || { warn "Use apenas letras, números, ponto, hífen e sublinhado."; return 1; }; } +
-v_ns()       { [[ -z $1 || $1 =~ ^[A-Za-z0-9._/-]+$ ]] || { warn "Namespace inválido (ex.: producao ou clientes/acme)."; return 1; }; } +
-v_posint()   { [[ $1 =~ ^[1-9][0-9]*$ ]] || { warn "Informe um inteiro maior ou igual a 1."; return 1; }; } +
-v_time()     { [[ $1 =~ ^([01]?[0-9]|2[0-3]):[0-5][0-9]$ ]] || { warn "Horário no formato HH:MM (ex.: 03:30)."; return 1; }; } +
-v_hours()    { [[ $1 =~ ^([1-9]|1[0-9]|2[0-3])$ ]] || { warn "Informe de 1 a 23 horas."; return 1; }; } +
-v_authid() { +
-  local re='^[A-Za-z0-9._-]+@[A-Za-z0-9._-]+![A-Za-z0-9._-]+$' +
-  [[ $1 =~ $re ]] || { warn "Formato: usuario@realm!token  (ex.: root@pam!prune)"; return 1; } +
-} +
-v_fp() { +
-  local re='^([0-9A-Fa-f]{2}:){31}[0-9A-Fa-f]{2}$' +
-  [[ $1 =~ $re ]] || { warn "Fingerprint SHA-256 inválido (32 pares hex separados por ':')."; return 1; } +
-} +
-v_cron() { +
-  local -a f; read -ra f <<<"$1" +
-  (( ${#f[@]} == 5 )) && [[ $1 =~ ^[0-9A-Za-z*/,\ -]+$ ]] \ +
-    || { warn "Expressão cron precisa de 5 campos (min hora dia mês dia-semana)."; return 1; } +
-}+
  
-# ------------------------------------------------------------------ helpers PBS +===== Download =====
-repo() { printf '%s@%s:%s:%s' "$AUTH_ID" "$PBS_HOST" "$PBS_PORT" "$DATASTORE"; } +
-ns_args() { [[ -n $NAMESPACE ]] && printf -- '--ns\n%s\n' "$NAMESPACE"; }+
  
-pbc() { +Baixe o script diretamente:
-  local -a ns; mapfile -t ns < <(ns_args) +
-  PBS_REPOSITORY="$(repo)" PBS_PASSWORD="$SECRET" PBS_FINGERPRINT="$FINGERPRINT" \ +
-    timeout 60 proxmox-backup-client "$@" "${ns[@]}" </dev/null +
-}+
  
-fetch_fingerprint() { +[[https://cursoproxmox.com.br/prune/pbs-prune-setup.sh|pbs-prune-setup.sh]]
-  timeout 8 openssl s_client -connect "${PBS_HOST}:${PBS_PORT}" -servername "$PBS_HOST" </dev/null 2>/dev/null \ +
-    | openssl x509 -noout -fingerprint -sha256 2>/dev/null | cut -d= -f2 +
-}+
  
-is_local_host() { +===== Instalação =====
-  [[ $1 == 127.0.0.1 || $1 == localhost || $1 == "$(hostname)" || $1 == "$(hostname -f 2>/dev/null)" ]] && return 0 +
-  hostname -I 2>/dev/null | tr ' ' '\n' | grep -qxF "$1" +
-}+
  
-# ------------------------------------------------------------------ pré-checagem +No PBS:
-preflight() { +
-  step "Verificando pré-requisitos" +
-  [[ $EUID -eq 0 ]] || die "Execute como root." +
-  local c missing=0 +
-  for c in proxmox-backup-client openssl timeout flock; do +
-    if command -v "$c" >/dev/null 2>&1; then ok "$c"; else fail "$c não encontrado"; missing=1; fi +
-  done +
-  (( missing )) && die "Instale os pacotes faltando (proxmox-backup-client vem no PVE/PBS; em Debian puro use o repositório do PBS)." +
-  [[ -d ${PREFIX}/etc/cron.d ]] || die "Diretório /etc/cron.d não existe — o cron está instalado?" +
-  ok "cron" +
-  command -v proxmox-backup-manager >/dev/null 2>&1 && { IS_LOCAL_PBS=1; ok "Rodando no próprio PBS — criação automática de token disponível"; } +
-  return 0 +
-}+
  
-# ------------------------------------------------------------------ 1. conexão +<code bash> 
-step_connection() { +chmod +x /root/pbs-prune-setup.sh 
-  step "1/5 · Conexão com o Proxmox Backup Server" +/root/pbs-prune-setup.sh 
-  local def_host=""; (( IS_LOCAL_PBS )) && def_host="127.0.0.1" +</code>
-  ask PBS_HOST "IP ou hostname do PBS" "${PBS_HOST:-$def_host}" v_host +
-  ask PBS_PORT "Porta da API" "$PBS_PORT" v_port+
  
-  if (( IS_LOCAL_PBS )) && is_local_host "$PBS_HOST"; then +O assistente solicitará:
-    info "Datastores disponíveis:" +
-    proxmox-backup-manager datastore list 2>/dev/null | sed 's/^/     /' +
-  fi +
-  ask DATASTORE "Nome do datastore" "$DATASTORE" v_name +
-  ask NAMESPACE "Namespace (Enter = raiz)" "$NAMESPACE" v_ns+
  
-  tip "Recomendado: token dedicado, ex.: root@pam!prune" +  * endereço do PBS; 
-  ask AUTH_ID "Auth-ID do token (usuario@realm!token)" "$AUTH_ID" v_authid+  * datastore; 
 +  * namespace, se utilizado; 
 +  * API Token; 
 +  * VMs/CTs; 
 +  * quantidade de backups a manter; 
 +  * agendamento.
  
-  setup_token +Antes da instalação é possível realizar um ''dry-run''.
-  setup_fingerprint +
-  test_connection || step_connection +
-}+
  
-setup_token() { +===== Estrutura criada =====
-  local user=${AUTH_ID%%!*} tok=${AUTH_ID#*!} opt out acl_path+
  
-  if (( IS_LOCAL_PBS )) && is_local_host "$PBS_HOST" && confirm "Criar/ajustar o token e a permissão automaticamente?" S; then +Após a instalação:
-    if proxmox-backup-manager user list-tokens "$user" --output-format json 2>/dev/null | grep -qF "\"${AUTH_ID}\""; then +
-      warn "O token ${AUTH_ID} já existe." +
-      choose opt "O que deseja fazer?" "Usar o token existente (vou digitar o secret)" "Regenerar o token (o secret atual deixa de funcionar)" +
-      if (( opt == 2 )); then +
-        proxmox-backup-manager user delete-token "$user" "$tok" >/dev/null 2>&1 || die "Falha ao remover o token antigo." +
-      else +
-        ask_secret SECRET "Secret do token" +
-      fi +
-    fi +
-    if [[ -z $SECRET ]]; then +
-      out=$(proxmox-backup-manager user generate-token "$user" "$tok" --output-format json 2>&1) \ +
-        || die "Falha ao gerar o token: $out" +
-      SECRET=$(sed -n 's/.*"value"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' <<<"$out") +
-      [[ -n $SECRET ]] || die "Não consegui ler o secret gerado: $out" +
-      ok "Token ${AUTH_ID} criado" +
-    fi +
-    acl_path="/datastore/${DATASTORE}${NAMESPACE:+/$NAMESPACE}" +
-    if proxmox-backup-manager acl update "$acl_path" DatastoreAdmin --auth-id "$AUTH_ID" >/dev/null 2>&1; then +
-      ok "Permissão DatastoreAdmin em ${acl_path}" +
-    else +
-      warn "Não consegui aplicar a ACL. Aplique manualmente:" +
-      tip "proxmox-backup-manager acl update ${acl_path} DatastoreAdmin --auth-id '${AUTH_ID}'" +
-    fi +
-  else +
-    if [[ -n $SECRET ]] && confirm "Manter o secret já configurado?" S; then return 0; fi +
-    tip "O token precisa da role DatastoreAdmin em /datastore/${DATASTORE} (prune de grupos de outros donos)." +
-    ask_secret SECRET "Secret do token" +
-  fi +
-}+
  
-setup_fingerprint() { +<code> 
-  local fp +/usr/local/sbin/ 
-  info "Obtendo o fingerprint do certificado de ${PBS_HOST}:${PBS_PORT}..." +└── pbs-prune
-  fp=$(fetch_fingerprint || true) +
-  if [[ -n $fp ]]; then +
-    printf '     %s%s%s\n' "$C_B" "$fp" "$C_0" +
-    tip "Confira em: PBS → Painel → Mostrar Fingerprint (ou: proxmox-backup-manager cert info)" +
-    if confirm "O fingerprint confere?" S; then FINGERPRINT=$fp; return 0; fi +
-  else +
-    warn "Não foi possível ler o certificado automaticamente." +
-  fi +
-  ask FINGERPRINT "Cole o fingerprint SHA-256" "$FINGERPRINT" v_fp +
-}+
  
-test_connection() { +/etc/pbs-prune/ 
-  local out +├── pbs-prune.conf 
-  info "Testando conexão em $(repo)${NAMESPACE:+ (ns: $NAMESPACE)}..." +├── groups.conf 
-  if out=$(pbc list --output-format text 2>&1); then +└── secret
-    mapfile -t AVAILABLE < <(grep -oE '\b(vm|ct|host)/[A-Za-z0-9._-]+' <<<"$out" | sort -u -V) +
-    ok "Conectado — ${#AVAILABLE[@]} grupo(s) de backup encontrados" +
-    return 0 +
-  fi +
-  fail "Falha na conexão:" +
-  sed 's/^/     /' <<<"$out" | tail -n 5 >&2 +
-  confirm "Revisar os dados de conexão?" S && return 1 +
-  confirm "Continuar mesmo assim?" N || die "Abortado." +
-  AVAILABLE=() +
-  return 0 +
-}+
  
-# ------------------------------------------------------------------ 2. grupos +/etc/cron.d/ 
-print_groups() { +└── pbs-prune
-  local i +
-  if (( ${#G_NAMES[@]} == 0 )); then tip "(nenhum grupo configurado)"; return; fi +
-  printf '  %s%-4s %-18s %s%s\n' "$C_B" "#" "GRUPO" "MANTER (keep-last)" "$C_0" +
-  for i in "${!G_NAMES[@]}"; do +
-    printf '  %-4s %-18s %s\n' "$((i+1))" "${G_NAMES[$i]}" "${G_KEEP[$i]}" +
-  done +
-}+
  
-group_index() { local i; for i in "${!G_NAMES[@]}"; do [[ ${G_NAMES[$i]} == "$1" ]] && { echo "$i"; return 0; }; done; return 1; } +/etc/logrotate.d/ 
-in_available() { printf '%s\n' "${AVAILABLE[@]}" | grep -qxF "$1"; }+└── pbs-prune
  
-resolve_group() {   # entrada: "100", "vm/100", "ct/200"  -> saída: grupo +/var/log/ 
-  local input=$1 opt +└── pbs-prune.log 
-  if [[ $input =~ ^(vm|ct|host)/[A-Za-z0-9._-]+$ ]]; then echo "$input"; return 0; fi +</code>
-  [[ $input =~ ^[0-9]+$ ]] || { warn "Informe o ID (ex.: 100) ou o grupo (ex.: ct/200)."; return 1; } +
-  local has_vm=0 has_ct=0 +
-  in_available "vm/$input" && has_vm=1 +
-  in_available "ct/$input" && has_ct=1 +
-  if (( has_vm && has_ct )); then +
-    choose opt "Existem vm/$input e ct/$input. Qual?" "vm/$input (QEMU)" "ct/$input (LXC)" >&2 +
-    (( opt == 1 )) && echo "vm/$input" || echo "ct/$input" +
-  elif (( has_vm )); then echo "vm/$input" +
-  elif (( has_ct )); then echo "ct/$input" +
-  else +
-    warn "ID $input não encontrado no datastore${NAMESPACE:+ / ns $NAMESPACE}." +
-    choose opt "Adicionar mesmo assim como:" "vm/$input (QEMU)" "ct/$input (LXC)" "Cancelar" >&2 +
-    case $opt in 1) echo "vm/$input";; 2) echo "ct/$input";; *) return 1;; esac +
-  fi +
-}+
  
-step_groups() { +Arquivos principais:
-  step "2/5 · VMs/CTs e retenção" +
-  if (( ${#AVAILABLE[@]} )); then +
-    info "Grupos encontrados no datastore:" +
-    if command -v column >/dev/null 2>&1; then +
-      printf '%s\n' "${AVAILABLE[@]}" | column -c 70 | sed 's/^/     /' +
-    else +
-      printf '     %s\n' "${AVAILABLE[@]}" +
-    fi +
-  fi +
-  tip "Digite o ID (100) ou o grupo (ct/200). Enter vazio finaliza."+
  
-  local input group keep idx opt n +^ Arquivo ^ Função ^ 
-  while :; do +| ''/usr/local/sbin/pbs-prune'' | Executor do prune | 
-    printf '\n' +| ''/etc/pbs-prune/pbs-prune.conf'' | Configuração | 
-    read -rp "  ID da VM/CT: " input || die "Entrada encerrada." +| ''/etc/pbs-prune/groups.conf'' | Retenção por VM/CT | 
-    input=${input// /} +| ''/etc/pbs-prune/secret'' | Secret do API Token | 
-    if [[ -z $input ]]; then +| ''/etc/cron.d/pbs-prune'' | Agendamento | 
-      if (( ${#G_NAMES[@]} == 0 )); then warn "Adicione pelo menos um grupo."; continue; fi +| ''/var/log/pbs-prune.log'' | Log das execuções |
-      printf '\n'; print_groups; printf '\n' +
-      choose opt "Lista concluída?" "Sim, continuar" "Adicionar mais" "Remover um item" "Limpar a lista" +
-      case $opt in +
-        1) break ;; +
-        2) continue ;; +
-        3) ask n "Número do item a remover" "" v_posint +
-           if (( n <= ${#G_NAMES[@]} )); then +
-             ok "Removido ${G_NAMES[$((n-1))]}" +
-             unset 'G_NAMES[n-1]' 'G_KEEP[n-1]'; G_NAMES=("${G_NAMES[@]}"); G_KEEP=("${G_KEEP[@]}") +
-           else warn "Item inexistente."; fi ;; +
-        4) G_NAMES=(); G_KEEP=(); ok "Lista limpa." ;; +
-      esac +
-      continue +
-    fi+
  
-    group=$(resolve_group "$input") || continue +===== Configuração das VMs/CTs =====
-    if idx=$(group_index "$group"); then +
-      warn "$group já está na lista (keep-last ${G_KEEP[$idx]})." +
-      confirm "Alterar a retenção?" S || continue +
-      ask keep "Quantos backups manter de $group" "${G_KEEP[$idx]}" v_posint +
-      G_KEEP[$idx]=$keep +
-    else +
-      ask keep "Quantos backups manter de $group" "7" v_posint +
-      G_NAMES+=("$group"); G_KEEP+=("$keep") +
-    fi +
-    ok "$group → manter os últimos $keep" +
-  done +
-}+
  
-# ------------------------------------------------------------------ 3. simulação +Arquivo:
-step_dryrun() { +
-  step "3/5 · Simulação (dry-run)" +
-  confirm "Simular agora o que seria mantido/removido?" S || { tip "Simulação pulada."; return 0; } +
-  local i out kept removed +
-  printf '  %s%-18s %-10s %-9s %s%s\n' "$C_B" "GRUPO" "KEEP-LAST" "MANTÉM" "REMOVE" "$C_0" +
-  for i in "${!G_NAMES[@]}"; do +
-    if out=$(pbc prune "${G_NAMES[$i]}" --keep-last "${G_KEEP[$i]}" --dry-run --output-format json 2>&1); then +
-      kept=$(grep -oE '"keep":[[:space:]]*true' <<<"$out" | wc -l) +
-      removed=$(grep -oE '"keep":[[:space:]]*false' <<<"$out" | wc -l) +
-      printf '  %-18s %-10s %-9s %s%s%s\n' "${G_NAMES[$i]}" "${G_KEEP[$i]}" "$kept" \ +
-        "$( (( removed > 0 )) && echo "$C_Y" )" "$removed" "$C_0" +
-    else +
-      printf '  %-18s %-10s %s%s%s\n' "${G_NAMES[$i]}" "${G_KEEP[$i]}" "$C_R" "erro: $(tail -n1 <<<"$out")" "$C_0" +
-    fi +
-  done +
-  printf '\n' +
-  confirm "Resultado OK? (N volta para editar a lista)" S || { step_groups; step_dryrun; } +
-}+
  
-# ------------------------------------------------------------------ 4. agendamento +<code> 
-step_schedule() { +/etc/pbs-prune/groups.conf 
-  step "4/5 · Agendamento" +</code>
-  tip "Agende DEPOIS da janela de backup e ANTES do Garbage Collection do datastore." +
-  local opt t h m d dname +
-  local -a days=("Domingo" "Segunda" "Terça" "Quarta" "Quinta" "Sexta" "Sábado") +
-  choose opt "Frequência:" "Diário" "Semanal" "A cada N horas" "Expressão cron personalizada" "Não agendar (só executar manualmente)" +
-  case $opt in +
-    1) ask t "Horário (HH:MM)" "03:30" v_time; h=$((10#${t%%:*})); m=$((10#${t##*:})) +
-       CRON_EXPR="$m $h * * *"; CRON_DESC="Diário às $(printf '%02d:%02d' "$h" "$m")" ;; +
-    2) choose d "Dia da semana:" "${days[@]}"; d=$((d-1)); dname=${days[$d]} +
-       ask t "Horário (HH:MM)" "03:30" v_time; h=$((10#${t%%:*})); m=$((10#${t##*:})) +
-       CRON_EXPR="$m $h * * $d"; CRON_DESC="Toda ${dname} às $(printf '%02d:%02d' "$h" "$m")" ;; +
-    3) ask h "Intervalo em horas" "6" v_hours +
-       CRON_EXPR="15 */$h * * *"; CRON_DESC="A cada $h hora(s), no minuto 15" ;; +
-    4) ask CRON_EXPR "Expressão (min hora dia mês dia-semana)" "${CRON_EXPR:-30 3 * * *}" v_cron +
-       CRON_DESC="Personalizado" ;; +
-    5) CRON_EXPR=""; CRON_DESC="Sem agendamento" ;; +
-  esac +
-  ok "${CRON_DESC}${CRON_EXPR:+  (${CRON_EXPR})}" +
-}+
  
-# ------------------------------------------------------------------ 5. instalação +Exemplo:
-write_runner() { +
-  mkdir -p "$(dirname "$RUNNER")" +
-  cat >"$RUNNER" <<'RUNNER_EOF' +
-#!/usr/bin/env bash +
-# pbs-prune — executor de prune individual por VM/CT (gerado pelo pbs-prune-setup) +
-# Uso: pbs-prune [--dry-run] [--list] +
-set -uo pipefail+
  
-CONF="${PBS_PRUNE_CONF:-@CONF_FILE@}" +<code> 
-[[ -r $CONF ]] || { echo "Configuração não encontrada: $CONF" >&2; exit 2; } +vm/100 7 
-# shellcheck source=/dev/null +vm/101 15 
-source "$CONF"+ct/200 30 
 +</code>
  
-DRY=() +Formato:
-case "${1:-}" in +
-  -n|--dry-run) DRY=(--dry-run) ;; +
-  -l|--list)    grep -vE '^\s*(#|$)' "$GROUPS_FILE"; exit 0 ;; +
-  -h|--help)    echo "Uso: $(basename "$0") [--dry-run] [--list]"; exit 0 ;; +
-  "") ;; +
-  *) echo "Opção inválida: $1" >&2; exit 2 ;; +
-esac+
  
-exec 9>"$LOCK_FILE" +<code> 
-flock -n 9 || { echo "Já existe uma execução em andamento." >&2; exit 3; }+GRUPO KEEP-LAST 
 +</code>
  
-log() { +===== Comandos =====
-  local line; line="$(date '+%F %T') $*" +
-  printf '%s\n' "$line" >>"$LOG_FILE" +
-  [[ -t 1 ]] && printf '%s\n' "$line" +
-  logger -t pbs-prune -- "$*" 2>/dev/null +
-  return 0 +
-}+
  
-export PBS_REPOSITORY="${AUTH_ID}@${PBS_HOST}:${PBS_PORT}:${DATASTORE}" +Simular:
-export PBS_FINGERPRINT="$FINGERPRINT" +
-PBS_PASSWORD="$(<"$SECRET_FILE")" || { log "ERRO: não foi possível ler $SECRET_FILE"; exit 2; } +
-export PBS_PASSWORD+
  
-NS=(); [[ -n ${NAMESPACE:-} ]] && NS=(--ns "$NAMESPACE")+<code bash> 
 +pbs-prune --dry-run 
 +</code>
  
-total=0 errors=0 removed_total=0 start=$SECONDS +Executar:
-log "===== início${DRY:+ (dry-run)} · ${PBS_REPOSITORY}${NAMESPACE:+ · ns=$NAMESPACE} =====" +
-while read -r group keep _; do +
-  [[ -z ${group:-} || $group == \#* ]] && continue +
-  total=$((total + 1)) +
-  if out=$(timeout 600 proxmox-backup-client prune "$group" "${NS[@]}" --keep-last "$keep" \ +
-             "${DRY[@]}" --output-format json </dev/null 2>&1); then +
-    removed=$(grep -oE '"keep":[[:space:]]*false' <<<"$out" | wc -l) +
-    removed_total=$((removed_total + removed)) +
-    log "OK    ${group}  keep-last=${keep}  removidos=${removed}" +
-  else +
-    errors=$((errors + 1)) +
-    log "ERRO  ${group}  keep-last=${keep}" +
-    while IFS= read -r l; do log "      $l"; done <<<"$out" +
-  fi +
-done <"$GROUPS_FILE" +
-log "===== fim · grupos=${total} erros=${errors} snapshots removidos=${removed_total} · $((SECONDS - start))s ====="+
  
-(( errors == 0 )) +<code bash> 
-RUNNER_EOF +pbs-prune 
-  sed -i "s|@CONF_FILE@|${CONF_FILE}|" "$RUNNER" +</code>
-  chmod 750 "$RUNNER" +
-}+
  
-write_config() { +Listar grupos:
-  install -d -m 700 "$CONF_DIR" +
-  umask 077 +
-  { +
-    echo "# Gerado por pbs-prune-setup v${VERSION} em $(date '+%F %T'). Rode o setup novamente para alterar." +
-    printf 'PBS_HOST=%q\nPBS_PORT=%q\nDATASTORE=%q\nNAMESPACE=%q\nAUTH_ID=%q\nFINGERPRINT=%q\n' \ +
-      "$PBS_HOST" "$PBS_PORT" "$DATASTORE" "$NAMESPACE" "$AUTH_ID" "$FINGERPRINT" +
-    printf 'CRON_EXPR=%q\nCRON_DESC=%q\n' "$CRON_EXPR" "$CRON_DESC" +
-    printf 'SECRET_FILE=%q\nGROUPS_FILE=%q\nLOG_FILE=%q\nLOCK_FILE=%q\n' \ +
-      "$SECRET_FILE" "$GROUPS_FILE" "$LOG_FILE" "$LOCK_FILE" +
-  } >"$CONF_FILE" +
-  printf '%s' "$SECRET" >"$SECRET_FILE" +
-  chmod 600 "$CONF_FILE" "$SECRET_FILE" +
-  umask 022 +
-}+
  
-write_groups() { +<code bash> 
-  local i +pbs-prune --list 
-  install -d -m 700 "$CONF_DIR" +</code>
-  { +
-    echo "# grupo      keep-last   (vm/ID = QEMU · ct/ID = LXC)" +
-    echo "# Pode editar à mão; uma linha por grupo." +
-    for i in "${!G_NAMES[@]}"; do printf '%-12s %s\n' "${G_NAMES[$i]}" "${G_KEEP[$i]}"; done +
-  } >"$GROUPS_FILE" +
-  chmod 600 "$GROUPS_FILE" +
-}+
  
-write_cron() { +Acompanhar log:
-  if [[ -z $CRON_EXPR ]]; then rm -f "$CRON_FILE"; return 0; fi +
-  mkdir -p "$(dirname "$CRON_FILE")" "$(dirname "$LOG_FILE")" "$(dirname "$LOCK_FILE")" +
-  cat >"$CRON_FILE" <<EOF +
-# pbs-prune — ${CRON_DESC} (gerado por pbs-prune-setup) +
-SHELL=/bin/bash +
-PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin +
-${CRON_EXPR} root ${RUNNER} >/dev/null 2>&1 +
-EOF +
-  chmod 644 "$CRON_FILE" +
-}+
  
-write_logrotate() { +<code bash> 
-  mkdir -p "$(dirname "$LOGROTATE_FILE")" +tail -f /var/log/pbs-prune.log 
-  cat >"$LOGROTATE_FILE" <<EOF +</code>
-${LOG_FILE} { +
-    monthly +
-    rotate 12 +
-    compress +
-    missingok +
-    notifempty +
-} +
-EOF +
-}+
  
-step_review_install() { +===== Garbage Collection =====
-  step "5/5 · Revisão e instalação" +
-  printf '  %-14s %s\n' "Repositório:" "$(repo)" "Namespace:" "${NAMESPACE:-(raiz)}" \ +
-    "Fingerprint:" "${FINGERPRINT:0:23}…" "Agendamento:" "${CRON_DESC}${CRON_EXPR:+ (${CRON_EXPR})}" +
-  printf '\n'; print_groups; printf '\n' +
-  confirm "Instalar com essas configurações?" S || die "Instalação cancelada. Nada foi alterado."+
  
-  write_config;    ok "Configuração     ${CONF_FILE}" +O prune remove as referências dos snapshots.
-  write_groups;    ok "Lista de grupos  ${GROUPS_FILE}" +
-  ok "Secret           ${SECRET_FILE} (600)" +
-  write_runner;    ok "Executor         ${RUNNER}" +
-  write_cron;      [[ -n $CRON_EXPR ]] && ok "Agendamento      ${CRON_FILE}" || tip "Sem agendamento instalado." +
-  write_logrotate; ok "Logrotate        ${LOGROTATE_FILE}" +
-}+
  
-finish() { +O espaço físico no datastore será efetivamente recuperado após a execução do **Garbage Collection (GC)**.
-  printf '\n' +
-  if confirm "Executar o prune agora (valendo)?" N; then +
-    "$RUNNER" && ok "Execução concluída." || warn "Execução terminou com erros — veja o log." +
-  fi +
-  step "Pronto" +
-  printf '  %-34s %s\n' \ +
-    "pbs-prune --dry-run" "simular" \ +
-    "pbs-prune" "executar agora" \ +
-    "pbs-prune --list" "ver grupos configurados" \ +
-    "tail -f ${LOG_FILE}" "acompanhar o log" \ +
-    "$(basename "$0")" "editar lista / agendamento / desinstalar" +
-  tip "Lembrete: o espaço só é liberado quando o Garbage Collection do datastore rodar." +
-  printf '\n' +
-}+
  
-# ------------------------------------------------------------------ carregar / desinstalar +Por isso, recomenda-se executar na ordem:
-load_existing() { +
-  # shellcheck source=/dev/null +
-  source "$CONF_FILE" +
-  [[ -r $SECRET_FILE ]] && SECRET=$(<"$SECRET_FILE") +
-  G_NAMES=() G_KEEP=() +
-  local g k +
-  while read -r g k _; do +
-    [[ -z ${g:-} || $g == \#* ]] && continue +
-    G_NAMES+=("$g"); G_KEEP+=("$k") +
-  done <"$GROUPS_FILE" +
-}+
  
-uninstall() { +<code> 
-  step "Desinstalação" +Backup → Prune Individual → Garbage Collection 
-  [[ $EUID -eq 0 ]] || die "Execute como root." +</code>
-  confirm "Remover executor, configuração, agendamento e logrotate?" N || die "Cancelado." +
-  rm -f "$RUNNER" "$CRON_FILE" "$LOGROTATE_FILE" && ok "Executor, cron e logrotate removidos" +
-  rm -rf "$CONF_DIR" && ok "Configuração e secret removidos" +
-  tip "O log ${LOG_FILE} foi mantido. O token no PBS não foi removido:" +
-  tip "proxmox-backup-manager user delete-token <usuario@realm> <token>" +
-}+
  
-existing_menu() { +===== Desinstalação =====
-  local opt +
-  load_existing +
-  step "Instalação existente encontrada" +
-  printf '  %-14s %s\n' "Repositório:" "$(repo)" "Agendamento:" "${CRON_DESC:-—}${CRON_EXPR:+ (${CRON_EXPR})}" +
-  printf '\n'; print_groups; printf '\n' +
-  choose opt "O que deseja fazer?" \ +
-    "Editar a lista de VMs/CTs" "Alterar o agendamento" "Reconfigurar tudo" \ +
-    "Simular agora (dry-run)" "Desinstalar" "Sair" +
-  case $opt in +
-    1) test_connection || true; step_groups; step_dryrun; write_groups; ok "Lista atualizada: ${GROUPS_FILE}" ;; +
-    2) step_schedule; write_config; write_cron; ok "Agendamento atualizado" ;; +
-    3) full_flow; return ;; +
-    4) "$RUNNER" --dry-run ;; +
-    5) uninstall; exit 0 ;; +
-    6) exit 0 ;; +
-  esac +
-  finish +
-}+
  
-full_flow() { +<code bash> 
-  step_connection +/root/pbs-prune-setup.sh --uninstall 
-  step_groups +</code>
-  step_dryrun +
-  step_schedule +
-  step_review_install +
-  finish +
-}+
  
-# ------------------------------------------------------------------ main +A desinstalação remove o executor, configurações, cron e logrotate.
-case "${1:-}" in +
-  -h|--help)    sed -n '2,32p' "$0" | sed 's/^# \{0,1\}//'; exit 0 ;; +
-  -v|--version) echo "pbs-prune-setup $VERSION"; exit 0 ;; +
-  --uninstall)  banner; uninstall; exit 0 ;; +
-  "") ;; +
-  *) die "Opção inválida: $1 (use --help)" ;; +
-esac+
  
-banner +O API Token criado no PBS não é removido automaticamente.
-preflight +
-if [[ -f $CONF_FILE && -f $GROUPS_FILE ]]; then existing_menu; else full_flow; fi+
proxmox/prune-individual.1790542844.txt.gz · Última modificação: por admin
Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki