Utilisation des fonctionnalités RunBefore et RunAfter à l’aide de l’outil Azure Application Consistent Snapshot

Article
02/25/2025

Cet article sert de guide pour utiliser les fonctionnalités --runbefore et --runafter de l’outil Azure Application Consistent Snapshot, que vous pouvez utiliser avec Azure NetApp Files.

Introduction

AzAcSnap peut exécuter des commandes externes avant ou après son exécution principale en utilisant respectivement les options --runbefore ou --runafter.

--runbefore exécute une commande shell avant l’exécution principale d’azacsnap et fournit quelques-uns des paramètres de ligne de commande azacsnap à l’environnement de l’interpréteur de commandes. Par défaut, azacsnap attend jusqu’à 30 secondes pour que la commande d’interpréteur de commandes externe se termine avant de tuer le processus et de revenir à l’exécution normale d’azacsnap. Ce retard peut être modifié en ajoutant un nombre de secondes d’attente après un caractère % (par exemple, --runbefore "mycommand.sh%60" permet de patienter jusqu’à 60 secondes pour que mycommand.sh se termine).

--runafter exécute une commande shell après l’exécution principale d’azacsnap et fournit certains paramètres de ligne de commande azacsnap à l’environnement de l’interpréteur de commandes. Par défaut, azacsnap attend jusqu’à 30 secondes pour que la commande d’interpréteur de commandes externe se termine avant de tuer le processus et de revenir à l’exécution normale d’azacsnap. Ce délai peut être remplacé en ajoutant un nombre à attendre en secondes après un % caractère (par exemple, --runafter "mycommand.sh%60" attend jusqu’à 60 secondes pour terminer mycommand.sh ).

azacsnap génère la liste suivante de variables d’environnement et les transmet au forked shell pour exécuter les commandes fournies en tant que paramètres et --runbefore--runafter:

$azCommand = option de commande passée à -c (par exemple, backup, test, etc.).
$azConfigFileName = nom de fichier de configuration.
$azPrefix = valeur --prefix.
$azRetention = valeur --retention.
$azSid = valeur --dbsid.
$azSnapshotName = nom d’instantané généré par azacsnap.

Remarque

Il existe uniquement une valeur pour $azSnapshotName dans l’option --runafter.

Exemple d’utilisation pour sauvegarder dans le stockage Blob Azure

Important

Les exemples sont fournis uniquement à des fins d’information. Nous ne garantissons pas l’exactitude, l’exhaustivité ou l’utilité des informations fournies. L’utilisation de ces exemples est à votre propre risque. Nous n’acceptons aucune responsabilité pour toute perte ou dommages qui peuvent provenir de l’utilisation de ces exemples. Nous n’offrons pas de prise en charge des exemples fournis dans cette documentation.

Par exemple, l’utilisation de cette nouvelle fonctionnalité consiste à charger un instantané dans Azure Blob à des fins d’archivage à l’aide de l’outil azcopy (Copier ou déplacer des données vers Stockage Azure à l’aide d’AzCopy).

Script Shell à charger dans stockage Blob Azure

Cet exemple de script shell a une sanza spéciale à la fin pour empêcher AzAcSnap de tuer la commande externe en raison du délai d’attente décrit précédemment. Cette sanza permet d’exécuter une commande longue, telle que le chargement de fichiers volumineux avec azcopy, sans être arrêtée prématurément.

Les instantanés ont besoin d’être montés sur le système qui effectue la copie, avec au minimum des privilèges d’accès en lecture seule. L’emplacement de base du point de montage pour les instantanés doit être fourni à la variable sourceDir dans le script.

L’instantané est chargé en tant que fichier unique à l’aide de la tar commande pour créer un tarball gzipped. Le fait de placer les fichiers dans une seule tarball conserve les autorisations et la propriété des fichiers, sinon le chargement des fichiers perd individuellement ces attributs.

cat snapshot-to-blob.sh

#!/bin/bash
# Utility to upload-to/list Azure Blob store.
#   If run as snapshot-to-blob.sh will upload a gzipped tarball of the snapshot.
#   If run as list-blobs.sh will list uploaded blobs.
#     e.g. `ln -s snapshot-to-blob.sh list-blobs.sh`


# _START_ Change these
SAS_KEY_FILE="${HOME}/bin/blob-credentials.saskey"
# the snapshots need to be mounted locally for copying, put source directory here
SOURCE_DIR="/mnt/saphana1/hana_data_PR1/.snapshot"
# _END_ Change these


