Esercitazione: Implementare un database con distribuzione geografica (database SQL di Azure)

Articolo
03/18/2024

Configurare un database nel database SQL di Azure e l'applicazione client per il failover in un'area remota e testare un piano di failover. Scopri come:

Creare un gruppo di failover
Eseguire un'applicazione Java per eseguire query su un database nel database SQL
Failover di test

Se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare.

Prerequisiti

Nota

Questo articolo usa il modulo Az di PowerShell di Azure, che è il modulo di PowerShell consigliato per l'interazione con Azure. Per iniziare a usare il modulo Az PowerShell, vedere Installare Azure PowerShell. Per informazioni su come eseguire la migrazione al modulo AZ PowerShell, vedere Eseguire la migrazione di Azure PowerShell da AzureRM ad Az.

Importante

Il modulo Azure Resource Manager di PowerShell è ancora supportato da Database SQL di Azure, ma tutte le attività di sviluppo future sono incentrate sul modulo Az.Sql. Per informazioni su questi cmdlet, vedere AzureRM.Sql. Gli argomenti per i comandi nei moduli Az e AzureRm sono sostanzialmente identici.

Per completare l'esercitazione, verificare di avere installato i componenti seguenti:

Azure PowerShell
Un database singolo nel database SQL di Azure. Per crearne uno, usare:
Nota

In questa esercitazione viene usato il database di esempio AdventureWorksLT.

Importante

Assicurarsi di configurare le regole del firewall in modo da usare l'indirizzo IP pubblico del computer in cui si eseguono i passaggi dell'esercitazione. Le regole del firewall a livello di database verranno replicate automaticamente nel server secondario.

Per informazioni, vedere Creare una regola del firewall a livello di database o per determinare l'indirizzo IP usato per la regola del firewall a livello di server per il proprio computer, vedere Creare una regola del firewall a livello di server.

Creare un gruppo di failover

Usando Azure PowerShell, creare gruppi di failover tra un server esistente e un nuovo server in un'altra area. Aggiungere quindi il database di esempio al gruppo di failover.

PowerShell
L’interfaccia della riga di comando di Azure

Importante

Questo esempio richiede Azure PowerShell Az 1.0 o versioni successive. Eseguire Get-Module -ListAvailable Az per determinare le versioni installate. Se è necessario installarlo, vedere Installare il modulo Azure PowerShell.

Eseguire Connect-AzAccount per accedere ad Azure.

Per creare un gruppo di failover, eseguire lo script seguente:

$admin = "<adminName>"
$password = "<password>"
$resourceGroup = "<resourceGroupName>"
$location = "<resourceGroupLocation>"
$server = "<serverName>"
$database = "<databaseName>"
$drLocation = "<disasterRecoveryLocation>"
$drServer = "<disasterRecoveryServerName>"
$failoverGroup = "<globallyUniqueFailoverGroupName>"

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

# create a failover group between the servers
New-AzSqlDatabaseFailoverGroup –ResourceGroupName $resourceGroup -ServerName $server `
    -PartnerServerName $drServer –FailoverGroupName $failoverGroup –FailoverPolicy Automatic -GracePeriodWithDataLossHours 2

# add the database to the failover group
Get-AzSqlDatabase -ResourceGroupName $resourceGroup -ServerName $server -DatabaseName $database | `
    Add-AzSqlDatabaseToFailoverGroup -ResourceGroupName $resourceGroup -ServerName $server -FailoverGroupName $failoverGroup

Importante

Eseguire az login per accedere ad Azure.

$admin = "<adminName>"
$password = "<password>"
$resourceGroup = "<resourceGroupName>"
$location = "<resourceGroupLocation>"
$server = "<serverName>"
$database = "<databaseName>"
$drLocation = "<disasterRecoveryLocation>" # must be different then $location
$drServer = "<disasterRecoveryServerName>"
$failoverGroup = "<globallyUniqueFailoverGroupName>"

