Tutoriel : Configuration des files d'attente pour la gestion manuelle de la charge de travail (WLM)

Ouvrez Amazon Redshift RSQL et connectez-vous à votre base de données d'TICKITexemple. Si vous n'avez pas cette base de données, consultez Prérequis.

Exécutez la requête suivante pour créer la vue WLM _ QUEUE _ STATE _VW.

create view WLM_QUEUE_STATE_VW as
select (config.service_class-5) as queue
, trim (class.condition) as description
, config.num_query_tasks as slots
, config.query_working_mem as mem
, config.max_execution_time as max_time
, config.user_group_wild_card as "user_*"
, config.query_group_wild_card as "query_*"
, state.num_queued_queries queued
, state.num_executing_queries executing
, state.num_executed_queries executed
from
STV_WLM_CLASSIFICATION_CONFIG class,
STV_WLM_SERVICE_CLASS_CONFIG config,
STV_WLM_SERVICE_CLASS_STATE state
where
class.action_service_class = config.service_class 
and class.action_service_class = state.service_class 
and config.service_class > 4
order by config.service_class;

Exécutez la requête suivante pour afficher les informations que la vue contient.

select * from wlm_queue_state_vw;

Voici un exemple de résultat.

query | description                               | slots | mem | max_time | user_* | query_* | queued | executing | executed
------+-------------------------------------------+-------+-----+----------+--------+---------+--------+-----------+----------
    0 | (super user) and (query group: superuser) |     1 | 357 |        0 |  false | false   |      0 |         0 |        0
    1 | (querytype:any)                           |     5 | 836 |        0 |  false | false   |      0 |         1 |      160

DansRSQL, exécutez la requête suivante pour créer la vue WLM _ QUERY _ STATE _VW.

create view WLM_QUERY_STATE_VW as
select query, (service_class-5) as queue, slot_count, trim(wlm_start_time) as start_time, trim(state) as state, trim(queue_time) as queue_time, trim(exec_time) as exec_time
from stv_wlm_query_state;

Exécutez la requête suivante pour afficher les informations que la vue contient.

select * from wlm_query_state_vw;

Voici un exemple de résultat.

query | queue | slot_count | start_time          | state     | queue_time | exec_time
------+-------+------------+---------------------+-----------+------------+-----------
 1249 |     1 |          1 | 2014-09-24 22:19:16 | Executing | 0          | 516

Ouvrez deux RSQL fenêtres. Si vous avez déjà une fenêtre ouverte, il vous suffit d'en ouvrir une seconde. Vous pouvez choisir le même compte utilisateur pour ces deux connexions.

Dans RSQL la fenêtre 1, exécutez la requête suivante.

select * from wlm_query_state_vw;

Voici un exemple de résultat.

query | queue | slot_count | start_time          | state     | queue_time | exec_time
------+-------+------------+---------------------+-----------+------------+-----------
 1258 |     1 |          1 | 2014-09-24 22:21:03 | Executing | 0          | 549

Cette requête retourne un résultat faisant référence à elle-même. La requête en cours d'exécution est l'SELECTinstruction de cette vue. Une requête sur cette vue retourne toujours au moins un résultat. Comparez ce résultat à celui obtenu après le démarrage de la requête de longue durée à l'étape suivante.

Dans RSQL la fenêtre 2, exécutez une requête à partir de la base de données TICKIT d'exemple. Cette requête doit être exécutée pendant environ une minute afin que vous ayez le temps d'explorer les résultats de la vue WLM _ QUEUE _ STATE _VW et de la vue WLM _ QUERY _ STATE _VW que vous avez créées précédemment. Dans certains cas, vous pouvez constater que la requête ne s'exécute pas assez longtemps pour que vous puissiez interroger les deux vues. Dans ces cas, vous pouvez augmenter la valeur du filtre sur l.listid pour qu'elle s'exécute plus longtemps.

Pour désactiver la mise en cache du résultat sur la séance en cours, définissez le paramètre enable_result_cache_for_session sur off, comme illustré ci-après.

