MySQL offline migrálása az Azure Database for MySQL-be a PowerShell és az Azure Database Migration Service használatával

  • Cikk

Ebben a cikkben egy helyszíni példányba visszaállított MySQL-adatbázist migrál az Azure Database for MySQL-be az Azure Database Migration Service offline migrálási funkciójának használatával a Microsoft Azure PowerShellen keresztül. A cikk a MySQL-adatbázis Azure-ba történő offline migrálásához egymás után végrehajtható PowerShell-szkriptek gyűjteményét ismerteti. Az oktatóanyagban ismertetett teljes PowerShell-szkriptet letöltheti a GitHub-adattárból.

Megjegyzés:

Jelenleg nem lehet teljes adatbázis-migrálást futtatni az Az.DataMigration modullal. Addig is a PowerShell-példaszkript "is" lesz megadva, amely a DMS REST API-t használja, és lehetővé teszi a migrálás automatizálását. Ezt a szkriptet a rendszer módosítja vagy elavulttá teszi, amint az Az.DataMigration modul és az Azure CLI hivatalos támogatást ad hozzá.

Megjegyzés:

A MySQL-hez készült Amazon Relational Database Service (RDS) és az Amazon Aurora (MySQL-alapú) is támogatott a migrálás forrásaként.

Fontos

Az online migráláshoz használhat nyílt forráskódú eszközöket, például a MyDumper/MyLoadert adatbetöltési replikációval.

A cikk segít automatizálni azt a forgatókönyvet, amelyben a forrás- és céladatbázisnevek azonosak vagy eltérőek lehetnek, és a migrálás részeként a céladatbázis összes tábláját vagy néhány tábláját át kell migrálni, amelyek neve és táblázatszerkezete azonos. Bár a cikkek feltételezik, hogy a forrás egy MySQL-adatbázispéldány, és a cél az Azure Database for MySQL, a forráskiszolgáló nevének és hitelesítő adatainak módosításával használható az egyik Azure Database for MySQL-adatbázisból a másikba való migrálásra. Emellett az alacsonyabb verziójú MySQL-kiszolgálókról (5.6-os vagy újabb verziókról) való migrálás is támogatott.

Fontos

A DMS előzetes verziójú funkciói önkiszolgáló, opt-in alapon érhetők el. Az előzetes verziókat "ahogy van" és "rendelkezésre állóként" biztosítjuk, és a szolgáltatási szerződésekből és a korlátozott jótállásból kizárjuk őket. Ezért ezek a funkciók nem éles használatra vannak szánva. További információkért lásd a Microsoft Azure előzetes verziójának használati feltételeit.

Ebben a cikkben az alábbiakkal ismerkedhet meg:

  • Adatbázisséma migrálása.
  • Hozzon létre egy erőforráscsoportot.
  • Egy Azure Database Migration Service-példány létrehozása.
  • Migrálási projekt létrehozása egy Azure Database Migration Service-példányban.
  • Konfigurálja a migrálási projektet a MySQL offline migrálási funkciójának használatára.
  • A migrálás futtatása.

Előfeltételek

