Dela via

Skala ut databaser med shard map manager

  • Artikel

gäller för:Azure SQL Database

Använd en shard map manager för att enkelt skala ut databaser i Azure SQL Database. Karthanteraren för fragment är en särskild databas som upprätthåller global mappningsinformation om alla shards (databaser) i en sharduppsättning. Med metadata kan ett program ansluta till rätt databas baserat på värdet för partitioneringsnyckeln. Dessutom innehåller varje shard i uppsättningen kartor som spårar lokala shard-data (kallas shardar).

Hantering av shard-kartor

Att förstå hur dessa kartor konstrueras är viktigt för hantering av fragmentkartor. Detta görs med hjälp av klassen ShardMapManager (Java, .NET), som finns i Elastic Database-klientbiblioteket för att hantera shardkartor.

Shardkartor och shardmappningar

För varje shard måste du välja den typ av shardkarta som ska skapas. Valet beror på databasarkitekturen:

  1. Enskild klient per databas
  2. Flera hyresgäster per databas (två typer):
    1. Listkartläggning
    2. Områdeskartläggning

För en modell med en enda hyresgäst skapar du en list-mappning shardkarta. Modellen för en hyresgäst tilldelar en databas per hyresgäst. Det här är en effektiv modell för SaaS-utvecklare eftersom den förenklar hantering av fragmentkartor.

Listmappning

Modellen med flera klientorganisationer tilldelar flera klientorganisationer till en enskild databas (och du kan distribuera grupper av klientorganisationer över flera databaser). Använd den här modellen när du förväntar dig att varje klientorganisation har små databehov. I den här modellen tilldelar du en rad klienter till en databas genom intervallmappning med .

Intervallkartläggning

Eller så kan du implementera en databasmodell för flera klienter med hjälp av en -listmappning för att tilldela flera klienter till en enskild databas. Db1 används till exempel för att lagra information om klientorganisations-ID 1 och 5, och DB2 lagrar data för klientorganisation 7 och klient 10.

Flera hyresgäster på en enskild databas

Typer som stöds för partitioneringsnyckel

Elastic Scale stöder följande typer som horisontell partitioneringsnyckel:

.NÄT Java
heltal heltal
lång lång
GUID uuid
byte[] byte[]
datumtid Tidsstämpel
tidsintervall varaktighet
datetimeoffset offsetdatetime

Listor och intervallkartor för shard

Shard-kartor kan konstrueras med hjälp av listor med enskilda värden för shardnyckel, eller de kan konstrueras med hjälp av intervall av shardnyckelvärden.

Lista fragmentkartor

Shards innehåller shardlets och mappningen av shardletar till shards underhålls av en shardkarta. En lista över skärv-karta är en association mellan de enskilda nyckelvärden som identifierar skärvor och de databaser som fungerar som fragment. Listmappningar är explicita och olika nyckelvärden kan mappas till samma databas. Till exempel mappar nyckelvärdet 1 till Databas A och nyckelvärdena 3 och 6 mappar båda till Databas B.

Nyckel Shard-plats
1 Databas_A
3 Database_B
4 Database_C
6 Database_B
... ...

Intervallskärvkartor

I en områdesshardkartabeskrivs nyckelintervallet av ett par [Lågt Värde, Högt Värde) där Lågt Värde är miniminyckeln i intervallet, och Högt Värde är det första värdet som är högre än intervallet.

Till exempel innehåller [0, 100) alla heltal större än eller lika med 0 och mindre än 100. Observera att flera intervall kan peka på samma databas och att osammanhängande intervall stöds (till exempel [100, 200) och [400, 600) båda pekar på Databas C i följande exempel).

Nyckel Shard-plats
[1,50) Database_A
[50,100) Database_B
[100,200) Database_C
[400,600) Database_C
... ...

Var och en av tabellerna som visas ovan är ett konceptuellt exempel på ett ShardMap- objekt. Varje rad är ett förenklat exempel på en enskild PointMapping- (för listshardkartan) eller RangeMapping-objekt (för range shard map).

Hanterare för fragmentkarta

