Partage via

Tutoriel : Exemples de configuration resource governor et bonnes pratiques

  • Article

s’applique à :SQL ServerAzure SQL Managed Instance

Cet article contient des exemples de procédure pas à pas pour vous aider à configurer Resource Governor et à vérifier que votre configuration fonctionne comme prévu. Il commence par un exemple simple et progresse vers les plus complexes.

L’article comprend également des exemples de requêtes de surveillance Resource Governor et une liste des meilleures pratiques Resource Governor.

Tous les exemples supposent que initialement, resource governor est désactivé et utilise les paramètres par défaut, et qu’il n’existe pas de pools de ressources définis par l’utilisateur, de groupes de charges de travail et de classifieur.

Remarque

Pour modifier la configuration du gouverneur de ressources sur Azure SQL Managed Instance, vous devez vous trouver dans le contexte de la base de données master sur la réplique principale.

Modifier le groupe par défaut

Cet exemple utilise resource governor pour limiter la taille maximale d’une allocation de mémoire pour toutes les requêtes utilisateur. Pour ce faire, vous devez réduire le paramètre REQUEST_MAX_MEMORY_GRANT_PERCENT du groupe de charge de travail default de 25% par défaut à 10%. L’exemple n’utilise pas de fonction de classifieur . Cela signifie que le traitement de la connexion n’est pas affecté et que toutes les sessions utilisateur continuent d’être classées dans le groupe de charge de travail default.

Vous devrez peut-être limiter la taille des octrois de mémoire si les requêtes attendent de la mémoire, car d’autres requêtes ont réservé trop de mémoire. Pour plus d’informations, consultez Résoudre les problèmes de performances lentes ou de mémoire faible causées par les allocations de mémoire dans SQL Server.

  1. Modifiez le groupe de charge de travail par défaut.

    ALTER WORKLOAD GROUP [default] WITH (REQUEST_MAX_MEMORY_GRANT_PERCENT = 10);

  2. Permettre à Resource Governor de rendre notre configuration efficace.

    ALTER RESOURCE GOVERNOR RECONFIGURE;

  3. Validez le nouveau paramètre, y compris la nouvelle taille maximale d’une allocation de mémoire.

    SELECT group_id,
       wg.name AS workload_group_name,
       rp.name AS resource_pool_name,
       wg.request_max_memory_grant_percent_numeric AS request_max_memory_grant_percent,
       rp.max_memory_kb * wg.request_max_memory_grant_percent_numeric AS request_max_memory_grant_size_kb
FROM sys.resource_governor_workload_groups AS wg
INNER JOIN sys.dm_resource_governor_resource_pools AS rp
ON wg.pool_id = rp.pool_id;

  4. Pour revenir à la configuration initiale, exécutez le script suivant :

    ALTER WORKLOAD GROUP [default] WITH (REQUEST_MAX_MEMORY_GRANT_PERCENT = 25);
ALTER RESOURCE GOVERNOR RECONFIGURE;
ALTER RESOURCE GOVERNOR DISABLE;

Utiliser un groupe de charges de travail défini par l’utilisateur

Cet exemple utilise resource governor pour s’assurer que toutes les requêtes sur les sessions avec un nom d’application spécifique ne s’exécutent pas avec le degré de parallélisme (DOP) supérieur à quatre. Pour ce faire, classifiez les sessions dans un groupe de charge de travail avec le paramètre MAX_DOP défini sur 4.

Pour plus d’informations sur la configuration du degré maximal de parallélisme, consultez Configuration du serveur : degré maximal de parallélisme.

  1. Créez un groupe de charge de travail qui limite DOP. Le groupe utilise le pool de ressources default, car nous voulons uniquement limiter DOP pour une application spécifique, mais pas réserver ou limiter le processeur, la mémoire ou les ressources d’E/S.

    CREATE WORKLOAD GROUP limit_dop
WITH (
     MAX_DOP = 4
     )