Az alábbi lépések végrehajtásához a következőkre van szüksége:

  • Rendelkezik aktív előfizetéssel rendelkező Azure-fiókkal. Fiók ingyenes létrehozása.

  • Rendelkezik egy helyszíni MySQL-adatbázissal az 5.6-os vagy újabb verzióval. Ha nem, töltse le és telepítse a MySQL 5.6-os vagy újabb kiadását .

  • Példány létrehozása az Azure Database for MySQL-ben. A Workbench-alkalmazással való csatlakozással és adatbázis-létrehozással kapcsolatos részletekért tekintse meg a MySQL Workbench használatával történő kapcsolódással és adatok lekérdezésével foglalkozó cikket. Az Azure Database for MySQL-verziónak egyenlőnek vagy magasabbnak kell lennie, mint a helyszíni MySQL-verzió. A MySQL 5.7 például migrálható az Azure Database for MySQL 5.7-re, vagy frissíthető 8-ra.

  • Hozzon létre egy Microsoft Azure-beli virtuális hálózatot az Azure Database Migration Service-hez az Azure Resource Manager üzemi modellel, amely az ExpressRoute vagy VPN használatával biztosít helyek közötti kapcsolatot a helyszíni forráskiszolgálókkal. A virtuális hálózat létrehozásával kapcsolatos további információkért tekintse meg a virtuális hálózat dokumentációját, és különösen a részletes információkat tartalmazó rövid útmutatókat.

    Megjegyzés:

    A virtuális hálózat beállítása során, ha az ExpressRoute-ot hálózati társviszony-létesítéssel használja a Microsofttal, adja hozzá a Microsoft.Sql szolgáltatásvégpontot ahhoz az alhálózathoz, amelyben a szolgáltatás ki lesz építve. Ez a konfiguráció szükséges, mert az Azure Database Migration Service nem rendelkezik internetkapcsolattal.

  • Győződjön meg arról, hogy a virtuális hálózati hálózati biztonsági csoport szabályai nem blokkolják a ServiceTag for Storage és az AzureMonitor kimenő portját. A virtuális hálózati NSG-forgalom szűrésével kapcsolatos további részletekért lásd a hálózati forgalom szűrése hálózati biztonsági csoportokkal című cikket.

  • Nyissa meg a Windows tűzfalat, hogy az Azure Database Migration Service virtuális hálózatából érkező kapcsolatok hozzáférhessenek a forrás MySQL-kiszolgálóhoz, amely alapértelmezés szerint a 3306-os TCP-port.

  • Ha tűzfalberendezést használ a forrásadatbázis(ok) előtt, előfordulhat, hogy tűzfalszabályokat kell hozzáadnia ahhoz, hogy az Azure Database Migration Service virtuális hálózatából érkező kapcsolatok hozzáférhessenek a forrásadatbázis(ok)hoz a migráláshoz.

  • Hozzon létre egy kiszolgálószintű tűzfalszabályt , vagy konfigurálja a VNET-szolgáltatásvégpontokat a cél Azure Database for MySQL-hez, hogy engedélyezze az Azure Database Migration Service virtuális hálózatának hozzáférését a céladatbázisokhoz.

  • A forrásként szolgáló MySQL-nek a MySQL közösségi kiadásának kell lennie. A MySQL-példány verziójának megállapításához futtassa a következő parancsot a MySQL segédprogramban vagy a MySQL Workbenchben:

    SELECT @@version;

  • Az Azure Database for MySQL csak az InnoDB-táblákat támogatja. Ha a MyISAM-táblákat InnoDB-táblákká szeretné alakítani, tekintse meg a táblák MyISAM-ból InnoDB-vé konvertálását ismertető részt

  • A felhasználónak rendelkeznie kell az adatok forrásadatbázison való olvasására vonatkozó jogosultságokkal.

  • Az útmutató a PowerShell 7.2-s verzióját használja, amely a telepítési útmutatónak megfelelően telepíthető

  • Töltse le és telepítse a következő modulokat a PowerShell-galéria az Install-Module PowerShell parancsmaggal. Mindenképpen nyissa meg a PowerShell parancsablakot Rendszergazda istratorként való futtatással:

    • 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

Adatbázisséma migrálása

Az összes adatbázis-objektum, például a táblaséma, az indexek és a tárolt eljárások átviteléhez ki kell nyernünk a sémát a forrásadatbázisból, és alkalmazni kell a céladatbázisra. A séma kibontásához használhatja a mysqldump segédprogramot a --no-data paraméterrel. Ehhez olyan gépre van szüksége, amely a forrás MySQL-adatbázishoz és a cél Azure Database for MySQL-hez is csatlakozhat.

A séma mysqldump használatával történő exportálásához futtassa a következő parancsot:

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

Például:

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

Ha sémát szeretne importálni az Azure Database for MySQL-hez, futtassa a következő parancsot:

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

Például:

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

Ha idegen kulcsok vannak a sémában, a migrálás során a párhuzamos adatbetöltést az áttelepítési feladat kezeli. A séma áttelepítése során nem szükséges idegen kulcsokat elvetni.

Ha eseményindítók vannak az adatbázisban, az a forrásból való teljes adatmigrálás előtt kikényszeríti az adatintegritást a célban. A javaslat az, hogy a migrálás során tiltsa le a céltáblák eseményindítóit, majd engedélyezze az eseményindítókat a migrálás befejezése után.

