Sauvegardes de bases de données locales et sur cloud tiers - Data Management

La reprise après sinistre des données prend en charge les bases de données Alibaba Cloud, les bases de données auto-gérées sur des instances ECS, les bases de données locales et les bases de données hébergées sur des plateformes cloud tierces.

Remarques d'utilisation

Si la base de données source contient des tables dont le schéma est mal conçu, des tables volumineuses ou des champs de grande taille, une instance de sauvegarde aux spécifications faibles peut épuiser ses ressources et déclencher des exceptions de sauvegarde. Pour éviter ces problèmes, sélectionnez une instance de sauvegarde dotée de spécifications supérieures.

Procédure

Sauvegarde automatique du produit

Acheter un planning de sauvegarde (sauvegarde logique)

Connectez-vous à DMS 5.0.
Dans la barre de navigation supérieure, choisissez Security and disaster recovery (DBS) > Data Disaster Recovery (DBS) > Disaster Recovery Data Source.

Remarque
Si vous utilisez la console DMS en mode simple, placez le pointeur sur l'icône dans le coin supérieur gauche de la console DMS et choisissez All Features > Security and disaster recovery (DBS) > Data Disaster Recovery (DBS) > Disaster Recovery Data Source.
Sélectionnez une région en haut de la page. Dans l'onglet On-premises and third-party cloud databases, cliquez sur Product Automatic Backup, puis cliquez sur l'ID de la source de données cible pour ouvrir sa page de détails.
Sur la page Backup Policy, cliquez sur Configure Backup Policy.
Sur la page Select Backup Schedule, cliquez sur Purchase Backup Schedule pour accéder à la page d'achat du service Database Backup Service (DBS).

Configurez les paramètres suivants et cliquez sur Buy Now dans le coin inférieur droit.

Paramètre	Description
Product type	Sélectionnez Backup Schedule (Subscription).
Backup schedule region	Sélectionnez la région dans laquelle vous souhaitez stocker les données de sauvegarde. Remarque Assurez-vous que le planning de sauvegarde et l'instance ECS se trouvent dans la même région.
Data source type	Actuellement, seul MySQL est pris en charge.
Specification	Les spécifications du planning de sauvegarde que vous souhaitez utiliser. Des spécifications plus élevées offrent de meilleures performances de sauvegarde et de restauration. DBS prend en charge les spécifications de planning de sauvegarde suivantes : micro, small, medium, large et xlarge. Le type de spécification xlarge fournit des spécifications extra larges sans limite supérieure sur la quantité de données de sauvegarde. Remarque Si votre instance de base de données, telle qu'une base de données de production, nécessite un planning de sauvegarde haute performance pour des tâches de sauvegarde et de restauration rapides, nous vous recommandons de sélectionner la spécification xlarge ou large. Si les hautes performances de sauvegarde et de restauration ne sont pas une priorité, vous pouvez calculer vos besoins pour sélectionner la spécification de planning de sauvegarde la plus rentable. Pour plus d'informations, consultez Comment sélectionner une spécification de planning de sauvegarde. Si les bases de données et les tables que vous souhaitez sauvegarder présentent des problèmes tels que des schémas inappropriés, des tables volumineuses et des champs de grande taille, les ressources d'une instance de sauvegarde aux spécifications inférieures peuvent être insuffisantes pour effectuer la sauvegarde. Il en résulte une erreur de sauvegarde. Nous vous recommandons d'acheter une instance de sauvegarde aux spécifications supérieures pour éviter les erreurs de sauvegarde.
Backup method	Sélectionnez logical backup.
Storage space	Vous n'avez pas besoin de spécifier une capacité de stockage lors de l'achat du planning de sauvegarde. Vous êtes facturé en fonction de la quantité de données stockées dans le stockage intégré de DBS. Pour plus d'informations sur la facturation, consultez Frais de stockage.
Resource group	Sélectionnez le groupe de ressources par défaut ou un groupe de ressources personnalisé pour faciliter la gestion des plannings de sauvegarde.
Quantity	Sélectionnez la quantité souhaitée. Un planning de sauvegarde distinct est requis pour chaque instance de base de données. Par exemple, pour sauvegarder l'instance de base de données A et l'instance de base de données B, vous devez acheter deux plannings de sauvegarde.
Subscription duration	Sélectionnez la durée de l'abonnement pour le planning de sauvegarde.

Sur la page Confirm Order, vérifiez les détails de la commande, lisez et acceptez les Terms of Service, puis cliquez sur Pay.

Une fois le paiement effectué, revenez à la page Select Backup Schedule de l'étape 5 et cliquez sur Paid. Le planning de sauvegarde nouvellement acheté apparaît dans la liste.

Configurer une politique de sauvegarde

Sur la page Select Backup Schedule, sélectionnez le planning de sauvegarde que vous souhaitez configurer et cliquez sur Next.
Sur la page Select Databases and Tables, sélectionnez les bases de données ou les tables que vous souhaitez sauvegarder, cliquez sur pour les déplacer vers la zone Selected Objects, puis cliquez sur Submit.
Une fois les paramètres soumis, accédez à la page Backup Policy. Dans l'onglet Logical Backup, cliquez sur Start pour démarrer la sauvegarde.

Après avoir cliqué sur Start, le système lance immédiatement une tâche de sauvegarde complète et une tâche de sauvegarde incrémentielle.

Remarque
Si vous devez d'abord effectuer d'autres opérations, telles que la modification de la politique de sauvegarde, vous pouvez choisir de ne pas démarrer la sauvegarde immédiatement. Le système démarrera automatiquement la sauvegarde à l'heure spécifiée dans la politique de sauvegarde.

