ApsaraDB RDS:Instance-level migration of SQL Server to the cloud

Requisitos previos

• El origen debe ser una base de datos SQL Server autogestionada.

• The destination ApsaraDB RDS for SQL Server instance debe cumplir con los siguientes requisitos:

  • El espacio de almacenamiento disponible en la instancia debe ser mayor que el tamaño de los archivos de datos que se van a migrar. Si el espacio de almacenamiento disponible es insuficiente, upgrade the instance specifications.

  • Para SQL Server 2008 R2, debe crear una database en la instancia de destino con el mismo nombre que la base de datos de origen. Este requisito no aplica para otras versiones.

• Si inicia sesión como usuario de RAM, se deben cumplir los siguientes requisitos:

  • El usuario de RAM tiene asignados los permisos AliyunOSSFullAccess y AliyunRDSFullAccess. Para obtener más información sobre cómo otorgar permisos a un usuario de RAM, consulte Manage OSS permissions by using RAM y Manage ApsaraDB RDS permissions by using RAM.

  • Su cuenta de Alibaba Cloud (cuenta principal) autorizó a la cuenta de servicio oficial de ApsaraDB RDS a acceder a sus recursos de OSS.

    Haga clic en para ver el método de autorización

    1. Vaya a la página Restoration de la instancia de ApsaraDB RDS y luego haga clic en Restore Backup Data from OSS.

    2. En la página Import Guide, haga clic dos veces en Next para ir al paso 3. Import Data.

       Si en la esquina inferior izquierda de la página aparece You have authorized the ApsaraDB RDS official service account to access your OSS resources, la autorización ya se completó. De lo contrario, aún no está lista. En ese caso, haga clic en Authorization URL en la página para otorgarla.

       En la página 3. Data Import, configure los siguientes parámetros:

       • Database Name: introduzca el nombre de la base de datos de destino.

       • OSS Bucket: seleccione en la lista desplegable el bucket que almacena el archivo de copia de seguridad cargado.

       • OSS File List: introduzca un prefijo de nombre de archivo para buscar el archivo de copia de seguridad y luego selecciónelo.

       • Migration Method: seleccione Open Database (Only One Full Backup File) o Do Not Open Database (Differential Backup or Log Files Available).

       • Consistency Check Method: seleccione Synchronous DBCC o Asynchronous DBCC.

  • Cree manualmente create a permission policy en su cuenta de Alibaba Cloud (cuenta principal) y luego asigne la política al usuario de RAM.

    Haga clic en para ver el contenido de la política

    {
        "Version": "1",
        "Statement": [
            {
                "Action": [
                    "ram:GetRole"
                ],
                "Resource": "acs:ram:*:*:role/AliyunRDSImportRole",
                "Effect": "Allow"
            }
        ]
    }

Limitaciones

Esta solución solo admite la migración completa; actualmente no es compatible con la migración incremental.

Facturación

Si utiliza el método descrito en este tema para migrar datos, solo se le cobrará por el uso de los buckets de OSS.

Requisitos previos

python --version
python3 --version
py --version

python --version
python3 --version

pip install alibabacloud_rds20140815
pip install alibabacloud-oss-v2
pip install alibabacloud_tea_openapi
pip install alibabacloud_tea_util

1. Respalde las bases de datos SQL Server autogestionadas

1. Descargue el script de copia de seguridad.

2. Haga doble clic en el script de copia de seguridad para abrirlo en Microsoft SQL Server Management Studio (SSMS). Para obtener instrucciones sobre cómo conectarse con SSMS, consulte la documentación oficial.

