O Google usa tecnologia de IA na tradução de conteúdos para seu idioma de preferência. As traduções com IA podem ter erros.

Configurar backups consistentes com aplicativos

Este documento mostra como configurar backups programados e consistentes com o aplicativo e fluxos de trabalho de recuperação pontual (PITR, na sigla em inglês) para bancos de dados autogerenciados em execução em instâncias de máquina virtual (VM) do Linux do Compute Engine.

Ao fazer backup de cargas de trabalho de banco de dados com estado, como IBM Db2, SAP HANA, MySQL ou PostgreSQL, os snapshots padrão consistentes com falhas feitos pelo Backup e DR podem capturar o banco de dados enquanto as transações ainda estão em andamento. Essas transações incompletas podem corromper dados, deixar tabelas em estados inconsistentes e exigir rotinas de reparo de banco de dados longas após a recuperação de falhas. Os backups consistentes com o aplicativo resolvem esses problemas integrando-se ao agente convidado da VM para inativar o banco de dados e, opcionalmente, congelar o sistema de arquivos antes de criar um snapshot.

Antes de começar

Conclua as seguintes tarefas antes de configurar backups consistentes com o aplicativo.

Funções exigidas

Para receber as permissões necessárias para configurar backups consistentes com o aplicativo, peça ao administrador para conceder a você os seguintes papéis do IAM no projeto:

Para configurar e gerenciar planos de backup: usuário de backup e DR (roles/backupdr.backupUser)
Para gerenciar instâncias do Compute Engine: Admin da instância do Compute (v1) (roles/compute.instanceAdmin.v1)
Para acessar secrets do Secret Manager de scripts: acessador de secrets do Secret Manager (roles/secretmanager.secretAccessor)

Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Também é possível conseguir as permissões necessárias com papéis personalizados ou outros papéis predefinidos.

Pré-requisitos

No Google Cloud console do, na página do seletor de projetos, escolha ou crie um Google Cloud projeto do.

Acessar o seletor de projetos
Verifique se o faturamento foi ativado para o projeto.

Saiba como confirmar se o faturamento está ativado
Ative as APIs Backup e DR e Secret Manager.

Ativar as APIs
Verifique se os dados do banco de dados e os arquivos de registro estão armazenados em discos permanentes padrão Persistent Disks. Os volumes do Google Cloud Hyperdisk não oferecem suporte a operações de limpeza do convidado.
Se você planeja configurar a recuperação pontual, configure o banco de dados para arquivar as transações e refazer os registros em um Persistent Disk dedicado e separado, por exemplo, montado em /db2/ACT/log_archive.

Usar o framework de limpeza do convidado "traga seu próprio script" (BYOS, na sigla em inglês)

O Backup e DR usa o framework de limpeza do convidado "traga seu próprio script" (BYOS, na sigla em inglês) para inativar o banco de dados antes de um snapshot ser feito. O ambiente de convidado depende de dois scripts que residem no diretório /etc/google/snapshots/ na instância de VM do Linux:

Script pré-snapshot (/etc/google/snapshots/pre.sh) : é executado antes do snapshot. Esse script precisa inativar as operações do banco de dados e pode congelar o sistema de arquivos.
Script pós-snapshot (/etc/google/snapshots/post.sh) : é executado após o snapshot. Esse script precisa descongelar o sistema de arquivos e retomar as operações do banco de dados.

Para saber mais sobre modelos de script específicos do banco de dados, consulte Analisar scripts de amostra por tipo de banco de dados.

Opcional: congelar e descongelar sistemas de arquivos

O congelamento do sistema de arquivos usando o utilitário padrão do Linux fsfreeze é opcional e não obrigatório. A inativação do banco de dados garante a consistência da transação no nível do aplicativo. No entanto, se você precisar de mais consistência no nível do sistema de arquivos, inclua os comandos de congelamento e descongelamento do sistema de arquivos nos scripts.

Verifique se os scripts pre.sh e post.sh na VM estão configurados para processar o congelamento opcional do sistema de arquivos para volumes de registro sem suspender as operações do banco de dados.

Adicionar instruções de congelamento do sistema de arquivos ao pre.sh

Se você escolher congelar sistemas de arquivos, adicione a seguinte lógica de descoberta e congelamento no final do script pre.sh após inativar o banco de dados:

# Discover local writeable mount points
MOUNT_POINTS=$(findmnt -n -l -o TARGET -t xfs,ext4,ext3,ext2,btrfs)

# FREEZE FILESYSTEMS (Optional)
for mnt in $MOUNT_POINTS; do
    if ! sudo fsfreeze -f "$mnt"; then
        logger "Error: Failed to freeze $mnt. Cleaning up..."
        # Attempt emergency thaw
        for thaw_mnt in $MOUNT_POINTS; do sudo fsfreeze -u "$thaw_mnt" 2>/dev/null; done
        # Add your database-specific resume/cleanup commands here before exiting
        exit 1
    fi
    logger "Filesystem $mnt is frozen."
done

Adicionar instruções de descongelamento do sistema de arquivos ao post.sh

Se você congelar sistemas de arquivos em pre.sh, adicione a seguinte lógica de descongelamento no início do script post.sh antes de retomar o banco de dados:

# Discover local writeable mount points
MOUNT_POINTS=$(findmnt -n -l -o TARGET -t xfs,ext4,ext3,ext2,btrfs)

# UNFREEZE FILESYSTEMS (Optional)
for mnt in $MOUNT_POINTS; do
    sudo fsfreeze -u "$mnt"
    logger "Filesystem $mnt is unfrozen."
done

Buscar credenciais dinamicamente com o Secret Manager

Evite codificar credenciais ou senhas de banco de dados estáticas nos scripts de shell. Em vez disso, use o Secret Manager para buscar credenciais dinamicamente no ambiente de execução. Substitua as variáveis de senha estática nos scripts pela seguinte lógica:

# Fetch the database password from Secret Manager dynamically
DBPASSWORD=$(gcloud secrets versions access latest \
    --secret="SECRET_NAME" \
    --format='get(payload.data)' | tr -d '\n')

if [ $? -ne 0 ]; then
    logger "Critical Error: Unable to fetch the password from Secret Manager."
    exit 1