Sauvegarde automatique fournie par l'utilisateur

Important

Actuellement, seules les sources de données MySQL 5.5 sont prises en charge.
Actuellement, seule la région Chine (Hangzhou) est prise en charge.

Configurer la source de sauvegarde et télécharger des fichiers

Connectez-vous à DMS 5.0.
Dans la barre de navigation supérieure, choisissez Security and disaster recovery (DBS) > Data Disaster Recovery (DBS) > Disaster Recovery Data Source.

Remarque
Si vous utilisez la console DMS en mode simple, placez le pointeur sur l'icône dans le coin supérieur gauche de la console DMS et choisissez All Features > Security and disaster recovery (DBS) > Data Disaster Recovery (DBS) > Disaster Recovery Data Source.
Sélectionnez une région en haut de la page. Dans l'onglet On-premises and third-party cloud databases, choisissez comment ajouter une source de données en fonction de son type.

Cliquez sur Add Data Source. Dans la boîte de dialogue qui s'affiche, configurez les paramètres suivants, sélectionnez le planning de sauvegarde cible, puis cliquez sur Next.

Paramètre

Description

Data source name

Saisissez un nom descriptif.

Engine type

Type de moteur de base de données. Seul MySQL est pris en charge.

Engine version

Sélectionnez la version du moteur de base de données.

Engine parameters

{"lower_case_table_names":1}

Si aucun planning de sauvegarde n'est disponible, cliquez sur Purchase Backup Schedule pour accéder à la page d'achat DBS et en acheter un.

Description

Product type

Sélectionnez Backup Schedule (Subscription). La méthode de facturation au paiement à l'utilisation n'est pas prise en charge.

Backup Schedule (Subscription)

Sélectionnez la région dans laquelle vous souhaitez stocker les données de sauvegarde.

Backup schedule region

Sélectionnez Data source type.

MySQL

Sélectionnez Specification. Pour obtenir des informations sur le quota de données gratuit inclus avec cette spécification, consultez Spécifications du planning de sauvegarde.

xmicro

Sélectionnez Backup method.

physical backup

Vous n'avez pas besoin de spécifier une capacité de stockage lors de l'achat du planning de sauvegarde. Vous êtes facturé en fonction de la quantité de données stockées dans le DBS stockage intégré. Pour plus d'informations sur la facturation, consultez Frais de stockage.

Storage space

Sélectionnez le groupe de ressources par défaut ou un groupe de ressources personnalisé pour faciliter la gestion des plannings de sauvegarde.

Resource group

Sélectionnez la quantité souhaitée. Un planning de sauvegarde distinct est requis pour chaque instance de base de données. Par exemple, pour sauvegarder l'instance de base de données A et l'instance de base de données B, vous devez acheter deux plannings de sauvegarde.

Quantity

Sélectionnez la durée de l'abonnement pour le planning de sauvegarde.

Téléchargez l'ensemble de sauvegarde vers le compartiment spécifié. Pour plus de détails, consultez Télécharger des données pour les sauvegardes automatiques fournies par l'utilisateur.
Une fois le téléchargement terminé, cliquez sur Subscription duration.

Afficher les informations de sauvegarde

Dans l'onglet OK, cliquez sur l'ID de la source de données cible.

Sur la page des détails de la source de données, le volet de navigation de gauche propose des options telles que Basic Information, Backup Policy, Backup Data, Recovery Drill et Task Management. Par défaut, l'onglet Basic Information s'affiche, où vous pouvez consulter des champs tels que Data Source ID, Data Source Name, Resource Group ID, Data Source Type, Backup Method, Access Time, Engine Type, Data Source Authorization Status, Source Database Endpoint et Port.

Configurer une politique de sauvegarde

Dans l'onglet User-provided automatic backup, recherchez la source de données cible et cliquez sur User-provided automatic backup dans la colonne Actions.

Dans la boîte de dialogue Backup Policy, configurez la Full backup retention period (de 7 à 7 300 jours, par défaut : 30), la Log backup retention period (de 7 à 7 300 jours, par défaut : 7) et la Snapshot retention period (de 1 à 7 300 jours, par défaut : 7), puis cliquez sur OK.
Une fois la configuration terminée, cliquez sur View Backup Policy.

Afficher et télécharger les données de sauvegarde

Dans l'onglet OK, cliquez sur l'ID de la source de données cible.
Dans le volet de navigation de gauche, cliquez sur User-provided automatic backup.

Remarque
Après avoir exécuté le script de téléchargement des données et créé la source de données, le système de gestion des sauvegardes synchronise tous les nouveaux ensembles de sauvegarde générés vers la page Backup Data.
Recherchez l'ensemble de sauvegarde cible et cliquez sur Backup Data dans la colonne Download pour le télécharger sur votre ordinateur local.

Créer une tâche de restauration

Remarque

Pour créer une tâche de restauration, un ensemble de sauvegarde généré doit exister sur la page Backup Data et son statut doit être Completed.

Dans l'onglet Actions, cliquez sur l'ID de la source de données cible.

Dans le volet de navigation de gauche, cliquez sur User-provided automatic backup, puis cliquez sur Backup Data pour configurer les paramètres de restauration.

Paramètre

Description

Create Restore Task

Saisissez un nom descriptif pour la tâche de restauration.

Restore task name

Sélectionnez la destination de l'instance restaurée. Par défaut, les données sont restaurées vers une nouvelle instance RDS.

Restore to