# create a backup server in the failover region
az sql server create --admin-password $password --admin-user $admin `
    --name $drServer --resource-group $resourceGroup --location $drLocation

# create a failover group between the servers
az sql failover-group create --name $failoverGroup --partner-server $drServer `
    --resource-group $resourceGroup --server $server --add-db $database `
    --failover-policy Automatic --grace-period 2

Le impostazioni di replica geografica possono essere modificate anche nel portale di Azure, selezionando il database e quindi scegliendo Impostazioni>Replica geografica.

Geo-replication settings

Eseguire il progetto di esempio

Nella console creare un progetto Maven con il comando seguente:

mvn archetype:generate "-DgroupId=com.sqldbsamples" "-DartifactId=SqlDbSample" "-DarchetypeArtifactId=maven-archetype-quickstart" "-Dversion=1.0.0"

Digitare Y e premere INVIO.
Passare alla directory del nuovo progetto.
```
cd SqlDbSample
```
Con l'editor preferito, aprire il file pom.xml nella cartella del progetto.
Includere la dipendenza Microsoft JDBC Driver per SQL Server aggiungendo la sezione dependency seguente. La dipendenza deve essere incollata all'interno della sezione dependencies più estesa.
```
<dependency>
  <groupId>com.microsoft.sqlserver</groupId>
  <artifactId>mssql-jdbc</artifactId>
 <version>6.1.0.jre8</version>
