Couchbase Backup and Restore: A Quick How to Start Guide

En este artículo, obtendrás una visión general de cómo hacer copias de seguridad de las ediciones Couchbase Community y Enterprise en Ubuntu y cómo configurar una estrategia básica de copia de seguridad de Couchbase.

Las secuencias de comandos y técnicas descritas aquí no están listas para la producción, es posible que todavía tenga que hacer algunas mejoras de acuerdo a su entorno para que sea tolerante a fallos.

También le recomiendo encarecidamente que lea la documentación oficial a la que se hace referencia en este artículo, ya que muchos parámetros opcionales no se mencionan.

Recomendaciones generales

Máquinas de reserva

Aunque en clusters con un volumen de datos pequeño y un número reducido de nodos se podría incluso utilizar uno de los nodos para realizar copias de seguridad de los datos durante las horas de menor actividad, es muy recomendable ejecutar siempre las copias de seguridad en una máquina externa que funcione dentro de la misma red.

No subestime la cantidad de memoria y CPU necesaria para ejecutar procesos de copia de seguridad sanos. Compartir la misma máquina puede afectar al rendimiento de su clúster y también hacen que las copias de seguridad fallen cuando no hay suficientes recursos disponibles.

Si necesita reducir los costes de funcionamiento de un servidor adicional para las copias de seguridad, la mayoría de los proveedores de nube le permiten programar cuándo debe iniciarse una instancia y, a continuación, en su script de copia de seguridad, puede apagar la máquina una vez que todo haya terminado.

En Kubernetes, debería ser aún más fácil, ya que podría utilizar CronJobs para hacer prácticamente lo mismo o simplemente definir políticas de copia de seguridad si utiliza Couchbase Autonomous Operator.

Política de conservación

Tanto Incremental como acumulativo dependen de la última copia de seguridad completa. Por lo tanto, es importante recordar que no se pueden archivar copias de seguridad antiguas basándose únicamente en la fecha, sino que también hay que tener en cuenta sus dependencias.

Si tienes un SLA pequeño, también deberías plantearte dejar las últimas copias de seguridad en un almacenamiento en bloque de fácil acceso. Dependiendo del tamaño de tu base de datos y de la velocidad de la red, descargar datos de algún almacenamiento de objetos podría costarte unos minutos preciosos.

Pruebas de recuperación

Aunque es inviable probar todas y cada una de las copias de seguridad, es crucial contar con una estrategia recurrente de pruebas de copias de seguridad para comprobar su estado. Las copias de seguridad de prueba también te ayudan a familiarizarte con las herramientas de restauración de datos y a saber cuánto tiempo necesitarás para recuperar completamente la base de datos (dos cosas importantes que hay que saber cuando algo va mal).

Couchbase ya tiene internamente una serie de características que evitarán la pérdida de datos, por ejemplo, el número de réplicas para cada vBucket que se configura cuando creas el bucket por primera vez. Asumiendo que tu base de datos está correctamente configurada, los escenarios más probables en los que necesitarás recuperar la base de datos son :

Si pierde más nodos que el número de réplicas. (Por ejemplo, ha configurado 2 réplicas pero ha perdido 3 nodos a la vez).
Una operación que dejará inconsistente toda la base de datos (por ejemplo, se despliega una nueva versión de la aplicación con un error que actualiza/elimina un elevado número de registros ).

Preparación de la máquina de copia de seguridad

Si planea ejecutar sus copias de seguridad en una máquina dedicada, debe copiar el archivo papelera de su instalación de Couchbase a esta máquina, o simplemente instalar Couchbase en esta máquina también. Por ejemplo, en Ubuntu, debe ejecutar los siguientes comandos:

curl -O https://packages.couchbase.com/releases/couchbase-release/couchbase-release-1.0-amd64.deb
sudo dpkg -i ./couchbase-release-1.0-amd64.deb
sudo apt-get update

rizo -O https://paquetes.couchbase.com/libera/couchbase-liberar/couchbase-liberar-1.0-amd64.deb