USING [default];

  2. Créez la fonction classifieur. La fonction utilise la fonction intégrée APP_NAME() pour déterminer le nom de l’application spécifié dans la chaîne de connexion cliente. Si le nom de l’application est défini sur limited_dop_application, la fonction retourne le nom du groupe de charge de travail qui limite DOP. Sinon, la fonction retourne default comme nom de groupe de charge de travail.

    USE master;
GO

CREATE FUNCTION dbo.rg_classifier()
RETURNS sysname
WITH SCHEMABINDING
AS
BEGIN

DECLARE @WorkloadGroupName sysname = N'default';

IF APP_NAME() = N'limited_dop_application'
    SELECT @WorkloadGroupName = N'limit_dop';

RETURN @WorkloadGroupName;

END;
GO

  3. Modifiez la configuration du gouverneur de ressources pour rendre notre configuration efficace et activer resource governor.

    ALTER RESOURCE GOVERNOR WITH (CLASSIFIER_FUNCTION = dbo.rg_classifier);
ALTER RESOURCE GOVERNOR RECONFIGURE;

  4. Interrogez sys.resource_governor_configuration pour vérifier que Resource Governor est activé et utilise la fonction classifieur que nous avons créée.

    SELECT OBJECT_SCHEMA_NAME(classifier_function_id) AS classifier_schema_name,
       OBJECT_NAME(classifier_function_id) AS classifier_object_name,
       is_enabled
FROM sys.resource_governor_configuration;

    classifier_schema_name      classifier_object_name      is_enabled
----------------------      ----------------------      ----------
dbo                         rg_classifier               1

  5. Vérifiez que les sessions portant un nom d’application spécifique sont classées dans le groupe de charge de travail limit_dop, tandis que d’autres sessions continuent d’être classées dans le groupe de charge de travail default. Nous allons utiliser une requête utilisant les vues système sys.dm_exec_sessions et sys.resource_governor_workload_groups pour renvoyer le nom de l’application et le nom du groupe de charge de travail pour la session active.

    1. Dans SQL Server Management Studio (SSMS), sélectionnez Fichier dans le menu principal, Nouveau, Requête du Moteur de Base de Données.

    2. Dans la boîte de dialogue Se connecter au moteur de base de données, spécifiez la même instance du moteur de base de données où vous avez créé le groupe de charge de travail et la fonction classifieur. Sélectionnez l’onglet Paramètres de connexion supplémentaires, puis entrez App=limited_dop_application. Cela permet à SSMS d’utiliser limited_dop_application comme nom d’application lors de la connexion à l’instance.

    3. Sélectionnez Connect pour ouvrir une nouvelle connexion.

    4. Dans la même fenêtre de requête, exécutez la requête suivante :

      SELECT s.program_name AS application_name,
       wg.name AS workload_group_name,
       wg.max_dop
FROM sys.dm_exec_sessions AS s
INNER JOIN sys.resource_governor_workload_groups AS wg
ON s.group_id = wg.group_id
WHERE s.session_id = @@SPID;

      Vous devez voir la sortie suivante, montrant que la session a été classifiée dans le groupe de charge de travail limit_dop avec le nombre maximal de DOP défini sur quatre :

      application_name            workload_group_name     max_dop
----------------            -------------------     -------
limited_dop_application     limit_dop               4

    5. Répétez les étapes ci-dessus, mais n’entrez rien dans la zone sous l’onglet Paramètres de connexion supplémentaires. La sortie change, affichant le nom de l’application SSMS par défaut et le groupe de charge de travail default avec la valeur de 0 par défaut pour le nombre maximal de DOP.

      application_name                                    workload_group_name     max_dop
----------------                                    -------------------     -------
Microsoft SQL Server Management Studio - Query      default                 0

  6. Pour revenir à la configuration initiale de cet exemple, déconnectez toutes les sessions à l’aide du groupe de charge de travail limit_dop, puis exécutez le script T-SQL suivant. Le script comprend les étapes suivantes :

    1. Désactivez resource governor afin que la fonction classifieur puisse être supprimée.
    2. Supprimez le groupe de charges de travail. Cela nécessite qu’aucune session n’utilise ce groupe de charge de travail.
    3. Reconfigurez le gouverneur de ressources pour recharger la configuration effective sans la fonction classifieur et le groupe de charge de travail. Cela active Resource Governor.
    4. Désactivez resource governor pour revenir à la configuration initiale.
    /* Disable resource governor so that the classifier function can be dropped. */