Sélectionnez l'emplacement de la base de données. La valeur par défaut est RDS.

Database location

Sélectionnez la région où réside l'instance. Actuellement, seule la région Instance region est prise en charge.

China (Hangzhou)

Sélectionnez le VPC.

VPC

Sélectionnez le vSwitch.

vSwitch

Sélectionnez la série d'instances pour l'instance restaurée.

Instance series

Sélectionnez la spécification de l'instance pour l'instance restaurée.

Instance specification

Sélectionnez l'espace de stockage requis.

Storage space

Sélectionnez un mode de restauration. Actuellement, seule la restauration à un instant donné est prise en charge.

Restore mode

Sélectionnez un instant donné. Pour connaître la plage de temps disponible, consultez les informations situées à côté du paramètre Restore time.

Une fois la tâche configurée, cliquez sur Restore mode. Une tâche de restauration est créée pour l'instant sélectionné et ses détails apparaissent sur la page des tâches de restauration.

Afficher les tâches de restauration

Dans l'onglet Submit, cliquez sur l'ID de la source de données cible.
Dans le volet de navigation de gauche, choisissez User-provided automatic backup > Task Management.
Cliquez sur l'ID de l'instance dans la colonne Restore Tasks pour accéder à la page des informations de base de l'instance RDS restaurée.

Afficher les tests de reprise

Dans l'onglet Restore Result, cliquez sur l'ID de la source de données cible.

Dans le volet de navigation de gauche, cliquez sur User-provided automatic backup.

Vue d'ensemble des tests de reprise

Consultez la vue d'ensemble des tests de reprise, qui inclut le Recovery Drill, la Recovery drill overview, la Restore task success rate et la Average restore duration.

Paramètre

Description

Data backup drill coverage

Le taux de réussite des tâches de restauration lancées dans la plage de temps filtrée.

Log backup drill coverage

La durée moyenne des tâches de restauration réussies dans la plage de temps filtrée.

Restore task success rate

Le pourcentage de sauvegardes de données provenant d'instances MySQL open source ou RDS for MySQL ayant fait l'objet d'un test de reprise dans la plage de temps filtrée.

Average restore duration

Le pourcentage de sauvegardes de journaux provenant d'instances MySQL open source ou RDS for MySQL ayant fait l'objet d'un test de reprise dans la plage de temps filtrée.

Chronologie des tests de reprise

La chronologie affiche les détails des tests de reprise. Vous pouvez cliquer sur un point de la chronologie pour afficher les informations correspondant à cet instant précis.

Détails des tests de reprise pour les données de sauvegarde

Cliquez sur Data backup drill coverage pour afficher les détails des tests de reprise pour les sauvegardes de données. Cliquez sur l'ID de l'instance dans la colonne Log backup drill coverage pour accéder à la page des informations de base de l'instance RDS restaurée.

Cliquez sur Data Backup pour afficher la liste des détails des tests de reprise pour les sauvegardes de journaux.

Télécharger les données de sauvegarde utilisateur

Prérequis

Configurez une source de données et obtenez son ID. Pour plus d'informations, consultez la rubrique Ajouter une source de données.
Créez un utilisateur RAM, accordez-lui les autorisations nécessaires pour gérer le service Alibaba Cloud requis, puis récupérez un AccessKey ID et un AccessKey Secret. Pour plus d'informations, consultez les rubriques Créer un utilisateur RAM et Gérer les autorisations des utilisateurs RAM.

Dépendances

Outils en ligne de commande : Bash et Python 3.
Bibliothèques Python : oss2, alibabacloud_openapi_util, alibabacloud_tea_openapi et alibabacloud_tea_util.

## Install the Alibaba Cloud OpenAPI SDK.
pip3 install --upgrade pip
pip3 install -i https://mirrors.aliyun.com/pypi/simple/ oss2 alibabacloud_openapi_util alibabacloud_tea_openapi alibabacloud_tea_util

Scripts de téléchargement complets

Les scripts de téléchargement des données de sauvegarde se composent de deux parties :

Script Bash

Il s'agit du point d'entrée pour l'exécution du script. Remplacez les paramètres par des espaces réservés par vos valeurs réelles selon vos besoins.

boot_backup.sh : ce script simule la création d'une sauvegarde complète locale à l'aide de Xtrabackup.

#!/bin/bash
## The AccessKey pair of an Alibaba Cloud account has permissions on all API operations. Using these credentials to perform operations is a high-risk practice. We recommend that you create and use a RAM user for API access or routine O&M.
## For security reasons, do not hardcode your AccessKey ID and AccessKey secret in your code. This can lead to credential leaks. Instead, store them in a configuration file or use environment variables.
AK=<YOUR_ACCESS_KEY_ID>
SK=<YOUR_ACCESS_KEY_SECRET>
DBS_API=dbs-api.<your-region-id>.aliyuncs.com
DATASOURCE_ID=<your-data-source-id>
## Get the current path of the script.
BASE_PATH=$(cd `dirname $0`; pwd)
TS=`date +%Y%m%d_%H%M%S`
XTRA_DATA_DIR=~/tool/xtrabackup_data/$TS
mkdir -p $XTRA_DATA_DIR
## Run the Xtrabackup command and redirect error logs to the xtrabackup.log file.
~/innobackupex --defaults-file=/etc/my.cnf --user='<your-db-account>' --password='<your-db-password>' --host='<your-db-host>' --port=<your-db-port> --socket='/var/lib/mysql/mysql.sock' --parallel=4 $XTRA_DATA_DIR/ 2>$XTRA_DATA_DIR/xtrabackup.log
## Get the current Xtrabackup backup directory.
backup_dir=`ls $XTRA_DATA_DIR | grep -v xtrabackup.log | head -n1`
echo -e "\033[33mexecute innobackupex success, backup_dir: $backup_dir" && echo -n -e "\033[0m" && chmod 755 $XTRA_DATA_DIR/$backup_dir
## Package the directory into a .tar.gz file.
cd $XTRA_DATA_DIR/$backup_dir && tar -czvf ../$backup_dir.tar.gz . && file ../$backup_dir.tar.gz
echo -e "\033[33mpackage to $backup_dir.tar.gz" && echo -n -e "\033[0m" && sleep 2
## Call the Python script to upload the backup file and register its metadata.
python3 $BASE_PATH/upload_and_register_backup_set.py --access_key_id $AK --access_key_secret $SK --endpoint $DBS_API --datasource_id $DATASOURCE_ID --region_code=cn-hangzhou --data_type=FullBackup --file_path=$XTRA_DATA_DIR/$backup_dir.tar.gz --xtrabackup_log_path=$XTRA_DATA_DIR/xtrabackup.log