sudo dpkg -i ./couchbase-liberar-1.0-amd64.deb

sudo apt-consiga actualización

A continuación, deberá ejecutar el siguiente comando según su versión de Couchbase:

Comunidad Couchbase:

sudo apt-get install couchbase-server-community

1	sudo apt-consiga instale couchbase-servidor-comunidad

Couchbase para empresas

sudo apt-get install couchbase-server

1	sudo apt-consiga instale couchbase-servidor

Después de esto, todos los archivos que necesitaremos para este artículo deberían estar bajo el directorio /opt/couchbase/bin carpeta ("/Aplicaciones/Couchbase Server.app/Contenidos/Recursos/couchbase-core/bin“ en Mac).

Para reducir los inconvenientes de referenciar el papelera en cada comando, te sugiero que lo añadas a la carpeta SENDERO o crear un enlace simbólico en la carpeta /usr/bin directorio:

Comunidad Couchbase:

/usr/bin$ sudo ln -s /opt/couchbase/bin/cbbackup cbbackup

1	/usr/papelera$ sudo ln -s /op/couchbase/papelera/cbbackup cbbackup

Couchbase Enterprise:

/usr/bin$ sudo ln -s /opt/couchbase/bin/cbbackupmgr cbbackupmgr

1	/usr/papelera$ sudo ln -s /op/couchbase/papelera/cbbackupmgr cbbackupmgr

Cómo hacer una copia de seguridad de Couchbase Community

Couchbase Community viene con dos herramientas principales para ayudarte a respaldar y restaurar los datos de tu cluster Couchbase: cbbackup y cbrestore. Ambas herramientas están disponibles en papelera de su instalación de Couchbase.

CBBACKUP tiene 3 modos principales:

- - completo - La completo realizará una copia de seguridad completa.
  - dif - (por defecto) dif realizará una copia de seguridad incremental diferencial, que copia sólo los cambios desde la última copia de seguridad completa o incremental.
  - accu - La accu realiza una copia de seguridad incremental acumulativa, que respalda todos los cambios desde la última copia de seguridad completa.

Una estrategia sencilla de copia de seguridad podría ser similar a la siguiente:

- - Copia de seguridad completa los domingos a la 1 de la madrugada;
  - Copias de seguridad incrementales diarias a la 1 de la madrugada;

Empecemos creando un script que ejecutará nuestra copia de seguridad completa, creará un archivo llamado full_backup_couchbase.sh con el siguiente contenido:

#!/bin/bash -e

echo "Running Couchbase Full Backup"

cd /opt/couchbase/bin/
./cbbackup http://COUCHBASE_NODE_IP:8091 /YOUR/BACKUP/DIR -u yourusername -p yourpassword! -m full

echo "Full Couchbase Backup concluded"

#!/bin/bash -e

echo "Ejecutando la copia de seguridad completa de Couchbase"

cd /op/couchbase/papelera/

./cbbackup http://COUCHBASE_NODE_IP:8091 /SU/RESPALDO/DIR -u tunombredeusuario -p tucontraseña! -m completo

echo "Copia de seguridad completa de Couchbase concluida"

A continuación, vamos a utilizar CronTab para programar nuestra copia de seguridad completa, ejecute el siguiente comando:

sudo vim /etc/crontab

1	sudo vim /etc/crontab

Prensa "i" para entrar en el modo de edición y, a continuación, añada la siguiente línea:

0 1 * * Sun   yourLocalUser  /PATH/TO/YOUR/SCRIPT/full_backup_couchbase.sh

1	0 1 * * Sol tuUsuarioLocal /SENDERO/A/SU/GUIÓN/full_backup_couchbase.sh

Tenga en cuenta que tuUsuarioLocal se refiere al usuario local de la máquina, el script se ejecutará utilizando ese contexto. Guarda el archivo una vez que termines ("esc", luego ":wq" en caso de que no estés acostumbrado a vim)

Ahora, vamos a crear el script para ejecutar las copias de seguridad incrementales, la única diferencia aquí es el modo parámetro. Cree un archivo llamado incremental_backup_couchbase.sh y añada el siguiente contenido:

#!/bin/bash -e
echo "Running Couchbase Incremental Backup"

cd /opt/couchbase/bin/
./cbbackup http://YOUR_COUCHBASE_NODE_IP:8091 /YOUR/BACKUP/DIR -u your_couchbase_username -p your_couchbase_password -m diff

echo "Couchbase Incremental Backup concluded"

#!/bin/bash -e

echo "Ejecutando la copia de seguridad incremental de Couchbase"

cd /op/couchbase/papelera/

./cbbackup http://TU_NODO_DE_BASE_COUCH:8091 /SU/RESPALDO/DIR -u tu_nombre_de_usuario -p tu_contraseña -m dif

echo "Couchbase Incremental Backup concluido"

Añadamos también este script a la pestaña CronTab:

sudo vim /etc/crontab

1	sudo vim /etc/crontab

Y luego añade la siguiente línea:

0 1 * * 1-6  yourLocalUser  /PATH/TO/YOUR/SCRIPT/incremental_backup_couchbase.sh

1	0 1 * * 1-6 tuUsuarioLocal /SENDERO/A/SU/GUIÓN/incremental_backup_couchbase.sh

El crontab anterior dice que este script se ejecutará de lunes a sábado a la 01 am. No olvides que ambos scripts deben ser ejecutables:

chmod +x incremental_backup_couchbase.sh 
chmod +x full_backup_couchbase.sh

1 2	chmod +x incremental_backup_couchbase.sh chmod +x full_backup_couchbase.sh

Ejecute ambos scripts para asegurarse de que funcionan correctamente. En la última sesión de este artículo, aprenderá a probar también su crontab.

Cómo hacer una copia de seguridad de Couchbase Enterprise

Couchbase Enterprise viene con una herramienta más completa llamada cbbackupmgr que te ofrece algunas funciones adicionales:

- - Compactación de copias de seguridad en un repositorio de copias de seguridad para liberar espacio en disco;
  - Lista el contenido del archivo de copia de seguridad;
  - Fusiona dos o más copias de seguridad;

Como ahora tenemos algunas funciones extra podríamos crear un script más elaborado que haga lo siguiente:

1. 1. Configure el directorio si aún no está configurado (cbbackupmgr config)
  2. Ejecutar una copia de seguridad completa/delta
  3. Fusionar copias de seguridad incrementales antiguas para recuperar espacio en disco

Aquí tiene un script llamado backup_with_periodic_merge.sh que podría utilizar para hacer exactamente lo que se describe más arriba:

#!/bin/bash
set -e

#DIR="${BASH_SOURCE%/*}"
#if [[ ! -d "$DIR" ]]; then DIR="$PWD"; fi
#. "$DIR/cbbackupmgr"

#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
#  Function _usage
#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
function _usage
{
   echo "Usage: ./backup-with-periodic-merge.sh [options]"
   echo "This script will take a cluster wide backup first and will keep specified number of restorepoints by merging backups older than restorepoints."
   echo "    Options:"
   echo "	--archive <s>           Directory where backups would be archived (default: /backups)"
   echo "	--repo <s>		Repository name used for the backup (default: couchbase)"
   echo "	--cluster <s>           The cluster address (default: localhost)"
   echo " 	--username <s>          Cluster Admin or RBAC username (default: Administrator)"
   echo "	--password <s>          Cluster Admin or RBAC password (default: password)"
   echo "	--threads <n>           Number of threads used for backup process (default: 2)"
   echo "	--restorepoints <n>     Number of backups at any given time for restore during outage (default: 3)"
   echo "	--help                  Display this help and exit"
   exit 5
}

# set the defaults, these can all be overriden as environment variables or passed via the cli
CB_USERNAME=${CB_USERNAME:='Administrator'}
CB_PASSWORD=${CB_PASSWORD:='password'}
CLUSTER=${CLUSTER:='localhost'}
ARCHIVE=${ARCHIVE:='/backups'}
REPO=${REPO:='couchbase'}
THREADS=${THREADS:=2}
RESTOREPOINTS=${RESTOREPOINTS=3}

#***************************************************************************#
BACKUPREGEX="[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}_[0-9]{2}_[0-9]{2}.[0-9]{6}"
CBBACKUPMGR=cbbackupmgr

# parse any cli arguments
while [ $# -gt 0 ]
do
  case $1 in
    --username ) CB_USERNAME=$2
      shift 1
      ;;
    --password ) CB_PASSWORD=$2
      shift 1
      ;;
    --cluster ) CLUSTER=$2
      shift 1
      ;;
    --archive ) ARCHIVE=$2
      shift 1
      ;;
    --threads ) THREADS=$2
      shift 1
      ;;
    --restorepoints ) RESTOREPOINTS=$2
      shift 1
      ;;
    --repo ) REPO=$2
      shift 1
      ;;
    --help )
      _usage
      ;;
    *)
      echo ERROR : Invalid command line option :  "$1"
      _usage
     ;;
  esac
  shift