Hajtsa végre a következő szkriptet a MySQL Workbenchben a céladatbázison a drop trigger szkript kinyeréséhez és az eseményindító szkript hozzáadásához.

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

Futtassa a létrehozott drop trigger lekérdezést (DropQuery oszlop) az eredményben az eseményindítók céladatbázisban való elvetéséhez. Az eseményindító hozzáadása lekérdezés menthető az adatmigrálás befejezése után.

Bejelentkezés a Microsoft Azure-előfizetésbe

Az Csatlakozás-AzAccount PowerShell paranccsal jelentkezzen be az Azure-előfizetésbe a PowerShell használatával, a Bejelentkezés az Azure PowerShell-lel című cikk útmutatásának megfelelően.

Az alábbi szkript beállítja a PowerShell-munkamenet bejelentkezés utáni alapértelmezett előfizetését, és létrehoz egy segédnaplózási függvényt a formázott konzolnaplókhoz.

[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
    }
}

A Microsoft.DataMigration erőforrás-szolgáltató regisztrálása

Az erőforrás-szolgáltató regisztrációját minden Azure-előfizetésen csak egyszer kell elvégezni. A regisztráció nélkül nem fog tudni létrehozni egy Azure Database Migration Service-példányt.

Regisztrálja az erőforrás-szolgáltatót a Register-AzResourceProvider paranccsal. Az alábbi szkript regisztrálja az Azure Database Migration Service-hez szükséges erőforrás-szolgáltatót 

Register-AzResourceProvider -ProviderNamespace Microsoft.DataMigration

Erőforráscsoport létrehozása

Az Azure-erőforráscsoport olyan logikai tároló, amelybe a rendszer üzembe helyezi és kezeli az Azure-erőforrásokat. Hozzon létre egy erőforráscsoportot a DMS-erőforrások létrehozása előtt.

Hozzon létre egy erőforráscsoportot a New-AzResourceGroup paranccsal.

Az alábbi példa egy myResourceGroup nevű erőforráscsoportot hoz létre az USA 2. nyugati régiójában az alapértelmezett mySubscription előfizetés alatt.

# 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." }

Egy Azure Database Migration Service-példány létrehozása

Az Azure Database Migration Service új példányát a New-AzDataMigrationService paranccsal hozhatja létre. Ez a parancs a következő szükséges paramétereket várja:

  • Azure-erőforráscsoport neve. A New-AzResourceGroup paranccsal létrehozhatja az Azure-erőforráscsoportot a korábban bemutatott módon, és paraméterként megadhatja a nevét.
  • Szolgáltatásnév. Az Azure Database Migration Service kívánt egyedi szolgáltatásnevének megfelelő sztring
  • Hely. A szolgáltatás helyét adja meg. Azure-adatközpont helyének megadása, például az USA nyugati régiója vagy Délkelet-Ázsia
  • Termékváltozat. Ez a paraméter megfelel a DMS termékváltozat nevének. A jelenleg támogatott termékváltozat neve Standard_1vCore, Standard_2vCores, Standard_4vCores, Premium_4vCores.
  • Virtuális alhálózat azonosítója. A Get-AzVirtualNetworkSubnetConfig paranccsal lekérheti egy alhálózat adatait.

Az alábbi szkript arra számít, hogy a myVirtualNetwork virtuális hálózat alapértelmezett nevű alhálózattal rendelkezik, majd létrehoz egy myDmService nevű adatbázis-migrálási szolgáltatást a 3. lépésben létrehozott erőforráscsoport alatt és ugyanabban a régióban.

# 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." }

Migrálási projekt létrehozása

Az Azure Database Migration Service-példány létrehozása után létre fog hozni egy migrálási projektet. A migrálási projekt meghatározza az áttelepítés típusát, amelyet el kell végezni.

Az alábbi szkript létrehoz egy myfirstmysqlofflineproject nevű migrálási projektet a MySQL-ből az Azure Database for MySQL-be való offline migráláshoz a 4. lépésben létrehozott Adatbázis-migrálási szolgáltatás példánya alatt, ugyanabban a régióban.

# 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." }

Adatbázis-Csatlakozás ion info objektum létrehozása a forrás- és célkapcsolatokhoz