ALTER RESOURCE GOVERNOR DISABLE;
ALTER RESOURCE GOVERNOR WITH (CLASSIFIER_FUNCTION = NULL);
DROP FUNCTION IF EXISTS dbo.rg_classifier;

/* Drop the workload group. This requires that no sessions are using this workload group. */
DROP WORKLOAD GROUP limit_dop;

/* Reconfigure resource governor to reload the effective configuration without the classifier function and the workload group. This enables resource governor. */
ALTER RESOURCE GOVERNOR RECONFIGURE;

/* Disable resource governor to revert to the initial configuration. */
ALTER RESOURCE GOVERNOR DISABLE;

Utiliser plusieurs pools de ressources et groupes de charge de travail

Cet exemple utilise resource governor pour classifier les sessions d’une application de traitement des commandes dans différents groupes de charges de travail et pools de ressources en fonction de l’heure de la journée. Cette configuration alloue davantage de ressources à l’application pendant les heures de traitement maximales et limite ses ressources pendant les heures creuses. L’exemple suppose que l’application n’utilise pas de sessions longues.

  1. Créez deux pools de ressources pour le traitement des heures de pointe et des heures creuses.

    • Le pool peak_hours_pool garantit (réserves) un minimum de 20% de bande passante moyenne du processeur via MIN_CPU_PERCENTet ne limite pas la bande passante processeur en définissant MAX_CPU_PERCENT sur 100.
    • Le pool off_hours_pool ne réserve pas de bande passante processeur en définissant MIN_CPU_PERCENT sur 0, mais limite la bande passante du processeur à 50% lorsque la contention du processeur est présente en définissant MAX_CPU_PERCENT sur 50.
    CREATE RESOURCE POOL peak_hours_pool
WITH (
     MIN_CPU_PERCENT = 20,
     MAX_CPU_PERCENT = 100
     );

CREATE RESOURCE POOL off_hours_pool
WITH (
     MIN_CPU_PERCENT = 0,
     MAX_CPU_PERCENT = 50
     );

    Les pools de ressources peuvent réserver et limiter les ressources système telles que le processeur, la mémoire et les E/S. Pour plus d’informations, consultez CREATE RESOURCE POOL.

  2. Créez deux groupes de charge de travail, un pour chaque pool de ressources respectivement.

    • Le peak_hours_group ne limite pas le nombre de requêtes simultanées en définissant GROUP_MAX_REQUESTS sur la valeur par défaut de 0.
    • Le off_hours_group limite le nombre de requêtes simultanées dans toutes les sessions classées dans ce groupe, en définissant GROUP_MAX_REQUESTS sur 200.
    CREATE WORKLOAD GROUP peak_hours_group
WITH (
     GROUP_MAX_REQUESTS = 0
     )
USING peak_hours_pool;

CREATE WORKLOAD GROUP off_hours_group
WITH (
     GROUP_MAX_REQUESTS = 200
     )
USING off_hours_pool;

    Les groupes de charge de travail définissent des stratégies telles que le nombre maximal de requêtes, le degré maximal de parallélisme et la taille maximale d’allocation de mémoire. Pour plus d’informations, consultez CREATE WORKLOAD GROUP.

  3. Créez et remplissez une table qui définit les intervalles de temps de pointe et de congé.

    • Chaque ligne du tableau définit l’heure de début et de fin de l’intervalle, ainsi que le nom du groupe de charge de travail à utiliser pendant l’intervalle.
    • L’heure de début et de fin de chaque intervalle est inclusive.
    • La table est créée dans la base de données master afin qu’elle puisse être utilisée dans une fonction de classifieur liée au schéma.
    USE master;