done


# Checking if the directory is already configured
REPODIR="${ARCHIVE}"
if [[ "${REPODIR:${#REPODIR}-1}" != "/" ]]; then
    REPODIR="${ARCHIVE}/${REPO}"
else
    REPODIR="${ARCHIVE}${REPO}"
fi

echo $REPODIR
if [ ! -d "$REPODIR" ]; then
  echo "Backup repository does not exist yet"
  CMD="${CBBACKUPMGR} config  --archive $ARCHIVE --repo $REPO"
  echo "Configuring backup repository..."
  eval "$CMD"
fi


#########################################################################################
### Couchbase Backup run in 4 steps:
###    1) Full/delta backup
###    2) Compact last backup
###    3) Merge
#########################################################################################
############## STEP 1 : BACKUP
echo "---------------------------------------------------------"
echo  BEGIN STEP 1: BACKUP : "$(date)"
CMD="${CBBACKUPMGR} backup  --archive $ARCHIVE --repo $REPO --cluster couchbase://${CLUSTER} --username $CB_USERNAME --password $CB_PASSWORD --threads ${THREADS}"
echo -e "Running backup... \n Command:  $CMD"
eval "$CMD"

############## STEP 2 : COMPACT BACKUP
echo "---------------------------------------------------------"
echo  BEGIN STEP 2: COMPACTION : "$(date)"
BACKUPLIST=$("${CBBACKUPMGR}" list --archive "${ARCHIVE}" --repo "${REPO}" | awk '{print $NF}' | grep -E "${BACKUPREGEX}")
echo -e "List of backup snapshots ... \n\n$BACKUPLIST"
LASTBACKUP=$(echo "${BACKUPLIST}" | sed '$!d')
echo Last backup name is: "${LASTBACKUP}"
CMD="${CBBACKUPMGR} compact --archive ${ARCHIVE} --repo ${REPO} --backup ${LASTBACKUP}"
echo -e "Compacting the backup...\n Command: ${CMD}"
eval "$CMD"