3. Modifique los siguientes parámetros según sea necesario.

   Haga clic en para expandir el ejemplo

   SELECT
       /**
       * The list of databases to back up. Use a semicolon (;) or a comma (,) as the delimiter.
       * An empty value ('') or null backs up all databases except for system databases.
       * example: '[testdb]: TestDR, Test, readonly'
       **/
       @backup_databases_list = N'[dtstestdata],[testdb]'
       @backup_type = N'FULL',                    -- The backup type. Valid values: FULL (full backup), DIFF (differential backup), LOG (log backup).
       @backup_folder = N'C:\BACKUP'              -- The folder to store the backup files.
       @is_run = 1                                -- Specifies whether to run the backup. 1: Runs the backup. 0: Performs a check only.

   Parámetro	Descripción
   @backup_databases_list	Las bases de datos que se van a respaldar. Utilice un punto y coma (;) o una coma (,) para separar varios nombres de bases de datos.
   @backup_type	El tipo de copia de seguridad. Valores válidos: FULL: copia de seguridad completa. DIFF: copia de seguridad diferencial. LOG: copia de seguridad de registros. Importante Para este procedimiento, debe establecer este parámetro en FULL.
   @backup_folder	El directorio local donde se almacenarán los archivos de copia de seguridad. Este directorio se crea automáticamente si no existe.
   @is_run	Especifica si se ejecuta la copia de seguridad. Valores válidos: 1: ejecuta la copia de seguridad. 0: solo realiza una comprobación.

4. Ejecute el script de copia de seguridad para respaldar las bases de datos en el directorio especificado.

   Una vez finalizada la copia de seguridad, se generan archivos de copia de seguridad .bak en el directorio C:\backup, por ejemplo, dtstestdata_FULL_20200408154821.bak y testdb_FULL_20200408154821.bak. Estos archivos indican que el script de copia de seguridad se ejecutó correctamente.

2. Cargue los archivos de copia de seguridad en OSS

1. Antes de cargar los archivos de copia de seguridad en OSS, debe crear un bucket en OSS.

   • Si ya existe un bucket en OSS, asegúrese de que cumpla con los siguientes requisitos:

     • La storage class del bucket es Standard. Las clases de almacenamiento IA, Archive, Cold Archive y Deep Cold Archive no son compatibles.

     • Server-side encryption no está habilitado para el bucket.

   • Si no existe ningún bucket en OSS, cree uno primero. (Asegúrese de que OSS esté activated.)

     1. Inicie sesión en la consola de OSS, haga clic en Buckets y luego haga clic en Create bucket.

     2. Configure los siguientes parámetros clave y conserve los valores predeterminados para el resto.

        Importante

        • El bucket se usa únicamente para esta migración de datos , por lo que solo necesita configurar los parámetros clave. Una vez concluida la migración, elimine el bucket oportunamente para evitar fugas de datos y cargos adicionales.

        • No habilite server-side encryption al crear el bucket.

        Parámetro	Descripción	Ejemplo
        Bucket Name	El nombre del bucket. El nombre debe ser único a nivel global y no se puede cambiar después de crear el bucket. Reglas de nomenclatura: El nombre solo puede contener letras minúsculas, dígitos y guiones (-). El nombre debe comenzar y terminar con una letra minúscula o un dígito. El nombre debe tener entre 3 y 63 caracteres de longitud.	migratetest
        Region	La región donde reside el bucket. Si carga datos en el bucket desde una instancia de ECS a través de la red interna y restaura los datos en la instancia de ApsaraDB RDS también por la red interna, asegúrese de que la instancia de ECS, el bucket y la instancia de ApsaraDB RDS residan en la misma región.	China (Hangzhou)
        Storage Type	Seleccione Standard. La operación de migración descrita en este tema no admite buckets de otras clases de almacenamiento.	Standard