Scripts Python

upload_and_register_backup_set.py : ce script télécharge les données de sauvegarde complète et de sauvegarde des journaux, analyse les métadonnées correspondantes et enregistre les métadonnées de l'ensemble de sauvegarde auprès du Database Backup Service (DBS).

# -*- coding: utf-8 -*-
# This file is auto-generated, don't edit it. Thanks.
import os
import argparse
import re
import time
import json
from datetime import datetime
import oss2
from alibabacloud_openapi_util.client import Client as OpenApiUtilClient
from alibabacloud_tea_openapi import models as open_api_models
from alibabacloud_tea_openapi.client import Client as OpenApiClient
from alibabacloud_tea_util import models as util_models
import xtrabackup_info_parser
import xtrabackup_log_parser
def init_command_args():
    parser = argparse.ArgumentParser(description="A sample command-line parser.")
    parser.add_argument("--access_key_id", help="Your Alibaba Cloud AccessKey ID.")
    parser.add_argument("--access_key_secret", help="Your Alibaba Cloud AccessKey secret.")
    parser.add_argument("--endpoint", help="The API endpoint for your service.")
    parser.add_argument("--region_code", help="The region code of your data source.")
    parser.add_argument("--datasource_id", help="The ID of your data source.")
    parser.add_argument("--data_type", help="The type of the backup set: FullBackup or LogBackup.")
    parser.add_argument("--file_path", help="The file path of the backup set.")
    parser.add_argument("--xtrabackup_info_path", help="The path to the xtrabackup_info file.")
    parser.add_argument("--xtrabackup_log_path", help="The path to the xtrabackup.log file.")
    parser.add_argument("--begin_time", help="The start time of the binlog.")
    parser.add_argument("--end_time", help="The end time of the binlog.")
    args = parser.parse_args()
    if args.access_key_id:
        print(f"access_key_id: ************")
    if args.access_key_secret:
        print(f"access_key_secret: ************")
    if args.endpoint:
        print(f"endpoint: {args.endpoint}")
    if args.region_code:
        print(f"region_code: {args.region_code}")
    if args.datasource_id:
        print(f"datasource_id: {args.datasource_id}")
    if args.data_type:
        print(f"data_type: {args.data_type}")
    if args.file_path:
        print(f"file_path: {args.file_path}")
    if args.xtrabackup_info_path:
        print(f"xtrabackup_info_path: {args.xtrabackup_info_path}")
    if args.xtrabackup_log_path:
        print(f"xtrabackup_log_path: {args.xtrabackup_log_path}")
    if args.begin_time:
        print(f"begin_time: {args.begin_time}")
    if args.end_time:
        print(f"end_time: {args.end_time}")
    print('\n')
    return args
def date_to_unix_timestamp(date_str):
    # Converts a date string to a Unix timestamp in milliseconds.
    dt_obj = datetime.strptime(date_str, "%Y-%m-%d %H:%M:%S")
    timestamp_seconds = time.mktime(dt_obj.timetuple())
    return int(timestamp_seconds) * 1000
def create_oss_client(params):
    # Authentication details for Alibaba Cloud OSS.
    access_key_id = params['AccessKeyId']
    access_key_secret = params['AccessKeySecret']
    security_token = params['SecurityToken']
    bucket_name = params['BucketName']
    endpoint = params['OssEndpoint']
    # Initialize the OSS client.
    auth = oss2.StsAuth(access_key_id, access_key_secret, security_token)
    return oss2.Bucket(auth, endpoint, bucket_name)
def upload_oss_file(oss_client, file_path, object_key):
    """
    Uploads a large file to OSS using multipart upload.
    :param oss_client: The OSS client instance.
    :param file_path: The path to the local file.
    :param object_key: The object key in OSS, which serves as the file name.
    """
    # Set the part size in bytes. Default is 5 MB.
    part_size = 1024 * 1024 * 5
    # Initiate the multipart upload.
    upload_id = oss_client.init_multipart_upload(object_key).upload_id
    # Open the file and read its content.
    with open(file_path, 'rb') as file_obj:
        parts = []
        while True:
            data = file_obj.read(part_size)
            if not data:
                break
            # Upload a part.
            result = oss_client.upload_part(object_key, upload_id, len(parts) + 1, data)
            parts.append(oss2.models.PartInfo(len(parts) + 1, result.etag))
        # Complete the multipart upload.
        oss_client.complete_multipart_upload(object_key, upload_id, parts)
