Effectuer un scale-out des bases de données avec le Gestionnaire de cartes de partitions

S’applique à :Azure SQL Database

Pour facilement effectuer un scale-out des bases de données sur Azure SQL Database, utilisez un Gestionnaire de cartes de partitions. Le Gestionnaire de cartes de partitions est une base de données spéciale qui gère les informations de mappage global sur toutes les partitions (bases de données) dans un ensemble de partitions. Les métadonnées permettent à une application de se connecter à la base de données qui convient en fonction de la valeur de la clé de partitionnement. En outre, chaque fragment de l’ensemble contient des cartes qui suivent les données des fragments locaux (appelés shardlets).

Pour la gestion des cartes de fragments, il est essentiel de comprendre comment elles sont construites. Cette opération s’effectue à l’aide de la classe ShardMapManager (Java, .NET), trouvée dans la création de bases de données cloud évolutives pour gérer les cartes de partitions.

Cartes de fragments et mappages de fragments

Pour chaque shard, vous devez sélectionner le type de carte de shard à créer. Votre choix dépend de l’architecture de la base de données :

1. Client unique par base de données
2. Plusieurs locataires par base de données (deux types) :
   1. Mappage de liste
   2. Mappage de plage

Pour un modèle à locataire unique, créez une carte de fragments mappage de liste. Le modèle à un seul client attribue une base de données par client. Il s’agit d’un modèle efficace pour les développeurs SaaS, car il simplifie la gestion des cartes de partition.

Le modèle multilocataire affecte plusieurs locataires à une base de données individuelle (et vous pouvez distribuer des groupes de locataires entre plusieurs bases de données). Utilisez ce modèle lorsque vous pensez que chaque client va avoir de faibles besoins en termes de données. Dans ce modèle, attribuez une plage de clients à une base de données à l’aide du mappage de plage.

Vous pouvez également implémenter un modèle de base de données mutualisé à l’aide d’un mappage de liste pour affecter plusieurs locataires à une base de données individuelle. Par exemple, DB1 est utilisée pour stocker les informations d’ID client 1 et 5 et DB2 stocke les données pour les clients 7 et 10.

Types pris en charge pour les clés de partitionnement

L'échelle élastique prend en charge les types suivants comme clés de partitionnement :

Liste et cartes de fragments de plage

Vous pouvez construire des cartes de partition en utilisant des listes de valeurs de clés de partitionnement individuelles ou des plages de valeurs de clés de partitionnement.

Cartes de partition de liste

Les shards contiennent des shardlets (micro-partitions) et le mappage de ces shardlets en shards est tenu à jour par une carte de fragmentation. Une carte de fragments de liste est une association entre les valeurs de clés individuelles identifiant les micro-fragments et les bases de données servant de fragments. mappages de liste sont explicites et plusieurs valeurs de clés peuvent être mappées à la même base de données. Par exemple, la valeur de clé 1 est mappée vers la base de données A, et les valeurs de clés 3 et 6 sont toutes deux mappées vers la base de données B.

Cartes de fragments de plage

Dans une carte de partitions de plage, la plage de clé est décrite par une paire [valeur inférieure, valeur supérieure) , où la valeur inférieure correspond à la clé minimale de la plage, tandis que la valeur supérieure correspond à la première valeur supérieure à la plage.

Par exemple, [0, 100) inclut tous les entiers égaux ou supérieurs à 0 et inférieurs à 100. Plusieurs plages peuvent pointer vers la même base de données et les plages disjointes sont prises en charge (par exemple, [100,200) et [400 600) pointent vers la base de données C dans l’exemple suivant.)

Chacune des tables ci-dessus est un exemple conceptuel d’un ShardMap objet. Chaque ligne est un exemple simplifié d’un objet individuel PointMapping (pour la carte de partitions de liste) ou RangeMapping (pour la carte de partitions de plage).

Gestionnaire des cartes de partitions

Dans la bibliothèque cliente, le gestionnaire des cartes de partitions correspond à une collection de cartes de partitions. Les données gérées par une ShardMapManager instance sont conservées à trois emplacements :

1. Carte de partitions globale (GSM) : vous spécifiez une base de données pour servir de référentiel à l'ensemble de ses cartes de partitions et mappages. Les tables spéciales et les procédures stockées sont automatiquement créées pour gérer les informations. Il s'agit généralement d'une petite base de données à laquelle vous pouvez accéder rapidement, et elle ne doit pas être utilisée pour d'autres besoins de l'application. Les tables se trouvent dans un schéma spécial nommé __ShardManagement.
2. Carte de partitions locale (LSM) : chaque base de données que vous définissez en tant que partition est modifiée pour contenir plusieurs petites tables et des procédures stockées spéciales qui contiennent et gèrent les informations de carte de partitions propres à cette partition. Ces informations sont redondantes avec les informations contenues dans la GSM et elles permettent aux applications de valider les informations de carte de partitions mises en cache sans placer aucune charge sur la GSM. L'application utilise la LSM pour déterminer la validité d'un mappage mis en cache. Les tables correspondant au LSM sur chaque fragment se trouvent également dans le schéma __ShardManagement.
3. Cache d’application : chaque instance d’application accédant à un ShardMapManager objet conserve un cache local en mémoire de ses mappages. Elle stocke les informations de routage récupérées récemment.