set enable_result_cache_for_session to off;

Dans RSQL la fenêtre 2, exécutez la requête suivante.

select avg(l.priceperticket*s.qtysold) from listing l, sales s where l.listid < 100000;

Dans RSQL la fenêtre 1, interrogez WLM _ QUEUE _ STATE _VW et WLM _ QUERY _ STATE _VW et comparez les résultats aux résultats précédents.

select * from wlm_queue_state_vw;
select * from wlm_query_state_vw;

Voici quelques exemples de résultats.

query | description                               | slots | mem | max_time | user_* | query_* | queued | executing | executed
------+-------------------------------------------+-------+-----+----------+--------+---------+--------+-----------+----------
    0 | (super user) and (query group: superuser) |     1 | 357 |        0 |  false | false   |      0 |         0 |        0
    1 | (querytype:any)                           |     5 | 836 |        0 |  false | false   |      0 |         2 |      163
                        
query | queue | slot_count | start_time          | state     | queue_time | exec_time
------+-------+------------+---------------------+-----------+------------+-----------
 1267 |     1 |          1 | 2014-09-24 22:22:30 | Executing | 0          | 684
 1265 |     1 |          1 | 2014-09-24 22:22:36 | Executing | 0          | 4080859

Ouvrez RSQL et exécutez la requête suivante. La requête utilise la vue WLM _ QUEUE _ STATE _VW que vous avez créée dansÉtape 1 : Création de la vue WLM _ QUEUE _ STATE _VW. Si vous aviez déjà une séance connectée à la base de données avant le redémarrage du cluster, vous devez vous reconnecter.

select * from wlm_queue_state_vw;

Voici un exemple de résultat.

query | description                               | slots | mem | max_time | user_* | query_* | queued | executing | executed
------+-------------------------------------------+-------+-----+----------+--------+---------+--------+-----------+----------
    0 | (super user) and (query group: superuser) |     1 | 357 |        0 |  false | false   |      0 |         0 |        0
    1 | (query group: test)                       |     2 | 627 |        0 |  false | false   |      0 |         0 |        0
    2 | (suser group: admin)                      |     3 | 557 |        0 |  false | false   |      0 |         0 |        0
    3 | (querytype:any)                           |     5 | 250 |        0 |  false | false   |      0 |         1 |        0

Comparer ces résultats à ceux que vous avez reçus dans Étape 1 : Création de la vue WLM _ QUEUE _ STATE _VW. Notez qu'il y a désormais deux files d'attente supplémentaires. Queue 1 est maintenant la file d'attente du groupe de requêtes de test et Queue 2 la file d'attente du groupe utilisateur administrateur.

Queue 3 est maintenant la file d'attente par défaut. La dernière file d'attente de la liste est toujours la file d'attente par défaut. Elle correspond à la file d'attente vers laquelle les requêtes sont routées par défaut si aucun groupe d'utilisateurs ni groupe de requêtes n'est spécifié dans une requête.

Exécutez la requête suivante pour confirmer que votre requête s'exécute maintenant dans la file d'attente 3.

select * from wlm_query_state_vw;

Voici un exemple de résultat.

query | queue | slot_count | start_time          | state     | queue_time | exec_time
------+-------+------------+---------------------+-----------+------------+-----------
 2144 |     3 |          1 | 2014-09-24 23:49:59 | Executing | 0          | 550430

Exécutez la requête suivante pour l'acheminer vers le groupe de requêtes test.

set query_group to test;
select avg(l.priceperticket*s.qtysold) from listing l, sales s where l.listid <40000;

Dans l'autre RSQL fenêtre, exécutez la requête suivante.

select * from wlm_query_state_vw;

Voici un exemple de résultat.

query | queue | slot_count | start_time          | state     | queue_time | exec_time
------+-------+------------+---------------------+-----------+------------+-----------
 2168 |     1 |          1 | 2014-09-24 23:54:18 | Executing | 0          | 6343309
 2170 |     3 |          1 | 2014-09-24 23:54:24 | Executing | 0          | 847

