Migrowanie programu MySQL do usługi Azure Database for MySQL w trybie offline przy użyciu programu PowerShell i usługi Azure Database Migration Service

Artykuł
09/18/2024

W tym artykule przeprowadzisz migrację bazy danych MySQL przywróconej do wystąpienia lokalnego do usługi Azure Database for MySQL przy użyciu możliwości migracji offline usługi Azure Database Migration Service za pośrednictwem programu Microsoft Azure PowerShell. W artykule dokumentacji kolekcji skryptów programu PowerShell, które można wykonać w sekwencji w celu przeprowadzenia migracji bazy danych MySQL do platformy Azure w trybie offline. Pełny skrypt programu PowerShell opisany w tym samouczku można pobrać z repozytorium GitHub.

Uwaga

Obecnie nie można uruchomić pełnej migracji bazy danych przy użyciu modułu Az.DataMigration. W międzyczasie przykładowy skrypt programu PowerShell jest dostarczany "zgodnie z oczekiwaniami", który korzysta z interfejsu API REST usługi DMS i umożliwia zautomatyzowanie migracji. Ten skrypt zostanie zmodyfikowany lub przestarzały po dodaniu oficjalnej pomocy technicznej w module Az.DataMigration i interfejsie wiersza polecenia platformy Azure.

Usługi Amazon Relational Database Service (RDS) dla baz danych MySQL i Amazon Aurora (oparte na bazie mySQL) są również obsługiwane jako źródła migracji.

Ważne

W przypadku migracji online można użyć narzędzi typu open source, takich jak MyDumper/MyLoader z replikacją typu data-in.

Artykuł pomaga zautomatyzować scenariusz, w którym nazwy źródłowej i docelowej bazy danych mogą być takie same lub różne i w ramach migracji muszą być migrowane wszystkie lub kilka tabel w docelowej bazie danych, które mają taką samą nazwę i strukturę tabel. Mimo że w artykułach przyjęto założenie, że źródłem jest wystąpienie bazy danych MySQL i element docelowy usługi Azure Database for MySQL, można użyć go do migracji z jednej usługi Azure Database for MySQL do innej, zmieniając nazwę i poświadczenia serwera źródłowego. Ponadto migracja z serwerów MySQL w niższej wersji (w wersji 5.6 lub nowszej) do wyższych wersji jest również obsługiwana.

Ważne

Funkcje usługi DMS w wersji zapoznawczej są dostępne na zasadzie samoobsługi. Wersje zapoznawcze są udostępniane w wersji "as is" i "jako dostępne" i są wykluczone z umów dotyczących poziomu usług i ograniczonej gwarancji. W związku z tym te funkcje nie są przeznaczone do użytku produkcyjnego. Aby uzyskać więcej informacji, zobacz Dodatkowe warunki użytkowania dla wersji zapoznawczych platformy Microsoft Azure.

W tym artykule omówiono sposób wykonywania następujących zadań:

Migrowanie schematu bazy danych.
Utwórz grupę zasobów.
Tworzenie wystąpienia usługi Azure Database Migration Service.
Utwórz projekt migracji w wystąpieniu usługi Azure Database Migration Service.
Skonfiguruj projekt migracji tak, aby korzystał z możliwości migracji offline dla programu MySQL.
Uruchamianie migracji.

Wymagania wstępne

Aby wykonać następujące kroki, potrzebne są następujące elementy:

Posiadanie konta platformy Azure z aktywną subskrypcją. Utwórz konto bezpłatnie.
Mieć lokalną bazę danych MySQL w wersji 5.6 lub nowszej. Jeśli nie, pobierz i zainstaluj program MySQL Community Edition 5.6 lub nowszy.
Utwórz wystąpienie usługi Azure Database for MySQL. Zapoznaj się z artykułem Używanie aplikacji MySQL Workbench do nawiązywania połączeń i wykonywania zapytań o dane , aby uzyskać szczegółowe informacje na temat nawiązywania połączenia i tworzenia bazy danych przy użyciu aplikacji Workbench. Wersja usługi Azure Database for MySQL powinna być równa lub wyższa niż lokalna wersja programu MySQL. Na przykład program MySQL 5.7 może przeprowadzić migrację do usługi Azure Database for MySQL 5.7 lub uaktualnić do wersji 8.
Utwórz sieć wirtualną platformy Microsoft Azure dla usługi Azure Database Migration Service przy użyciu modelu wdrażania usługi Azure Resource Manager, który zapewnia łączność typu lokacja-lokacja z lokalnymi serwerami źródłowymi przy użyciu usługi ExpressRoute lub sieci VPN. Aby uzyskać więcej informacji na temat tworzenia sieci wirtualnej, zobacz dokumentację sieci wirtualnej, a zwłaszcza artykuły Szybki start ze szczegółowymi informacjami krok po kroku.

Uwaga