fi

Substitua SECRET_NAME pelo nome do secret no Secret Manager.

Analisar scripts de amostra por tipo de banco de dados

As amostras a seguir fornecem implementações pre.sh e post.sh para mecanismos de banco de dados compatíveis em execução em instâncias do Linux.

Observação:para cargas de trabalho do Microsoft SQL Server, ao contrário dos ambientes Linux que dependem de scripts personalizados, o Windows aproveita o serviço de cópia de sombra de volume (VSS, na sigla em inglês) integrado. Em ambientes Windows, o fluxo de trabalho de limpeza do convidado envolve o agente VSS do Google Cloud para interagir com os serviços do sistema Windows. Antes de um snapshot ser feito, o VSS limpa automaticamente os buffers do sistema de arquivos e inativa as cargas de trabalho compatíveis do SQL Server, confirmando todos os dados na memória no disco para garantir uma consistência robusta no nível do aplicativo. Para mais informações, consulte [Criar um snapshot de disco consistente do aplicativo do Windows](/compute/docs/instances/windows/creating-windows-persistent-disk-snapshot).

IBM Db2

Script pré-snapshot (/etc/google/snapshots/pre.sh)

 #!/bin/bash
 # Location: /etc/google/snapshots/pre.sh
 # 1. Define Mount Points for the Database
 MOUNT_POINTS=("DATA_MOUNT_POINT" "LOG_MOUNT_POINT")
 logger "BYOS Framework: Starting pre-snapshot script."

 # 2. QUIESCE DATABASE (Generic Hook)
 # Replace with DB-specific command (e.g., 'db2 set write suspend')
 logger "Suspending Database I/O..."
 # [INSERT DB QUIESCE COMMAND HERE]

 # 3. FREEZE FILESYSTEMS (Optional)
 for mnt in "${MOUNT_POINTS[@]}"; do
     if ! sudo fsfreeze -f "$mnt"; then
         logger "Error: Failed to freeze $mnt."
         # Attempt emergency thaw
         for thaw_mnt in "${MOUNT_POINTS[@]}"; do sudo fsfreeze -u "$thaw_mnt" 2>/dev/null; done
         # [INSERT DB RESUME COMMAND HERE]
         exit 1
     fi
     logger "Filesystem $mnt is frozen."
 done

Script pós-snapshot (/etc/google/snapshots/post.sh)

 #!/bin/bash
 # Location: /etc/google/snapshots/post.sh
 MOUNT_POINTS=("DATA_MOUNT_POINT" "LOG_MOUNT_POINT")
 logger "BYOS Framework: Starting post-snapshot script."

 # 1. UNFREEZE FILESYSTEMS (Optional)
 for mnt in "${MOUNT_POINTS[@]}"; do
     sudo fsfreeze -u "$mnt"
     logger "Filesystem $mnt is unfrozen."
 done

 # 2. RESUME DATABASE (Generic Hook)
 # Replace with DB-specific command (e.g., 'db2 set write resume')
 logger "Resuming Database I/O..."
 # [INSERT DB RESUME COMMAND HERE]
 logger "BYOS Framework: Cleanup complete."

Oracle

Script pré-snapshot (/etc/google/snapshots/pre.sh)

 sudo mkdir -p /etc/google/snapshots
 sudo tee /etc/google/snapshots/pre.sh > /dev/null << 'EOF'
 #!/bin/bash
 # Place Oracle (ASM) into hot backup mode before Backup and DR captures disks
 su - oracle -c "sqlplus -s / as sysdba" << 'SQL'
 WHENEVER SQLERROR EXIT FAILURE;
 ALTER DATABASE BEGIN BACKUP;
 EXIT;
 SQL

 if [ $? -ne 0 ]; then
   echo "Error: Failed to place Oracle in backup mode. Aborting snapshot." >&2
   exit 1
 fi
 EOF

 sudo chmod 750 /etc/google/snapshots/pre.sh

Script pós-snapshot (/etc/google/snapshots/post.sh)

 sudo tee /etc/google/snapshots/post.sh > /dev/null << 'EOF'
 #!/bin/bash
 # Release Oracle from backup mode and archive current redo log to +FRA
 su - oracle -c "sqlplus -s / as sysdba" << 'SQL'
 WHENEVER SQLERROR EXIT FAILURE;
 ALTER DATABASE END BACKUP;
 ALTER SYSTEM ARCHIVE LOG CURRENT;
 EXIT;
 SQL

 if [ $? -ne 0 ]; then
   echo "Warning: Failed to execute ALTER DATABASE END BACKUP." >&2
   exit 1
 fi
 EOF

 sudo chmod 750 /etc/google/snapshots/post.sh

SAP HANA

Script pré-snapshot (/etc/google/snapshots/pre.sh)

 #!/bin/bash
 # Location: /etc/google/snapshots/pre.sh

 DISK_ARG="$1"

 # 1. Configuration & Discovery
 DBSID="DBSID"
 DBADM="DBADM"
 ID_FILE="/tmp/hana_snapshot_id_$DBSID"
 HDB_KEY="HDB_KEY"

 if [[ "$DISK_ARG" == "," ]] || [[ "$DISK_ARG" == "1/0" ]] || [[ "$DISK_ARG" == "sda" ]]; then
     # Dynamically discover all local writeable mount points for full VM image consistency
     # Filters out pseudo, temporary, and read-only filesystems
     MOUNT_POINTS=$(findmnt -n -l -o TARGET -t xfs,ext4,ext3,ext2,btrfs)

     logger "SAP HANA Full VM BYOS: Starting pre-snapshot script for $DBSID."

     # 2. QUIESCE DATABASE (Create SAP HANA Snapshot)
     logger "SAP HANA Full VM BYOS: Creating database snapshot..."

     # Determine HANA Version
     # Versions 2.0+ use 'FOR FULL SYSTEM' syntax
     HANAVERSION=$(su - $DBADM -c "HDB version" | grep "version:" | awk '{print $2}' | cut -d'.' -f1)

     if [ "$HANAVERSION" = "1" ]; then
         SQL="BACKUP DATA CREATE SNAPSHOT COMMENT 'SNAPSHOT_$(date +%Y%m%d)'"
     else
         SQL="BACKUP DATA FOR FULL SYSTEM CREATE SNAPSHOT COMMENT 'SNAPSHOT_$(date +%Y%m%d)'"
     fi

     # Execute the snapshot command via hdbsql
     su - $DBADM -c "hdbsql -j -U $HDB_KEY \"$SQL\""
     if [ $? -ne 0 ]; then
         logger "Error: Failed to create SAP HANA snapshot."
         exit 1
     fi

     # Retrieve the BACKUP_ID for the prepared snapshot
     ID=$(su - $DBADM -c "hdbsql -j -t -U $HDB_KEY \"SELECT BACKUP_ID FROM M_BACKUP_CATALOG WHERE STATE_NAME = 'prepared' ORDER BY SYS_START_TIME DESC\"" | head -n 2 | tr -d '"' | tail -n 1)

     if [ -z "$ID" ]; then
         logger "Error: Could not retrieve BACKUP_ID for prepared snapshot."
         exit 1
     fi

     echo "$ID" > "$ID_FILE"
     logger "SAP HANA Full VM BYOS: Database snapshot prepared with ID $ID."
 fi