Construire un ShardMapManager

Un ShardMapManager objet est construit à l’aide d’un modèle de fabrique (Java, .NET). La ShardMapManagerFactory.GetSqlShardMapManager méthode (Java, .NET) accepte les informations d’identification (y compris le nom du serveur et le nom de la base de données contenant le GSM) sous la forme d’une ConnectionString instance et retourne une instance d’un ShardMapManager.

Dans ce code, une application tente d’ouvrir un existant ShardMapManager avec la TryGetSqlShardMapManager (méthode Java, .NET ). Si les objets représentant un ShardMapManager global (GSM) n’existent pas encore dans la base de données, la bibliothèque cliente les crée à l’aide de la CreateSqlShardMapManager méthode (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.
}

Pour la version .NET, vous pouvez utiliser PowerShell pour créer un Shard Map Manager.

Obtenir un objet RangeShardMap ou ListShardMap

Après avoir créé un gestionnaire de cartes de partitions, vous pouvez obtenir RangeShardMap (Java, .NET) ou ListShardMap (Java, .NET) à l’aide de la méthode TryGetRangeShardMap (Java, .NET), TryGetListShardMap (Java, .NET), ou 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;
}

Identifiants d'administration du plan de répartition des fragments

Les applications d'administration et de manipulation de cartes de partitions diffèrent des applications acheminant des connexions grâce aux cartes de partitions.

Pour administrer des cartes de fragmentation (ajouter ou modifier des fragments, des cartes de fragmentation, des mappages de fragmentation, etc.), vous devez instancier le ShardMapManager en utilisant des informations d’identification qui ont des privilèges de lecture/écriture sur la base de données GSM et sur chaque base de données servant de fragment. Les informations d'identification doivent permettre l'écriture dans les tables à la fois dans le GSM et le LSM lors de la saisie ou de la modification des informations de la carte de partitions, ainsi que lors de la création de tables LSM sur de nouvelles partitions.

Consultez Informations d’identification utilisées pour accéder à la bibliothèque cliente de la base de données élastique.

Seules les métadonnées sont affectées

Les méthodes utilisées pour remplir ou modifier les ShardMapManager données ne modifient pas les données utilisateur stockées dans les partitions elles-mêmes. Par exemple, les méthodes telles que CreateShard, DeleteShard, UpdateMapping, etc. affectent uniquement les métadonnées de la carte de partitions. Ils ne suppriment, n'ajoutent ni ne modifient aucune donnée utilisateur contenue dans les fragments. Au lieu de cela, ces méthodes sont conçues pour être utilisées en conjonction avec des opérations distinctes que vous effectuez pour créer ou supprimer des bases de données réelles, ou pour déplacer des lignes d'une partition à une autre afin de rééquilibrer un environnement partitionné. (L’outil de fractionnement-fusion inclus dans les outils de base de données élastiques utilise ces API et orchestre le déplacement réel des données entre les partitions.) Consultez la section Déplacement de données entre des bases de données cloud scale-out.

Routage dépendant des données

Le Gestionnaire de cartes de partitions est utilisé dans les applications devant se connecter à une base de données pour exploiter leurs données. Ces connexions doivent être associées à la base de données correcte. Cette opération est nommée Routage dépendant des données. Pour ces applications, instanciez un objet gestionnaire de carte de fragments à partir de l'usine avec les informations d'identification ayant un accès en lecture seule sur la base de données GSM. Les requêtes de connexion individuelles ultérieures fournissent les informations d'identification requises pour la connexion à la base de données de partitions adéquate.

Ces applications (utilisant ShardMapManager ouvert avec des informations d’identification en lecture seule) ne peuvent pas modifier les mappages ou les mappages Pour cela, vous devez créer des applications d'administration ou des scripts PowerShell qui fourniront des informations d'identification dotées de privilèges élevés comme indiqué précédemment. Consultez Informations d’identification utilisées pour accéder à la bibliothèque cliente de la base de données élastique.

Pour plus d’informations, consultez Utiliser le routage dépendant des données pour router une requête vers une base de données appropriée.

Modifier une carte de partition

Une carte de fragments peut être modifiée de différentes manières. Toutes les méthodes suivantes modifient les métadonnées décrivant les partitions et leurs mappages, mais elles ne modifient pas physiquement les données dans les partitions et ne créent ni ne suppriment les bases de données réelles. Certaines des opérations suivantes sur la carte de partitions peuvent être coordonnées avec des actions administratives qui déplacent physiquement des données ou qui ajoutent et suppriment des bases de données servant de partitions.

Ces méthodes fonctionnent ensemble en tant que blocs de construction disponibles pour la modification de la distribution globale des données dans votre environnement de base de données partitionnée.

