Dela via

Använda databeroende routning för att dirigera en fråga till en lämplig databas

  • Artikel

Gäller för:Azure SQL Database

Databeroende routning är möjligheten att använda data i en fråga för att dirigera begäran till en lämplig databas. Databeroende routning är ett grundläggande mönster när du arbetar med fragmenterade databaser. Begärandekontexten kan också användas för att dirigera begäran, särskilt om partitioneringsnyckeln inte är en del av frågan. Varje specifik fråga eller transaktion i ett program som använder databeroende routning är begränsad till åtkomst till en databas per begäran. För elastiska Azure SQL Database-verktyg utförs den här routningen med klassen ShardMapManager (Java, .NET).

Programmet behöver inte spåra olika anslutningssträng- eller DB-platser som är associerade med olika datasektorer i den fragmenterade miljön. I stället öppnar Shard Map Manager anslutningar till rätt databaser när det behövs, baserat på data i fragmentkartan och värdet för den partitioneringsnyckel som är målet för programmets begäran. Nyckeln är vanligtvis customer_id, tenant_id, date_key eller någon annan specifik identifierare som är en grundläggande parameter i databasbegäran.

Mer information finns i Skala ut SQL Server med databeroende routning.

Ladda ned klientbiblioteket

Så här laddar du ned:

Använda en ShardMapManager i ett databeroende routningsprogram

Program bör instansiera ShardMapManager under initieringen med hjälp av fabriksanropet GetSQLShardMapManager (Java, .NET). I det här exemplet initieras både en ShardMapManager och en specifik ShardMap som den innehåller. Det här exemplet visar metoderna GetSqlShardMapManager och GetRangeShardMap (Java, .NET).

ShardMapManager smm = ShardMapManagerFactory.getSqlShardMapManager(connectionString, ShardMapManagerLoadPolicy.Lazy);
RangeShardMap<int> rangeShardMap = smm.getRangeShardMap(Configuration.getRangeShardMapName(), ShardKeyType.Int32);

ShardMapManager smm = ShardMapManagerFactory.GetSqlShardMapManager(smmConnectionString, ShardMapManagerLoadPolicy.Lazy);
RangeShardMap<int> customerShardMap = smm.GetRangeShardMap<int>("customerMap");

Använd autentiseringsuppgifter med lägsta möjliga behörighet för att hämta fragmentkartan

Om ett program inte manipulerar själva shardkartan bör de autentiseringsuppgifter som används i fabriksmetoden ha skrivskyddad behörighet för den globala Shard Map-databasen . Dessa autentiseringsuppgifter skiljer sig vanligtvis från autentiseringsuppgifter som används för att öppna anslutningar till shard map manager. Se även Autentiseringsuppgifter som används för att komma åt Elastic Database-klientbiblioteket.

Anropa metoden Open Anslut ionForKey

Metoden ShardMap.Open Anslut ionForKey (Java, .NET) returnerar en anslutning som är redo att utfärda kommandon till lämplig databas baserat på värdet för nyckelparametern. Shard-information cachelagras i programmet av ShardMapManager, så dessa begäranden omfattar vanligtvis inte en databassökning mot den globala Shard Map-databasen.

// Syntax:
public Connection openConnectionForKey(Object key, String connectionString, ConnectionOptions options)

// Syntax:
public SqlConnection OpenConnectionForKey<TKey>(TKey key, string connectionString, ConnectionOptions options)

Om verifieringen mot den lokala fragmentkartan misslyckas (vilket indikerar att cachen är felaktig) frågar Shard Map Manager den globala fragmentkartan för att hämta det nya korrekta värdet för sökningen, uppdatera cachen och hämta och returnera lämplig databasanslutning.

Använd endast Anslut ionOptions.None när ändringar i shardmappning inte förväntas när ett program är online. I så fall kan cachelagrade värden antas alltid vara korrekta, och det extra valideringsanropet till måldatabasen kan hoppas över på ett säkert sätt. Det minskar databastrafiken. ConnectionOptions kan också anges via ett värde i en konfigurationsfil för att ange om partitioneringsändringar förväntas eller inte under en tidsperiod.

I det här exemplet används värdet för en heltalsnyckel customerID med hjälp av ett ShardMap-objekt med namnet customerShardMap.