Podczas konfigurowania sieci wirtualnej Jeśli używasz usługi ExpressRoute z komunikacją równorzędną sieciową do firmy Microsoft, dodaj punkt końcowy usługi Microsoft.Sql do podsieci, w której zostanie aprowizowana usługa. Taka konfiguracja jest konieczna, ponieważ usługa Azure Database Migration Service nie ma łączności z Internetem.
Upewnij się, że reguły sieciowej grupy zabezpieczeń sieci wirtualnej nie blokują portu wychodzącego 443 elementu ServiceTag for Storage i AzureMonitor. Aby uzyskać więcej informacji na temat filtrowania ruchu sieciowej grupy zabezpieczeń sieci wirtualnej, zapoznaj się z artykułem Filtrowanie ruchu sieciowego przy użyciu sieciowych grup zabezpieczeń.
Otwórz zaporę systemu Windows, aby zezwolić na połączenia z usługi Virtual Network for Azure Database Migration Service w celu uzyskania dostępu do źródłowego serwera MySQL, który domyślnie jest portem TCP 3306.
W przypadku używania urządzenia zapory przed źródłowymi bazami danych może być konieczne dodanie reguł zapory w celu zezwolenia na połączenia z sieci wirtualnej dla usługi Azure Database Migration Service w celu uzyskania dostępu do źródłowych baz danych na potrzeby migracji.
Utwórz regułę zapory na poziomie serwera lub skonfiguruj punkty końcowe usługi sieci wirtualnej dla docelowej usługi Azure Database for MySQL, aby umożliwić usłudze Virtual Network dla usługi Azure Database Migration Service dostęp do docelowych baz danych.
Źródłowy serwer MySQL musi znajdować się w obsługiwanej bazie danych MySQL Community Edition. Aby określić wersję instancji programu MySQL, w narzędziu MySQL lub środowisku roboczym bazy danych MySQL uruchom następujące polecenie:
```
SELECT @@VERSION;
```
Usługa Azure Database for MySQL obsługuje wyłącznie tabele InnoDB. Aby przekonwertować tabele MyISAM na format InnoDB, zapoznaj się z artykułem Konwertowanie tabel z formatu MyISAM na InnoDB
Użytkownik musi mieć uprawnienia do odczytywania danych w źródłowej bazie danych.
W przewodniku jest używany program PowerShell w wersji 7.2, który można zainstalować zgodnie z przewodnikiem instalacji
Pobierz i zainstaluj następujące moduły z Galeria programu PowerShell przy użyciu polecenia cmdlet Install-Module programu PowerShell. Otwórz okno polecenia programu PowerShell przy użyciu polecenia Uruchom jako administrator:
- Az.Resources
- Az.Network
- Az.DataMigration
```
Install-Module Az.Resources
Install-Module Az.Network
Install-Module Az.DataMigration
Import-Module Az.Resources
Import-Module Az.Network
Import-Module Az.DataMigration
```

Migrowanie schematu bazy danych

Aby przenieść wszystkie obiekty bazy danych, takie jak schematy tabel, indeksy i procedury składowane, musimy wyodrębnić schemat ze źródłowej bazy danych i zastosować je do docelowej bazy danych. Aby wyodrębnić schemat, użyj polecenia mysqldump z parametrem --no-data. W tym celu potrzebna jest maszyna, która może łączyć się zarówno ze źródłową bazą danych MySQL, jak i docelową bazą danych Azure Database for MySQL.

Aby wyeksportować schemat przy użyciu narzędzia mysqldump, uruchom następujące polecenie:

mysqldump -h [servername] -u [username] -p[password] --databases [db name] --no-data > [schema file path]

Na przykład:

mysqldump -h 10.10.123.123 -u root -p --databases migtestdb --no-data > d:\migtestdb.sql

Aby zaimportować schemat do docelowej usługi Azure Database for MySQL, uruchom następujące polecenie:

mysql.exe -h [servername] -u [username] -p[password] [database]< [schema file path]

Na przykład:

mysql.exe -h mysqlsstrgt.mysql.database.azure.com -u docadmin@mysqlsstrgt -p migtestdb < d:\migtestdb.sql

Jeśli masz klucze obce w schemacie, obciążenie danych równoległych podczas migracji będzie obsługiwane przez zadanie migracji. Podczas migracji schematu nie trzeba usuwać kluczy obcych.

Jeśli masz wyzwalacze w bazie danych, wymusi integralność danych w lokalizacji docelowej przed pełną migracją danych ze źródła. Zaleca się wyłączenie wyzwalaczy we wszystkich tabelach w obiekcie docelowym podczas migracji, a następnie włączenie wyzwalaczy po zakończeniu migracji.

Wykonaj następujący skrypt w aplikacji MySQL Workbench w docelowej bazie danych, aby wyodrębnić skrypt wyzwalacza upuszczania i dodać skrypt wyzwalacza.

SELECT
    SchemaName,
    GROUP_CONCAT(DropQuery SEPARATOR ';\n') as DropQuery,
    CONCAT('DELIMITER $$ \n\n', GROUP_CONCAT(AddQuery SEPARATOR '$$\n'), '$$\n\nDELIMITER ;') as AddQuery
FROM
(
SELECT
    TRIGGER_SCHEMA as SchemaName,
    CONCAT('DROP TRIGGER `', TRIGGER_NAME, "`") as DropQuery,
    CONCAT('CREATE TRIGGER `', TRIGGER_NAME, '` ', ACTION_TIMING, ' ', EVENT_MANIPULATION,
            '\nON `', EVENT_OBJECT_TABLE, '`\n' , 'FOR EACH ', ACTION_ORIENTATION, ' ',
            ACTION_STATEMENT) as AddQuery
FROM
    INFORMATION_SCHEMA.TRIGGERS
ORDER BY EVENT_OBJECT_SCHEMA, EVENT_OBJECT_TABLE, ACTION_TIMING, EVENT_MANIPULATION, ACTION_ORDER ASC
) AS Queries
GROUP BY SchemaName;