############## STEP 3 : MERGING OLD BACKUPS
echo "---------------------------------------------------------"
echo  BEGIN STEP 3: Merging old backup : "$(date)"
COUNT=$(echo "${BACKUPLIST}" | wc -l)
eval "${CBBACKUPMGR}" list --archive "${ARCHIVE}" --repo "${REPO}"

if [ "$COUNT" -gt "$RESTOREPOINTS" ]; then
  START=$(echo "${BACKUPLIST}" | sed -n 1p)
  END=$(echo "${BACKUPLIST}" | sed -n $((1+COUNT-RESTOREPOINTS))p)
  echo -e "Start $START, END $END"
  CMD="${CBBACKUPMGR} merge --archive ${ARCHIVE} --repo ${REPO} --start ${START} --end ${END}"
  echo -e "Merging old backups...\n Command: ${CMD}"
  eval "$CMD"
fi

eval "${CBBACKUPMGR}" list --archive "${ARCHIVE}" --repo "${REPO}"

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

#!/bin/bash

configure -e

#DIR="${BASH_SOURCE%/*}"

#if [[ ! -d "$DIR" ]]; then DIR="$PWD"; fi

#. "$DIR/cbbackupmgr"

#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

# Función _uso

#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

función Uso

{

echo "Uso: ./backup-with-periodic-merge.sh [opciones]"

echo "Este script tomará primero una copia de seguridad de todo el clúster y mantendrá el número especificado de puntos de restauración fusionando las copias de seguridad más antiguas que los puntos de restauración."

echo " Opciones:"

echo "--archive ~~Directorio donde se archivarían las copias de seguridad (por defecto: /backups)"~~

~~echo "--repo ~~Nombre del repositorio utilizado para la copia de seguridad (por defecto: couchbase)"~~~~

~~echo " --cluster ~~La dirección del clúster (por defecto: localhost)"~~~~

~~echo " --username ~~Administrador del clúster o nombre de usuario RBAC (por defecto: Administrador)"~~~~

~~echo "--password ~~Cluster Admin o RBAC password (por defecto: password)"~~~~

~~echo "--threads Número de hilos utilizados para el proceso de copia de seguridad (por defecto: 2)"~~

~~echo "--restorepoints Número de copias de seguridad en un momento dado para restaurar durante una interrupción (por defecto: 3)"~~

~~echo " --help Mostrar esta ayuda y salir"~~

~~salida 5~~

}