int customerId = 12345;
int productId = 4321;
// Looks up the key in the shard map and opens a connection to the shard
try (Connection conn = shardMap.openConnectionForKey(customerId, Configuration.getCredentialsConnectionString())) {
    // Create a simple command that will insert or update the customer information
    PreparedStatement ps = conn.prepareStatement("UPDATE Sales.Customer SET PersonID = ? WHERE CustomerID = ?");

    ps.setInt(1, productId);
    ps.setInt(2, customerId);
    ps.executeUpdate();
} catch (SQLException e) {
    e.printStackTrace();
}

int customerId = 12345;
int newPersonId = 4321;

// Connect to the shard for that customer ID. No need to call a SqlConnection
// constructor followed by the Open method.
using (SqlConnection conn = customerShardMap.OpenConnectionForKey(customerId, Configuration.GetCredentialsConnectionString(), ConnectionOptions.Validate))
{
    // Execute a simple command.
    SqlCommand cmd = conn.CreateCommand();
    cmd.CommandText = @"UPDATE Sales.Customer
                        SET PersonID = @newPersonID WHERE CustomerID = @customerID";

    cmd.Parameters.AddWithValue("@customerID", customerId);cmd.Parameters.AddWithValue("@newPersonID", newPersonId);
    cmd.ExecuteNonQuery();
}

Metoden Open Anslut ionForKey returnerar en ny redan öppen anslutning till rätt databas. Anslut joner som används på det här sättet drar fortfarande full nytta av anslutningspooler.

Metoden Open Anslut ionForKeyAsync (Java, .NET) är också tillgänglig om programmet använder asynkron programmering.

Integrera med tillfällig felhantering

En bra metod för att utveckla dataåtkomstprogram i molnet är att se till att tillfälliga fel fångas upp av appen och att åtgärderna görs flera gånger innan ett fel uppstår. Tillfällig felhantering för molnprogram beskrivs i Tillfälliga felhantering (Java, .NET).

Tillfällig felhantering kan samexistera naturligt med mönstret Databeroende routning. Det viktigaste kravet är att försöka utföra hela begäran om dataåtkomst igen, inklusive användningsblocket som hämtade den databeroende routningsanslutningen. Föregående exempel kan skrivas om på följande sätt.

Exempel – databeroende routning med tillfällig felhantering

int customerId = 12345;
int productId = 4321;
try {
    SqlDatabaseUtils.getSqlRetryPolicy().executeAction(() -> {
        // Looks up the key in the shard map and opens a connection to the shard
        try (Connection conn = shardMap.openConnectionForKey(customerId, Configuration.getCredentialsConnectionString())) {
            // Create a simple command that will insert or update the customer information
            PreparedStatement ps = conn.prepareStatement("UPDATE Sales.Customer SET PersonID = ? WHERE CustomerID = ?");

            ps.setInt(1, productId);
            ps.setInt(2, customerId);
            ps.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    });
} catch (Exception e) {
    throw new StoreException(e.getMessage(), e);
}

int customerId = 12345;
int newPersonId = 4321;

Configuration.SqlRetryPolicy.ExecuteAction(() -> {

    // Connect to the shard for a customer ID.
    using (SqlConnection conn = customerShardMap.OpenConnectionForKey(customerId, Configuration.GetCredentialsConnectionString(), ConnectionOptions.Validate))
    {
        // Execute a simple command
        SqlCommand cmd = conn.CreateCommand();

        cmd.CommandText = @"UPDATE Sales.Customer
                            SET PersonID = @newPersonID
                            WHERE CustomerID = @customerID";

        cmd.Parameters.AddWithValue("@customerID", customerId);
        cmd.Parameters.AddWithValue("@newPersonID", newPersonId);
        cmd.ExecuteNonQuery();

        Console.WriteLine("Update completed");
    }
});

Paket som krävs för att implementera tillfällig felhantering laddas ned automatiskt när du skapar exempelprogrammet för elastisk databas.

Transaktionskonsekvens

Transaktionsegenskaper garanteras för alla åtgärder som är lokala för en shard. Till exempel körs transaktioner som skickas via databeroende routning inom omfånget för målshard för anslutningen. För närvarande finns det inga funktioner för att registrera flera anslutningar i en transaktion, och därför finns det inga transaktionsgarantier för åtgärder som utförs över shards.

Nästa steg

Information om hur du kopplar från en shard eller om du vill koppla om en shard finns i Använda klassen RecoveryManager för att åtgärda problem med fragmentkartan.

Ytterligare resurser

Använder du inte elastiska databasverktyg än? Kolla in vår komma igång-guide. Om du har frågor kan du kontakta oss på microsofts Q&A-frågesida för SQL Database och för funktionsförfrågningar, lägga till nya idéer eller rösta på befintliga idéer i SQL Database-feedbackforumet.