Script pós-snapshot (/etc/google/snapshots/post.sh)

 #!/bin/bash
 # Location: /etc/google/snapshots/post.sh

 DISK_ARG="$1"

 # 1. Configuration & Discovery
 DBSID="DBSID"
 DBADM="DBADM"
 ID_FILE="/tmp/hana_snapshot_id_$DBSID"
 HDB_KEY="HDB_KEY"

 if [[ "$DISK_ARG" == "," ]] || [[ "$DISK_ARG" == "1/0" ]] || [[ "$DISK_ARG" == "sda" ]]; then
     # Discover all local writeable mount points to perform unfreeze
     MOUNT_POINTS=$(findmnt -n -l -o TARGET -t xfs,ext4,ext3,ext2,btrfs)

     logger "SAP HANA Full VM BYOS: Starting post-snapshot script for $DBSID."

     # 3. RESUME DATABASE (Close SAP HANA Snapshot)
     if [ -f "$ID_FILE" ]; then
         ID=$(cat "$ID_FILE")
         logger "SAP HANA Full VM BYOS: Closing database snapshot ID $ID..."

         # Determine HANA version for correct syntax
         HANAVERSION=$(su - $DBADM -c "HDB version" | grep "version:" | awk '{print $2}' | cut -d'.' -f1)

         if [ "$HANAVERSION" = "1" ]; then
             SQL="BACKUP DATA CLOSE SNAPSHOT BACKUP_ID $ID SUCCESSFUL 'SNAPSHOT_COMPLETED'"
         else
             SQL="BACKUP DATA FOR FULL SYSTEM CLOSE SNAPSHOT BACKUP_ID $ID SUCCESSFUL 'SNAPSHOT_COMPLETED'"
         fi

         # Execute the close snapshot command
         RESULT=$(su - $DBADM -c "hdbsql -j -U $HDB_KEY \"$SQL\"")
         if [ $? -ne 0 ]; then
             logger "Error: Failed to close SAP HANA snapshot. $RESULT"
         else
             logger "SAP HANA Full VM BYOS: Database snapshot closed successfully."
         fi

         # Cleanup the temporary ID file
         rm -f "$ID_FILE"
     else
         logger "Error: Snapshot ID file not found. Manual intervention required to close HANA snapshot."
     fi

     logger "SAP HANA Full VM BYOS: Cleanup complete."

 else
     MOUNT_POINTS="/hanabackup"

     for mnt in $MOUNT_POINTS; do
         sudo fsfreeze -u "$mnt"
         logger "Filesystem $mnt is unfrozen."
     done
 fi

Substitua:

DBSID: o identificador do sistema SAP HANA (SID) em letras maiúsculas.
DBADM: o usuário do SO do administrador do SAP HANA (como <sid>adm).
HDB_KEY: a chave do usuário do SAP HANA configurada para acesso ao banco de dados.

SAP ASE

Script pré-snapshot (/etc/google/snapshots/pre.sh)

 #!/bin/bash
 # Location: /etc/google/snapshots/pre.sh
 # 1. Configuration
 OSUSER="OS_USER"
 SYB_SERVER="SYB_SERVER_NAME"
 SYB_USER="SYB_USER"
 SYB_PASS="SYB_PASSWORD"
 SYB_DBLIST="DATABASE_LIST"
 TAG_NAME="SNAPSHOT_$(date +%Y%m%d)"
 MANIFEST_DIR="/var/tmp/sybase_manifests" # Directory for manifest files
 # 2. Discovery
 # Dynamically discover local writeable mount points
 MOUNT_POINTS=$(findmnt -n -l -o TARGET -t xfs,ext4,ext3,ext2,btrfs)

 logger "Sybase Full VM BYOS: Starting pre-snapshot script."
 # 3. QUIESCE DATABASE
 mkdir -p "$MANIFEST_DIR"
 chown $OSUSER "$MANIFEST_DIR"

 logger "Sybase Full VM BYOS: Quiescing databases: $SYB_DBLIST..."
 # Command logic from act_sybase_pre.sh
 # We use 'hold' to suspend activity and create the manifest file
 su - $OSUSER -c "isql -U$SYB_USER -P$SYB_PASS -S$SYB_SERVER -X --retserverror" <<EOF
 quiesce database $TAG_NAME hold $SYB_DBLIST for external dump to '$MANIFEST_DIR/manifest_$TAG_NAME.dat' with override
 go
 exit
 EOF
 if [ $? -ne 0 ]; then
     logger "Error: Failed to quiesce Sybase databases."
     exit 1
 fi
 # 4. FREEZE FILESYSTEMS (Optional)
 for mnt in $MOUNT_POINTS; do
     if ! sudo fsfreeze -f "$mnt"; then
         logger "Error: Failed to freeze $mnt."
         # Attempt emergency thaw
         for thaw_mnt in $MOUNT_POINTS; do sudo fsfreeze -u "$thaw_mnt" 2>/dev/null; done
         # Release the database quiesce
         su - $OSUSER -c "isql -U$SYB_USER -P$SYB_PASS -S$SYB_SERVER -X" <<EOF
         quiesce database $TAG_NAME release
         go
         exit
 EOF
         exit 1
     fi
     logger "Filesystem $mnt is frozen."
 done