class OssUploader:
    def __init__(self, access_key_id, access_key_secret, endpoint, region_code, datasource_id):
        self.access_key_id = access_key_id
        self.access_key_secret = access_key_secret
        self.endpoint = endpoint
        self.region_code = region_code
        self.datasource_id = datasource_id
        config = open_api_models.Config(access_key_id, access_key_secret)
        # For more information about endpoints, see https://api.alibabacloud.com/product/Dbs.
        config.endpoint = endpoint
        self.client = OpenApiClient(config)
    """
    Registers backup set metadata.
    """
    def configure_backup_set_info(self, req_param):
        params = open_api_models.Params(
            # The name of the API operation.
            action='ConfigureBackupSetInfo',
            # The version of the API operation.
            version='2021-01-01',
            # The protocol.
            protocol='HTTPS',
            # The HTTP method.
            method='POST',
            auth_type='AK',
            style='RPC',
            # The path of the API operation.
            pathname='/',
            # The format of the request body.
            req_body_type='json',
            # The format of the response body.
            body_type='json'
        )
        # Runtime options.
        runtime = util_models.RuntimeOptions()
        request = open_api_models.OpenApiRequest(
            query=OpenApiUtilClient.query(req_param)
        )
        # The response is a map that contains the response body, headers, and HTTP status code.
        print(f"ConfigureBackupSetInfo request: {req_param}")
        data = self.client.call_api(params, request, runtime)
        print(f"ConfigureBackupSetInfo response: {data}")
        return data['body']['Data']
    """
    Gets OSS upload information.
    """
    def describe_bak_datasource_storage_access_info(self, req_param):
        params = open_api_models.Params(
            # The name of the API operation.
            action='DescribeBakDataSourceStorageAccessInfo',
            # The version of the API operation.
            version='2021-01-01',
            # The protocol.
            protocol='HTTPS',
            # The HTTP method.
            method='POST',
            auth_type='AK',
            style='RPC',
            # The path of the API operation.
            pathname='/',
            # The format of the request body.
            req_body_type='json',
            # The format of the response body.
            body_type='json'
        )
        # Runtime options.
        runtime = util_models.RuntimeOptions()
        request = open_api_models.OpenApiRequest(
            query=OpenApiUtilClient.query(req_param)
        )
        # The response is a map that contains the response body, headers, and HTTP status code.
        print(f"DescribeBakDataSourceStorageAccessInfo request: {req_param}")
        data = self.client.call_api(params, request, runtime)
        print(f"DescribeBakDataSourceStorageAccessInfo response: {data}")
        return data['body']['Data']
    def _fetch_oss_access_info(self, params):
        info = self.describe_bak_datasource_storage_access_info({
            'RegionId': params['RegionId'],
            'DataSourceId': params['DataSourceId'],
            'RegionCode': params['RegionCode'],
            'BackupType': params['BackupType'],
            'BackupSetId': params['BackupSetId']
        })
        return info['OssAccessInfo']
    def upload_and_register_backup_set(self, file_path, data_type, extra_meta):
        filename = os.path.basename(file_path)
        params = {'BackupMode': 'Automated', 'BackupMethod': 'Physical', 'RegionId': self.region_code,
                  'RegionCode': self.region_code, 'DataSourceId': self.datasource_id, 'BackupSetName': filename,
                  'ExtraMeta': extra_meta, 'BackupType': data_type, 'UploadStatus': 'WaitingUpload'}
        # Register the backup set for the first time to obtain a backup set ID.
        data = self.configure_backup_set_info(params)
        params['BackupSetId'] = data['BackupSetId']
        print(f"------ configure_backup_set_info success: {file_path}, {data_type}, {params['BackupSetId']}, WaitingUpload\n")
        # Upload the file to OSS.
        oss_info = self._fetch_oss_access_info(params)
        oss_client = create_oss_client(oss_info)
        upload_oss_file(oss_client, file_path, oss_info['ObjectKey'])
        print(f"------ upload_oss_file success: {file_path}, {data_type}, {params['BackupSetId']}\n")
        # Mark the backup set as uploaded.
        params['UploadStatus'] = 'UploadSuccess'
        self.configure_backup_set_info(params)
        print(f"------ configure_backup_set_info success: {file_path}, {data_type}, {params['BackupSetId']}, UploadSuccess\n")
if __name__ == '__main__':
    args = init_command_args()
    uploader = OssUploader(args.access_key_id, args.access_key_secret,
                           args.endpoint, args.region_code, args.datasource_id)
    # Construct extra_meta differently for full backups and log backups.
    extra_meta = '{}'
    if args.data_type == 'FullBackup':
        obj = {}
        if args.xtrabackup_log_path is not None:
            obj = xtrabackup_log_parser.analyze_slave_status(logpath=args.xtrabackup_log_path)
        elif args.xtrabackup_info_path is not None:
            parser = xtrabackup_info_parser.ExtraMetaParser(file_path=args.xtrabackup_info_path)
            obj = parser.get_extra_meta()
        extra_meta = {'BINLOG_FILE': obj.get('BINLOG_FILE'),
                      'version': obj.get("SERVER_VERSION"),
                      'dataBegin': date_to_unix_timestamp(obj.get("START_TIME")),
                      'dataEnd': date_to_unix_timestamp(obj.get("END_TIME")),
                      'consistentTime': int(date_to_unix_timestamp(obj.get("END_TIME")) / 1000)}
        extra_meta = json.dumps(extra_meta)
    elif args.data_type == 'LogBackup':
        obj = {'dataBegin': date_to_unix_timestamp(args.begin_time),
               'dataEnd': date_to_unix_timestamp(args.end_time)}
        extra_meta = json.dumps(obj)
    print(f"get extra meta json string: {extra_meta}")
    # Upload the data and register the backup set metadata.
    uploader.upload_and_register_backup_set(file_path=args.file_path, data_type=args.data_type, extra_meta=extra_meta)