Uruchom wygenerowane zapytanie wyzwalacza upuszczania (kolumna DropQuery) w wyniku, aby usunąć wyzwalacze w docelowej bazie danych. Można zapisać zapytanie dodawania wyzwalacza, które będzie używane po zakończeniu migracji danych.

Zaloguj się do subskrypcji platformy Microsoft Azure

Użyj polecenia Connect-AzAccount programu PowerShell, aby zalogować się do subskrypcji platformy Azure przy użyciu programu PowerShell, zgodnie z instrukcjami w artykule Logowanie się za pomocą programu Azure PowerShell.

Poniższy skrypt ustawia domyślną subskrypcję dla logowania po zalogowaniu sesji programu PowerShell i tworzy funkcję rejestrowania pomocnika dla sformatowanych dzienników konsoli.

[string] $SubscriptionName = "mySubscription"
$ErrorActionPreference = "Stop";

Connect-AzAccount
Set-AzContext -Subscription $SubscriptionName
$global:currentSubscriptionId = (Get-AzContext).Subscription.Id;

function LogMessage([string] $Message, [bool] $IsProcessing = $false) {
    if ($IsProcessing) {
        Write-Host "$(Get-Date -Format "yyyy-MM-dd HH:mm:ss"): $Message" -ForegroundColor Yellow
    }
    else {
        Write-Host "$(Get-Date -Format "yyyy-MM-dd HH:mm:ss"): $Message" -ForegroundColor Green
    }
}

Rejestrowanie dostawcy zasobów Microsoft.DataMigration

Rejestracja dostawcy zasobów musi odbywać się tylko raz w każdej subskrypcji platformy Azure. Bez rejestracji nie będzie można utworzyć wystąpienia usługi Azure Database Migration Service.

Zarejestruj dostawcę zasobów przy użyciu polecenia Register-AzResourceProvider . Poniższy skrypt rejestruje dostawcę zasobów wymaganego dla usługi Azure Database Migration Service

Register-AzResourceProvider -ProviderNamespace Microsoft.DataMigration

Tworzenie grupy zasobów

Grupa zasobów platformy Azure to logiczny kontener przeznaczony do wdrażania zasobów platformy Azure i zarządzania nimi. Utwórz grupę zasobów przed utworzeniem jakichkolwiek zasobów usługi DMS.

Utwórz grupę zasobów przy użyciu polecenia New-AzResourceGroup .

Poniższy przykład tworzy grupę zasobów o nazwie myResourceGroup w regionie Zachodnie stany USA 2 w ramach subskrypcji domyślnej mySubscription.

# Get the details of resource group
[string] $Location = "westus2"
[string] $ResourceGroupName = "myResourceGroup"

$resourceGroup = Get-AzResourceGroup -Name $ResourceGroupName
if (-not($resourceGroup)) {
    LogMessage -Message "Creating resource group $ResourceGroupName..." -IsProcessing $true
    $resourceGroup = New-AzResourceGroup -Name $ResourceGroupName -Location $Location
    LogMessage -Message "Created resource group - $($resourceGroup.ResourceId)."
}
else { LogMessage -Message "Resource group $ResourceGroupName exists." }

Tworzenie wystąpienia usługi Azure Database Migration Service

Nowe wystąpienie usługi Azure Database Migration Service można utworzyć przy użyciu polecenia New-AzDataMigrationService . To polecenie oczekuje następujących wymaganych parametrów:

Nazwa grupy zasobów platformy Azure. Możesz użyć polecenia New-AzResourceGroup , aby utworzyć grupę zasobów platformy Azure, jak pokazano wcześniej i podać jej nazwę jako parametr.
Nazwa usługi. Ciąg odpowiadający żądanej unikatowej nazwie usługi dla usługi Azure Database Migration Service
Lokalizacja. Określa lokalizację usługi. Określanie lokalizacji centrum danych platformy Azure, takiej jak Zachodnie stany USA lub Azja Południowo-Wschodnia
Jednostka SKU. Ten parametr odpowiada nazwie jednostki SKU usługi DMS. Obecnie obsługiwana nazwa jednostki SKU to Standard_1vCore, Standard_2vCores, Standard_4vCores, Premium_4vCores.
Identyfikator podsieci wirtualnej. Aby uzyskać informacje o podsieci, możesz użyć polecenia Get-AzVirtualNetworkSubnetConfig .

Poniższy skrypt oczekuje, że sieć wirtualna myVirtualNetwork istnieje z podsiecią o nazwie default , a następnie tworzy usługę Database Migration Service o nazwie myDmService w grupie zasobów utworzonej w kroku 3 i w tym samym regionie.

# Get a reference to the DMS service - Create if not exists
[string] $VirtualNetworkName = "myVirtualNetwork"
[string] $SubnetName = "default"
[string] $ServiceName = "myDmService"