</dependency>
```

Specificare la versione di Java aggiungendo la sezione properties dopo la sezione dependencies:

<properties>
  <maven.compiler.source>1.8</maven.compiler.source>
  <maven.compiler.target>1.8</maven.compiler.target>
</properties>

Supportare i file manifesto aggiungendo la sezione build dopo la sezione properties:

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-jar-plugin</artifactId>
      <version>3.0.0</version>
      <configuration>
        <archive>
          <manifest>
            <mainClass>com.sqldbsamples.App</mainClass>
          </manifest>
        </archive>
     </configuration>
    </plugin>
  </plugins>
</build>

Salvare e chiudere il file pom.xml.

Aprire il file App.java in ..\SqlDbSample\src\main\java\com\sqldbsamples e sostituirne il contenuto con il codice seguente:

package com.sqldbsamples;

import java.sql.Connection;
import java.sql.Statement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Timestamp;
import java.sql.DriverManager;
import java.util.Date;
import java.util.concurrent.TimeUnit;

public class App {

   private static final String FAILOVER_GROUP_NAME = "<your failover group name>";  // add failover group name

   private static final String DB_NAME = "<your database>";  // add database name
   private static final String USER = "<your admin>";  // add database user
   private static final String PASSWORD = "<your password>";  // add database password

   private static final String READ_WRITE_URL = String.format("jdbc:" +
      "sqlserver://%s.database.windows.net:1433;database=%s;user=%s;password=%s;encrypt=true;" +
      "hostNameInCertificate=*.database.windows.net;loginTimeout=30;",
      FAILOVER_GROUP_NAME, DB_NAME, USER, PASSWORD);
   private static final String READ_ONLY_URL = String.format("jdbc:" +
      "sqlserver://%s.secondary.database.windows.net:1433;database=%s;user=%s;password=%s;encrypt=true;" +
      "hostNameInCertificate=*.database.windows.net;loginTimeout=30;",
      FAILOVER_GROUP_NAME, DB_NAME, USER, PASSWORD);

   public static void main(String[] args) {
      System.out.println("#######################################");
      System.out.println("## GEO DISTRIBUTED DATABASE TUTORIAL ##");
      System.out.println("#######################################");
      System.out.println("");

      int highWaterMark = getHighWaterMarkId();

      try {
         for(int i = 1; i < 1000; i++) {
             //  loop will run for about 1 hour
             System.out.print(i + ": insert on primary " +
                (insertData((highWaterMark + i)) ? "successful" : "failed"));
             TimeUnit.SECONDS.sleep(1);
             System.out.print(", read from secondary " +
                (selectData((highWaterMark + i)) ? "successful" : "failed") + "\n");
             TimeUnit.SECONDS.sleep(3);
         }
      } catch(Exception e) {
         e.printStackTrace();
   }
}

private static boolean insertData(int id) {
   // Insert data into the product table with a unique product name so we can find the product again
   String sql = "INSERT INTO SalesLT.Product " +
      "(Name, ProductNumber, Color, StandardCost, ListPrice, SellStartDate) VALUES (?,?,?,?,?,?);";

   try (Connection connection = DriverManager.getConnection(READ_WRITE_URL);
           PreparedStatement pstmt = connection.prepareStatement(sql)) {
      pstmt.setString(1, "BrandNewProduct" + id);
      pstmt.setInt(2, 200989 + id + 10000);
      pstmt.setString(3, "Blue");
      pstmt.setDouble(4, 75.00);
      pstmt.setDouble(5, 89.99);
      pstmt.setTimestamp(6, new Timestamp(new Date().getTime()));
      return (1 == pstmt.executeUpdate());
   } catch (Exception e) {
      return false;
   }
}

private static boolean selectData(int id) {
   // Query the data previously inserted into the primary database from the geo replicated database
   String sql = "SELECT Name, Color, ListPrice FROM SalesLT.Product WHERE Name = ?";

   try (Connection connection = DriverManager.getConnection(READ_ONLY_URL);
           PreparedStatement pstmt = connection.prepareStatement(sql)) {
      pstmt.setString(1, "BrandNewProduct" + id);
      try (ResultSet resultSet = pstmt.executeQuery()) {
         return resultSet.next();
      }
   } catch (Exception e) {
      return false;
   }
}

private static int getHighWaterMarkId() {
   // Query the high water mark id stored in the table to be able to make unique inserts
   String sql = "SELECT MAX(ProductId) FROM SalesLT.Product";
   int result = 1;
   try (Connection connection = DriverManager.getConnection(READ_WRITE_URL);
           Statement stmt = connection.createStatement();
           ResultSet resultSet = stmt.executeQuery(sql)) {
      if (resultSet.next()) {
          result =  resultSet.getInt(1);
         }
      } catch (Exception e) {
       e.printStackTrace();
      }
      return result;
   }
}

Salvare e chiudere il file App.java.
Nella console dei comandi eseguire il comando seguente:
```
mvn package
```

Avviare l'applicazione che verrà eseguita per circa un'ora finché non si arresterà manualmente, tenendo conto del tempo necessario per eseguire il test di failover.

mvn -q -e exec:java "-Dexec.mainClass=com.sqldbsamples.App"

#######################################
## GEO DISTRIBUTED DATABASE TUTORIAL ##
#######################################

1. insert on primary successful, read from secondary successful
2. insert on primary successful, read from secondary successful
3. insert on primary successful, read from secondary successful
...

Failover di test

Eseguire gli script seguenti per simulare un failover e osservare i risultati dell'applicazione. Si noti come alcune operazioni di inserimento e selezione avranno esito negativo durante la migrazione del database.

PowerShell
L’interfaccia della riga di comando di Azure

È anche possibile verificare il ruolo del server per il ripristino di emergenza durante il test con il comando seguente:

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

Per testare un failover:

Avviare un failover manuale del gruppo di failover:

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

Ripristinare il gruppo di failover nel server primario:

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

È anche possibile verificare il ruolo del server per il ripristino di emergenza durante il test con il comando seguente:

az sql failover-group show --name $failoverGroup --resource-group $resourceGroup --server $drServer

Per testare un failover:

Avviare un failover manuale del gruppo di failover:

az sql failover-group set-primary --name $failoverGroup --resource-group $resourceGroup --server $drServer

Ripristinare il gruppo di failover nel server primario:

az sql failover-group set-primary --name $failoverGroup --resource-group $resourceGroup --server $server

Passaggi successivi

Revisionare l’elenco di controllo disponibilità elevata e ripristino di emergenza.

Contenuto del database SQL di Azure correlato:

Esercitazione: Implementare un database con distribuzione geografica (database SQL di Azure)

Prerequisiti

Creare un gruppo di failover

Eseguire il progetto di esempio

Failover di test

Passaggi successivi

Commenti e suggerimenti

Commenti e suggerimenti

Risorse aggiuntive