Script pós-snapshot (/etc/google/snapshots/post.sh)

 #!/bin/bash
 # Location: /etc/google/snapshots/post.sh

 # 1. Configuration
 OSUSER="OS_USER"
 SYB_SERVER="SYB_SERVER_NAME"
 SYB_USER="SYB_USER"
 SYB_PASS="SYB_PASSWORD"
 TAG_NAME="SNAPSHOT_$(date +%Y%m%d)"
 MANIFEST_DIR="/var/tmp/sybase_manifests"

 # 2. Discovery
 MOUNT_POINTS=$(findmnt -n -l -o TARGET -t xfs,ext4,ext3,ext2,btrfs)

 logger "Sybase Full VM BYOS: Starting post-snapshot script."

 # 3. UNFREEZE FILESYSTEMS (Optional)
 for mnt in $MOUNT_POINTS; do
     sudo fsfreeze -u "$mnt"
     logger "Filesystem $mnt is unfrozen."
 done

 # 4. RESUME DATABASE
 logger "Sybase Full VM BYOS: Releasing databases for tag $TAG_NAME..."

 # Command logic from act_sybase_post.sh
 su - $OSUSER -c "isql -U$SYB_USER -P$SYB_PASS -S$SYB_SERVER -X" <<EOF
 use master
 go
 quiesce database $TAG_NAME release
 go
 exit
 EOF

 if [ $? -ne 0 ]; then
     logger "Error: Failed to release Sybase databases."
 else
     logger "Sybase Full VM BYOS: Databases released successfully."
     # Cleanup manifest
     rm -f "$MANIFEST_DIR/manifest_$TAG_NAME.dat"
 fi

 logger "Sybase Full VM BYOS: Cleanup complete."

Substitua:

OS_USER: o usuário do sistema operacional que executa o SAP ASE (como sybase).
SYB_SERVER_NAME: o nome do servidor SAP ASE.
SYB_USER: o usuário do banco de dados com permissões para inativar bancos de dados.
SYB_PASSWORD: a senha do usuário do banco de dados (ou busque dinamicamente com o Secret Manager).
DATABASE_LIST: uma lista separada por vírgulas de bancos de dados a serem inativados.

SAP IQ

Script pré-snapshot (/etc/google/snapshots/pre.sh)

 #!/bin/bash
 # Location: /etc/google/snapshots/pre.sh

 # 1. Configuration
 OSUSER="OS_USER"
 DB_NAME="DB_NAME"
 CONN_STR="uid=DB_USER;pwd=DB_PASSWORD;dbn=$DB_NAME;eng=ENGINE_NAME"
 BKP_DIR="/var/tmp/sybaseiq_bkp"
 FULL_BKP_FILE="$BKP_DIR/FULL_VIR_DEC"

 # 2. Discovery
 # Dynamically discover all local writeable mount points for full VM consistency
 MOUNT_POINTS=$(findmnt -n -l -o TARGET -t xfs,ext4,ext3,ext2,btrfs)

 logger "SybaseIQ Full VM BYOS: Starting pre-snapshot script."

 # 3. QUIESCE DATABASE (Virtual Decoupled Backup)
 mkdir -p "$BKP_DIR"
 chown $OSUSER "$BKP_DIR"

 logger "SybaseIQ Full VM BYOS: Preparing virtual decoupled backup..."

 # Execute the quiesce command logic from act_sybaseiq_pre.sh
 su -m $OSUSER -c "dbisql -nogui -c '$CONN_STR' \"BACKUP DATABASE FULL VIRTUAL DECOUPLED TO '$FULL_BKP_FILE'\""

 if [ $? -ne 0 ]; then
     logger "Error: Failed to freeze (not able to take full_vir_dec backup)."
     exit 1
 fi

 # 4. FREEZE FILESYSTEMS (Optional)
 for mnt in $MOUNT_POINTS; do
     if ! sudo fsfreeze -f "$mnt"; then
         logger "Error: Failed to freeze $mnt."
         # Attempt emergency thaw
         for thaw_mnt in $MOUNT_POINTS; do sudo fsfreeze -u "$thaw_mnt" 2>/dev/null; done
         # Cleanup quiesce file as backup is invalid
         rm -f "$FULL_BKP_FILE"
         exit 1
     fi
     logger "Filesystem $mnt is frozen."
 done

Script pós-snapshot (/etc/google/snapshots/post.sh)

 #!/bin/bash
 # Location: /etc/google/snapshots/post.sh
 # 1. Configuration
 OSUSER="OS_USER"
 DB_NAME="DB_NAME"
 CONN_STR="uid=DB_USER;pwd=DB_PASSWORD;dbn=$DB_NAME;eng=ENGINE_NAME"
 BKP_DIR="/var/tmp/sybaseiq_bkp"
 FULL_BKP_FILE="$BKP_DIR/FULL_VIR_DEC"
 INC_BKP_FILE="$BKP_DIR/INC_BKP"
 # 2. Discovery
 MOUNT_POINTS=$(findmnt -n -l -o TARGET -t xfs,ext4,ext3,ext2,btrfs)
 logger "SybaseIQ Full VM BYOS: Starting post-snapshot script."
 # 3. UNFREEZE FILESYSTEMS (Optional)
 for mnt in $MOUNT_POINTS; do
     sudo fsfreeze -u "$mnt"
     logger "Filesystem $mnt is unfrozen."
 done
 # 4. RESUME DATABASE (Post-Snapshot Cleanup)
 logger "SybaseIQ Full VM BYOS: Performing incremental since full backup..."
 # Logic from act_sybaseiq_post.sh to finish the decoupled sequence
 su -m $OSUSER -c "dbisql -nogui -c '$CONN_STR' \"BACKUP DATABASE INCREMENTAL SINCE FULL TO '$INC_BKP_FILE'\""
 if [ $? -ne 0 ]; then
     logger "Error: Failed post-quiesce incremental backup."
 fi
 # Remove temporary files created during quiesce
 rm -f "$FULL_BKP_FILE"*
 logger "SybaseIQ Full VM BYOS: Cleanup complete."