• Pour ajouter ou supprimer des partitions : utilisez CreateShard (Java, .NET) et DeleteShard (Java, .NET) de la classe shardmap (Java, .NET).

  • Le serveur et la base de données représentant la partition cible doivent déjà exister pour pouvoir exécuter ces opérations. Ces méthodes n’ont pas d’incidence sur les bases de données elles-mêmes. Elles affectent uniquement les métadonnées de la carte de partitions.

• Pour créer ou supprimer des points ou des plages mappés aux partitions : utilisez CreateRangeMapping (Java, .NET), DeleteMapping (Java, .NET) de la classe RangeShardMapping (Java, .NET) et CreatePointMapping (Java, .NET) de la classe ListShardMap (Java, .NET).

  De nombreux points ou plages peuvent être mappés vers le même fragment. Ces méthodes affectent uniquement les métadonnées : elles n’affectent pas les données qui peuvent déjà être présentes dans des partitions. Si les données doivent être supprimées de la base de données afin d’être cohérentes avec DeleteMapping les opérations, vous effectuez ces opérations séparément, mais conjointement avec l’utilisation de ces méthodes.

• Pour fractionner des plages existantes en deux ou fusionner des plages adjacentes en une seule : utilisez SplitMapping (Java, .NET) et MergeMappings (Java, .NET).

  Les opérations de fractionnement et de fusion ne modifient pas la partition vers laquelle les valeurs de clé sont mappées. Une scission divise un segment existant en deux parties, tout en restant mappées vers le même shard. Une fusion opère sur deux plages adjacentes qui sont déjà mappées à la même shard, les fusionnant en une seule plage. Le déplacement de points ou de plages eux-mêmes entre les fragments doit être coordonné en utilisant UpdateMapping conjointement avec le déplacement réel des données. Vous pouvez utiliser le service de fractionnement/fusion qui fait partie des outils de base de données élastiques pour coordonner les modifications de la carte de fragments avec le déplacement des données lorsque celui-ci est nécessaire.

• Pour reconfigurer (ou déplacer) des points individuels ou des plages vers différents fragments, vous pouvez utiliser UpdateMapping (Java, .NET).

  Étant donné que les données peuvent avoir besoin d’être déplacées d’un shard vers un autre pour être cohérentes avec UpdateMapping les opérations, vous devez effectuer ce déplacement séparément, tout en utilisant ces méthodes conjointement.

• Pour prendre des mappages en ligne et hors connexion : utilisez MarkMappingOffline (Java, .NET) et MarkMappingOnline (Java, .NET) pour contrôler l’état en ligne d’un mappage.

  Certaines opérations sur les mappages de partition ne sont autorisées que lorsqu’un mappage est hors ligne, notamment UpdateMapping et DeleteMapping. Quand un mappage est hors connexion, une requête dépendant des données basée sur une clé incluse dans ce mappage retourne une erreur. En outre, lorsqu'une plage est d'abord mise hors connexion, toutes les connexions vers la partition concernée sont supprimées automatiquement afin d'éviter des résultats incohérents ou incomplets pour les requêtes émises vers les plages en cours de modification.

Les mappages sont des objets immuables dans .NET. Toutes les méthodes ci-dessus qui modifient les mappages invalident également les références à ceux-ci dans votre code. Pour faciliter l’exécution des séquences d’opérations qui modifient l’état d’un mappage, toutes les méthodes qui modifient un mappage renvoient une nouvelle référence de mappage, permettant aux opérations d’être chaînées. Par exemple, pour supprimer un mappage existant dans shardmap sm qui contient la clé 25, vous pouvez exécuter les éléments suivants :

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

Ajouter un fragment

Les applications ont souvent besoin d'ajouter de nouveaux fragments pour gérer des données attendues de nouvelles clés ou plages de clés, pour une carte de fragments qui existe déjà. Par exemple, une application partitionnée par ID de locataire peut avoir besoin d’approvisionner une nouvelle partition pour un nouveau locataire, ou les données partitionnées mensuellement peuvent avoir besoin d’une nouvelle partition provisionnée avant le début de chaque nouveau mois.

Si la nouvelle plage de valeurs de clé n’appartient pas déjà à un mappage existant et qu’aucun déplacement de données n’est nécessaire, il est facile d’ajouter la nouvelle partition et d’associer la nouvelle clé ou plage à cette partition. Pour plus d’informations sur l’ajout de nouvelles partitions, consultez Ajout d’une partition à l’aide d’outils de base de données élastique.

Cependant, pour les scénarios requérant le déplacement de données, l’outil de fusion/fractionnement est requis pour orchestrer le déplacement des données entre les partitions conjointement aux mises à jour nécessaires de la carte de partitions. Pour plus d’informations sur l’utilisation de l’outil de scission-fusion, consultez Déplacement de données entre des bases de données cloud évolutives

Contenu connexe

Vous n’utilisez pas encore d’outils de base de données élastique ? Consultez notre Guide de prise en main. Pour toute question, contactez-nous par le biais de la page de questions Microsoft Q&A sur SQL Database et, pour vos demandes de fonctionnalités, ajoutez de nouvelles idées ou votez pour les idées existantes sur le forum de commentaires SQL Database.