Dela via

Självstudie: Konfigurationsexempel och metodtips för Resource Governor

  • Artikel

gäller för:SQL ServerAzure SQL Managed Instance

Den här artikeln innehåller genomgångsexempel som hjälper dig att konfigurera resursguvernören och verifiera att konfigurationen fungerar som förväntat. Det börjar med ett enkelt exempel och går vidare till de mer komplexa.

Artikeln innehåller även exempel på resursguvernör övervakningsfrågor och en lista över resursguvernör bästa praxis.

Alla exempel förutsätter att resursguvernören till en början är inaktiverad och använder standardinställningar och att det inte finns några användardefinierade resurspooler, arbetsbelastningsgrupper och klassificerare.

Not

Om du vill ändra konfigurationen av resursguvernören i Azure SQL Managed Instance måste du vara i kontexten för den master databasen på den primära repliken.

Ändra standardgruppen

I det här exemplet används resursguvernör för att begränsa den maximala storleken på ett minnesbidrag för alla användarfrågor. Detta görs genom att minska inställningen för REQUEST_MAX_MEMORY_GRANT_PERCENT för arbetsbelastningsgruppen default från standardvärdet 25% till 10%. I exemplet används inte en klassificerarfunktion. Det innebär att inloggningsbearbetningen inte påverkas och att alla användarsessioner fortsätter att klassificeras i arbetsbelastningsgruppen default.

Du kan behöva begränsa storleken på minnestilldelningar om frågeställningar väntar på minne eftersom andra frågeställningar reserverade för mycket minne. Mer information finns i Felsöka problem med långsamma prestanda eller minnesbrist som orsakas av minnestillskott i SQL Server.

  1. Ändra standardarbetsbelastningsgruppen.

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

  2. Aktivera resursguvernör för att göra konfigurationen effektiv.

    ALTER RESOURCE GOVERNOR RECONFIGURE;

  3. Verifiera den nya inställningen, inklusive den nya maximala storleken på ett minnesbidrag.

    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. Om du vill återgå till den inledande konfigurationen kör du följande skript:

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

Använda en användardefinierad arbetsbelastningsgrupp

I det här exemplet används resursguvernör för att säkerställa att alla begäranden på sessioner med ett specifikt programnamn inte körs med graden av parallellitet (DOP) högre än fyra. Detta görs genom att klassificera sessioner i en arbetsbelastningsgrupp med inställningen MAX_DOP inställd på 4.