GO

CREATE TABLE dbo.workload_interval
(
workload_group_name sysname NOT NULL,
start_time time(7) NOT NULL,
end_time time(7) NOT NULL,
CONSTRAINT pk_workload_interval PRIMARY KEY (start_time, workload_group_name),
CONSTRAINT ak_workload_interval_1 UNIQUE (end_time, workload_group_name),
CONSTRAINT ck_workload_interval_1 CHECK (start_time < end_time)
);
GO

INSERT INTO dbo.workload_interval
VALUES (N'off_hours_group', '00:00', '06:29:59.9999999'),
       (N'peak_hours_group', '06:30', '18:29:59.9999999'),
       (N'off_hours_group', '18:30', '23:59:59.9999999');

  4. Créez la fonction classifieur.

    • Les données de la table sont censées avoir une seule ligne correspondante pour une heure donnée de la journée. Si les données ne respectent pas cette règle, la fonction retourne default comme nom du groupe de charge de travail.
    • L’exemple de fonction suivant retourne également default si le nom de l’application retourné par la fonction APP_NAME() intégrée est autre que order_processing.
    USE master;
GO

CREATE OR ALTER FUNCTION dbo.rg_classifier()
RETURNS sysname
WITH SCHEMABINDING
AS
BEGIN

DECLARE @WorkloadGroupName sysname = N'default';

SELECT @WorkloadGroupName = workload_group_name
FROM dbo.workload_interval
WHERE APP_NAME() = N'order_processing'
      AND
      CAST(GETDATE() AS time(7)) BETWEEN start_time AND end_time;

IF @@ROWCOUNT > 1
    SELECT @WorkloadGroupName = N'default';

RETURN @WorkloadGroupName;

END;
GO

  5. Il s’agit d’une étape facultative. Au lieu de créer une table dans la base de données master, vous pouvez utiliser un constructeur table-valued pour définir les intervalles de temps directement dans la fonction classifieur. Il s’agit de l’approche recommandée lorsque la taille des données est petite et que les critères de fonction classifieur ne sont pas fréquemment modifiés. Voici un exemple de classifieur qui utilise un constructeur table au lieu d’une table dans master.

    USE master;
GO

CREATE OR ALTER FUNCTION dbo.rg_classifier()
RETURNS sysname
WITH SCHEMABINDING
AS
BEGIN

DECLARE @WorkloadGroupName sysname = N'default';

SELECT @WorkloadGroupName = workload_group_name
FROM (
     VALUES (CAST(N'off_hours_group' AS sysname),  CAST('00:00' AS time(7)), CAST('06:29:59.9999999' AS time(7))),
            (CAST(N'peak_hours_group' AS sysname), CAST('06:30' AS time(7)), CAST('18:29:59.9999999' AS time(7))),
            (CAST(N'off_hours_group' AS sysname),  CAST('18:30' AS time(7)), CAST('23:59:59.9999999'AS time(7)))
     ) AS wg (workload_group_name, start_time, end_time)
WHERE APP_NAME() = N'order_processing'
      AND
      CAST(GETDATE() AS time(7)) BETWEEN start_time AND end_time;

IF @@ROWCOUNT > 1
    SELECT @WorkloadGroupName = N'default';

RETURN @WorkloadGroupName;

END;
GO

  6. Modifiez la configuration du gouverneur de ressources pour rendre notre configuration efficace et activer resource governor.

    ALTER RESOURCE GOVERNOR WITH (CLASSIFIER_FUNCTION = dbo.rg_classifier);
ALTER RESOURCE GOVERNOR RECONFIGURE;

  7. Vérifiez que resource governor est activé, utilise la fonction classifieur spécifiée et que la fonction classifieur fonctionne comme prévu à l’aide d’étapes similaires comme dans l’exemple précédent. Cette fois, nous entrons App=order_processing sous l’onglet Paramètres de connexion supplémentaires dans la boîte de dialogue de connexion SSMS pour correspondre au nom de l’application dans la fonction de classification. Exécutez la requête suivante pour déterminer le nom de l’application, le groupe de charge de travail, le pool de ressources et la réservation et la limite du processeur pour la session active :

    SELECT s.program_name AS application_name,
       wg.name AS workload_group_name,
       wg.group_max_requests,
       rp.name AS resource_pool_name,
       rp.min_cpu_percent,
       rp.max_cpu_percent