# _START_ AzCopy Settings
#Overrides where the job plan files (used for progress tracking and resuming) are stored, to avoid filling up a disk.
export AZCOPY_JOB_PLAN_LOCATION="${HOME}/.azcopy/plans/"
#Overrides where the log files are stored, to avoid filling up a disk.
export AZCOPY_LOG_LOCATION="${HOME}/.azcopy/logs/"
#If set, to anything, on-screen output will include counts of chunks by state
export AZCOPY_SHOW_PERF_STATES=true
# _END_ AzCopy Settings


# do not change any of the following


# Make sure we got some command line args
if [ "$(basename "$0")" = "snapshot-to-blob.sh" ] && ([ "$1" = "" ] || [ "$2" = "" ]); then
  echo "Usage: $0 <SNAPSHOT_NAME> <PREFIX>"
  exit 1
fi

# Make sure we can read the SAS key credential file.
if [ -r "${SAS_KEY_FILE}" ]; then
  source "${SAS_KEY_FILE}"
else
  echo "Credential file '${SAS_KEY_FILE}' not found, exiting!"
fi


# Assign the rest of the Global variables.
SNAPSHOT_NAME=$1
PREFIX=$2
BLOB_STORE="$(echo "${PORTAL_GENERATED_SAS}" | cut -f1 -d'?')"
BLOB_SAS_KEY="$(echo "${PORTAL_GENERATED_SAS}" | cut -f2 -d'?')"
ARCHIVE_LOG="logs/$(basename "$0").log"

# Archive naming (daily.1, daily.2, etc...)
DAY_OF_WEEK=$(date "+%u")
MONTH_OF_YEAR=$(date "+%m")
ARCHIVE_BLOB_TGZ="${PREFIX}.${DAY_OF_WEEK}.tgz"

#######################################
# Write to the log.
# Globals:
#   None
# Arguments:
#   LOG_MSG
#######################################
write_log(){
  LOG_MSG=$1
  date=$(date "+[%d/%h/%Y:%H:%M:%S %z]")
  echo "$date ${LOG_MSG}" >> "${ARCHIVE_LOG}"
}


#######################################
# Run and Log the command.
# Globals:
#   None
# Arguments:
#   CMD_TO_RUN
#######################################
run_cmd(){
  CMD_TO_RUN="${1}"
  write_log "[RUNCMD] ${CMD_TO_RUN}"
  bash -c "${CMD_TO_RUN}"
}


#######################################
# Check snapshot exists and then background the upload to Blob store.
# Globals:
#   SOURCE_DIR
#   SNAPSHOT_NAME
#   ARCHIVE_LOG
# Arguments:
#   None
#######################################
snapshot_to_blob(){
  # Check SOURCE_DIR and SNAPSHOT_NAME exist
  if [ ! -d "${SOURCE_DIR}/${SNAPSHOT_NAME}" ]; then
    echo "${SOURCE_DIR}/${SNAPSHOT_NAME} not found, exiting!" | tee -a "${ARCHIVE_LOG}"
    exit 1
  fi
  # background ourselves so AzAcSnap exits cleanly
  echo "Backgrounding '$0 $@' to prevent blocking azacsnap"
  echo "write_logging to ${ARCHIVE_LOG}"
  {
    trap '' HUP
    # the script
    upload_to_blob
    list_blob >> "${ARCHIVE_LOG}"
  } < /dev/null > /dev/null 2>&1 &
}


#######################################
# Upload to Blob store.
# Globals:
#   SOURCE_DIR
#   SNAPSHOT_NAME
#   ARCHIVE_BLOB_TGZ
#   BLOB_STORE
#   BLOB_SAS_KEY
#   ARCHIVE_LOG
# Arguments:
#   None
#######################################
upload_to_blob(){
  # Copy snapshot to blob store
  echo "Starting upload of ${SNAPSHOT_NAME} to ${BLOB_STORE}/${ARCHIVE_BLOB_TGZ}" >> "${ARCHIVE_LOG}"
  run_cmd "azcopy env ; cd ${SOURCE_DIR}/${SNAPSHOT_NAME} && tar zcvf - * | azcopy cp \"${BLOB_STORE}/${ARCHIVE_BLOB_TGZ}?${BLOB_SAS_KEY}\" --from-to PipeBlob && cd -"
  echo "Completed upload of ${SNAPSHOT_NAME} ${BLOB_STORE}/${ARCHIVE_BLOB_TGZ}" >> "${ARCHIVE_LOG}"

  # Complete
  echo "Finished ($0 ${SNAPSHOT_NAME} ${PREFIX}) @ $(date "+%d-%h-%Y %H:%M")" >> "${ARCHIVE_LOG}"
  echo "--------------------------------------------------------------------------------" >> "${ARCHIVE_LOG}"
  # col 12345678901234567890123456789012345678901234567890123456789012345678901234567890
}