La requête a été acheminée vers le groupe de requêtes de test, à savoir queue 1 maintenant.

Sélectionnez tout à partir de la vue d'état de la file d'attente.

select * from wlm_queue_state_vw;

Vous voyez un résultat similaire au suivant.

query | description                               | slots | mem | max_time | user_* | query_* | queued | executing | executed
------+-------------------------------------------+-------+-----+----------+--------+---------+--------+-----------+----------
    0 | (super user) and (query group: superuser) |     1 | 357 |        0 |  false | false   |      0 |         0 |        0
    1 | (query group: test)                       |     2 | 627 |        0 |  false | false   |      0 |         1 |        0
    2 | (suser group: admin)                      |     3 | 557 |        0 |  false | false   |      0 |         0 |        0
    3 | (querytype:any)                           |     5 | 250 |        0 |  false | false   |      0 |         1 |        0

Maintenant, réinitialisez le groupe de requêtes et exécutez la longue requête à nouveau :

reset query_group;
select avg(l.priceperticket*s.qtysold) from listing l, sales s where l.listid <40000;

Exécutez les requêtes sur les vues pour afficher les résultats.

select * from wlm_queue_state_vw;
select * from wlm_query_state_vw;

Voici quelques exemples de résultats.

query | description                               | slots | mem | max_time | user_* | query_* | queued | executing | executed
------+-------------------------------------------+-------+-----+----------+--------+---------+--------+-----------+----------
    0 | (super user) and (query group: superuser) |     1 | 357 |        0 |  false | false   |      0 |         0 |        0
    1 | (query group: test)                       |     2 | 627 |        0 |  false | false   |      0 |         0 |        1
    2 | (suser group: admin)                      |     3 | 557 |        0 |  false | false   |      0 |         0 |        0
    3 | (querytype:any)                           |     5 | 250 |        0 |  false | false   |      0 |         2 |        5
 
query | queue | slot_count | start_time          | state     | queue_time | exec_time
------+-------+------------+---------------------+-----------+------------+-----------
 2186 |     3 |          1 | 2014-09-24 23:57:52 | Executing | 0          | 649
 2184 |     3 |          1 | 2014-09-24 23:57:48 | Executing | 0          | 4137349

Le résultat doit être que la requête s'exécute maintenant dans la file d'attente 3 à nouveau.

Dans la base de données, créez un nouvel utilisateur de base de données nommé en adminwlm exécutant la commande suivante dans une RSQL fenêtre.

create user adminwlm createuser password '123Admin';

Puis, exécutez les commandes suivantes pour créer le nouveau groupe d'utilisateurs et lui ajouter votre nouvel utilisateur adminwlm.

create group admin;
alter group admin add user adminwlm;

Dans RSQL la fenêtre 2, exécutez les requêtes suivantes pour passer au adminwlm compte et exécuter une requête sous le nom de cet utilisateur.

set session authorization 'adminwlm';
select avg(l.priceperticket*s.qtysold) from listing l, sales s where l.listid <40000;

Dans RSQL la fenêtre 1, exécutez la requête suivante pour voir la file d'attente vers laquelle les requêtes sont acheminées.

select * from wlm_query_state_vw;
select * from wlm_queue_state_vw;

Voici quelques exemples de résultats.

query | description                               | slots | mem | max_time | user_* | query_* | queued | executing | executed
------+-------------------------------------------+-------+-----+----------+--------+---------+--------+-----------+----------
    0 | (super user) and (query group: superuser) |     1 | 357 |        0 |  false | false   |      0 |         0 |        0
    1 | (query group: test)                       |     2 | 627 |        0 |  false | false   |      0 |         0 |        1
    2 | (suser group: admin)                      |     3 | 557 |        0 |  false | false   |      0 |         1 |        0
    3 | (querytype:any)                           |     5 | 250 |        0 |  false | false   |      0 |         1 |        8
 