FROM sys.dm_exec_sessions AS s
INNER JOIN sys.resource_governor_workload_groups AS wg
ON s.group_id = wg.group_id
INNER JOIN sys.resource_governor_resource_pools AS rp
ON wg.pool_id = rp.pool_id
WHERE s.session_id = @@SPID;

    Les résultats dépendent de l’heure du jour. Par exemple, si l’heure actuelle est 14:30, le résultat indique que peak_hours_group et peak_hours_pool sont utilisés :

    application_name    workload_group_name     group_max_requests      resource_pool_name      min_cpu_percent     max_cpu_percent
-----------------   --------------------    ------------------      -------------------     ---------------     ---------------
order_processing    peak_hours_group        0                       peak_hours_pool         20                  100

  8. Pour revenir à la configuration initiale de cet exemple, déconnectez toutes les sessions à l’aide des groupes de charge de travail peak_hours_group et off_hours_group, puis exécutez le script T-SQL suivant. Le script comprend les étapes suivantes :

    1. Désactivez resource governor afin que la fonction classifieur puisse être supprimée.
    2. Supprimez les groupes de charges de travail. Cela nécessite qu’aucune session n’utilise ces groupes de charges de travail.
    3. Une fois les groupes de charge de travail supprimés, supprimez les pools de ressources.
    4. Reconfigurez le gouverneur de ressources pour recharger la configuration effective sans la fonction classifieur et les groupes de charges de travail définis par l’utilisateur et les pools de ressources. Cela active Resource Governor.
    5. Désactivez resource governor pour revenir à la configuration initiale.
    /* Disable resource governor so that the classifier function can be dropped. */
ALTER RESOURCE GOVERNOR DISABLE;
ALTER RESOURCE GOVERNOR WITH (CLASSIFIER_FUNCTION = NULL);
DROP FUNCTION IF EXISTS dbo.rg_classifier;
DROP TABLE IF EXISTS dbo.workload_interval;

/* Drop the workload groups. This requires that no sessions are using these workload groups. */
DROP WORKLOAD GROUP peak_hours_group;
DROP WORKLOAD GROUP off_hours_group;

/* Once the workload groups are dropped, drop the resource pools. */
DROP RESOURCE POOL peak_hours_pool;
DROP RESOURCE POOL off_hours_pool;

/* Reconfigure resource governor to reload the effective configuration without the classifier function and user-defined workload groups and resource pools. This enables resource governor. */
ALTER RESOURCE GOVERNOR RECONFIGURE;

/* Disable resource governor to revert to the initial configuration. */
ALTER RESOURCE GOVERNOR DISABLE;

Surveiller Resource Governor à l’aide des vues système

Les requêtes d'exemple dans cette section montrent comment surveiller les statistiques et le comportement du gouverneur des ressources en temps réel.

Les statistiques resource governor sont cumulatives depuis le dernier redémarrage du serveur. Si vous devez collecter des statistiques à partir d’un certain temps, vous pouvez réinitialiser les statistiques à l’aide de l’instruction ALTER RESOURCE GOVERNOR RESET STATISTICS.

Statistiques d’exécution du pool de ressources

Pour chaque pool de ressources, resource governor effectue le suivi de l’utilisation du processeur et de la mémoire, des événements hors mémoire, des allocations de mémoire, des E/S et d’autres statistiques. Pour plus d’informations, consultez sys.dm_resource_governor_resource_pools.

La requête suivante retourne un sous-ensemble de statistiques disponibles pour tous les pools de ressources :