xtrabackup_info_parser.py : ce script analyse les métadonnées du fichier xtrabackup_info.

# -*- coding: utf-8 -*-
# This file is auto-generated, don't edit it. Thanks.
import re
import json
class ExtraMetaParser:
    def __init__(self, file_path):
        self.file_path = file_path
        pass
    def _parse_xtrabackup_info(self):
        config_data = {}
        with open(self.file_path, 'r') as file:
            for line in file:
                line = line.strip()
                if line and not line.startswith('#'):
                    key, value = line.split('=', 1)
                    config_data[key.strip()] = value.strip()
        return config_data
    def get_extra_meta(self):
        config_data = self._parse_xtrabackup_info()
        print(f"xtrabackup_info: {config_data}")
        binlog_pos = config_data.get("binlog_pos")
        pattern = f"filename '(.*)', position (.*)"
        match = re.search(pattern, binlog_pos)
        return {'BINLOG_FILE': match.group(1),
                'SERVER_VERSION': config_data.get("server_version"),
                'START_TIME': config_data.get("start_time"),
                'END_TIME': config_data.get("end_time")}

xtrabackup_log_parser.py : ce script analyse les métadonnées du fichier xtrabackup.log généré pendant le processus de sauvegarde.

#!/usr/bin/python
# coding:utf8
import io
import re
import sys
from datetime import datetime
from six import binary_type, text_type
def parse_date_part(date_part, time_part):
    """
    Parses and returns a full datetime string from the given date and time parts.
    """
    # Get the first two digits of the current year (the century).
    current_century = datetime.now().strftime("%Y")[:2]
    year_short = date_part[:2]
    # Construct the full year.
    year_full = current_century + year_short
    date_full = year_full + date_part[2:]
    datetime_str = date_full + " " + time_part
    dt = datetime.strptime(datetime_str, "%Y%m%d %H:%M:%S")
    formatted_datetime = dt.strftime("%Y-%m-%d %H:%M:%S")
    return text_type(formatted_datetime)
def analyze_slave_status(logpath=None):
    slave_status = {}
    start_time_pattern = (
        r"(\d{6}) (\d{2}:\d{2}:\d{2}) .*Connecting to MySQL server host:"
    )
    """
        240925 17:46:58 completed OK!
        240925 02:22:58 innobackupex: completed OK!
        240925 02:22:58 xtrabackup: completed OK!
    """
    end_time_pattern = r"(\d{6}) (\d{2}:\d{2}:\d{2}) .*completed OK!"
    with io.open(logpath, "rb") as fp:
        lines = fp.read().splitlines()
        for i in reversed(range(len(lines))):
            line = lines[i]
            if isinstance(line, binary_type):
                line = line.decode("utf-8")
            m = re.search(start_time_pattern, line)
            if m:
                # Extract the date and time parts.
                date_part = m.group(1)
                time_part = m.group(2)
                slave_status["START_TIME"] = parse_date_part(date_part, time_part)
                continue
            m = re.search(r"Using server version (\S*)", line)
            if m:
                slave_status["SERVER_VERSION"] = text_type(m.group(1))
                continue
            m = re.search("MySQL binlog position:", line)
            if m:
                binlog_line = line
                m = re.search(r"filename '(\S*)'", binlog_line)
                if m:
                    slave_status["BINLOG_FILE"] = text_type(m.group(1))
                m = re.search(r"position (\d+)", binlog_line)
                m2 = re.search(r"position '(\d+)'", binlog_line)
                if m:
                    try:
                        slave_status["BINLOG_POS"] = int(m.group(1))
                    except ValueError:
                        pass
                elif m2:
                    try:
                        slave_status["BINLOG_POS"] = int(m2.group(1))
                    except ValueError:
                        pass
                continue
            m = re.search("consistent_time (\d+)", line)
            if m:
                try:
                    slave_status["CONSISTENT_TIME"] = int(m.group(1))
                except ValueError:
                    pass
                continue
            m = re.search(end_time_pattern, line)
            if m:
                date_part = m.group(1)
                time_part = m.group(2)
                slave_status["END_TIME"] = parse_date_part(date_part, time_part)
                continue
    return slave_status
if __name__ == "__main__":
    logpath = sys.argv[1]
    slave_status = analyze_slave_status(logpath)
    print(slave_status)

Flux de travail du script Bash

Définissez votre AccessKey ID et votre AccessKey Secret, l'endpoint OpenAPI du Database Backup Service (DBS) ainsi que l'ID de la source de données.

#!/bin/bash
## The AccessKey pair of an Alibaba Cloud account has permissions on all API operations. Using these credentials to perform operations is a high-risk practice. We recommend that you create and use a RAM user for API access or routine O&M.
## For security reasons, do not hardcode your AccessKey ID and AccessKey secret in your code. This can lead to credential leaks. Instead, store them in a configuration file or use environment variables.
AK=<YOUR_ACCESS_KEY_ID>
SK=<YOUR_ACCESS_KEY_SECRET>
DBS_API=dbs-api.<your-region-id>.aliyuncs.com
DATASOURCE_ID=<your-data-source-id>