A migrálási projekt létrehozása után létre kell hoznia az adatbázis kapcsolati adatait. Ez a kapcsolati információ a forrás- és célkiszolgálókhoz való csatlakozásra szolgál a migrálási folyamat során.

Az alábbi szkript a forrás- és cél MySQL-példányok kiszolgálónevét, felhasználónevét és jelszavát veszi át, és létrehozza a kapcsolati információs objektumokat. A szkript arra kéri a felhasználót, hogy adja meg a forrás- és cél MySQL-példányok jelszavát. Csendes szkriptek esetén a hitelesítő adatok lekérhetők az Azure Key Vaultból.

# 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."

Táblanevek listájának kinyerése a céladatbázisból

Az adatbázistáblázatok listája migrálási feladattal és kapcsolati információval nyerhető ki. A táblalista a forrásadatbázisból és a céladatbázisból is ki lesz nyerve, hogy a megfelelő leképezés és ellenőrzés elvégezhető legyen.

A következő szkript a forrás- és céladatbázisok nevét veszi fel, majd a GetUserTablesMySql migrálási feladatával kinyeri a táblázatlistát az adatbázisokból.

# 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."

Táblaleképezés létrehozása a felhasználói konfiguráció alapján

Az áttelepítési feladat konfigurálásának részeként létre fog hozni egy leképezést a forrás- és a céltáblák között. A leképezés a táblanév szintjén van, de a feltételezés az, hogy a megfeleltetett táblák táblázatszerkezete (oszlopszám, oszlopnevek, adattípusok stb.) pontosan megegyezik.

A következő szkript létrehoz egy leképezést a 7. lépésben kinyert cél- és forrástáblalista alapján. Részleges adatbetöltés esetén a felhasználó megadhat egy táblázatlistát a táblák szűréséhez. Ha nincs megadva felhasználói bemenet, akkor a rendszer az összes céltáblát leképezi. A szkript azt is ellenőrzi, hogy létezik-e azonos nevű tábla a forrásban. Ha a táblanév nem szerepel a forrásban, akkor a rendszer figyelmen kívül hagyja a céltáblát az áttelepítéshez.

# 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."

A migrálási feladat bemeneteinek létrehozása és konfigurálása

A táblaleképezés létrehozása után létrehozza a Migrate.MySql.AzureDbForMySql típusú migrálási feladat bemeneteit, és konfigurálja a tulajdonságokat.

Az alábbi szkript létrehozza az áttelepítési feladatot, és beállítja a kapcsolatokat, az adatbázisneveket és a táblaleképezést.

# 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");

Teljesítményhangolási paraméterek konfigurálása

A PowerShell-modulnak megfelelően kevés választható paraméter érhető el, amelyek a környezet alapján hangolhatók. Ezek a paraméterek a migrálási feladat teljesítményének javítására használhatók. Ezek a paraméterek nem kötelezőek, alapértelmezett értékük PEDIG NULL.

Megjegyzés:

Az alábbi teljesítménykonfigurációk nagyobb átviteli sebességet mutattak a prémium termékváltozatra való migrálás során.

  • WriteDataRangeBatchTaskCount = 12
  • DelayProgress Frissítések InStorageInterval = 30 másodperc
  • ThrottleQueryTableDataRangeTaskAtBatchCount = 36

Az alábbi szkript a paraméterek felhasználói értékeit veszi át, és beállítja a paramétereket az áttelepítési feladat tulajdonságaiban.

# 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;

Az áttelepítési feladat létrehozása és futtatása

Miután konfigurálta a tevékenység bemenetét, a rendszer most létrehozza és végrehajtja a feladatot az ügynökön. A szkript elindítja a feladat végrehajtását, és megvárja, amíg az áttelepítés befejeződik.

Az alábbi szkript meghívja a konfigurált migrálási feladatot, és megvárja, amíg befejeződik.

# 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
}

Az adatbázis-migrálási szolgáltatás törlése

Ugyanazt az adatbázis-áttelepítési szolgáltatást több migráláshoz is használhatja, így a létrehozott példány újra felhasználható. Ha nem használja tovább az Adatbázis-áttelepítési szolgáltatást, törölheti a szolgáltatást a Remove-AzDataMigrationService paranccsal.

Az alábbi szkript törli az Azure Database Migration Service-példányt és a hozzá tartozó projekteket.

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

További lépések