ApsaraDB RDS:Migração de SQL Server para a nuvem no nível de instância

Pré-requisitos

• A source deve ser um banco de dados SQL Server autogerenciado.

• The destination ApsaraDB RDS for SQL Server instance deve atender aos seguintes requisitos:

  • O espaço de armazenamento disponível na instância deve ser maior que o tamanho dos arquivos de dados a serem migrados. Se o espaço for insuficiente, upgrade the instance specifications.

  • Para o SQL Server 2008 R2, crie um database na instância de destino com o mesmo nome do banco de dados de source. Esse requisito não se aplica a outras versões.

• Se você fizer login como usuário RAM, atenda aos seguintes requisitos:

  • O usuário RAM deve ter as permissões AliyunOSSFullAccess e AliyunRDSFullAccess. Para obter mais informações sobre como conceder permissões a um usuário RAM, consulte Manage OSS permissions by using RAM e Manage ApsaraDB RDS permissions by using RAM.

  • Sua conta Alibaba Cloud (conta primária) deve ter autorizado a conta de serviço oficial do ApsaraDB RDS a acessar seus recursos do OSS.

    Clique em para visualizar o método de autorização

    1. Acesse a página Restoration da instância ApsaraDB RDS e clique em Restore Backup Data from OSS.

    2. Na página Import Guide, clique em Next duas vezes para avançar até a etapa 3. Import Data.

       Se a mensagem You have authorized the ApsaraDB RDS official service account to access your OSS resources aparecer no canto inferior esquerdo da página, a autorização estará concluída. Caso contrário, clique em Authorization URL na página para conceder a autorização.

       Na página 3. Data Import, configure os seguintes parâmetros:

       • Database Name: Insira o nome do banco de dados de destino.

       • OSS Bucket: Selecione na lista suspensa o bucket que armazena o arquivo de backup carregado.

       • OSS File List: Insira um prefixo de nome de arquivo para pesquisar o arquivo de backup e selecione-o.

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

       • Consistency Check Method: Selecione Synchronous DBCC ou Asynchronous DBCC.

  • Crie manualmente uma create a permission policy na sua conta Alibaba Cloud (conta primária) e anexe a política ao usuário RAM.

    Clique em para visualizar o conteúdo da política

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

Limitações

Esta solução suporta apenas migração completa; a migração incremental não é suportada atualmente.

Faturamento

Ao utilizar o método descrito neste tópico para migrar dados, há cobrança apenas pelo uso de buckets do OSS.

Pré-requisitos

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. Fazer backup de bancos de dados SQL Server autogerenciados

1. Baixe o script de backup.

2. Clique em duas vezes no script de backup para abri-lo no Microsoft SQL Server Management Studio (SSMS). Para instruções sobre como conectar-se usando o SSMS, consulte a documentação oficial.

3. Modifique os seguintes parâmetros conforme necessário.

   Clique em para expandir o exemplo

   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	Descrição
   @backup_databases_list	Os bancos de dados a serem copiados. Use ponto e vírgula (;) ou vírgula (,) para separar vários nomes de bancos de dados.
   @backup_type	O tipo de backup. Valores válidos: FULL: backup completo. DIFF: backup diferencial. LOG: backup de log. Importante Para este procedimento, defina este parâmetro como FULL.
   @backup_folder	O diretório local para armazenar os arquivos de backup. Este diretório é criado automaticamente se não existir.
   @is_run	Especifica se o backup deve ser executado. Valores válidos: 1: Executa o backup. 0: Realiza apenas uma verificação.

4. Execute o script de backup para copiar os bancos de dados para o diretório especificado.

   Após a conclusão do backup, arquivos de backup .bak serão gerados no diretório C:\backup, por exemplo, dtstestdata_FULL_20200408154821.bak e testdb_FULL_20200408154821.bak. Esses arquivos indicam que o script de backup foi executado com sucesso.

2. Carregar arquivos de backup no OSS