2. Cargue el archivo de copia de seguridad en OSS.

   Cuando termine de respaldar la base de datos autogestionada, cargue el archivo de copia de seguridad en un bucket de OSS que resida en la misma región que su instancia de ApsaraDB RDS. Si el bucket y la instancia de ApsaraDB RDS están en la misma región, pueden comunicarse a través de la red interna. En este caso, no se generan cargos por tráfico de Internet y los datos se cargan más rápido. Puede usar uno de los siguientes métodos:

   Cargar archivos con ossbrowser (recomendado)

   1. Descargue ossbrowser.

   2. En este ejemplo se utiliza Windows x64. Descomprima el paquete descargado oss-browser-win32-x64.zip y luego haga doble clic en la aplicación oss-browser.exe.

   3. Seleccione AK como método de inicio de sesión, configure los parámetros Access Key ID y Access Key Secret, conserve los valores predeterminados para el resto y luego haga clic en Log On.

      Nota

      Un AccessKey se utiliza para la autenticación de identidad con el fin de garantizar la seguridad de los datos. Mantenga su AccessKey en secreto.

   4. Haga clic en el bucket de destino para acceder a él.

   5. Haga clic en , seleccione el archivo de copia de seguridad que desea cargar y luego haga clic en Open. El archivo local se carga en OSS.

   Cargar archivos mediante la consola de OSS

   Nota

   Si el archivo de copia de seguridad pesa menos de 5 GB, cárguelo directamente en la consola de OSS.

   1. Inicie sesión en la consola de OSS.

   2. Haga clic en Buckets y luego haga clic en el nombre del bucket de destino.

   3. En Files, haga clic en Upload File.

   4. Arrastre el archivo de copia de seguridad a la sección Files to Upload o haga clic en Select Files y seleccione el archivo de copia de seguridad que desea cargar.

   5. Haga clic en Upload File en la parte inferior de la página. El archivo de copia de seguridad local se carga en OSS.

   Cargar archivos mediante la API de OSS (ejemplo de proyecto en Python 3)

   Nota

   Si el archivo de copia de seguridad pesa más de 5 GB, llame a las operaciones de la API de OSS para cargarlo en el bucket de OSS mediante carga multiparte.

   # -*- coding: utf-8 -*-
   """
   Alibaba Cloud OSS Python SDK v2
   Dependency: pip install alibabacloud-oss-v2
   """
   
   import os
   import sys
   from pathlib import Path
   import alibabacloud_oss_v2 as oss
   from alibabacloud_oss_v2 import exceptions as oss_ex
   
   def get_client_from_env(region: str, endpoint: str | None = None) -> oss.Client:
       """
       Create a v2 client from environment variables.
       - Prioritize using Region (recommended), but also support custom Endpoints (optional).
       - Compatible with both AK and STS:
           * AK: Requires OSS_ACCESS_KEY_ID / OSS_ACCESS_KEY_SECRET
           * STS: Also requires OSS_SESSION_TOKEN (compatible with the old variable OSS_SECURITY_TOKEN)
       """
       # Compatibility: If the user uses the old variable OSS_SECURITY_TOKEN, map it to the v2 expected OSS_SESSION_TOKEN
       sec_token_legacy = os.getenv("OSS_SECURITY_TOKEN")
       if sec_token_legacy and not os.getenv("OSS_SESSION_TOKEN"):
           os.environ["OSS_SESSION_TOKEN"] = sec_token_legacy
   
       ak = os.getenv("OSS_ACCESS_KEY_ID")
       sk = os.getenv("OSS_ACCESS_KEY_SECRET")
       st = os.getenv("OSS_SESSION_TOKEN")  # STS Token (optional)
   
       if not (ak and sk):
           raise ValueError("No valid AK found. Set the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables. "
                            "If using STS, also set OSS_SESSION_TOKEN (or the old name OSS_SECURITY_TOKEN).")
   
       # Indicate the type of credential used
       if st:
           print("STS Token (OSS_SESSION_TOKEN) detected. Using STS credentials.")
       else:
           print("No STS Token detected. Using AccessKey (AK) credentials.")
   
       credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()
       cfg = oss.config.load_default()
       cfg.credentials_provider = credentials_provider
   
       # Basic network configuration
       cfg.region = region  # Example: 'cn-hangzhou'
       if endpoint:
           # Optional: Custom Endpoint (e.g., internal network, accelerated, dedicated domain)
           cfg.endpoint = endpoint
   
       # You can also add other configurations here, such as: cfg.use_accelerate_endpoint = True
       return oss.Client(cfg)
   
   def resumable_upload_file_v2(
       client: oss.Client,
       bucket_name: str,
       object_key: str,
       file_path: str,
       part_size: int = 1 * 1024 * 1024,
       parallel_num: int = 4,
       checkpoint_dir: str | None = None,
   ):
       """
       Implement concurrent multipart upload with resumable upload.
   
       :param client: Initialized oss.Client
       :param bucket_name: Destination bucket name
       :param object_key: Destination object key (without bucket name)
       :param file_path: Full path of the local file
       :param part_size: Part size in bytes, default is 1 MB
       :param parallel_num: Number of concurrent upload threads, default is 4
       :param checkpoint_dir: Directory to store breakpoint information; if None, resumable upload is disabled
       """
       file_path = str(file_path)
       if not Path(file_path).exists():
           raise FileNotFoundError(f"Error: Local file not found. Check the file_path configuration: {file_path}")
   
       # Construct the Uploader; enable resumable upload based on whether checkpoint_dir is provided
       if checkpoint_dir:
           uploader = client.uploader(
               enable_checkpoint=True,
               checkpoint_dir=checkpoint_dir,
               part_size=part_size,
               parallel_num=parallel_num,
           )
       else:
           uploader = client.uploader(
               part_size=part_size,
               parallel_num=parallel_num,
           )
   
       print(f"Starting to upload file: {file_path}")
       print(f"Destination Bucket: {bucket_name}")
       print(f"Destination Object: {object_key}")
       print(f"Part size: {part_size} bytes, Concurrency: {parallel_num}")
       if checkpoint_dir:
           print(f"Resumable upload: Enabled (checkpoint_dir={checkpoint_dir})")
       else:
           print("Resumable upload: Disabled (set checkpoint_dir to enable)")
   
       # Execute the upload (Uploader automatically chooses between multi/single part concurrent upload based on size)
       result = uploader.upload_file(
           oss.PutObjectRequest(bucket=bucket_name, key=object_key),
           filepath=file_path,
       )
   
       print("-" * 30)
       print("File uploaded successfully!")
       print(f"HTTP Status: {result.status_code}")
       print(f"ETag: {result.etag}")
       print(f"Request ID: {result.request_id}")
       # CRC-64 checksum; v2 enables data validation by default
       print(f"CRC64: {result.hash_crc64}")
       print("-" * 30)
   
   def main():
       # Before running the code example, make sure you have set the corresponding environment variables.
       # macOS/Linux:
       #   AK method:
       #     export OSS_ACCESS_KEY_ID=YOUR_AK_ID
       #     export OSS_ACCESS_KEY_SECRET=YOUR_AK_SECRET
       #   STS method:
       #     export OSS_ACCESS_KEY_ID=YOUR_STS_ID
       #     export OSS_ACCESS_KEY_SECRET=YOUR_STS_SECRET
       #     export OSS_SECURITY_TOKEN=YOUR_STS_TOKEN
       #
       # Windows:
       #   Powershell: $env:OSS_ACCESS_KEY_ID="YOUR_AK_ID"
       #   cmd: set OSS_ACCESS_KEY_ID=YOUR_AK_ID
   
       # ===================== Parameters (modify as needed) =====================
       # Region example: 'cn-hangzhou'; we recommend using Region first
       region = "cn-hangzhou"
   
       # Optional: Custom Endpoint (for internal network, dedicated domain, accelerated domain name, etc.)
       # Example: 'https://oss-cn-hangzhou.aliyuncs.com'
       endpoint = 'https://oss-cn-hangzhou.aliyuncs.com'
   
       # Bucket and Object
       bucket_name = "examplebucket"
       object_key = "test.bak"
   
       # Full path of the local file to upload.
       # Windows example: r'D:\localpath\examplefile.txt'  (note the r at the beginning)
       # macOS/Linux example: '/Users/test/examplefile.txt'
       file_path = r"D:\oss\test.bak"
   
       # Sharding and concurrency
       part_size = 1 * 1024 * 1024  # Default is 1 MB; OSS requires a minimum part size of 100 KB
       parallel_num = 4
   
       # Resumable upload directory (pass None to disable; we recommend specifying a writable directory)
       checkpoint_dir = str(Path.cwd() / ".oss_checkpoints")
       # =================== End of parameters ===================
   
       print("Script execution starts...")
       try:
           client = get_client_from_env(region=region, endpoint=endpoint)
           # If resumable upload is enabled, make sure the directory exists
           if checkpoint_dir:
               Path(checkpoint_dir).mkdir(parents=True, exist_ok=True)
   
           resumable_upload_file_v2(
               client=client,
               bucket_name=bucket_name,
               object_key=object_key,
               file_path=file_path,
               part_size=part_size,
               parallel_num=parallel_num,
               checkpoint_dir=checkpoint_dir,
           )
       except FileNotFoundError as e:
           print(e)
       except oss_ex.ServiceError as e:
           # Error returned by the OSS server
           print("\nAn OSS server-side error occurred.")
           print(f"HTTP Status: {getattr(e, 'status_code', 'N/A')}")
           print(f"Error Code: {getattr(e, 'code', 'N/A')}")
           print(f"Message: {getattr(e, 'message', 'N/A')}")
           print(f"Request ID: {getattr(e, 'request_id', 'N/A')}")
           print(f"Endpoint: {getattr(e, 'request_target', 'N/A')}")
       except oss_ex.BaseError as e:
           # SDK local/serialization/deserialization/credential errors
           print("\nAn OSS SDK client-side error occurred.")
           print(str(e))
       except Exception as e:
           print(f"\nAn unknown error occurred: {e}")
   
   if __name__ == "__main__":
       main()