~~# establece los valores por defecto, todos estos pueden ser anulados como variables de entorno o pasados a través de la cli~~

~~CB_USERNAME=${CB_USERNAME:=Administrador}~~

~~CB_PASSWORD=${CB_PASSWORD:=contraseña}~~

~~CLÚSTER=${CLÚSTER:=localhost}~~

~~ARCHIVO=${ARCHIVO:=/backups}~~

~~REPO=${REPO:=couchbase}~~

~~HILOS=${HILOS:=2}~~

~~RESTOREPOINTS=${RESTOREPOINTS=3}~~

~~#***************************************************************************#~~

~~BACKUPREGEX="[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}_[0-9]{2}_[0-9]{2}.[0-9]{6}"~~

~~CBBACKUPMGR=cbbackupmgr~~

~~# analiza cualquier argumento cli~~

~~mientras que [ $# -gt 0 ]~~

~~caso $1 en~~

~~--nombre de usuario ) CB_USERNAME=$2~~

~~turno 1~~

;;

~~--contraseña ) CB_PASSWORD=$2~~

~~turno 1~~

;;

~~--grupo ) CLÚSTER=$2~~

~~turno 1~~

;;

~~--archivo ) ARCHIVO=$2~~

~~turno 1~~

;;

~~--hilos ) HILOS=$2~~

~~turno 1~~

;;

~~--puntos de restauración ) RESTOREPOINTS=$2~~

~~turno 1~~

;;

~~--repo ) REPO=$2~~

~~turno 1~~

;;

~~--ayuda )~~

~~Uso~~

;;

~~echo ERROR : No válido comando línea opción : "$1"~~

~~Uso~~

;;

~~esac~~

~~turno~~

~~hecho~~

~~# Comprobación de si el directorio ya está configurado~~

~~REPODIR="${ARCHIVO}"~~

~~si [[ "${REPODIR:${#REPODIR}-1}" != "/" ]]; entonces~~

~~REPODIR="${ARCHIVE}/${REPO}"~~

~~si no~~

~~REPODIR="${ARCHIVE}${REPO}"~~

~~echo $REPODIR~~

~~si [ ! -d "$REPODIR" ]; entonces~~

~~echo "El repositorio de copias de seguridad aún no existe"~~