I klientbiblioteket är karthanteraren för shard en samling shardkartor. Data som hanteras av en ShardMapManager-instansen behålls på tre platser:

  1. Global Shard Map (GSM): Du anger en databas som ska fungera som lagringsplats för alla dess fragmentkartor och mappningar. Särskilda tabeller och lagrade procedurer skapas automatiskt för att hantera informationen. Detta är vanligtvis en liten databas och lätt åtsåt, och den bör inte användas för andra behov i programmet. Tabellerna finns i ett särskilt schema med namnet __ShardManagement.
  2. Local Shard Map (LSM): Varje databas som du anger som en shard ändras så att den innehåller flera små tabeller och särskilda lagrade procedurer som innehåller och hanterar shardmappningsinformation som är specifik för fragmentet. Den här informationen är redundant med informationen i GSM och gör det möjligt för programmet att verifiera cachelagrad shardkarta utan att lägga någon belastning på GSM; programmet använder LSM för att avgöra om en cachelagrad mappning fortfarande är giltig. Tabellerna som motsvarar LSM på varje shard finns också i schemat __ShardManagement.
  3. Application Cache: Varje programinstans som har åtkomst till ett ShardMapManager--objekt har en lokal minnesintern cache för sina mappningar. Den lagrar routningsinformation som nyligen har hämtats.

Skapa en ShardMapManager

Ett ShardMapManager--objekt skapas med hjälp av en fabrikmetod (Java, .NET). Metoden ShardMapManagerFactory.GetSqlShardMapManager (Java, .NET) tar autentiseringsuppgifter (inklusive servernamn och databasnamn som håller GSM) i form av en ConnectionString och returnerar en instans av en ShardMapManager.

Obs!ShardMapManager- bör bara instansieras en gång per appdomän, inom initieringskoden för ett program. Skapande av ytterligare instanser av ShardMapManager i samma appdomän resulterar i ökad minnes- och CPU-användning av programmet. En ShardMapManager- kan innehålla valfritt antal shardkartor. Även om en enda fragmentkarta kan vara tillräcklig för många program, finns det tillfällen då olika uppsättningar databaser används för olika scheman eller för unika ändamål. i dessa fall kan flera fragmentkartor vara att föredra.

