Data Management:Backups de bancos de dados on-premises e em nuvens de terceiros

Este é o ponto de entrada para a execução do script. Substitua os parâmetros de espaço reservado pelos seus valores reais conforme necessário.

boot_backup.sh: Este script simula a criação de um backup completo local usando 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

• upload_and_register_backup_set.py: Este script carrega dados de backup completo e de log, analisa os metadados correspondentes e registra os metadados do conjunto de backup no 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: Este script analisa metadados do arquivo 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: Este script analisa metadados do arquivo xtrabackup.log gerado durante o processo de backup.

  #!/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)