query | queue | slot_count | start_time          | state     | queue_time | exec_time
------+-------+------------+---------------------+-----------+------------+-----------
 2202 |     2 |          1 | 2014-09-25 00:01:38 | Executing | 0          | 4885796
 2204 |     3 |          1 | 2014-09-25 00:01:43 | Executing | 0          | 650

La file d'attente dans laquelle cette requête a été exécutée est la file d'attente 2, celle de l'utilisateur admin. Chaque fois que vous exécutez des requêtes en étant connecté sous l'identité de cet utilisateur, elles s'exécutent dans la file d'attente 2, sauf si vous spécifiez un autre groupe de requêtes à utiliser. La file d'attente choisie dépend des règles d'affectation de file d'attente. Pour de plus amples informations, veuillez consulter WLMrègles d'attribution des files d'attente.

Exécutez maintenant la requête suivante à partir de RSQL la fenêtre 2.

set query_group to test;
select avg(l.priceperticket*s.qtysold) from listing l, sales s where l.listid <40000;

Dans RSQL la fenêtre 1, exécutez la requête suivante pour voir la file d'attente vers laquelle les requêtes sont acheminées.

select * from wlm_queue_state_vw;
select * from wlm_query_state_vw;

Voici quelques exemples de résultats.

query | description                               | slots | mem | max_time | user_* | query_* | queued | executing | executed
------+-------------------------------------------+-------+-----+----------+--------+---------+--------+-----------+----------
    0 | (super user) and (query group: superuser) |     1 | 357 |        0 |  false | false   |      0 |         0 |        0
    1 | (query group: test)                       |     2 | 627 |        0 |  false | false   |      0 |         1 |        1
    2 | (suser group: admin)                      |     3 | 557 |        0 |  false | false   |      0 |         0 |        1
    3 | (querytype:any)                           |     5 | 250 |        0 |  false | false   |      0 |         1 |       10
 
query | queue | slot_count | start_time          | state     | queue_time | exec_time
------+-------+------------+---------------------+-----------+------------+-----------
 2218 |     1 |          1 | 2014-09-25 00:04:30 | Executing | 0          | 4819666
 2220 |     3 |          1 | 2014-09-25 00:04:35 | Executing | 0          | 685

Lorsque vous avez terminé, réinitialisez le groupe de requêtes.

reset query_group;

Augmentez la limite de requête pour vous assurer que vous disposez de suffisamment de temps pour interroger la vue WLM _ QUERY _ STATE _VW et obtenir un résultat.

set wlm_query_slot_count to 3; 
select avg(l.priceperticket*s.qtysold) from listing l, sales s where l.listid <40000;

Maintenant, interrogez WLM _ QUERY _ STATE _VW auprès de l'administrateur pour voir comment la requête s'exécute.

select * from wlm_query_state_vw;

Voici un exemple de résultat.

query | queue | slot_count | start_time          | state     | queue_time | exec_time
------+-------+------------+---------------------+-----------+------------+-----------
 2240 |     2 |          1 | 2014-09-25 00:08:45 | Executing | 0          | 3731414
 2242 |     3 |          1 | 2014-09-25 00:08:49 | Executing | 0          | 596

Notez que le nombre d'emplacements pour la requête est 3. Ce nombre signifie que la requête utilise les trois emplacements pour traiter la requête et alloue la totalité des ressources de la file d'attente à cette requête.

Maintenant, exécutez la requête suivante.

select * from WLM_QUEUE_STATE_VW;

Voici un exemple de résultat.

query | description                               | slots | mem | max_time | user_* | query_* | queued | executing | executed
------+-------------------------------------------+-------+-----+----------+--------+---------+--------+-----------+----------
    0 | (super user) and (query group: superuser) |     1 | 357 |        0 |  false | false   |      0 |         0 |        0
    1 | (query group: test)                       |     2 | 627 |        0 |  false | false   |      0 |         0 |        4
    2 | (suser group: admin)                      |     3 | 557 |        0 |  false | false   |      0 |         1 |        3
    3 | (querytype:any)                           |     5 | 250 |        0 |  false | false   |      0 |         1 |       25