SELECT rp.pool_id,
       rp.name AS resource_pool_name,
       wg.workload_group_count,
       rp.statistics_start_time,
       rp.total_cpu_usage_ms,
       rp.target_memory_kb,
       rp.used_memory_kb,
       rp.out_of_memory_count,
       rp.active_memgrant_count,
       rp.total_memgrant_count,
       rp.total_memgrant_timeout_count,
       rp.read_io_completed_total,
       rp.write_io_completed_total,
       rp.read_bytes_total,
       rp.write_bytes_total,
       rp.read_io_stall_total_ms,
       rp.write_io_stall_total_ms
FROM sys.dm_resource_governor_resource_pools AS rp
OUTER APPLY (
            SELECT COUNT(1) AS workload_group_count
            FROM sys.dm_resource_governor_workload_groups AS wg
            WHERE wg.pool_id = rp.pool_id
            ) AS wg;

Statistiques d’exécution du groupe de charge de travail

Pour chaque groupe de charge de travail, resource governor suit le temps processeur, le nombre de requêtes, les tâches bloquées, le temps d’attente de verrou, les optimisations des requêtes et d’autres statistiques. Pour plus d’informations, consultez sys.resource_governor_workload_groups.

La requête suivante retourne un sous-ensemble de statistiques disponibles pour tous les groupes de charges de travail :

SELECT wg.name AS workload_group_name,
       rp.name AS resource_pool_name,
       wg.statistics_start_time,
       wg.total_request_count,
       wg.total_cpu_usage_ms,
       wg.blocked_task_count,
       wg.total_lock_wait_time_ms,
       wg.total_query_optimization_count,
       wg.max_request_grant_memory_kb,
       wg.active_parallel_thread_count,
       wg.effective_max_dop,
       wg.request_max_memory_grant_percent_numeric
FROM sys.dm_resource_governor_workload_groups AS wg
INNER JOIN sys.dm_resource_governor_resource_pools AS rp
ON wg.pool_id = rp.pool_id

Agréger les sessions par groupe de charge de travail et attributs de session

La requête suivante retourne une distribution des sessions entre les groupes de charges de travail et agrège les statistiques de session pour chaque groupe de charge de travail.

Un nombre élevé de sessions avec l’état preconnect peut indiquer la lenteur dans l’exécution du classifieur.

SELECT wg.name AS workload_group_name,
       rp.name AS resource_pool_name,
       s.program_name AS application_name,
       s.login_name,
       s.host_name,
       s.status,
       d.name AS database_name,
       MIN(s.login_time) AS first_login_time,
       MAX(s.login_time) AS last_login_time,
       MAX(s.last_request_start_time) AS last_request_start_time,
       COUNT(1) AS session_count
FROM sys.dm_exec_sessions AS s
INNER JOIN sys.dm_resource_governor_workload_groups AS wg
ON s.group_id = wg.group_id
INNER JOIN sys.dm_resource_governor_resource_pools AS rp
ON wg.pool_id = rp.pool_id
INNER JOIN sys.databases AS d
ON s.database_id = d.database_id
GROUP BY wg.name,
         rp.name,
         s.program_name,
         s.login_name,
         s.host_name,
         s.status,
         d.name;

Agréger les requêtes par groupe de charge de travail et attributs de requête

La requête suivante retourne une distribution des requêtes entre les groupes de charges de travail et agrège les statistiques des requêtes pour chaque groupe de charge de travail :

SELECT wg.name AS workload_group_name,
       rp.name AS resource_pool_name,
       r.command,
       r.status,
       d.name AS database_name,
       COUNT(1) AS request_count,
       MIN(r.start_time) AS first_request_start_time,
       MAX(r.start_time) AS last_request_start_time,
       SUM(CAST(r.total_elapsed_time AS bigint)) AS total_elapsed_time_ms
FROM sys.dm_exec_requests AS r
INNER JOIN sys.dm_resource_governor_workload_groups AS wg
ON r.group_id = wg.group_id
INNER JOIN sys.dm_resource_governor_resource_pools AS rp
ON wg.pool_id = rp.pool_id
INNER JOIN sys.databases AS d
ON r.database_id = d.database_id
GROUP BY wg.name,
         rp.name,
         r.command,
         r.status,
         d.name;