Exécutez la commande Xtrabackup pour enregistrer les données de sauvegarde dans un répertoire spécifié et redirigez le journal des erreurs vers le fichier xtrabackup.log.
```
## Get the current path of the script.
BASE_PATH=$(cd `dirname $0`; pwd)
TS=`date +%Y%m%d_%H%M%S`
XTRA_DATA_DIR=~/tool/xtrabackup_data/$TS
mkdir -p $XTRA_DATA_DIR
## Run the Xtrabackup command and redirect error logs to the xtrabackup.log file.
~/innobackupex --defaults-file=/etc/my.cnf --user='<your-db-account>' --password='<your-db-password>' --host='<your-db-host>' --port=<your-db-port> --socket='/var/lib/mysql/mysql.sock' --parallel=4 $XTRA_DATA_DIR/ 2>$XTRA_DATA_DIR/xtrabackup.log
```
- Le script analyse ensuite le fichier xtrabackup.log pour obtenir les métadonnées de l'ensemble de sauvegarde complet. Ces métadonnées incluent l'heure de début et de fin de la sauvegarde, le point de cohérence ainsi que le nom du fichier binlog correspondant.
- Limitation :
  
  La commande Xtrabackup ne prend actuellement pas en charge les paramètres de compression et de chiffrement (--compress, --compress-threads, --encrypt, --encrypt-key-file et --encrypt-threads). Supprimez ces paramètres avant d'exécuter la commande.
Compressez et archivez le répertoire des données de sauvegarde complète dans un fichier .tar.gz.
```
## Get the current Xtrabackup backup directory.
backup_dir=`ls $XTRA_DATA_DIR | grep -v xtrabackup.log | head -n1`
echo -e "\033[33mexecute innobackupex success, backup_dir: $backup_dir" && echo -n -e "\033[0m" && chmod 755 $XTRA_DATA_DIR/$backup_dir
## Package the directory into a .tar.gz file.
cd $XTRA_DATA_DIR/$backup_dir && tar -czvf ../$backup_dir.tar.gz . && file ../$backup_dir.tar.gz
echo -e "\033[33mpackage to $backup_dir.tar.gz" && echo -n -e "\033[0m" && sleep 2
```
- Limitation : DBS accepte uniquement les données de sauvegarde dans les formats de fichier suivants :
  - tar : le répertoire est archivé dans un fichier .tar.
  - tar.gz : le répertoire est archivé dans un fichier .tar, puis compressé à l'aide de Gzip.
- Remarques d'utilisation :
  - Avant d'exécuter la commande tar, utilisez la commande chmod 755 pour définir les autorisations du répertoire.
  - Avant d'exécuter la commande tar, accédez à la racine du répertoire que vous souhaitez archiver.

Exécutez le script upload_and_register_backup_set.py pour télécharger les données de sauvegarde et enregistrer leurs métadonnées.

## Call the Python script to upload the backup file and register its metadata.
python3 $BASE_PATH/upload_and_register_backup_set.py --access_key_id $AK --access_key_secret $SK --endpoint $DBS_API --datasource_id $DATASOURCE_ID --region_code=cn-hangzhou --data_type=FullBackup --file_path=$XTRA_DATA_DIR/$backup_dir.tar.gz --xtrabackup_log_path=$XTRA_DATA_DIR/xtrabackup.log

Paramètre

Description

--access_key_id

Votre AccessKey ID Alibaba Cloud.

--access_key_secret

Votre AccessKey Secret Alibaba Cloud.

--endpoint

L'endpoint API du Database Backup Service (DBS).

--datasource_id

L'ID de la source de données dans DBS.

--region_code

L'ID de la région où réside la source de données.

--data_type

Le type de données de sauvegarde. Valeurs possibles : FullBackup pour une sauvegarde complète et LogBackup pour une sauvegarde des journaux.

--file_path

Le chemin d'accès au fichier de données de sauvegarde complète.

--xtrabackup_log_path

Le chemin d'accès au fichier xtrabackup.log généré lors de la sauvegarde complète.

Flux de travail du script Python

La fonction main constitue le point d'entrée.

Selon le paramètre data_type (FullBackup ou LogBackup), le script construit les informations extra_meta requises pour l'enregistrement des métadonnées.
Remarque
- BINLOG_FILE : le nom du fichier binlog.
- dataBegin : l'heure de début de la sauvegarde, sous forme d'horodatage Unix en millisecondes.
- dataEnd : l'heure de fin de la sauvegarde, sous forme d'horodatage Unix en millisecondes.
- consistentTime : le point de cohérence, sous forme d'horodatage Unix en secondes.
- Format de extra_meta pour une sauvegarde complète :
```
{
  'BINLOG_FILE':'mysql-bin.001',
  'version':'5.5',
  'dataBegin':17274********,
  'dataEnd':17274********,
  'consistentTime':17274********
}
```
- Format de extra_meta pour une sauvegarde des journaux :
```
{
  'dataBegin':17274********,
  'dataEnd':17274********
}
```

Appelez la méthode OssUploader.upload_and_register_backup_set pour télécharger les données de sauvegarde et enregistrer leurs métadonnées.