Substitua:

OS_USER: o usuário do sistema operacional que executa o SAP IQ (como sybiq).
DB_NAME: o nome do banco de dados SAP IQ.
DB_USER: o usuário do banco de dados com privilégios de DBA.
DB_PASSWORD: a senha do usuário do banco de dados (ou busque dinamicamente com o Secret Manager).
ENGINE_NAME: o nome do mecanismo de banco de dados SAP IQ.

SAP MaxDB

Script pré-snapshot (/etc/google/snapshots/pre.sh)

 #!/bin/bash
 # Location: /etc/google/snapshots/pre.sh

 # 1. Configuration
 DBSID="DBSID"
 OSUSER="OS_USER"
 MAXDB_KEY="-user DBM_USER,DBM_PASSWORD"
 AUTOLOG_TMPLT="LOG_BACKUP"

 # 2. Discovery
 # Dynamically discover all local writeable mount points for full VM consistency
 MOUNT_POINTS=$(findmnt -n -l -o TARGET -t xfs,ext4,ext3,ext2,btrfs)

 logger "MaxDB Full VM BYOS: Starting pre-snapshot script for $DBSID."

 # 3. QUIESCE DATABASE
 # Optional: Trigger a log backup first to ensure point-in-time recovery readiness
 logger "MaxDB Full VM BYOS: Triggering log backup..."
 su -m $OSUSER -c "dbmcli -d $DBSID $MAXDB_KEY -uUTL -c backup_start $AUTOLOG_TMPLT LOG"

 # Suspend logwriter to quiesce the database
 logger "MaxDB Full VM BYOS: Suspending logwriter..."
 su -m $OSUSER -c "dbmcli -d $DBSID $MAXDB_KEY -uUTL -c util_execute suspend logwriter"
 if [ $? -ne 0 ]; then
     logger "Error: Failed to suspend MaxDB logwriter."
     exit 1
 fi

 # 4. FREEZE FILESYSTEMS (Optional)
 for mnt in $MOUNT_POINTS; do
     if ! sudo fsfreeze -f "$mnt"; then
         logger "Error: Failed to freeze $mnt."
         # Attempt emergency thaw
         for thaw_mnt in $MOUNT_POINTS; do sudo fsfreeze -u "$thaw_mnt" 2>/dev/null; done
         # Resume the logwriter as the backup is no longer consistent
         su -m $OSUSER -c "dbmcli -d $DBSID $MAXDB_KEY -uUTL -c util_execute resume logwriter"
         exit 1
     fi
     logger "Filesystem $mnt is frozen."
 done

Script pós-snapshot (/etc/google/snapshots/post.sh)

 #!/bin/bash
 # Location: /etc/google/snapshots/post.sh

 # 1. Configuration
 DBSID="DBSID"
 OSUSER="OS_USER"
 MAXDB_KEY="-user DBM_USER,DBM_PASSWORD"

 # 2. Discovery
 MOUNT_POINTS=$(findmnt -n -l -o TARGET -t xfs,ext4,ext3,ext2,btrfs)

 logger "MaxDB Full VM BYOS: Starting post-snapshot script for $DBSID."

 # 3. UNFREEZE FILESYSTEMS (Optional)
 for mnt in $MOUNT_POINTS; do
     sudo fsfreeze -u "$mnt"
     logger "Filesystem $mnt is unfrozen."
 done

 # 4. RESUME DATABASE
 logger "MaxDB Full VM BYOS: Resuming logwriter..."
 su -m $OSUSER -c "dbmcli -d $DBSID $MAXDB_KEY -uUTL -c util_execute resume logwriter"
 if [ $? -ne 0 ]; then
     logger "Error: Failed to resume MaxDB logwriter."
 else
     logger "MaxDB Full VM BYOS: Logwriter resumed successfully."
 fi

 logger "MaxDB Full VM BYOS: Cleanup complete."

Substitua:

DBSID: o identificador do sistema SAP MaxDB (SID) em letras maiúsculas.
OS_USER: o usuário do sistema operacional que executa o MaxDB (como sdba).
DBM_USER: o usuário do gerenciador de banco de dados (DBM, na sigla em inglês).
DBM_PASSWORD: a senha do usuário do DBM (ou use uma chave DBM armazenada: -k KEY_NAME).

PostgreSQL

Script pré-snapshot (/etc/google/snapshots/pre.sh)

 #!/bin/bash
 # 1. Configuration
 OSUSER="OS_USER"
 PG_HOME="PG_HOME"
 DBUSER="DB_USER"
 PORT=PORT_NUMBER
 DBNAME="DB_NAME"
 FIFO="/tmp/pg_backup_fifo_$PORT"
 PID_FILE="/tmp/pg_backup_pid_$PORT"
 ACT_JOBNAME="SNAPSHOT_$(date +%Y%m%d%H%M%S)"

 # 2. Discovery
 MOUNT_POINTS=$(findmnt -n -l -o TARGET -t xfs,ext4,ext3,ext2,btrfs)
 export PATH=$PG_HOME/bin:$PATH

 logger "PostgreSQL Full VM BYOS: Starting pre-snapshot script."

 # 3. QUIESCE DATABASE (Session-Bound)
 rm -f "$FIFO"
 mkfifo "$FIFO"
 chown "$OSUSER" "$FIFO"

 su "$OSUSER" -c "psql -p $PORT -U $DBUSER -d $DBNAME -f $FIFO" > /tmp/pg_backup_output.log 2>&1 &
 echo $! > "$PID_FILE"

 psql_version=$(su "$OSUSER" -c "psql --version" | awk '{print $3}' | cut -d'.' -f1)
 if [ "$psql_version" -ge 15 ]; then
     CMD="SELECT pg_backup_start('$ACT_JOBNAME');"
 else
     CMD="SELECT pg_start_backup('$ACT_JOBNAME');"
 fi

 echo "$CMD" > "$FIFO"
 sleep 2

 # 4. FREEZE FILESYSTEMS (Optional)
 for mnt in $MOUNT_POINTS; do
     if ! sudo fsfreeze -f "$mnt"; then
         logger "Error: Failed to freeze $mnt. Cleaning up..."
         for thaw_mnt in $MOUNT_POINTS; do sudo fsfreeze -u "$thaw_mnt" 2>/dev/null; done
         echo "SELECT pg_backup_stop(); exit;" > "$FIFO"
         rm -f "$FIFO" "$PID_FILE"
         exit 1
     fi
     logger "Filesystem $mnt is frozen."
 done