#######################################
# List contents of Blob store.
# Globals:
#   BLOB_STORE
#   BLOB_SAS_KEY
# Arguments:
#   None
#######################################
list_blob(){
  LOG_MSG="Current list of files stored in ${BLOB_STORE}"
  write_log "${LOG_MSG}"
  echo "${LOG_MSG}"
  run_cmd "azcopy list \"${BLOB_STORE}?${BLOB_SAS_KEY}\"  --properties LastModifiedTime "
}


# Log when script started.
write_log "Started ($0 ${SNAPSHOT_NAME} ${PREFIX}) @ $(date "+%d-%h-%Y %H:%M")"


# Check what this was called as ($0) and run accordingly.
case "$(basename "$0")" in
  "snapshot-to-blob.sh" )
    snapshot_to_blob
    ;;
  "list-blobs.sh" )
    list_blob
    ;;
  *)
    echo "Command '$0' not recognised!"
    ;;
esac

Le fichier saskey contient l’exemple de clé SAS suivant (contenu modifié pour des raisons de sécurité) :

cat blob-credentials.saskey

# we need a generated SAS key, get this from the portal with read,add,create,write,list permissions
PORTAL_GENERATED_SAS="https://<targetstorageaccount>.blob.core.windows.net/<blob-store>?sp=racwl&st=2021-06-10T21:10:38Z&se=2021-06-11T05:10:38Z&spr=https&sv=2020-02-10&sr=c&sig=<key-material>"

Planification du script shell

L’entrée crontab suivante est une seule ligne et s’exécute azacsnap à 12h05. Remarquez l’appel à snapshot-to-blob.sh qui passe le nom et le préfixe de l’instantané :

5 0 * * *         ( . ~/.bash_profile ; cd /home/azacsnap/bin ; ./azacsnap -c backup --volume data --prefix daily --retention 1 --configfile HANA.json --trim --ssl openssl --runafter 'env ; ./snapshot-to-blob.sh $azSnapshotName $azPrefix')

Restauration à partir du stockage Blob Azure

La restauration à partir de l’une de ces archives stockées dans le stockage Blob Azure à un niveau élevé est la suivante :

Copiez l’archive d’instantané sur l’ordinateur local. L’emplacement cible doit être séparé des fichiers de base de données et avec une capacité suffisante pour permettre l’archivage des fichiers et l’extraction, par exemple /var/tmp.
1. S’ils ont créé l’archive à l’aide de l’exemple --runafter de script shell, ils peuvent éventuellement extraire le tarball gzipped directement à partir du stockage Blob Azure à l’emplacement cible à l’aide d’un canal AzCopy pour extraire, par exemple :
  1. cd ${TARGET_DIRECTORY}
  2. azcopy cp "${BLOB_STORE}/${ARCHIVE_BLOB_TGZ}?${BLOB_SAS_KEY}" --from-to BlobPipe | tar zxvf -
Extrayez le contenu de l’archive d’instantanés.
Passez en revue le contenu de l’emplacement cible après l’extraction, en comparant les autorisations de fichier et la propriété aux fichiers de base de données d’origine.
1. Par exemple, procédez ls -lRcomme suit :
Arrêtez les processus du serveur de base de données.
Copiez les fichiers de l’emplacement cible restaurés à l’étape 1 vers leur emplacement d’origine.
Poursuivez avec le processus de récupération de base de données normal.

Partage via

Utilisation des fonctionnalités RunBefore et RunAfter à l’aide de l’outil Azure Application Consistent Snapshot

Introduction

Exemple d’utilisation pour sauvegarder dans le stockage Blob Azure

Script Shell à charger dans stockage Blob Azure

Planification du script shell

Restauration à partir du stockage Blob Azure

Étapes suivantes

Commentaires

Ressources supplémentaires