if __name__ == '__main__':
    args = init_command_args()
    uploader = OssUploader(args.access_key_id, args.access_key_secret,
                           args.endpoint, args.region_code, args.datasource_id)
    # Construct extra_meta differently for full backups and log backups.
    extra_meta = '{}'
    if args.data_type == 'FullBackup':
        obj = {}
        if args.xtrabackup_log_path is not None:
            obj = xtrabackup_log_parser.analyze_slave_status(logpath=args.xtrabackup_log_path)
        elif args.xtrabackup_info_path is not None:
            parser = xtrabackup_info_parser.ExtraMetaParser(file_path=args.xtrabackup_info_path)
            obj = parser.get_extra_meta()
        extra_meta = {'BINLOG_FILE': obj.get('BINLOG_FILE'),
                      'version': obj.get("SERVER_VERSION"),
                      'dataBegin': date_to_unix_timestamp(obj.get("START_TIME")),
                      'dataEnd': date_to_unix_timestamp(obj.get("END_TIME")),
                      'consistentTime': int(date_to_unix_timestamp(obj.get("END_TIME")) / 1000)}
        extra_meta = json.dumps(extra_meta)
    elif args.data_type == 'LogBackup':
        obj = {'dataBegin': date_to_unix_timestamp(args.begin_time),
               'dataEnd': date_to_unix_timestamp(args.end_time)}
        extra_meta = json.dumps(obj)
    print(f"get extra meta json string: {extra_meta}")
    # Upload the data and register the backup set metadata.
    uploader.upload_and_register_backup_set(file_path=args.file_path, data_type=args.data_type, extra_meta=extra_meta)

Le processus de téléchargement au sein de la méthode OssUploader.upload_and_register_backup_set.

class OssUploader:
    def __init__(self, access_key_id, access_key_secret, endpoint, region_code, datasource_id):
        self.access_key_id = access_key_id
        self.access_key_secret = access_key_secret
        self.endpoint = endpoint
        self.region_code = region_code
        self.datasource_id = datasource_id
        config = open_api_models.Config(access_key_id, access_key_secret)
        # For more information about endpoints, see https://api.alibabacloud.com/product/Dbs.
        config.endpoint = endpoint
        self.client = OpenApiClient(config)
    """
    Registers backup set metadata.
    """
    def configure_backup_set_info(self, req_param):
        params = open_api_models.Params(
            # The name of the API operation.
            action='ConfigureBackupSetInfo',
            # The version of the API operation.
            version='2021-01-01',
            # The protocol.
            protocol='HTTPS',
            # The HTTP method.
            method='POST',
            auth_type='AK',
            style='RPC',
            # The path of the API operation.
            pathname='/',
            # The format of the request body.
            req_body_type='json',
            # The format of the response body.
            body_type='json'
        )
        # Runtime options.
        runtime = util_models.RuntimeOptions()
        request = open_api_models.OpenApiRequest(
            query=OpenApiUtilClient.query(req_param)
        )
        # The response is a map that contains the response body, headers, and HTTP status code.
        print(f"ConfigureBackupSetInfo request: {req_param}")
        data = self.client.call_api(params, request, runtime)
        print(f"ConfigureBackupSetInfo response: {data}")
        return data['body']['Data']
    """
    Gets OSS upload information.
    """
    def describe_bak_datasource_storage_access_info(self, req_param):
        params = open_api_models.Params(
            # The name of the API operation.
            action='DescribeBakDataSourceStorageAccessInfo',
            # The version of the API operation.
            version='2021-01-01',
            # The protocol.
            protocol='HTTPS',
            # The HTTP method.
            method='POST',
            auth_type='AK',
            style='RPC',
            # The path of the API operation.
            pathname='/',
            # The format of the request body.
            req_body_type='json',
            # The format of the response body.
            body_type='json'
        )
        # Runtime options.
        runtime = util_models.RuntimeOptions()
        request = open_api_models.OpenApiRequest(
            query=OpenApiUtilClient.query(req_param)
        )
        # The response is a map that contains the response body, headers, and HTTP status code.
        print(f"DescribeBakDataSourceStorageAccessInfo request: {req_param}")
        data = self.client.call_api(params, request, runtime)
        print(f"DescribeBakDataSourceStorageAccessInfo response: {data}")
        return data['body']['Data']
    def _fetch_oss_access_info(self, params):
        info = self.describe_bak_datasource_storage_access_info({
            'RegionId': params['RegionId'],
            'DataSourceId': params['DataSourceId'],
            'RegionCode': params['RegionCode'],
            'BackupType': params['BackupType'],
            'BackupSetId': params['BackupSetId']
        })
        return info['OssAccessInfo']
    def upload_and_register_backup_set(self, file_path, data_type, extra_meta):
        filename = os.path.basename(file_path)
        params = {'BackupMode': 'Automated', 'BackupMethod': 'Physical', 'RegionId': self.region_code,
                  'RegionCode': self.region_code, 'DataSourceId': self.datasource_id, 'BackupSetName': filename,
                  'ExtraMeta': extra_meta, 'BackupType': data_type, 'UploadStatus': 'WaitingUpload'}
        # Register the backup set for the first time to obtain a backup set ID.
        data = self.configure_backup_set_info(params)
        params['BackupSetId'] = data['BackupSetId']
        print(f"------ configure_backup_set_info success: {file_path}, {data_type}, {params['BackupSetId']}, WaitingUpload\n")
        # Upload the file to OSS.
        oss_info = self._fetch_oss_access_info(params)
        oss_client = create_oss_client(oss_info)
        upload_oss_file(oss_client, file_path, oss_info['ObjectKey'])
        print(f"------ upload_oss_file success: {file_path}, {data_type}, {params['BackupSetId']}\n")
        # Mark the backup set as uploaded.
        params['UploadStatus'] = 'UploadSuccess'
        self.configure_backup_set_info(params)
        print(f"------ configure_backup_set_info success: {file_path}, {data_type}, {params['BackupSetId']}, UploadSuccess\n")