Script pós-snapshot (/etc/google/snapshots/post.sh)

 #!/bin/bash
 PORT=PORT_NUMBER
 FIFO="/tmp/pg_backup_fifo_$PORT"
 PID_FILE="/tmp/pg_backup_pid_$PORT"

 MOUNT_POINTS=$(findmnt -n -l -o TARGET -t xfs,ext4,ext3,ext2,btrfs)
 logger "PostgreSQL Full VM BYOS: Starting post-snapshot script."

 # 1. UNFREEZE FILESYSTEMS (Optional)
 for mnt in $MOUNT_POINTS; do
     sudo fsfreeze -u "$mnt"
     logger "Filesystem $mnt is unfrozen."
 done

 # 2. RESUME DATABASE (Close Session)
 if [ -p "$FIFO" ]; then
     logger "PostgreSQL Full VM BYOS: Closing backup session via FIFO..."
     echo "SELECT pg_backup_stop(); SELECT pg_stop_backup(); exit;" > "$FIFO"
     if [ -f "$PID_FILE" ]; then
         wait "$(cat "$PID_FILE")" 2>/dev/null
     fi
     rm -f "$FIFO" "$PID_FILE"
     logger "PostgreSQL Full VM BYOS: Database session closed."
 else
     logger "Error: FIFO not found. Session may have terminated unexpectedly."
 fi
 logger "PostgreSQL Full VM BYOS: Cleanup complete."

Substitua:

OS_USER: o usuário do sistema operacional que executa o PostgreSQL (como postgres).
PG_HOME: o caminho para o diretório de instalação do PostgreSQL.
DB_USER: o usuário do banco de dados PostgreSQL com privilégios de superusuário.
PORT_NUMBER: o número da porta em que o PostgreSQL escuta (padrão: 5432).
DB_NAME: o nome do banco de dados a ser conectado.

MySQL

Script pré-snapshot (/etc/google/snapshots/pre.sh)

 #!/bin/bash
 # 1. Configuration
 DBUSER="DB_USER"
 DBPASSWORD="DB_PASSWORD"
 PORTNO=PORT_NUMBER
 SOCKET_FILE="/var/run/mysqld/mysqld.sock"
 MYSQL_PATH="/usr/bin/mysql"
 FIFO="/tmp/mysql_backup_fifo_$PORTNO"
 PID_FILE="/tmp/mysql_backup_pid_$PORTNO"

 # 2. Discovery
 MOUNT_POINTS=$(findmnt -n -l -o TARGET -t xfs,ext4,ext3,ext2,btrfs)

 logger "MySQL Full VM BYOS: Starting pre-snapshot script."

 # 3. QUIESCE DATABASE (Session-Bound Lock)
 rm -f "$FIFO"
 mkfifo "$FIFO"

 $MYSQL_PATH -u"$DBUSER" -p"$DBPASSWORD" -S"$SOCKET_FILE" -P"$PORTNO" < "$FIFO" > /tmp/mysql_backup_output.log 2>&1 &
 echo $! > "$PID_FILE"

 logger "MySQL Full VM BYOS: Issuing FLUSH TABLES WITH READ LOCK..."
 echo "FLUSH TABLES WITH READ LOCK; SELECT SLEEP(86400);" > "$FIFO"
 sleep 2

 # 4. FREEZE FILESYSTEMS (Optional)
 for mnt in $MOUNT_POINTS; do
     if ! sudo fsfreeze -f "$mnt"; then
         logger "Error: Failed to freeze $mnt. Cleaning up..."
         for thaw_mnt in $MOUNT_POINTS; do sudo fsfreeze -u "$thaw_mnt" 2>/dev/null; done
         kill $(cat "$PID_FILE") 2>/dev/null
         rm -f "$FIFO" "$PID_FILE"
         exit 1
     fi
     logger "Filesystem $mnt is frozen."
 done

Script pós-snapshot (/etc/google/snapshots/post.sh)

 #!/bin/bash
 PORTNO=PORT_NUMBER
 FIFO="/tmp/mysql_backup_fifo_$PORTNO"
 PID_FILE="/tmp/mysql_backup_pid_$PORTNO"

 MOUNT_POINTS=$(findmnt -n -l -o TARGET -t xfs,ext4,ext3,ext2,btrfs)
 logger "MySQL Full VM BYOS: Starting post-snapshot script."

 # 1. UNFREEZE FILESYSTEMS (Optional)
 for mnt in $MOUNT_POINTS; do
     sudo fsfreeze -u "$mnt"
     logger "Filesystem $mnt is unfrozen."
 done

 # 2. RESUME DATABASE (Unlock)
 if [ -f "$PID_FILE" ]; then
     logger "MySQL Full VM BYOS: Releasing locks..."
     kill $(cat "$PID_FILE") 2>/dev/null
     rm -f "$FIFO" "$PID_FILE"
     logger "MySQL Full VM BYOS: Locks released and session closed."
 else
     logger "Error: PID file not found. Lock may have been lost prematurely."
 fi
 logger "MySQL Full VM BYOS: Cleanup complete."

Substitua:

DB_USER: o usuário do banco de dados MySQL com privilégios administrativos.
DB_PASSWORD: a senha do banco de dados MySQL (ou busque dinamicamente com o Secret Manager).
PORT_NUMBER: o número da porta em que o MySQL escuta (padrão: 3306).

MariaDB