I den här koden försöker ett program öppna en befintlig ShardMapManager- med metoden TryGetSqlShardMapManager (Java, .NET. Om objekt som representerar en Global ShardMapManager- (GSM) ännu inte finns i databasen, skapar klientbiblioteket dem med hjälp av metoden CreateSqlShardMapManager (Java, .NET).

// Try to get a reference to the Shard Map Manager in the shardMapManager database.
// If it doesn't already exist, then create it.
ShardMapManager shardMapManager = null;
boolean shardMapManagerExists = ShardMapManagerFactory.tryGetSqlShardMapManager(shardMapManagerConnectionString,ShardMapManagerLoadPolicy.Lazy, refShardMapManager);
shardMapManager = refShardMapManager.argValue;

if (shardMapManagerExists) {
    ConsoleUtils.writeInfo("Shard Map %s already exists", shardMapManager);
}
else {
    // The Shard Map Manager does not exist, so create it
    shardMapManager = ShardMapManagerFactory.createSqlShardMapManager(shardMapManagerConnectionString);
    ConsoleUtils.writeInfo("Created Shard Map %s", shardMapManager);
}

// Try to get a reference to the Shard Map Manager via the Shard Map Manager database.  
// If it doesn't already exist, then create it.
ShardMapManager shardMapManager;
bool shardMapManagerExists = ShardMapManagerFactory.TryGetSqlShardMapManager(
                                        connectionString,
                                        ShardMapManagerLoadPolicy.Lazy,
                                        out shardMapManager);

if (shardMapManagerExists)
{
    Console.WriteLine("Shard Map Manager already exists");
}
else
{
    // Create the Shard Map Manager.
    ShardMapManagerFactory.CreateSqlShardMapManager(connectionString);
    Console.WriteLine("Created SqlShardMapManager");

    shardMapManager = ShardMapManagerFactory.GetSqlShardMapManager(
            connectionString,
            ShardMapManagerLoadPolicy.Lazy);

// The connectionString contains server name, database name, and admin credentials for privileges on both the GSM and the shards themselves.
}

För .NET-versionen kan du använda PowerShell för att skapa en ny Shard Map Manager.

Hämta ett RangeShardMap eller ListShardMap

När du har skapat en shardkarthanterare kan du hämta RangeShardMap (Java, .NET) eller ListShardMap (Java, .NET) med hjälp av TryGetRangeShardMap (Java, .NET), metoden TryGetListShardMap (Java, .NET) eller Metoden GetShardMap (Java, .NET).

// Creates a new Range Shard Map with the specified name, or gets the Range Shard Map if it already exists.
static <T> RangeShardMap<T> createOrGetRangeShardMap(ShardMapManager shardMapManager,
            String shardMapName,
            ShardKeyType keyType) {
    // Try to get a reference to the Shard Map.
    ReferenceObjectHelper<RangeShardMap<T>> refRangeShardMap = new ReferenceObjectHelper<>(null);
    boolean isGetSuccess = shardMapManager.tryGetRangeShardMap(shardMapName, keyType, refRangeShardMap);
    RangeShardMap<T> shardMap = refRangeShardMap.argValue;

    if (isGetSuccess && shardMap != null) {
        ConsoleUtils.writeInfo("Shard Map %1$s already exists", shardMap.getName());
    }
    else {
        // The Shard Map does not exist, so create it
        try {
            shardMap = shardMapManager.createRangeShardMap(shardMapName, keyType);
        }
        catch (Exception e) {
            e.printStackTrace();
        }
        ConsoleUtils.writeInfo("Created Shard Map %1$s", shardMap.getName());
    }

    return shardMap;
}

// Creates a new Range Shard Map with the specified name, or gets the Range Shard Map if it already exists.
public static RangeShardMap<T> CreateOrGetRangeShardMap<T>(ShardMapManager shardMapManager, string shardMapName)
{
    // Try to get a reference to the Shard Map.
    RangeShardMap<T> shardMap;
    bool shardMapExists = shardMapManager.TryGetRangeShardMap(shardMapName, out shardMap);

    if (shardMapExists)
    {
        ConsoleUtils.WriteInfo("Shard Map {0} already exists", shardMap.Name);
    }
    else
    {
        // The Shard Map does not exist, so create it
        shardMap = shardMapManager.CreateRangeShardMap<T>(shardMapName);
        ConsoleUtils.WriteInfo("Created Shard Map {0}", shardMap.Name);
    }

    return shardMap;
}

Autentiseringsuppgifter för Shard-mappningsadministration

Program som administrerar och manipulerar shardkartor skiljer sig från dem som använder shardkartorna för att dirigera anslutningar.

För att administrera shardkartor (lägga till eller ändra shards, shardkartor, shardmappningar osv.) måste du instansiera ShardMapManager med autentiseringsuppgifter som har läs-/skrivbehörighet för både GSM-databasen och varje databas som fungerar som en shard. Autentiseringsuppgifterna måste tillåta skrivningar mot tabellerna i både GSM och LSM eftersom information om fragmentkartan anges eller ändras, samt för att skapa LSM-tabeller på nya fragment.

Se autentiseringsuppgifter som används för att komma åt Elastic Database-klientbiblioteket.

Endast metadata som påverkas

Metoder som används för att fylla i eller ändra ShardMapManager data ändrar inte användardata som lagras i själva shardsna. Till exempel påverkar metoder som CreateShard, DeleteShard, UpdateMappingosv. endast metadata för horisontell mappning. De tar inte bort, lägger till eller ändrar användardata som finns i fragmenten. I stället är dessa metoder utformade för att användas tillsammans med separata åtgärder som du utför för att skapa eller ta bort faktiska databaser, eller som flyttar rader från en shard till en annan för att balansera om en fragmenterad miljö. (Verktyget för delad-sammanslagning som ingår med elastiska databasverktyg använder dessa API:er tillsammans med orkestrering av faktisk dataförflyttning mellan shards.) Se Skalning med hjälp av verktyget för delad-sammanslagning i Elastic Database.

Databeroende routning

Karthanteraren för shard används i program som kräver databasanslutningar för att utföra appspecifika dataåtgärder. Dessa anslutningar måste associeras med rätt databas. Detta kallas databeroende routning. För dessa program instansierar du ett shard map manager-objekt från fabriken med autentiseringsuppgifter som har skrivskyddad åtkomst i GSM-databasen. Enskilda begäranden om senare anslutningar anger de autentiseringsuppgifter som krävs för att ansluta till lämplig sharddatabas.

Observera att dessa program (som använder ShardMapManager öppnade med skrivskyddade autentiseringsuppgifter) inte kan göra ändringar i kartorna eller mappningarna. För dessa behov skapar du administrativa program eller PowerShell-skript som tillhandahåller högre privilegierade autentiseringsuppgifter enligt beskrivningen tidigare. Se autentiseringsuppgifter som används för att komma åt Elastic Database-klientbiblioteket.

Mer information finns i Databeroende routning.

Ändra en fragmentkarta

En fragmentkarta kan ändras på olika sätt. Alla följande metoder ändrar metadata som beskriver shards och deras mappningar, men de ändrar inte data fysiskt i fragmenten, och de skapar eller tar inte heller bort de faktiska databaserna. Vissa av åtgärderna på fragmentkartan som beskrivs nedan kan behöva samordnas med administrativa åtgärder som fysiskt flyttar data eller som lägger till och tar bort databaser som fungerar som shards.

Dessa metoder fungerar tillsammans som de byggstenar som är tillgängliga för att ändra den övergripande fördelningen av data i din fragmenterade databasmiljö.

  • Om du vill lägga till eller ta bort shards: använd CreateShard (Java, .NET) och DeleteShard (Java, .NET) i shardmappen (Java, .NET) klass.

    Servern och databasen som representerar målshard måste redan finnas för att dessa åtgärder ska kunna köras. Dessa metoder har ingen inverkan på själva databaserna, bara på metadata i fragmentkartan.

  • Skapa eller ta bort punkter eller intervall som mappas till shards: använd CreateRangeMapping (Java, .NET), DeleteMapp (Java, .NET) i klassen RangeShardMapping (Java, .NET) och CreatePointMapping (Java, .NET) i ListShardMap (Java, .NET)-klass.

    Många olika punkter eller intervall kan mappas till samma fragment. Dessa metoder påverkar endast metadata – de påverkar inte data som redan finns i shards. Om data behöver tas bort från databasen för att vara konsekvent med DeleteMapping-åtgärder utför du dem separat men i samband med dessa metoder.

  • Om du vill dela upp befintliga intervall i två eller sammanfoga angränsande intervall i ett: använd SplitMapping (Java, .NET) och MergeMappings (Java, .NET).

    Observera att delnings- och sammanslagningsåtgärder inte ändrar shard till vilken nyckelvärden mappas. En delning delar upp ett befintligt intervall i två delar, men lämnar båda som mappade till samma "shard" (dataskärva). En sammanslagning sker på två angränsande intervall som redan är mappade till samma fragment och slår samman dem till ett enda intervall. Själva förflyttningen av punkter eller intervall mellan fragment måste samordnas med hjälp av funktionen UpdateMapping i samarbete med den faktiska dataförflyttningen. Du kan använda tjänsten Split/Merge som är en del av elastiska databasverktyg för att samordna shard map-ändringar med dataflytt när förflyttning behövs.

  • Om du vill mappa om (eller flytta) enskilda punkter eller intervall till olika shards: använd UpdateMapping (Java, .NET).

    Eftersom data kan behöva flyttas från en shard till en annan för att vara konsekvent med UpdateMapping operationer, måste du utföra datamigreringen separat men i samband med att använda dessa metoder.

  • Så här tar du mappningar online och offline: använd MarkMappingOffline (Java, .NET) och MarkMappingOnline (Java, .NET) för att styra onlinetillståndet för en mappning.

    Vissa åtgärder på shardmappningar tillåts endast när en mappning är i ett offline- tillstånd, inklusive UpdateMapping och DeleteMapping. När en mappning är offline returnerar en databeroende begäran baserat på en nyckel som ingår i mappningen ett fel. Dessutom, när ett intervall först tas offline, avbryts alla anslutningar till det berörda fragmentet automatiskt för att förhindra inkonsekventa eller ofullständiga resultat för frågor som riktas mot de intervall som ändras.

Mappningar är oföränderliga objekt i .NET. Alla metoder ovan som ändrar mappningar ogiltigförklarar även alla referenser till dem i koden. För att göra det enklare att utföra sekvenser av åtgärder som ändrar en mappnings tillstånd returnerar alla metoder som ändrar en mappning en ny mappningsreferens, så att åtgärder kan länkas. Om du till exempel vill ta bort en befintlig mappning i shardmap sm som innehåller nyckeln 25 kan du köra följande:

    sm.DeleteMapping(sm.MarkMappingOffline(sm.GetMappingForKey(25)));

Lägga till en shard

Program behöver ofta lägga till nya shards för att hantera data som förväntas från nya nycklar eller nyckelintervall, för en fragmentkarta som redan finns. Till exempel kan ett program som är fragmenterat av klientorganisations-ID behöva etablera en ny shard för en ny klientorganisation, eller så kan data som partitioneras varje månad behöva en ny shard etablerad före början av varje ny månad.

Om det nya intervallet med nyckelvärden inte redan är en del av en befintlig mappning och ingen dataflytt krävs är det enkelt att lägga till det nya fragmentet och associera den nya nyckeln eller intervallet till fragmentet. Mer information om hur du lägger till nya shards finns i Lägga till en ny shard-.

För scenarier som kräver dataförflyttning krävs dock verktyget split-merge för att orkestrera dataförflyttningen mellan shards i kombination med nödvändiga uppdateringar av fragmentkartan. Mer information om hur du använder verktyget för delning och sammanslagning finns i Översikt över delnings- och sammankoppling

Relaterat innehåll

Använder du inte elastiska databasverktyg än? Kolla in vår komma igång-guide. För frågor kan du kontakta oss på Microsoft Q&En 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.