$dmsServiceResourceId = "/subscriptions/$($global:currentSubscriptionId)/resourceGroups/$ResourceGroupName/providers/Microsoft.DataMigration/services/$ServiceName"
$dmsService = Get-AzResource -ResourceId $dmsServiceResourceId -ErrorAction SilentlyContinue

# Create Azure DMS service if not existing
# Possible values for SKU currently are Standard_1vCore,Standard_2vCores,Standard_4vCores,Premium_4vCores
if (-not($dmsService)) {
    $virtualNetwork = Get-AzVirtualNetwork -ResourceGroupName $ResourceGroupName -Name $VirtualNetworkName
    if (-not ($virtualNetwork)) { throw "ERROR: Virtual Network $VirtualNetworkName does not exists" }

    $subnet = Get-AzVirtualNetworkSubnetConfig -VirtualNetwork $virtualNetwork -Name $SubnetName
    if (-not ($subnet)) { throw "ERROR: Virtual Network $VirtualNetworkName does not contains Subnet $SubnetName" }

    LogMessage -Message "Creating Azure Data Migration Service $ServiceName..." -IsProcessing $true
    $dmsService = New-AzDataMigrationService `
        -ResourceGroupName $ResourceGroupName `
        -Name $ServiceName `
        -Location $resourceGroup.Location `
        -Sku Premium_4vCores `
        -VirtualSubnetId $Subnet.Id

    $dmsService = Get-AzResource -ResourceId $dmsServiceResourceId
    LogMessage -Message "Created Azure Data Migration Service - $($dmsService.ResourceId)."
}
else { LogMessage -Message "Azure Data Migration Service $ServiceName exists." }

Tworzenie projektu migracji

Po utworzeniu wystąpienia usługi Azure Database Migration Service utworzysz projekt migracji. Projekt migracji określa typ migracji, który należy wykonać.

Poniższy skrypt tworzy projekt migracji o nazwie myfirstmysqlofflineproject na potrzeby migracji offline z programu MySQL do usługi Azure Database for MySQL w ramach wystąpienia usługi Database Migration Service utworzonego w kroku 4 i w tym samym regionie.

# Get a reference to the DMS project - Create if not exists
[string] $ProjectName = "myfirstmysqlofflineproject"

$dmsProjectResourceId = "/subscriptions/$($global:currentSubscriptionId)/resourceGroups/$($dmsService.ResourceGroupName)/providers/Microsoft.DataMigration/services/$($dmsService.Name)/projects/$projectName"
$dmsProject = Get-AzResource -ResourceId $dmsProjectResourceId -ErrorAction SilentlyContinue

# Create Azure DMS Project if not existing
if (-not($dmsProject)) {
    LogMessage -Message "Creating Azure DMS project $projectName for MySQL migration ..." -IsProcessing $true

    $newProjectProperties = @{"sourcePlatform" = "MySQL"; "targetPlatform" = "AzureDbForMySQL" }
    $dmsProject = New-AzResource `
        -ApiVersion 2018-03-31-preview `
        -Location $dmsService.Location `
        -ResourceId $dmsProjectResourceId `
        -Properties $newProjectProperties `
        -Force

    LogMessage -Message "Created Azure DMS project $projectName - $($dmsProject.ResourceId)."
}
else { LogMessage -Message "Azure DMS project $projectName exists." }

Tworzenie obiektu Informacji o połączeniu z bazą danych dla połączeń źródłowych i docelowych

Po utworzeniu projektu migracji utworzysz informacje o połączeniu z bazą danych. Te informacje o połączeniu będą używane do nawiązywania połączenia z serwerami źródłowymi i docelowymi podczas procesu migracji.

Poniższy skrypt przyjmuje nazwę serwera, nazwę użytkownika i hasło dla źródłowych i docelowych wystąpień programu MySQL oraz tworzy obiekty informacji o połączeniu. Skrypt monituje użytkownika o wprowadzenie hasła dla źródłowych i docelowych wystąpień programu MySQL. W przypadku skryptów dyskretnych poświadczenia można pobrać z usługi Azure Key Vault.

# Initialize the source and target database server connections
[string] $SourceServerName = "13.66.136.192"
[string] $SourceUserName = "docadmin@mysqlserver"
[securestring] $SourcePassword = Read-Host "Enter MySQL Source Server Password" -AsSecureString

[string] $TargetServerName = "migdocdevwus2mysqlsstrgt.mysql.database.azure.com"
[string] $TargetUserName = "docadmin@migdocdevwus2mysqlsstrgt"
[securestring] $TargetPassword = Read-Host "Enter MySQL Target Server Password" -AsSecureString

function InitConnection(
    [string] $ServerName,
    [string] $UserName,
    [securestring] $Password) {
    $connectionInfo = @{
        "dataSource"             = "";
        "serverName"             = "";
        "port"                   = 3306;
        "userName"               = "";
        "password"               = "";
        "authentication"         = "SqlAuthentication";
        "encryptConnection"      = $true;
        "trustServerCertificate" = $true;
        "additionalSettings"     = "";
        "type"                   = "MySqlConnectionInfo"
    }

    $connectionInfo.dataSource = $ServerName;
    $connectionInfo.serverName = $ServerName;
    $connectionInfo.userName = $UserName;
    $connectionInfo.password = (ConvertFrom-SecureString -AsPlainText $password).ToString();
    $connectionInfo;
}