~~CMD="${CBBACKUPMGR} config --archive $ARCHIVE --repo $REPO"~~

~~echo "Configurando el repositorio de copias de seguridad..."~~

~~evalúe "$CMD"~~

~~#########################################################################################~~

~~### Couchbase Backup se ejecuta en 4 pasos:~~

~~### 1) Copia de seguridad completa/triángulo~~

~~### 2) Última copia de seguridad compacta~~

~~### 3) Fusionar~~

~~#########################################################################################~~

~~############# PASO 1 : COPIA DE SEGURIDAD~~

~~echo "---------------------------------------------------------"~~

~~echo COMENZAR PASO 1: RESPALDO : "$(fecha)"~~

CMD="${CBBACKUPMGR} backup --archive $ARCHIVE --repo $REPO --cluster couchbase://${CLUSTER} --username $CB_USERNAME --password $CB_PASSWORD --threads ${THREADS} --username $CB_USERNAME --password $CB_PASSWORD --threads ${THREADS}"

~~echo -e "Ejecutando copia de seguridad... \n Comando: $CMD"~~

~~evalúe "$CMD"~~

~~############ PASO 2 : COPIA DE SEGURIDAD COMPACTA~~

~~echo "---------------------------------------------------------"~~

~~echo COMENZAR PASO 2: COMPACCIÓN : "$(fecha)"~~

~~LISTA DE RESPALDO=$("${CBBACKUPMGR}" lista --archivo "${ARCHIVO}" --repo "${REPO}" | awk '{print $NF}' | grep -E "${BACKUPREGEX}")~~

~~echo -e "Lista de instantáneas de copia de seguridad ... \n\n$BACKUPLIST"~~