Mer information om hur du konfigurerar den maximala graden av parallellitet finns i Server-konfiguration: maximal grad av parallellitet.

  1. Skapa en arbetsbelastningsgrupp som begränsar DOP. Gruppen använder default resurspool eftersom vi bara vill begränsa DOP för ett visst program, men inte reservera eller begränsa PROCESSOR-, minnes- eller I/O-resurser.

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

  2. Skapa klassificerarfunktionen. Funktionen använder den inbyggda funktionen APP_NAME() för att fastställa programnamnet som anges i klientanslutningssträngen. Om programnamnet är inställt på limited_dop_applicationreturnerar funktionen namnet på den arbetsbelastningsgrupp som begränsar DOP. Annars returnerar funktionen default som namnet på arbetsbelastningsgruppen.

    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. Ändra konfigurationen av resursguvernören för att göra konfigurationen effektiv och aktivera resursguvernör.

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

  4. Fråga sys.resource_governor_configuration för att verifiera att resursguvernören är aktiverad och använder den klassificerarfunktion som vi skapade.

    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. Kontrollera att sessioner med ett specifikt programnamn klassificeras i arbetsbelastningsgruppen limit_dop, medan andra sessioner fortsätter att klassificeras i default arbetsbelastningsgrupp. Vi använder en fråga som använder sys.dm_exec_sessions och sys.resource_governor_workload_groups systemvyer för att returnera programnamnet och arbetsbelastningsgruppens namn för den aktuella sessionen.

    1. I SQL Server Management Studio (SSMS) väljer du File på huvudmenyn, New, Database Engine Query.

    2. I dialogrutan Anslut till databasmotor anger du samma databasmotorinstans där du skapade arbetsbelastningsgruppen och klassificerarfunktionen. Välj fliken Ytterligare anslutningsparametrar och ange App=limited_dop_application. Detta gör att SSMS använder limited_dop_application som programnamn när du ansluter till instansen.

    3. Välj Anslut för att öppna en ny anslutning.

    4. Kör följande fråga i samma frågefönster:

      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;

      Du bör se följande utdata som visar att sessionen klassificerades i limit_dop arbetsbelastningsgrupp med maximal DOP inställt på fyra:

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

    5. Upprepa stegen ovan, men ange inget i rutan på fliken Ytterligare anslutningsparametrar. Utdata ändras, vilket visar standardnamnet för SSMS-programmet och default arbetsbelastningsgrupp med standardvärdet 0 för maximal DOP.

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

  6. Om du vill återgå till den inledande konfigurationen av det här exemplet kopplar du från alla sessioner med hjälp av arbetsbelastningsgruppen limit_dop och kör följande T-SQL-skript. Skriptet innehåller följande steg:

    1. Inaktivera resursguvernören så att klassificerarfunktionen kan tas bort.
    2. Ta bort arbetsbelastningsgruppen. Detta kräver att inga sessioner använder den här arbetsbelastningsgruppen.
    3. Konfigurera om resursstyrningen för att uppdatera den effektiva konfigurationen utan klassificerarfunktionen och arbetsbelastningsgruppen. Detta aktiverar resursguvernören.
    4. Inaktivera resursguvernören för att återgå till den inledande konfigurationen.
    /* 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;

Använda flera resurspooler och arbetsbelastningsgrupper

I det här exemplet används resursguvernör för att klassificera sessioner från ett orderbearbetningsprogram i olika arbetsbelastningsgrupper och resurspooler beroende på tid på dagen. Den här konfigurationen allokerar fler resurser till programmet under perioder med hög bearbetning och begränsar dess resurser under lediga timmar. Exemplet förutsätter att programmet inte använder långvariga sessioner.

  1. Skapa två resurspooler för bearbetning under rusningstider och icke-rusningstider.

    • Den peak_hours_pool poolen garanterar (reserverar) minst 20% av genomsnittlig processorbandbredd via MIN_CPU_PERCENToch begränsar inte processorbandbredden genom att ange MAX_CPU_PERCENT till 100.
    • Den off_hours_pool poolen reserverar inte någon processorbandbredd genom att ange MIN_CPU_PERCENT till 0, men begränsar processorbandbredden till 50% när processorkonkurration förekommer genom att ange MAX_CPU_PERCENT till 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
     );

    Resurspooler kan reservera och begränsa systemresurser som CPU, minne och I/O. Mer information finns i CREATE RESOURCE POOL.

  2. Skapa två arbetsbelastningsgrupper, en för varje resurspool.

    • peak_hours_group begränsar inte antalet samtidiga begäranden genom att ange GROUP_MAX_REQUESTS till standardvärdet för 0.
    • off_hours_group begränsar antalet samtidiga begäranden för alla sessioner som klassificeras i den här gruppen genom att ange GROUP_MAX_REQUESTS till 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;

    Arbetsbelastningsgrupper definierar principer som det maximala antalet begäranden, den maximala graden av parallellitet och den maximala storleken för minnesbidrag. Mer information finns i CREATE WORKLOAD GROUP.

  3. Skapa och fylla i en tabell som definierar tidsintervallen för hög och låg belastning.

    • Varje rad i tabellen definierar start- och sluttiden för intervallet och namnet på den arbetsbelastningsgrupp som ska användas under intervallet.
    • Start- och sluttiden för varje intervall är inkluderande.
    • Tabellen skapas i databasen master så att den kan användas i en schemabunden klassificerare.
    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. Skapa klassificerarfunktionen.

    • Data i tabellen förväntas ha en enda matchande rad för en viss tid på dagen. Om data bryter mot den regeln returnerar funktionen default som namnet på arbetsbelastningsgruppen.
    • Följande exempelfunktion returnerar också default om programnamnet som returneras av den inbyggda funktionen APP_NAME() är något annat än 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. Det här är ett valfritt steg. I stället för att skapa en tabell i master-databasen kan du använda en tabellvärdeskonstruktor för att definiera tidsintervallen direkt i klassificerarfunktionen. Detta är den rekommenderade metoden när datastorleken är liten och kriterierna för klassificerarens funktion inte ändras ofta. Här är ett exempel på samma klassificerare som använder en tabellvärdeskonstruktor i stället för en tabell i 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. Ändra konfigurationen av resursguvernören för att göra konfigurationen effektiv och aktivera resursguvernör.

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

  7. Kontrollera att resursguvernören är aktiverad, använder den angivna klassificerarfunktionen och att klassificerarfunktionen fungerar som förväntat med hjälp av liknande steg som i föregående exempel. Den här gången anger vi App=order_processing på fliken Ytterligare anslutningsparametrar i dialogrutan SSMS Connect för att matcha programnamnet i klassificerarfunktionen. Kör följande fråga för att fastställa programnamnet, arbetsbelastningsgruppen, resurspoolen och cpu-reservationen och gränsen för den aktuella sessionen:

    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;

    Resultatet beror på tid på dagen. Om den aktuella tiden till exempel är 14:30 visar resultatet att peak_hours_group och peak_hours_pool används:

    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. Om du vill återgå till den inledande konfigurationen av det här exemplet kopplar du från alla sessioner med hjälp av arbetsbelastningsgrupperna peak_hours_group och off_hours_group och kör följande T-SQL-skript. Skriptet innehåller följande steg:

    1. Inaktivera resursguvernören så att klassificerarfunktionen kan tas bort.
    2. Släpp arbetsbelastningsgrupperna. Detta kräver att inga sessioner använder dessa arbetsbelastningsgrupper.
    3. När arbetsbelastningsgrupperna har tagits bort släpper du resurspoolerna.
    4. Konfigurera om resursguvernören för att läsa in den effektiva konfigurationen igen utan klassificerarfunktionen och användardefinierade arbetsbelastningsgrupper och resurspooler. Detta aktiverar resursguvernören.
    5. Inaktivera resursguvernören för att återgå till den inledande konfigurationen.
    /* 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;

Övervaka resursguvernören med hjälp av systemvyer

Exempelfrågor i det här avsnittet visar hur du kan övervaka resursguvernörens körningsstatistik och beteende.

Statistik för resursguvernören är kumulativ sedan den senaste omstarten av servern. Om du behöver samla in statistik från en viss tidpunkt kan du återställa statistik med hjälp av ALTER RESOURCE GOVERNOR RESET STATISTICS-instruktionen.

Driftstatistik för resursgrupp

För varje resurspool spårar resursguvernören processor- och minnesanvändning, out-of-memory-händelser, minnesbidrag, I/O och annan statistik. Mer information finns i sys.dm_resource_governor_resource_pools.

Följande fråga returnerar en delmängd av tillgänglig statistik för alla resurspooler:

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;

Arbetsbelastningsgruppens körningsstatistik

För varje arbetsbelastningsgrupp spårar resursguvernören cpu-tid, antalet begäranden, blockerade uppgifter, låsväntetid, frågeoptimeringar och annan statistik. Mer information finns i sys.resource_governor_workload_groups.

Följande fråga returnerar en delmängd av tillgänglig statistik för alla arbetsbelastningsgrupper:

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

Aggregera sessioner efter arbetsbelastningsgrupp och sessionsattribut

Följande fråga returnerar en distribution av sessioner mellan arbetsbelastningsgrupper och sammanställd sessionsstatistik för varje arbetsbelastningsgrupp.

Ett stort antal sessioner med preconnect-statusen kan indikera långsam körning av klassificeraren.

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;

Aggregera begäranden efter arbetsbelastningsgrupp och begärandeattribut

Följande fråga returnerar en distribution av begäranden mellan arbetsbelastningsgrupper och sammanställd begärandestatistik för varje arbetsbelastningsgrupp:

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;

Metodtips för resursguvernör

  • Konfigurera dedikerad administratörsanslutning (DAC) och lär dig hur du använder den. För mer information, se Diagnostikanslutning för databasadministratörer. Om konfigurationen av resursguvernören inte fungerar kan du använda DAC för att felsöka den eller inaktivera resursguvernören.
  • När du konfigurerar resurspooler bör du vara försiktig med att ange stora värden för MIN_CPU_PERCENT, MIN_MEMORY_PERCENToch MIN_IOPS_PER_VOLUME. En MIN konfigurationsinställning reserverar resurser för en resurspool och gör dem otillgängliga för andra resurspooler, inklusive default-poolen. Mer information finns i Skapa en resurspool.
  • Funktionen klassificerare förlänger bearbetningstiden för inloggning. Undvik komplex logik och långvariga eller resursintensiva frågor i klassificeraren, särskilt om frågor använder stora tabeller. En alltför komplex funktion kan orsaka inloggningsfördröjningar eller tidsgränser för anslutning.
  • Om du behöver använda en tabell i klassificeraren och tabellen är liten och mestadels statisk kan du överväga att använda en tabellvärdeskonstruktor i stället, vilket visas i ett exempel tidigare i den här artikeln.
  • Undvik att använda en tabell som ofta ändras i klassificeraren. Det ökar risken för blockering som kan fördröja inloggningar och orsaka tidsgränser för anslutning. Följande lösningar kan minska risken, men de har nackdelar, inklusive risken för felaktig klassificering:
    • Överväg att använda NOLOCK tabelltips eller motsvarande READUNCOMMITTED tips. Mer information finns i READUNCOMMITTED.
    • Överväg att använda inställningen LOCK_TIMEOUT i början av klassificerarfunktionen och ange det till ett lågt värde, till exempel 1 000 millisekunder. Mer information finns i SET LOCK_TIMEOUT.
  • Du kan inte ändra en klassificerarfunktion medan den refereras i konfigurationen för resursguvernören. Du kan dock ändra konfigurationen så att den använder en annan klassificerare. Om du vill göra ändringar i klassificeraren bör du överväga att skapa ett par klassificerarfunktioner. Du kan till exempel skapa dbo.rg_classifier_A() och dbo.rg_classifier_B(). Följ dessa steg när du behöver ändra klassificeringslogik:
    1. Använd instruktionen ALTER FUNCTION för att göra ändringarna i funktionen inte som för närvarande används i konfigurationen av resursguvernören.
    2. Använd instruktionen ALTER RESOURCE GOVERNOR för att göra den ändrade klassificeraren aktiv och konfigurera sedan om resursguvernören. Till exempel: 
      ALTER RESOURCE GOVERNOR WITH (CLASSIFIER_FUNCTION = dbo.rg_classifier_B);
ALTER RESOURCE GOVERNOR RECONFIGURE;
    3. Om en ändring behövs igen följer du samma steg med hjälp av den andra funktionen (dbo.rg_classifier_A()).
  • Konfigurationen av resursguvernören lagras i master-databasen. Se till att regelbundet säkerhetskopiera masteroch vet hur du återställer den. Mer information finns i Säkerhetskopiera och återställa: Systemdatabaser. Eftersom det finns begränsningar när det gäller att återställa masterrekommenderar vi att du även sparar en kopia av konfigurationsskripten för resource governor separat. Du kan återskapa konfigurationen av resursguvernören från skript om master-databasen behöver återskapas.

Relaterat innehåll