Övning – Geo-distribuerade automatiska redundansgrupper med lässkalning

10 minuter

I den förra lektionen fick du lära dig om geo-replikering och automatiska redundansgrupper. I den här övningen ska du konfigurera automatiska redundansgrupper för din Azure SQL-databas. Sedan ska du initiera en redundansväxling och granska resultatet.

Automatiska redundansgrupper i Azure SQL

Om du vill konfigurera automatiska redundansgrupper för en eller flera databaser och visa resultatet måste du utföra följande steg:

Konfigurera miljön.
Skapa en tom Azure SQL Database-server i redundansväxlingsregionen.
Skapa en redundansgrupp mellan servrarna.
Konfigurera nätverket.
Lägga till en eller flera databaser i redundansgruppen.
Konfigurera program för kommandotolken.
Förstå de program som körs.
Initiera en redundansväxling.
Växla tillbaka.

Den här övningen vägleder dig genom att konfigurera automatiska redundansgrupper för din AdventureWorks-databas. Sedan använder du ett enkelt kommandoradsprogram till att förstå var läsningar och skrivningar sker och hur viktig logiken för omförsök är i dina program. Slutligen ska du göra en rolig övning där du får avgöra hur många skrivskyddade repliker som är associerade med en databas på nivån Affärskritisk, som också har en automatisk redundansgrupp.

Konfigurera miljön

Kopiera följande kod till Anteckningar eller något annat redigeringsprogram. Ange din information. Lägg till ditt lösenord för SQL-autentisering. För $drLocation anger du regionen där du vill att redundansgruppen ska köras. Vi rekommenderar att du väljer en region som är kopplad till den aktuella serverns region. Kontrollera listan med länkade regioner. Det får hur som helst inte vara samma region som för ursprungsdatabasen. Slutligen lägger du till IP-adressen till din lokala dator. Om du behöver identifiera IP-adressen öppnar du PowerShell lokalt och kör (Invoke-WebRequest -Uri "https://ipinfo.io/ip").Content.
```
# Add your info
$password = "password"
$drLocation = "westus2"
$ipAddress = "xx.xx.xx.xx"
```
Kör det uppdaterade kommandot i Azure Cloud Shell (till höger på den här sidan).

Kör det här skriptet i Azure Cloud Shell för att konfigurera variablerna för följande steg:

$admin = "cloudadmin"
$resourceGroup = Get-AzResourceGroup | Where ResourceGroupName -like <rgn>[sandbox resource group name]</rgn>
$location = $resourceGroup.Location
$resourceGroup = $resourceGroup.ResourceGroupName
$database = "AdventureWorks"
$server = Get-AzureRmSqlServer -ResourceGroupName $resourceGroup
$server = $server.ServerName
$drServer = "$($server)-dr"
$failoverGroup = "$($server)-fg"
$firewallRule = "AllowMyIp"
Write-Host "Variables Received"

Skapa en tom Azure SQL Database-server i redundansregionen genom att köra följande skript i Azure Cloud Shell:

# Create a backup server in the failover region
New-AzSqlServer -ResourceGroupName $resourceGroup `
    -ServerName $drServer `
    -Location $drLocation `
    -SqlAdministratorCredentials $(New-Object -TypeName System.Management.Automation.PSCredential `
    -ArgumentList $admin, $(ConvertTo-SecureString -String $password -AsPlainText -Force))
Write-Host "New Azure SQL Database logical server Created in different region"

Skapa en redundansgrupp mellan servrarna genom att köra följande skript i Azure Cloud Shell:

# Create a failover group between the servers
New-AzSqlDatabaseFailoverGroup -ResourceGroupName $resourceGroup `
    -ServerName $server `
    -PartnerServerName $drServer `
    -FailoverGroupName $failoverGroup 
Write-Host "New auto-failover group created between the two Azure SQL Database logical servers"

Konfigurera nätverket genom att köra följande skript i Azure Cloud Shell:
```
# Add a firewall rule that gives your VM access to the new server
New-AzSqlServerFirewallRule -ResourceGroupName $resourceGroup `
    -ServerName $drServer `
    -FirewallRuleName $firewallRule `
    -StartIpAddress $ipAddress `
    -EndIpAddress $ipAddress;
```
Den här nätverkskonfigurationen räcker för att illustrera begreppet automatiska redundansgrupper. Den skiljer sig dock något från hur du skulle göra i en företagsmiljö. I en företagsmiljö skulle datorn som behöver åtkomst förmodligen vara en uppsättning resurser som utgör någon typ av program. Om databasen redundansväxlar kanske du även vill redundansväxla ditt program, dina virtuella datorer eller andra resurser till den nya regionen. Båda resursuppsättningarna behöver åtkomst till resurserna, servrarna och databaserna i den andra regionen. För att göra detta kan du använda peering för virtuella nätverk, anslutningar mellan två virtuella nätverk eller potentiellt något annat (som Azure ExpressRoute). Det beror på ditt scenario.
Lägg till en eller flera databaser i redundansgruppen genom att köra det här skriptet i Azure Cloud Shell:
```
# Add the database or databases to the failover group
Get-AzSqlDatabase -ResourceGroupName $resourceGroup `
    -ServerName $server -DatabaseName $database | `
    Add-AzSqlDatabaseToFailoverGroup -ResourceGroupName $resourceGroup `
    -ServerName $server `
    -FailoverGroupName $failoverGroup