~~LASTBACKUP=$(echo "${BACKUPLIST}" | sed "¡$!d)~~

~~echo Última copia de seguridad nombre es: "${LASTBACKUP}"~~

~~CMD="${CBBACKUPMGR} compact --archive ${ARCHIVE} --repo ${REPO} --backup ${LASTBACKUP}"~~

~~echo -e "Compactando la copia de seguridad...\n Comando: ${CMD}"~~

~~evalúe "$CMD"~~

~~############ PASO 3 : FUSIONAR COPIAS DE SEGURIDAD ANTIGUAS~~

~~echo "---------------------------------------------------------"~~

~~echo COMENZAR PASO 3: Fusión antiguo copia de seguridad : "$(fecha)"~~

~~CONTAR=$(echo "${BACKUPLIST}" | wc -l)~~

~~evalúe "${CBBACKUPMGR}" lista --archivo "${ARCHIVO}" --repo "${REPO}"~~

~~si [ "$COUNT" -gt "$RESTOREPOINTS" ]; entonces~~

~~INICIO=$(echo "${BACKUPLIST}" | sed -n 1p)~~

~~FIN=$(echo "${BACKUPLIST}" | sed -n $((1+CONTAR-RESTOREPOINTS))p)~~

~~echo -e "Inicio $START, FIN $END"~~

~~CMD="${CBBACKUPMGR} merge --archive ${ARCHIVE} --repo ${REPO} --start ${START} --end ${END}"~~

~~echo -e "Fusionando copias de seguridad antiguas...\n Comando: ${CMD}"~~

~~evalúe "$CMD"~~

~~evalúe "${CBBACKUPMGR}" lista --archivo "${ARCHIVO}" --repo "${REPO}"~~

Para ejecutar el script puede especificar algo como lo siguiente:

./backup_with_periodic_merge.sh --archive /backups/incremental/ --cluster YOUR_COUCHBASE_IP:8091 --username cb_user --password cb_password

1	./copia_de_seguridad_con_fusión_periódica.sh --archivo /copias de seguridad/incremental/ --grupo TU_COUCHBASE_IP:8091 --nombre de usuario cb_usuario --contraseña cb_contraseña

Para evitar teclear este comando cada vez, vamos a crear un segundo script con todos los parámetros. Aquí un script llamado cb_incremental_backup.sh:

#!/bin/bash -e

cd /home/ubuntu/scripts/
./backup_with_periodic_merge.sh --archive /backups/incremental/ --cluster 10.0.0.8:8091 --username backup_user --password baWN4s9wwpb5PrmN

echo "The Couchbase PROD incremental backup has finished." | mail -s "Prod - Couchbase Incremental Backup" backup@mycompany.com -a "FROM:somegroup@mycompany.comr"

#!/bin/bash -e

cd /Inicio/ubuntu/guiones/

./copia_de_seguridad_con_fusión_periódica.sh --archivo /copias de seguridad/incremental/ --grupo 10.0.0.8:8091 --nombre de usuario usuario_de_seguridad --contraseña baWN4s9wwpb5PrmN

echo "La copia de seguridad incremental de Couchbase PROD ha finalizado". | correo -s "Prod - Copia de seguridad incremental de Couchbase" copia de seguridad@miempresa.com -a "FROM:somegroup@mycompany.comr"

Aquí estoy asumiendo que ambos archivos se encuentran en la carpeta /home/ubuntu/scripts. Al final de la secuencia de comandos, también estoy usando Postfix para enviar un correo electrónico a un grupo de usuarios una vez que todo el proceso ha finalizado. Definitivamente hay mejores formas de monitorizar si tus copias de seguridad se han ejecutado correctamente, pero si todavía no tienes ninguna estrategia mejor, enviar un correo electrónico es al menos un tipo básico de monitorización.

Programar este script para que se ejecute usando crontab será muy similar a lo que hemos hecho en la edición community, simplemente ejecuta el siguiente comando:

sudo vim /etc/crontab

1	sudo vim /etc/crontab

Y luego añade la siguiente línea:

0  1    * * *   yourLocalUser /home/ubuntu/scripts/cb_incremental_backup.sh

1	0 1 * * * tuUsuarioLocal /Inicio/ubuntu/guiones/cb_respaldo_incremental.sh

En cb_incremental_backup.sh ejecutará copias de seguridad incrementales todos los días a la 01 am. Le recomiendo que, además, ejecute copias de seguridad completas de vez en cuando para evitar tener una sola copia de seguridad completa con varias copias de seguridad incrementales.

Pruebe su CronTab

Puede probar rápidamente sus CronTabs utilizando cronitorBasta con ejecutar los siguientes comandos para instalarlo

curl -sOL https://cronitor.io/dl/cronitor-stable-linux-amd64.tgz
sudo tar xvf cronitor-stable-linux-amd64.tgz -C /usr/bin/

1 2	rizo -sOL https://cronitor.io/dl/cronitor-stable-linux-amd64.tgz sudo alquitrán xvf cronitor-estable-linux-amd64.tgz -C /usr/papelera/

A continuación, ejecute el siguiente comando para listar todos sus trabajos programados:

cronitor select

1	cronitor seleccione

Navega por la lista con las teclas de flecha, elige la que quieras ejecutar y pulsa intro:

Si todo está correctamente configurado, su script debería ejecutarse con éxito.

Denis Rosa, Defensor del Desarrollador, Couchbase

Platform

Self-Managed

Services

Capabilities

Why Couchbase?

Migrate to Capella

By Use Case

By Industry

By Application Need

Popular Docs

By Developer Role

Quickstart

Resource Center

About

Partnerships

Our Services

Partners: Register a Deal

Ready to register a deal with Couchbase?

Marriott

Todos los mensajes

Cómo hacer copias de seguridad de Couchbase: Guía de inicio rápido

Recomendaciones generales

Máquinas de reserva

Política de conservación

Pruebas de recuperación

Preparación de la máquina de copia de seguridad

Cómo hacer una copia de seguridad de Couchbase Community

Cómo hacer una copia de seguridad de Couchbase Enterprise

Pruebe su CronTab

Autor

Publicado por Denis Rosa, Defensor del Desarrollador, Couchbase

Dejar una respuesta Cancelar respuesta