Le paramètre de configuration wlm_query_slot_count est valide pour la séance en cours uniquement. Si cette session expire ou si un autre utilisateur exécute une requête, la WLM configuration est utilisée.

Réinitialisez le nombre d'emplacements et exécutez à nouveau le test.

reset wlm_query_slot_count;
select avg(l.priceperticket*s.qtysold) from listing l, sales s where l.listid <40000;

Voici quelques exemples de résultats.

query | description                               | slots | mem | max_time | user_* | query_* | queued | executing | executed
------+-------------------------------------------+-------+-----+----------+--------+---------+--------+-----------+----------
    0 | (super user) and (query group: superuser) |     1 | 357 |        0 |  false | false   |      0 |         0 |        0
    1 | (query group: test)                       |     2 | 627 |        0 |  false | false   |      0 |         0 |        2
    2 | (suser group: admin)                      |     3 | 557 |        0 |  false | false   |      0 |         1 |        2
    3 | (querytype:any)                           |     5 | 250 |        0 |  false | false   |      0 |         1 |       14
 
query | queue | slot_count | start_time          | state     | queue_time | exec_time
------+-------+------------+---------------------+-----------+------------+-----------
 2260 |     2 |          1 | 2014-09-25 00:12:11 | Executing | 0          | 4042618
 2262 |     3 |          1 | 2014-09-25 00:12:15 | Executing | 0          | 680

Dans les RSQL fenêtres 1 et 2, exécutez ce qui suit pour utiliser le groupe de requêtes de test.

set query_group to test;

Dans RSQL la fenêtre 1, exécutez la requête longue suivante.

select avg(l.priceperticket*s.qtysold) from listing l, sales s where l.listid <40000;

Comme la requête de longue durée est toujours en cours dans RSQL la fenêtre 1, exécutez ce qui suit. Elles augmentent le nombre d'emplacements pour utiliser tous les emplacements pour la file d'attente, puis commencent à exécuter la requête de longue durée.

set wlm_query_slot_count to 2;
select avg(l.priceperticket*s.qtysold) from listing l, sales s where l.listid <40000;

Ouvrez une troisième RSQL fenêtre et interrogez les vues pour voir les résultats.

select * from wlm_queue_state_vw;
select * from wlm_query_state_vw;

Voici quelques exemples de résultats.

query | description                               | slots | mem | max_time | user_* | query_* | queued | executing | executed
------+-------------------------------------------+-------+-----+----------+--------+---------+--------+-----------+----------
    0 | (super user) and (query group: superuser) |     1 | 357 |        0 |  false | false   |      0 |         0 |        0
    1 | (query group: test)                       |     2 | 627 |        0 |  false | false   |      1 |         1 |        2
    2 | (suser group: admin)                      |     3 | 557 |        0 |  false | false   |      0 |         0 |        3
    3 | (querytype:any)                           |     5 | 250 |        0 |  false | false   |      0 |         1 |       18
 
query | queue | slot_count | start_time          | state         | queue_time | exec_time
------+-------+------------+---------------------+---------------+------------+-----------
 2286 |     1 |          2 | 2014-09-25 00:16:48 | QueuedWaiting | 3758950    | 0
 2282 |     1 |          1 | 2014-09-25 00:16:33 | Executing     | 0          | 19335850
 2288 |     3 |          1 | 2014-09-25 00:16:52 | Executing     | 0          | 666

Notez que la première requête utilise l'un des emplacements alloués à la file d'attente 1 pour exécuter la requête. De plus, notez qu'une requête est en attente dans la file d'attente (queued a pour valeur 1 et state a pour valeur QueuedWaiting). Une fois la première requête terminée, la deuxième commence à s'exécuter. Cette exécution se produit parce que les deux requêtes sont acheminées vers le groupe de requêtes test et la deuxième requête doit attendre qu'il y ait un nombre suffisant d'emplacements pour commencer le traitement.