Write-Host "AdventureWorks database added to the auto-failover group"
```
Det tar lite tid innan skriptet körs. Du återställer databasen i den andra regionen, vilket innebär att du kopierar data från den ursprungliga regionen till regionen för haveriberedskap. Du kan gå vidare med stegen i nästa avsnitt och sedan komma tillbaka för att se om skriptet har slutförts.

Nu har du distribuerat och konfigurerat en automatisk redundansgrupp för databasen AdventureWorks.

Konfigurera program för kommandotolken

I den här övningen använder du två ostress-arbetsbelastningar till att kontrollera Updateability (om en databas är i tillståndet ReadWrite eller ReadOnly) för dina primära och sekundära servrar i redundansgruppen. Det här scenariot är tänkt att simulera ett program där du har skrivskyddade och skrivbara arbetsbelastningar.

Öppna två separata kommandotolkar. Ordna fönstren så att du kan se det här fönstret (webbläsaren) och båda kommandotolkarna.
Navigera till mappen Availability i båda kommandotolkarna, precis som i de tidigare övningarna. Du kan till exempel använda det här kommandot:
```
cd C:\Users\username\mslearn-azure-sql-fundamentals\05-Availability
```
Det första kommandotolksfönstret används till att kontrollera tillståndet för den primära servern i redundansgruppen du skapade. Kör det här kommandot med ditt servernamn och lösenord:
```
.\ostress.exe -S"<server-name>-fg.database.windows.net" -Q"SELECT DATABASEPROPERTYEX(DB_NAME(),'Updateability')" -U"cloudadmin" -d"AdventureWorks" -P"password" -n1 -r5000 -oprimary
```
Kommentar

Med automatiska redundansgrupper ansluter du till namnet på redundansgruppen, som är abstraktionen för databasen.
Det andra kommandotolksfönstret används till att kontrollera tillståndet för den sekundära servern i redundansgruppen du skapade. Kör det här kommandot med ditt servernamn och lösenord:
```
ostress.exe -S"<server-name>-fg.secondary.database.windows.net" -Q"SELECT DATABASEPROPERTYEX(DB_NAME(),'Updateability')" -U"cloudadmin" -d"AdventureWorks" -P"password" -n1 -r5000 -osecondary
```

Resultatet av det första kommandot bör vara READ_WRITE, eftersom det kontrollerar den primära redundansklusterservern och du inte har initierat några redundansväxlingar.

Resultatet av det andra kommandot ska vara READ_ONLY, eftersom det kontrollerar haveriberedskapen eller den sekundära server som du har konfigurerat. Du bör bara kunna skriva från en av servrarna vid samma tidpunkt.

I nästa steg ska du undersöka vad som händer på båda servrarna vid en redundansväxling.

Initiera en redundansväxling och granska resultatet

Använd Azure Cloud Shell-terminalen till höger på den här sidan för att kontrollera den sekundära serverns status:
```
(Get-AzSqlDatabaseFailoverGroup -FailoverGroupName $failoverGroup `
    -ResourceGroupName $resourceGroup -ServerName $drServer).ReplicationRole
```
Resultatet visar om den sekundära servern i den automatiska redundansgruppen används som primär eller sekundär databas.
Nu kan du se vad som händer vid en redundansväxling. Starta en manuell redundansväxling genom att ange följande Azure PowerShell-kommandon i Azure Cloud Shell-terminalen:
```
Switch-AzSqlDatabaseFailoverGroup -ResourceGroupName $resourceGroup `
 -ServerName $drServer -FailoverGroupName $failoverGroup
```
När redundansväxlingen inträffar kanske du märker att anslutningarna tas bort en stund, men eftersom appen fortsätter att försöka igen misslyckas inte programmet helt. När redundansväxlingen är slutförd bör du se resultaten READ_WRITE och READ_ONLY igen och att de inte ändras.

En av fördelarna med automatiska redundansgrupper i Azure SQL Database och Azure SQL Managed Instance är att du inte behöver uppdatera anslutningssträngarna efter en redundansväxling. Du fortsätter att ansluta till den primära (<failover-group>.database.windows.net) repliken för skrivbara arbetsbelastningar och den sekundära (<failover-group>.secondary.database.windows.net) för skrivskyddade arbetsbelastningar. Azure tar hand om dirigeringen till rätt databas för motsvarande region/server.

Kontrollera den sekundära serverns status genom att köra det här skriptet i Azure Cloud Shell:

(Get-AzSqlDatabaseFailoverGroup -FailoverGroupName $failoverGroup `
    -ResourceGroupName $resourceGroup -ServerName $drServer).ReplicationRole

Den här servern ska nu ha den primära rollen.

Växla tillbaka genom att köra det här skriptet i Azure Cloud Shell:

Switch-AzSqlDatabaseFailoverGroup -ResourceGroupName $resourceGroup `
 -ServerName $server -FailoverGroupName $failoverGroup

Slutligen kan du kontrollera den sekundära servern status igen. Kör det här skriptet i Azure Cloud Shell:

(Get-AzSqlDatabaseFailoverGroup -FailoverGroupName $failoverGroup `
    -ResourceGroupName $resourceGroup -ServerName $drServer).ReplicationRole

Nu kan du stänga båda kommandotolkarna och maximera webbläsarfönstret med Microsoft Learn.

I den här övningen har du lärt dig att distribuera och konfigurera automatiska redundansgrupper. Du har också lärt dig vad det innebär ur ett programperspektiv. Automatiska redundansgrupper är bara ett ta tillgängligheten och lässkalningen ett steg längre i Azure SQL.

Övning – Geo-distribuerade automatiska redundansgrupper med lässkalning

Automatiska redundansgrupper i Azure SQL

Konfigurera miljön

Konfigurera program för kommandotolken

Initiera en redundansväxling och granska resultatet

Feedback