Script pré-snapshot (/etc/google/snapshots/pre.sh)

 #!/bin/bash
 # Location: /etc/google/snapshots/pre.sh

 # 1. Configuration
 DBUSER="DB_USER"
 DBPASSWORD="DB_PASSWORD"
 PORTNO=PORT_NUMBER
 SOCKET_FILE="/var/run/mysqld/mysqld.sock"
 MARIADB_PATH="/usr/bin/mariadb" # or /usr/bin/mysql
 SRV_TYPE="Master" # Set to "Slave" for standby nodes
 FIFO="/tmp/mariadb_backup_fifo_$PORTNO"
 PID_FILE="/tmp/mariadb_backup_pid_$PORTNO"
 STARTPOS_FILE="/tmp/STARTPOS_FILE_$PORTNO.txt"

 # 2. Discovery
 # Dynamically discover all local writeable mount points for full VM consistency
 MOUNT_POINTS=$(findmnt -n -l -o TARGET -t xfs,ext4,ext3,ext2,btrfs)

 logger "MariaDB Full VM BYOS: Starting pre-snapshot script."

 # 3. QUIESCE DATABASE (Session-Bound)
 # Create a FIFO to hold the session open
 rm -f "$FIFO"
 mkfifo "$FIFO"

 # Start a background mariadb session that reads from the FIFO
 # This keeps the session (and locks) active until the process is killed
 $MARIADB_PATH -u"$DBUSER" -p"$DBPASSWORD" -S"$SOCKET_FILE" -P"$PORTNO" < "$FIFO" > /tmp/mariadb_backup_output.log 2>&1 &
 echo $! > "$PID_FILE"

 # Prepare quiesce query (Logic from act_mariadb_pre.sh)
 if [ "$SRV_TYPE" != "Slave" ]; then
     # Primary node: lock all tables
     logger "MariaDB Full VM BYOS: Issuing FLUSH TABLES WITH READ LOCK..."
     echo "FLUSH TABLES WITH READ LOCK; SELECT SLEEP(86400);" > "$FIFO"

     # Capture master status for PITR/replication info
     $MARIADB_PATH -u"$DBUSER" -p"$DBPASSWORD" -S"$SOCKET_FILE" -P"$PORTNO" -e "SHOW MASTER STATUS;" > "$STARTPOS_FILE"
 else
     # Replica node: stop the slave thread
     logger "MariaDB Full VM BYOS: Issuing STOP SLAVE..."
     echo "STOP SLAVE; SELECT SLEEP(86400);" > "$FIFO"

     # Capture slave status
     $MARIADB_PATH -u"$DBUSER" -p"$DBPASSWORD" -S"$SOCKET_FILE" -P"$PORTNO" -e "SHOW SLAVE STATUS \G;" > "$STARTPOS_FILE"
 fi

 # Wait a brief moment to ensure the command is processed
 sleep 2
 # 4. FREEZE FILESYSTEMS (Optional)
 for mnt in $MOUNT_POINTS; do
     if ! sudo fsfreeze -f "$mnt"; then
         logger "Error: Failed to freeze $mnt. Cleaning up..."
         # Attempt emergency thaw
         for thaw_mnt in $MOUNT_POINTS; do sudo fsfreeze -u "$thaw_mnt" 2>/dev/null; done
         # Kill the background session to release locks
         kill $(cat "$PID_FILE") 2>/dev/null
         rm -f "$FIFO" "$PID_FILE"
         exit 1
     fi
     logger "Filesystem $mnt is frozen."
 done

Script pós-snapshot (/etc/google/snapshots/post.sh)

 #!/bin/bash
 # Location: /etc/google/snapshots/post.sh
 # 1. Configuration
 PORTNO=PORT_NUMBER
 SRV_TYPE="Master"
 DBUSER="DB_USER"
 DBPASSWORD="DB_PASSWORD"
 SOCKET_FILE="/var/run/mysqld/mysqld.sock"
 MARIADB_PATH="/usr/bin/mariadb"
 FIFO="/tmp/mariadb_backup_fifo_$PORTNO"
 PID_FILE="/tmp/mariadb_backup_pid_$PORTNO"
 # 2. Discovery
 MOUNT_POINTS=$(findmnt -n -l -o TARGET -t xfs,ext4,ext3,ext2,btrfs)
 logger "MariaDB Full VM BYOS: Starting post-snapshot script."
 # 3. UNFREEZE FILESYSTEMS (Optional)
 for mnt in $MOUNT_POINTS; do
     sudo fsfreeze -u "$mnt"
     logger "Filesystem $mnt is unfrozen."
 done
 # 4. RESUME DATABASE
 if [ -f "$PID_FILE" ]; then
     logger "MariaDB Full VM BYOS: Resuming database operations..."
     # Kill the background sleep process to automatically release session-bound locks
     kill $(cat "$PID_FILE") 2>/dev/null
     # For slave nodes, explicitly ensure replication is started
     if [ "$SRV_TYPE" = "Slave" ]; then
         $MARIADB_PATH -u"$DBUSER" -p"$DBPASSWORD" -S"$SOCKET_FILE" -P"$PORTNO" -e "START SLAVE;"
     fi
     rm -f "$FIFO" "$PID_FILE"
     logger "MariaDB Full VM BYOS: Cleanup complete."
 else
     logger "Error: PID file not found. Database state might be inconsistent."
 fi

Substitua:

DB_USER: o usuário do banco de dados MariaDB com privilégios administrativos.
DB_PASSWORD: a senha do banco de dados MariaDB (ou busque dinamicamente com o Secret Manager).
PORT_NUMBER: o número da porta em que o MariaDB escuta (padrão: 3306).

Implantar scripts de limpeza do convidado

Depois de preparar os scripts pre.sh e post.sh para o banco de dados, implante-os na instância de VM do Linux:

Conecte-se à instância de VM do Linux que executa o banco de dados autogerenciado usando SSH.
Crie o diretório /etc/google/snapshots/ se ele ainda não existir:
```
sudo mkdir -p /etc/google/snapshots
```
Salve os scripts pre.sh e post.sh personalizados no diretório /etc/google/snapshots/ na instância de VM.

Verifique se os scripts têm permissões de execução:

sudo chmod 755 /etc/google/snapshots/pre.sh /etc/google/snapshots/post.sh

Ativar o agente convidado para snapshots

Para permitir que o Backup e DR execute scripts pré-snapshot e pós-snapshot, ative a integração de snapshots no ambiente de convidado do Compute Engine na instância de VM do Linux:

Conecte-se à instância de VM do Linux que executa o banco de dados autogerenciado usando SSH (se ainda não estiver conectado).
Abra o arquivo de configuração do ambiente de convidado em um editor de texto:
```
sudo nano /etc/default/instance_configs.cfg
```
Adicione ou modifique as seguintes configurações na seção [Snapshots] para ativar snapshots:
```
[Snapshots]
enabled = true
timeout_in_seconds = 120
```
Observação:o parâmetro timeout_in_seconds especifica o tempo máximo que o agente convidado espera que os scripts pre.sh e post.sh terminem. Ajuste esse valor para acomodar a duração das operações de inativação do banco de dados ou de congelamento do sistema de arquivos.
Reinicie o agente convidado na instância de VM para aplicar as mudanças:
```
sudo systemctl restart google-guest-agent
```

Configurar o plano de backup

Agora que a instância de VM está configurada com os scripts de limpeza do convidado e o agente convidado está ativado para snapshots, configure um plano de backup no Google Cloud console:

No Google Cloud console, acesse a página Backup e DR.

Acessar o Backup e DR
No menu de navegação, selecione Planos de backup.
Clique em Criar plano de backup ou selecione um plano de backup e clique em Editar.
Nas etapas de configuração do Backup de instâncias, localize as opções de consistência.
Selecione a opção Ativar consistência do aplicativo.
Salve e aplique o plano de backup à instância de VM. Na programação, o plano de backup aciona o agente convidado para executar o script pre.sh, fazer o snapshot e executar o script post.sh.

Configurar o backup do Persistent Disk para recuperação pontual do banco de dados

Para bancos de dados autogerenciados, como Db2 e SAP HANA, é possível configurar backups de Persistent Disk independentes para capturar registros de arquivo de banco de dados, permitindo a recuperação pontual. Se você não precisar de recuperação pontual, pule para Desativar scripts de limpeza do convidado.

Práticas recomendadas para backups de registro de recuperação pontual

Frequência:configure a programação do plano de backup para que esse disco de registro dedicado seja igual à granularidade do registro de recuperação pontual, por exemplo, a cada 15 minutos ou por hora.
Otimização de custos:o armazenamento de snapshots frequentes pode aumentar os custos de armazenamento. Para minimizar a sobrecarga, configure o período mínimo de retenção e o período do vault de imutabilidade correspondente para o tempo mínimo permitido que ainda satisfaça a janela de recuperação pontual.

Recuperar um banco de dados autogerenciado para um momento específico

Se você configurou backups de VM regulares com backups de registro Persistent Disk dedicados, siga este procedimento para restaurar o banco de dados para um momento específico. Se você não configurou backups de registro dedicados ou não precisa de recuperação pontual, consulte Restaurar uma instância do Compute Engine de um vault de backup para restaurar a VM diretamente e pule para Realizar tarefas pós-restauração.

Fluxo de trabalho de recuperação

Restaurar a VM de base: selecione o backup da instância (imagem de máquina) do vault de backup que precede o tempo de recuperação de destino. Restaure-o seguindo os procedimentos padrão de restauração do Compute Engine. Para instruções, consulte Restaurar uma instância do Compute Engine de um vault de backup.

Se você não configurou backups de registro dedicados ou não precisa de recuperação pontual, pule para a etapa 4.
Anexar discos de registro: identifique e restaure os snapshots de disco de registro relevantes capturados até o tempo de recuperação de destino. Anexe esses discos recém-criados à instância restaurada.

Observação: é possível restaurar o disco permanente usando o Google Cloud console ou a CLI gcloud durante o procedimento de reversão. Talvez seja necessário montar vários discos de backup de registro para garantir que todos os registros arquivados essenciais estejam disponíveis.
Reverter o banco de dados: conecte-se à instância restaurada usando SSH e execute o comando de reversão específico do banco de dados, como ROLLFORWARD DATABASE no Db2, usando os registros localizados nos discos permanentes recém-anexados.
Realizar tarefas pós-restauração: execute as etapas específicas do banco de dados necessárias para colocar o aplicativo on-line.

Cuidado:verifique se as configurações do banco de dados foram atualizadas se o nome da VM restaurada ou os caminhos de disco anexados forem diferentes do ambiente de origem.

Desativar scripts de limpeza do convidado

Para remover os scripts de limpeza do convidado personalizados e desativar a consistência do aplicativo:

Desvincule o plano de backup da instância: no Google Cloud console, acesse a página Backup e DR, localize a instância de VM em Recursos protegidos e desvincule ou exclua a associação do plano de backup.
Remova os scripts de limpeza do convidado: conecte-se à instância de VM do Linux usando SSH e remova os scripts de limpeza do convidado personalizados:
```
sudo rm -f /etc/google/snapshots/pre.sh /etc/google/snapshots/post.sh
```
Desative a integração de snapshots no agente convidado: abra /etc/default/instance_configs.cfg na instância de VM, defina enabled = false em [Snapshots], e reinicie o agente convidado:
```
sudo systemctl restart google-guest-agent
```

Configurar backups consistentes com aplicativos Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Antes de começar

Funções exigidas

Pré-requisitos

Usar o framework de limpeza do convidado "traga seu próprio script" (BYOS, na sigla em inglês)

Opcional: congelar e descongelar sistemas de arquivos

Adicionar instruções de congelamento do sistema de arquivos ao pre.sh

Adicionar instruções de descongelamento do sistema de arquivos ao post.sh

Buscar credenciais dinamicamente com o Secret Manager

Analisar scripts de amostra por tipo de banco de dados

IBM Db2

Oracle

SAP HANA

SAP ASE

SAP IQ

SAP MaxDB

PostgreSQL

MySQL

MariaDB

Implantar scripts de limpeza do convidado

Ativar o agente convidado para snapshots

Configurar o plano de backup

Configurar o backup do Persistent Disk para recuperação pontual do banco de dados

Práticas recomendadas para backups de registro de recuperação pontual

Recuperar um banco de dados autogerenciado para um momento específico

Fluxo de trabalho de recuperação

Desativar scripts de limpeza do convidado

A seguir

Configurar backups consistentes com aplicativos