3. Ejecute el script de migración

1. Descargue el script de migración de SQL Server.

2. Después de extraer el paquete, ejecute el siguiente comando para ver los parámetros del script.

   python ~/Downloads/RDSSQLCreateMigrateTasksBatchly.py -h

   El comando devuelve la siguiente salida:

   RDSSQLCreateMigrateTasksBatchly.py -k <access_key_id> -s <access_key_secret> -i <rds_instance_id> -e <oss_endpoint> -b <oss_bucket> -d <directory>

   A continuación se describen los parámetros.

   Parámetro	Descripción
   access_key_id	El AccessKey ID de su cuenta de Alibaba Cloud.
   access_key_secret	El AccessKey Secret de su cuenta de Alibaba Cloud.
   rds_instance_id	El ID de la instancia de RDS de destino.
   oss_endpoint	El endpoint de la región de OSS donde se encuentra su bucket.
   oss_bucket	El nombre del bucket que contiene los archivos de copia de seguridad.
   directory	El directorio del bucket de OSS para los archivos de copia de seguridad. Para el directorio raíz, introduzca /.

3. Ejecute el script de migración para completar la migración.

   Este tema proporciona un ejemplo de migración completa de todos los archivos de copia de seguridad que cumplen con condiciones específicas desde el directorio Migrationdata de un bucket de OSS llamado testdatabucket hacia una instancia de ApsaraDB RDS for SQL Server con el ID de instancia rm-2zesz5774ud8s****.

   python ~/Downloads/RDSSQLCreateMigrateTasksBatchly.py -k yourAccessKeyID -s yourAccessKeySecret -i rm-2zesz5774ud8s**** -e oss-cn-beijing.aliyuncs.com -b testdatabucket -d Migrationdata

4. Consulte el progreso de la tarea de migración

Siga las instrucciones correspondientes a la versión de SQL Server de su instancia de ApsaraDB RDS.

Errores comunes

Operaciones de API relacionadas