Meilleures pratiques du gouverneur de ressources

  • Configurez la connexion d’administrateur dédié (DAC) et découvrez comment l’utiliser. Pour plus d’informations, consultez Connexion de diagnostic pour les administrateurs de base de données. Si votre configuration de Resource Governor ne fonctionne pas, vous pouvez utiliser DAC pour le résoudre ou pour désactiver Resource Governor.
  • Lors de la configuration des pools de ressources, veillez à spécifier de grandes valeurs pour MIN_CPU_PERCENT, MIN_MEMORY_PERCENTet MIN_IOPS_PER_VOLUME. Un paramètre de configuration MIN réserve des ressources pour un pool de ressources et les rend indisponibles pour d’autres pools de ressources, y compris le pool default. Pour plus d’informations, consultez Créer un pool de ressources.
  • La fonction classifieur étend le temps de traitement de connexion. Évitez une logique complexe et des requêtes longues ou gourmandes en ressources dans le classifieur, en particulier si les requêtes utilisent des tables volumineuses. Une fonction trop complexe peut entraîner des retards de connexion ou des délais d’expiration de connexion.
  • Si vous devez utiliser une table dans le classifieur et que la table est petite et principalement statique, envisagez d’utiliser un constructeur valorisé par table à la place, comme illustré dans un exemple plus tôt dans cet article.
  • Évitez d’utiliser une table fréquemment modifiée dans le classifieur. Cela augmente le risque de blocage qui peut retarder les connexions et provoquer des délais d'attente de connexion. Les solutions de contournement suivantes peuvent atténuer le risque, mais elles présentent des inconvénients, notamment le risque de classification incorrecte :
    • Envisagez d’utiliser l’indicateur de table NOLOCK ou son équivalent READUNCOMMITTED. Pour plus d’informations, consultez READUNCOMMITTED.
    • Envisagez d’utiliser le paramètre LOCK_TIMEOUT au début de la fonction classifieur, en le définissant sur une valeur faible, telle que 1 000 millisecondes. Pour plus d’informations, consultez SET LOCK_TIMEOUT.
  • Vous ne pouvez pas modifier une fonction classifieur lorsqu’elle est référencée dans la configuration resource governor. Toutefois, vous pouvez modifier la configuration pour utiliser une fonction de classifieur différente. Si vous souhaitez apporter des modifications au classifieur, envisagez de créer une paire de fonctions de classifieur. Par exemple, vous pouvez créer dbo.rg_classifier_A() et dbo.rg_classifier_B(). Quand une modification de la logique classifieur est nécessaire, procédez comme suit :
    1. Utilisez l’instruction ALTER FUNCTION pour apporter les modifications apportées à la fonction pas actuellement utilisée dans la configuration du gouverneur de ressources.
    2. Utilisez l’instruction ALTER RESOURCE GOVERNOR pour activer le classifieur modifié, puis reconfigurez le gouverneur de ressources. Par exemple: 
      ALTER RESOURCE GOVERNOR WITH (CLASSIFIER_FUNCTION = dbo.rg_classifier_B);
ALTER RESOURCE GOVERNOR RECONFIGURE;
    3. Si une modification est nécessaire à nouveau, suivez les mêmes étapes à l’aide de l’autre fonction (dbo.rg_classifier_A()).
  • La configuration de Resource Governor est stockée dans la base de données master. Veillez à sauvegarder régulièrement masteret à savoir comment la restaurer. Pour plus d’informations, consultez Sauvegarder et restaurer : bases de données système. Étant donné qu’il existe des limitations relatives à la restauration de master, nous vous recommandons d’enregistrer également une copie des scripts de configuration resource governor séparément. Vous pouvez recréer la configuration du gouverneur de ressources à partir de scripts si la base de données master doit être reconstruite.

Contenu connexe