# Initialize the source and target connections
LogMessage -Message "Initializing source and target connection objects ..." -IsProcessing $true
$sourceConnInfo = InitConnection `
    $SourceServerName `
    $SourceUserName `
    $SourcePassword;

$targetConnInfo = InitConnection `
    $TargetServerName `
    $TargetUserName `
    $TargetPassword;

LogMessage -Message "Source and target connection object initialization complete."

Wyodrębnianie listy nazw tabel z docelowej bazy danych

Listę tabel bazy danych można wyodrębnić przy użyciu zadania migracji i informacji o połączeniu. Lista tabel zostanie wyodrębniona zarówno ze źródłowej bazy danych, jak i docelowej bazy danych, aby można było wykonać odpowiednie mapowanie i walidację.

Poniższy skrypt przyjmuje nazwy źródłowych i docelowych baz danych, a następnie wyodrębnia listę tabel z baz danych przy użyciu zadania migracji GetUserTablesMySql .

# Run scenario to get the tables from the target database to build
# the migration table mapping
[string] $TargetDatabaseName = "migtargetdb"
[string] $SourceDatabaseName = "migsourcedb"

function RunScenario([object] $MigrationService,
    [object] $MigrationProject,
    [string] $ScenarioTaskName,
    [object] $TaskProperties,
    [bool] $WaitForScenario = $true) {
    # Check if the scenario task already exists, if so remove it
    LogMessage -Message "Removing scenario if already exists..." -IsProcessing $true
    Remove-AzDataMigrationTask `
        -ResourceGroupName $MigrationService.ResourceGroupName `
        -ServiceName $MigrationService.Name `
        -ProjectName $MigrationProject.Name `
        -TaskName $ScenarioTaskName `
        -Force;

    # Start the new scenario task using the provided properties
    LogMessage -Message "Initializing scenario..." -IsProcessing $true
    New-AzResource `
        -ApiVersion 2018-03-31-preview `
        -Location $MigrationService.Location `
        -ResourceId "/subscriptions/$($global:currentSubscriptionId)/resourceGroups/$($MigrationService.ResourceGroupName)/providers/Microsoft.DataMigration/services/$($MigrationService.Name)/projects/$($MigrationProject.Name)/tasks/$($ScenarioTaskName)" `
        -Properties $TaskProperties `
        -Force | Out-Null;

    LogMessage -Message "Waiting for $ScenarioTaskName scenario to complete..." -IsProcessing $true
    if ($WaitForScenario) {
        $progressCounter = 0;
        do {
            if ($null -ne $scenarioTask) {
                Start-Sleep 10;
            }

            # Get calls can time out and will return a cancellation exception in that case
            $scenarioTask = Get-AzDataMigrationTask `
                -ResourceGroupName $MigrationService.ResourceGroupName `
                -ServiceName $MigrationService.Name `
                -ProjectName $MigrationProject.Name `
                -TaskName $ScenarioTaskName `
                -Expand `
                -ErrorAction Ignore;

            Write-Progress -Activity "Scenario Run $ScenarioTaskName  (Marquee Progress Bar)" `
                -Status $scenarioTask.ProjectTask.Properties.State `
                -PercentComplete $progressCounter

            $progressCounter += 10;
            if ($progressCounter -gt 100) { $progressCounter = 10 }
        }
        while (($null -eq $scenarioTask) -or ($scenarioTask.ProjectTask.Properties.State -eq "Running") -or ($scenarioTask.ProjectTask.Properties.State -eq "Queued"))
    }
    Write-Progress -Activity "Scenario Run $ScenarioTaskName" `
        -Status $scenarioTask.ProjectTask.Properties.State `
        -Completed

    # Now get it using REST APIs so we can expand the output
    LogMessage -Message "Getting expanded task results ..." -IsProcessing $true
    $psToken = (Get-AzAccessToken -ResourceUrl https://management.azure.com).Token;
    $token = ConvertTo-SecureString -String $psToken -AsPlainText -Force;
    $taskResource = Invoke-RestMethod `
        -Method GET `
        -Uri "https://management.azure.com$($scenarioTask.ProjectTask.Id)?api-version=2018-03-31-preview&`$expand=output" `
        -ContentType "application/json" `
        -Authentication Bearer `
        -Token $token;

    $taskResource.properties;
}

# create the get table task properties by initializing the connection and
# database name
$getTablesTaskProperties = @{
    "input"    = @{
        "connectionInfo"    = $null;
        "selectedDatabases" = $null;
    };
    "taskType" = "GetUserTablesMySql";
};

LogMessage -Message "Running scenario to get the list of tables from the target database..." -IsProcessing $true
$getTablesTaskProperties.input.connectionInfo = $targetConnInfo;
$getTablesTaskProperties.input.selectedDatabases = @($TargetDatabaseName);
# Create a name for the task
$getTableTaskName = "$($TargetDatabaseName)GetUserTables"
# Get the list of tables from the source
$getTargetTablesTask = RunScenario -MigrationService $dmsService `
    -MigrationProject $dmsProject `
    -ScenarioTaskName $getTableTaskName `
    -TaskProperties $getTablesTaskProperties;

if (-not ($getTargetTablesTask)) { throw "ERROR: Could not get target database $TargetDatabaseName table information." }
LogMessage -Message "List of tables from the target database acquired."

LogMessage -Message "Running scenario to get the list of tables from the source database..." -IsProcessing $true
$getTablesTaskProperties.input.connectionInfo = $sourceConnInfo;
$getTablesTaskProperties.input.selectedDatabases = @($SourceDatabaseName);
# Create a name for the task
$getTableTaskName = "$($SourceDatabaseName)GetUserTables"
# Get the list of tables from the source
$getSourceTablesTask = RunScenario -MigrationService $dmsService `
    -MigrationProject $dmsProject `
    -ScenarioTaskName $getTableTaskName `
    -TaskProperties $getTablesTaskProperties;

if (-not ($getSourceTablesTask)) { throw "ERROR: Could not get source database $SourceDatabaseName table information." }
LogMessage -Message "List of tables from the source database acquired."

Tworzenie mapowania tabeli na podstawie konfiguracji użytkownika

W ramach konfigurowania zadania migracji utworzysz mapowanie między tabelami źródłowymi i docelowymi. Mapowanie znajduje się na poziomie nazwy tabeli, ale założeniem jest to, że struktura tabeli (liczba kolumn, nazwy kolumn, typy danych itp.) mapowanych tabel jest dokładnie taka sama.

Poniższy skrypt tworzy mapowanie na podstawie listy docelowej i źródłowej tabeli wyodrębnionej w kroku 7. W przypadku częściowego ładowania danych użytkownik może podać listę tabel do filtrowania tabel. Jeśli nie podano żadnych danych wejściowych użytkownika, wszystkie tabele docelowe są mapowane. Skrypt sprawdza również, czy tabela o tej samej nazwie istnieje w źródle, czy nie. Jeśli nazwa tabeli nie istnieje w źródle, tabela docelowa jest ignorowana na potrzeby migracji.

# Create the source to target table map
# Optional table settings
# DEFAULT: $IncludeTables = $null => include all tables for migration
# DEFAULT: $ExcludeTables = $null => exclude no tables from migration
# Exclude list has higher priority than include list
# Array of qualified source table names which should be migrated
[string[]] $IncludeTables = @("migsourcedb.coupons", "migsourcedb.daily_cash_sheets");
[string[]] $ExcludeTables = $null;

LogMessage -Message "Creating the table map based on the user input and database table information ..." `
    -IsProcessing $true

$targetTables = $getTargetTablesTask.Output.DatabasesToTables."$TargetDatabaseName";
$sourceTables = $getSourceTablesTask.Output.DatabasesToTables."$SourceDatabaseName";
$tableMap = New-Object 'system.collections.generic.dictionary[string,string]';

$schemaPrefixLength = $($SourceDatabaseName + ".").Length;
$tableMappingError = $false
foreach ($srcTable in $sourceTables) {
    # Removing the database name prefix from the table name so that comparison
    # can be done in cases where database name given are different
    $tableName = $srcTable.Name.Substring($schemaPrefixLength, `
            $srcTable.Name.Length - $schemaPrefixLength)

    # In case the table is part of exclusion list then ignore the table
    if ($null -ne $ExcludeTables -and $ExcludeTables -contains $srcTable.Name) {
        continue;
    }

    # Either the include list is null or the table is part of the include list then add it in the mapping
    if ($null -eq $IncludeTables -or $IncludeTables -contains $srcTable.Name) {
        # Check if the table exists in the target. If not then log TABLE MAPPING ERROR
        if (-not ($targetTables | Where-Object { $_.name -ieq "$($TargetDatabaseName).$tableName" })) {
            $tableMappingError = $true
            Write-Host "TABLE MAPPING ERROR: $($targetTables.name) does not exists in target." -ForegroundColor Red
            continue;
        }

        $tableMap.Add("$($SourceDatabaseName).$tableName", "$($TargetDatabaseName).$tableName");
    }
}

# In case of any table mapping errors identified, throw an error and stop the process
if ($tableMappingError) { throw "ERROR: One or more table mapping errors were identified. Please see previous messages." }
# In case no tables are in the mapping then throw error
if ($tableMap.Count -le 0) { throw "ERROR: Could not create table mapping." }
LogMessage -Message "Migration table mapping created for $($tableMap.Count) tables."

Tworzenie i konfigurowanie danych wejściowych zadania migracji

Po utworzeniu mapowania tabeli utworzysz dane wejściowe dla zadania migracji typu Migrate.MySql.AzureDbForMySql i skonfigurujesz właściwości.

Poniższy skrypt tworzy zadanie migracji i ustawia połączenia, nazwy baz danych i mapowanie tabel.

# Create and configure the migration scenario based on the connections
# and the table mapping
$offlineMigTaskProperties = @{
    "input"    = @{
        "sourceConnectionInfo"  = $null;
        "targetConnectionInfo"  = $null;
        "selectedDatabases"     = $null;
        "optionalAgentSettings" = @{
            "EnableCacheBatchesInMemory"         = $true;
            "DisableIncrementalRowStatusUpdates" = $true;
        };
        "startedOn"             = $null;
    };
    "taskType" = "Migrate.MySql.AzureDbForMySql";
};
$offlineSelectedDatabase = @{
    "name"               = $null;
    "targetDatabaseName" = $null;
    "tableMap"           = $null;
};

LogMessage -Message "Preparing migration scenario configuration ..." -IsProcessing $true

# Select the database to be migrated
$offlineSelectedDatabase.name = $SourceDatabaseName;
$offlineSelectedDatabase.tableMap = New-Object PSObject -Property $tableMap;
$offlineSelectedDatabase.targetDatabaseName = $TargetDatabaseName;

# Set connection info and the database mapping
$offlineMigTaskProperties.input.sourceConnectionInfo = $sourceConnInfo;
$offlineMigTaskProperties.input.targetConnectionInfo = $targetConnInfo;
$offlineMigTaskProperties.input.selectedDatabases = @($offlineSelectedDatabase);
$offlineMigTaskProperties.input.startedOn = [System.DateTimeOffset]::UtcNow.ToString("O");

Konfigurowanie parametrów dostrajania wydajności

Jako właściwość modułu programu PowerShell dostępnych jest kilka opcjonalnych parametrów, które można dostroić na podstawie środowiska. Te parametry mogą służyć do poprawy wydajności zadania migracji. Wszystkie te parametry są opcjonalne, a ich wartością domyślną jest NULL.

Następujące konfiguracje wydajności wykazały zwiększoną przepływność podczas migracji do jednostki SKU w warstwie Premium.

WriteDataRangeBatchTaskCount = 12
DelayProgressUpdatesInStorageInterval = 30 sekund
ThrottleQueryTableRangeTaskAtBatchCount = 36

Poniższy skrypt pobiera wartości użytkownika parametrów i ustawia parametry we właściwościach zadania migracji.

# Setting optional parameters from fine tuning the data transfer rate during migration
# DEFAULT values for all the configurations is $null
LogMessage -Message "Adding optional migration performance tuning configuration ..." -IsProcessing $true
# Partitioning settings
# Optional setting that configures the maximum number of parallel reads on tables located on the source database.
[object] $DesiredRangesCount = 4
# Optional setting that configures that size of the largest batch that will be committed to the target server.
[object] $MaxBatchSizeKb = 4096
# Optional setting that configures the minimum number of rows in each batch written to the target.
[object] $MinBatchRows = $null
# Task count settings
# Optional setting that configures the number of databases that will be prepared for migration in parallel.
[object] $PrepareDatabaseForBulkImportTaskCount = $null
# Optional setting that configures the number of tables that will be prepared for migration in parallel.
[object] $PrepareTableForBulkImportTaskCount = $null
# Optional setting that configures the number of threads available to read ranges on the source.
[object] $QueryTableDataRangeTaskCount = 8
# Optional setting that configures the number of threads available to write batches to the target.
[object] $WriteDataRangeBatchTaskCount = 12
# Batch cache settings
# Optional setting that configures how much memory will be used to cache batches in memory before reads on the source are throttled.
[object] $MaxBatchCacheSizeMb = $null
# Optional setting that configures the amount of available memory at which point reads on the source will be throttled.
[object] $ThrottleQueryTableDataRangeTaskAtAvailableMemoryMb = $null
# Optional setting that configures the number of batches cached in memory that will trigger read throttling on the source.
[object] $ThrottleQueryTableDataRangeTaskAtBatchCount = 36
# Performance settings
# Optional setting that configures the delay between updates of result objects in Azure Table Storage.
[object] $DelayProgressUpdatesInStorageInterval = "00:00:30"

function AddOptionalSetting($optionalAgentSettings, $settingName, $settingValue) {
    # If no value specified for the setting, don't bother adding it to the input
    if ($null -eq $settingValue) {
        return;
    }

    # Add a new property to the JSON object to capture the setting which will be customized
    $optionalAgentSettings | add-member -MemberType NoteProperty -Name $settingName -Value $settingValue
}

# Set any optional settings in the input based on parameters to this cmdlet
AddOptionalSetting $offlineMigTaskProperties.input.optionalAgentSettings "DesiredRangesCount" $DesiredRangesCount;
AddOptionalSetting $offlineMigTaskProperties.input.optionalAgentSettings "MaxBatchSizeKb" $MaxBatchSizeKb;
AddOptionalSetting $offlineMigTaskProperties.input.optionalAgentSettings "MinBatchRows" $MinBatchRows;
AddOptionalSetting $offlineMigTaskProperties.input.optionalAgentSettings "PrepareDatabaseForBulkImportTaskCount" $PrepareDatabaseForBulkImportTaskCount;
AddOptionalSetting $offlineMigTaskProperties.input.optionalAgentSettings "PrepareTableForBulkImportTaskCount" $PrepareTableForBulkImportTaskCount;
AddOptionalSetting $offlineMigTaskProperties.input.optionalAgentSettings "QueryTableDataRangeTaskCount" $QueryTableDataRangeTaskCount;
AddOptionalSetting $offlineMigTaskProperties.input.optionalAgentSettings "WriteDataRangeBatchTaskCount" $WriteDataRangeBatchTaskCount;
AddOptionalSetting $offlineMigTaskProperties.input.optionalAgentSettings "MaxBatchCacheSizeMb" $MaxBatchCacheSizeMb;
AddOptionalSetting $offlineMigTaskProperties.input.optionalAgentSettings "ThrottleQueryTableDataRangeTaskAtAvailableMemoryMb" $ThrottleQueryTableDataRangeTaskAtAvailableMemoryMb;
AddOptionalSetting $offlineMigTaskProperties.input.optionalAgentSettings "ThrottleQueryTableDataRangeTaskAtBatchCount" $ThrottleQueryTableDataRangeTaskAtBatchCount;
AddOptionalSetting $offlineMigTaskProperties.input.optionalAgentSettings "DelayProgressUpdatesInStorageInterval" $DelayProgressUpdatesInStorageInterval;

Tworzenie i uruchamianie zadania migracji

Po skonfigurowaniu danych wejściowych dla zadania zadanie zostanie utworzone i wykonane na agencie. Skrypt wyzwala wykonanie zadania i czeka na ukończenie migracji.

Poniższy skrypt wywołuje skonfigurowane zadanie migracji i czeka na jego ukończenie.

# Running the migration scenario
[string] $TaskName = "mysqlofflinemigrate"

LogMessage -Message "Running data migration scenario ..." -IsProcessing $true
$summary = @{
    "SourceServer"   = $SourceServerName;
    "SourceDatabase" = $SourceDatabaseName;
    "TargetServer"   = $TargetServerName;
    "TargetDatabase" = $TargetDatabaseName;
    "TableCount"     = $tableMap.Count;
    "StartedOn"      = $offlineMigTaskProperties.input.startedOn;
}

Write-Host "Job Summary:" -ForegroundColor Yellow
Write-Host $(ConvertTo-Json $summary) -ForegroundColor Yellow

$migrationResult = RunScenario -MigrationService $dmsService `
    -MigrationProject $dmsProject `
    -ScenarioTaskName $TaskName `
    -TaskProperties $offlineMigTaskProperties

LogMessage -Message "Migration completed with status - $($migrationResult.state)"
#Checking for any errors or warnings captured by the task during migration
$dbLevelResult = $migrationResult.output | Where-Object { $_.resultType -eq "DatabaseLevelOutput" }
$migrationLevelResult = $migrationResult.output | Where-Object { $_.resultType -eq "MigrationLevelOutput" }
if ($dbLevelResult.exceptionsAndWarnings) {
    Write-Host "Following database errors were captured: $($dbLevelResult.exceptionsAndWarnings)" -ForegroundColor Red
}
if ($migrationLevelResult.exceptionsAndWarnings) {
    Write-Host "Following migration errors were captured: $($migrationLevelResult.exceptionsAndWarnings)" -ForegroundColor Red
}
if ($migrationResult.errors.details) {
    Write-Host "Following task level migration errors were captured: $($migrationResult.errors.details)" -ForegroundColor Red
}

Usuwanie usługi Database Migration Service

Tej samej usługi Database Migration Service można używać do wielu migracji, aby można było ponownie użyć wystąpienia utworzonego po utworzeniu. Jeśli nie zamierzasz nadal korzystać z usługi Database Migration Service, możesz usunąć usługę przy użyciu polecenia Remove-AzDataMigrationService .

Poniższy skrypt usuwa wystąpienie usługi Azure Database Migration Service i skojarzone z nim projekty.

Remove-AzDataMigrationService -ResourceId $($dmsService.ResourceId)

Udostępnij za pośrednictwem

Migrowanie programu MySQL do usługi Azure Database for MySQL w trybie offline przy użyciu programu PowerShell i usługi Azure Database Migration Service

Wymagania wstępne

Migrowanie schematu bazy danych

Zaloguj się do subskrypcji platformy Microsoft Azure

Rejestrowanie dostawcy zasobów Microsoft.DataMigration

Tworzenie grupy zasobów

Tworzenie wystąpienia usługi Azure Database Migration Service

Tworzenie projektu migracji

Tworzenie obiektu Informacji o połączeniu z bazą danych dla połączeń źródłowych i docelowych

Wyodrębnianie listy nazw tabel z docelowej bazy danych

Tworzenie mapowania tabeli na podstawie konfiguracji użytkownika

Tworzenie i konfigurowanie danych wejściowych zadania migracji

Konfigurowanie parametrów dostrajania wydajności

Tworzenie i uruchamianie zadania migracji

Usuwanie usługi Database Migration Service

Opinia

Dodatkowe zasoby

Udostępnij za pośrednictwem

Migrowanie programu MySQL do usługi Azure Database for MySQL w trybie offline przy użyciu programu PowerShell i usługi Azure Database Migration Service

Wymagania wstępne

Migrowanie schematu bazy danych

Zaloguj się do subskrypcji platformy Microsoft Azure

Rejestrowanie dostawcy zasobów Microsoft.DataMigration

Tworzenie grupy zasobów

Tworzenie wystąpienia usługi Azure Database Migration Service

Tworzenie projektu migracji

Tworzenie obiektu Informacji o połączeniu z bazą danych dla połączeń źródłowych i docelowych

Wyodrębnianie listy nazw tabel z docelowej bazy danych

Tworzenie mapowania tabeli na podstawie konfiguracji użytkownika

Tworzenie i konfigurowanie danych wejściowych zadania migracji

Konfigurowanie parametrów dostrajania wydajności

Tworzenie i uruchamianie zadania migracji

Usuwanie usługi Database Migration Service

Powiązana zawartość

Opinia

Dodatkowe zasoby