1. Antes de carregar arquivos de backup no OSS, crie um bucket no OSS.

   • Se já existir um bucket no OSS, certifique-se de que ele atenda aos seguintes requisitos:

     • A storage class do bucket é Standard. As classes de armazenamento IA, Archive, Cold Archive e Deep Cold Archive não são suportadas.

     • Server-side encryption não está ativado para o bucket.

   • Se não houver nenhum bucket no OSS, crie um bucket primeiro. (Certifique-se de que o OSS esteja activated.)

     1. Faça login no console do OSS, clique em Buckets e depois em Create bucket.

     2. Configure os seguintes parâmetros principais e mantenha os valores padrão para os demais.

        Importante

        • Este bucket serve exclusivamente para esta migração de dados , portanto, basta configure os parâmetros essenciais. Após terminar a migração, exclua o bucket prontamente para evitar vazamentos de dados e custos adicionais.

        • Não ative server-side encryption ao crie o bucket.

        Parâmetro	Descrição	Exemplo
        Bucket Name	Nome do bucket. Deve ser globalmente único e não pode ser alterado após a crie do bucket. Regras de nomenclatura: O nome pode conter apenas letras minúsculas, dígitos e hifens (-). Deve começar e terminar com uma letra minúscula ou dígito. O comprimento deve estar entre 3 e 63 caracteres.	migratetest
        Region	Região onde o bucket reside. Ao carregar dados no bucket a partir de uma instância ECS via rede interna e restaurar os dados na instância ApsaraDB RDS também pela rede interna, garanta que a instância ECS, o bucket e a instância ApsaraDB RDS estejam na mesma região.	China (Hangzhou)
        Storage Type	Selecione Standard. A operação de migração descrita neste tópico não suporta buckets de outras classes de armazenamento.	Standard

2. Carregue o arquivo de backup no OSS.

   Após concluir o backup do banco de dados autogerenciado, carregue o arquivo de backup em um bucket do OSS localizado na mesma região da sua instância ApsaraDB RDS. Quando o bucket e a instância ApsaraDB RDS residem na mesma região, a comunicação ocorre via rede interna. Nesse cenário, não há cobrança de tráfego de Internet e o upload de dados é mais rápido. Escolha um dos métodos abaixo:

   Carregar arquivos usando ossbrowser (recomendado)

   1. Baixe ossbrowser.

   2. Neste exemplo, utiliza-se Windows x64. Descompacte o pacote baixado oss-browser-win32-x64.zip e clique em duas vezes no aplicativo oss-browser.exe.

   3. Selecione AK como método de login, configure os parâmetros Access Key ID e Access Key Secret, mantenha os valores padrão para os demais parâmetros e clique em Log On.

      Nota

      Um AccessKey é utilizado para autenticação de identidade visando garantir a segurança dos dados. Mantenha seu AccessKey confidencial.

   4. Clique em no bucket de destino para acessá-lo.

   5. Clique em , selecione o arquivo de backup desejado e clique em Abrir. O arquivo local será carregado no OSS.

   Carregar arquivos usando o console do OSS

   Nota

   Se o arquivo de backup tiver menos de 5 GB, carregue-o diretamente pelo console do OSS.

   1. Faça login no console do OSS.

   2. Clique em Buckets e selecione o nome do bucket de destino.

   3. Na seção Files, clique em Upload File.

   4. Arraste o arquivo de backup para a área Files to Upload ou clique em Select Files e escolha o arquivo de backup a ser carregado.

   5. Clique em Upload File na parte inferior da página. O arquivo de backup local será enviado ao OSS.

   Carregar arquivos usando a API do OSS (exemplo de projeto Python 3)

   Nota

   Para arquivos de backup maiores que 5 GB, chame operações da API do OSS para realizar o upload multipart.

   # -*- 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. Executar o script de migração

1. Baixe o script de migração do SQL Server.

2. Após extrair o pacote, execute o comando abaixo para visualize os parâmetros do script.

   python ~/Downloads/RDSSQLCreateMigrateTasksBatchly.py -h

   O comando retorna a seguinte saída:

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

   A tabela a seguir descreve os parâmetros.

   Parâmetro	Descrição
   access_key_id	O AccessKey ID da sua conta Alibaba Cloud.
   access_key_secret	O AccessKey Secret da sua conta Alibaba Cloud.
   rds_instance_id	O ID da instância RDS de destino.
   oss_endpoint	A endpoint da região do OSS onde seu bucket está localizado.
   oss_bucket	Nome do bucket que contém os arquivos de backup.
   directory	Diretório no bucket do OSS para os arquivos de backup. Para o diretório raiz, insira /.

3. Execute o script de migração para concluir o processo.

   Este tópico apresenta um exemplo de migração completa de todos os arquivos de backup que atendem a condições específicas do diretório Migrationdata em um bucket do OSS chamado testdatabucket para uma instância ApsaraDB RDS for SQL Server com o ID rm-2zesz5774ud8s****.

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

4. Visualizar o progresso da tarefa de migração

Siga as instruções correspondentes à versão do SQL Server da sua instância ApsaraDB RDS.

Erros comuns

Operações de API relacionadas