O Amazon Redshift não permitirá mais a criação de UDFs do Python a partir do Patch 198. As UDFs do Python existentes continuarão a funcionar normalmente até 30 de junho de 2026. Para ter mais informações, consulte a [publicação de blog ](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). 

# Tutorial: Configuração de filas de gerenciamento do workload (WLM) manual
<a name="tutorial-configuring-workload-management"></a>

Com o Amazon Redshift, é possível configurar filas do gerenciamento de workloads (WLM) manual para priorizar e alocar recursos a diferentes tipos de consulta e usuário. As filas do WLM manual permitem que você controle as configurações de memória e simultaneidade de filas específicas, garantindo que as workloads essenciais recebam os recursos necessários e evitando que consultas de baixa prioridade monopolizem o sistema. As seções a seguir orientam você no processo de criação e configuração de filas do WLM manual no Amazon Redshift para atender aos requisitos de gerenciamento de workloads. 

## Visão geral
<a name="tutorial-wlm-overview"></a>

Recomendamos configurar o gerenciamento automático de workload (WLM) no Amazon Redshift. Para obter mais informações sobre o WLM automático, consulte [Gerenciamento do workload](cm-c-implementing-workload-management.md). No entanto, se você precisar de várias filas WLM, este tutorial o orienta no processo de configuração do gerenciamento de workload manual (WLM) no Amazon Redshift. Ao configurar o WLM manual, é possível melhorar a performance de consulta e a alocação de recursos no cluster.

O Amazon Redshift roteia as consultas do usuário para filas para processamento. O WLM define como essas consultas são roteadas para as filas. Por padrão, o Amazon Redshift tem duas filas disponíveis para consultas: uma para superusuários e outra para usuários. A fila de superusuários não pode ser configurada e processa somente uma consulta por vez. Você deve reservar essa fila somente para fins de solução de problemas. A fila de usuários pode processar até cinco consultas por vez, mas você pode configurá-la alterando o nível de simultaneidade da fila, se necessário. 

Quando tem diversos usuários executando consultas no banco de dados, você pode achar outra configuração mais eficiente. Por exemplo, se executarem operações que exijam muitos recursos, como VACUUM, alguns usuários poderão ter um impacto negativo sobre consultas menos intensivas, como relatórios. Convém considerar adicionar filas e configurá-las para workloads diferentes. 

**Tempo estimado:** 75 minutos

**Custo estimado:** 50 centavos

### Pré-requisitos
<a name="tutorial-wlm-prereq"></a>

Você precisa de um cluster do Amazon Redshift, do banco de dados TICKIT de amostra e da ferramenta cliente Amazon Redshift RSQL. Se você ainda não fez essa configuração, consulte o [Guia de conceitos básicos do Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/gsg/new-user.html) e o [Amazon Redshift RSQL](https://docs.aws.amazon.com/redshift/latest/mgmt/rsql-query-tool.html). 

### Seções
<a name="tutorial-wlm-steps"></a>
+ [Seção 1: Compreender o comportamento do processamento de filas padrão](#tutorial-wlm-understanding-default-processing)
+ [Seção 2: Modificar a configuração da fila de consultas do WLM](#tutorial-wlm-modifying-wlm-configuration)
+ [Seção 3: Rotear consultas para filas com base em grupos de usuários e grupos de consultas](#tutorial-wlm-routing-queries-to-queues)
+ [Seção 4: Usar wlm\$1query\$1slot\$1count para substituir temporariamente o nível de simultaneidade em uma fila](#tutorial-wlm-query-slot-count)
+ [Seção 5: Limpar os recursos](#tutorial-wlm-cleaning-up-resources)

## Seção 1: Compreender o comportamento do processamento de filas padrão
<a name="tutorial-wlm-understanding-default-processing"></a>

Antes de começar a configurar o WLM manual, é útil entender o comportamento padrão do processamento de fila no Amazon Redshift. Nesta seção, crie duas visualizações de banco de dados que retornam informações de diversas tabelas do sistema. Depois, execute algumas consultas de teste para saber como as consultas são roteadas por padrão. Para obter mais informações sobre tabelas de sistema, consulte [Referência de visualizações e tabelas do sistema](cm_chap_system-tables.md). 

### Etapa 1: Criar a visualização WLM\$1QUEUE\$1STATE\$1VW
<a name="tutorial-wlm-create-queue-state-view"></a>

Nesta etapa, crie uma visualização chamada WLM\$1QUEUE\$1STATE\$1VW. Essa visualização retorna informações das tabelas de sistema a seguir.
+ [STV\$1WLM\$1CLASSIFICATION\$1CONFIG](r_STV_WLM_CLASSIFICATION_CONFIG.md)
+ [STV\$1WLM\$1SERVICE\$1CLASS\$1CONFIG](r_STV_WLM_SERVICE_CLASS_CONFIG.md)
+ [STV\$1WLM\$1SERVICE\$1CLASS\$1STATE](r_STV_WLM_SERVICE_CLASS_STATE.md)

Essa visualização será usada ao longo do tutorial para monitorar o que acontecerá com as filas depois que alterar a configuração do WLM. A tabela a seguir descreve os dados retornados pela visualização WLM\$1QUEUE\$1STATE\$1VW. 

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/tutorial-configuring-workload-management.html)

#### Como criar a visualização WLM\$1QUEUE\$1STATE\$1VW
<a name="how-to-wlm-create-queue-state-view"></a>

1. Abra o [Amazon Redshift RSQL](https://docs.aws.amazon.com/redshift/latest/mgmt/rsql-query-tool.html) e conecte-se ao seu banco de dados de amostra TICKIT. Se você não tiver esse banco de dados, consulte [Pré-requisitos](#tutorial-wlm-prereq).

1. Execute a consulta a seguir para criar a visualização WLM\$1QUEUE\$1STATE\$1VW.

   ```
   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;
   ```

1. Execute a consulta a seguir para ver as informações contidas pela visualização.

   ```
   select * from wlm_queue_state_vw;
   ```

   Este é um resultado de exemplo.

   ```
   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
   ```

### Etapa 2: Criar a visualização WLM\$1QUERY\$1STATE\$1VW
<a name="tutorial-wlm-create-query-state-view"></a>

Nesta etapa, crie uma visualização chamada WLM\$1QUERY\$1STATE\$1VW. Essa visualização retorna informações da tabela de sistema [STV\$1WLM\$1QUERY\$1STATE](r_STV_WLM_QUERY_STATE.md).

Essa visualização será usada ao longo do tutorial para monitorar as consultas em execução. A tabela a seguir descreve os dados retornados pela visualização WLM\$1QUERY\$1STATE\$1VW.

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/tutorial-configuring-workload-management.html)

#### Como criar a visualização WLM\$1QUERY\$1STATE\$1VW
<a name="how-to-wlm-create-query-state-view"></a>

1. Em RSQL, execute a consulta a seguir para criar a visualização WLM\$1QUERY\$1STATE\$1VW.

   ```
   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;
   ```

1. Execute a consulta a seguir para ver as informações contidas pela visualização.

   ```
   select * from wlm_query_state_vw;
   ```

   Este é um resultado de exemplo.

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

### Etapa 3: Executar consultas de teste
<a name="tutorial-wlm-run-test-queries"></a>

Nesta etapa, execute consultas de várias conexões em RSQL e examine as tabelas de sistema para determinar como as consultas foram roteadas para processamento. 

Para esta etapa, são necessárias duas janelas RSQL abertas: 
+ Na janela RSQL 1, execute consultas que monitoram o estado das filas e das consultas usando as visualizações já criadas neste tutorial.
+ Na janela RSQL 2, execute consultas demoradas para alterar os resultados encontrados na janela RSQL 1.

#### Como executar as consultas de teste
<a name="how-to-wlm-run-test-queries"></a>

1. Abra duas janelas RSQL. Se já tiver uma janela aberta, você precisará somente abrir uma segunda. Você pode usar a mesma conta de usuário para ambas as conexões.

1. Na janela RSQL 1, execute a consulta a seguir.

   ```
   select * from wlm_query_state_vw;
   ```

   Este é um resultado de exemplo.

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

   Essa consulta retorna um resultado autorreferencial. A consulta em execução no momento é a instrução SELECT nesta visualização. Uma consulta nessa visualização sempre retorna pelo menos um resultado. Compare esse resultado com o resultado ocorrido depois de iniciar a consulta demorada na próxima etapa.

1. Na janela RSQL 2, execute uma consulta no banco de dados de exemplo TICKIT. Essa consulta deve ser executada por aproximadamente um minuto, de maneira que você tenha tempo de explorar os resultados das visualizações WLM\$1QUEUE\$1STATE\$1VW e WLM\$1QUERY\$1STATE\$1VW criadas anteriormente. Em alguns casos, você poderá descobrir que a consulta não é executada por tempo suficiente para consultar ambas as visualizações. Nesses casos, aumente o valor do filtro em `l.listid `para fazer com seja excutada por mais tempo.
**nota**  
Para reduzir o tempo de execução da consulta e melhorar a performance do sistema, o Amazon Redshift armazena em cache os resultados de certos tipos de consultas na memória no nó líder. Quando o cache de resultados estiver habilitado, as consultas subsequentes serão executadas mais rapidamente. Para impedir que a consulta seja executada muito rapidamente, desabilite o cache de resultados para a sessão atual.

   Para desabilitar o cache de resultados da sessão atual, defina o parâmetro [enable\$1result\$1cache\$1for\$1session](r_enable_result_cache_for_session.md) como `off`, conforme mostrado a seguir.

   ```
   set enable_result_cache_for_session to off;
   ```

   Na janela RSQL 2, execute a consulta a seguir.

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

1. Na janela RSQL 1, as consultas WLM\$1QUEUE\$1STATE\$1VW e WLM\$1QUERY\$1STATE\$1VW comparam os resultados com os resultados anteriores.

   ```
   select * from wlm_queue_state_vw;
   select * from wlm_query_state_vw;
   ```

   Estes são resultados de exemplo.

   ```
   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
   ```

Observe as seguintes diferenças entre as consultas anteriores e os resultados nesta etapa:
+ Agora existem duas linhas em WLM\$1QUERY\$1STATE\$1VW. Um resultado é a consulta autorreferencial para executar uma operação SELECT nessa visualização. O segundo resultado é a consulta demorada da etapa anterior.
+ A coluna em execução em WLM\$1QUEUE\$1STATE\$1VW aumentou de 1 a 2. Essa entrada de coluna significa que existem duas consultas em execução na fila.
+ A coluna executada é incrementada sempre que você executa uma consulta na fila.

A visualização WLM\$1QUEUE\$1STATE\$1VW é útil para ter uma visualização geral das filas e quantas consultas estão sendo processadas em cada fila. A visualização WLM\$1QUERY\$1STATE\$1VW é útil para obter uma visão mais detalhada das consultas individuais em execução no momento.

## Seção 2: Modificar a configuração da fila de consultas do WLM
<a name="tutorial-wlm-modifying-wlm-configuration"></a>

Agora que compreende como as filas funcionam por padrão, aprenda como configurar filas de consultas usando WLM manual. Nesta seção, crie e configure um novo grupo de parâmetros para o cluster. Você cria duas filas de usuários adicionais e configura-as para aceitar consultas com base no grupo de usuários das consultas ou nos rótulos dos grupos de consultas. Todas as consultas que não forem roteadas para uma dessas duas filas serão roteadas para a fila padrão em tempo de execução.

**Para criar uma configuração manual de WLM em um grupo de parâmetros**

1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon Redshift em [https://console.aws.amazon.com/redshiftv2/](https://console.aws.amazon.com/redshiftv2/).

1. No menu de navegação, escolha **Configurations** (Configurações) e **Workload management** (Gerenciamento de workload) para exibir a página **Workload management** (Gerenciamento de workload). 

1. Escolha **Create (Criar)** para exibir a janela **Create parameter group (Criar grupo de parâmetros)**. 

1. Insira **WLMTutorial** tanto para **Nome do grupo de parâmetros** como para **Descrição** e depois escolha **Criar** para criar o grupo de parâmetros. 
**nota**  
O **Parameter group name (Nome do grupo de parâmetros)** é convertido para todas letras minúsculas quando criado. 

1. Na página **Workload management (Gerenciamento do workload)**, escolha o grupo de parâmetros **wlmtutorial** para exibir a página de detalhes com guias para **Parameters (Parâmetros)** e **Workload management (Gerenciamento do workload)**. 

1. Confirme se você está na página **Workload management (Gerenciamento do workload)** e escolha **Switch WLM mode (Alternar modo WLM)** para exibir a janela **Concurrency settings (Configurações de simultaneidade)**. 

1. Escolha **Manual WLM (WLM manual)** e escolha **Save (Salvar)** para alternar para o WLM manual. 

1. Escolha **Edit workload queues (Editar filas de workload)**. 

1. Escolha **Add queue (Adicionar fila)** duas vezes para adicionar duas filas. Agora existem três filas: **Queue 1 (Fila 1)**, **Queue 2 (Fila 2)** e **Default queue (Fila padrão)**. 

1. Insira informações para cada fila da seguinte maneira: 
   + Em **Queue 1 (Fila 1)**, insira **30** para **Memory (%) (Memória (%))**, **2** para **Concurrency on main (Simultaneidade em principal)** e **test** para **Query groups (Grupos de consultas)**. Deixe as outras configurações com os valores padrão.
   + Em **Queue 2 (Fila 2)**, insira **40** para **Memory (%) (Memória (%))**, **3** para **Concurrency on main (Simultaneidade em principal)** e **admin** para **User groups (Grupos de usuários)**. Deixe as outras configurações com os valores padrão.
   + Defina o valor de **Simultaneidade na principal** para a fila padrão como um valor maior ou igual a 1. Não faça nenhuma outra alteração na **Fila padrão**. O WLM atribui a memória não alocada à fila padrão. 

1. Para salvar suas configurações, escolha **Save (Salvar)**. 

Depois, associe o grupo de parâmetros que tem a configuração de WLM manual com um cluster.

**Para associar um grupo de parâmetros com uma configuração de WLM manual a um cluster.**

1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon Redshift em [https://console.aws.amazon.com/redshiftv2/](https://console.aws.amazon.com/redshiftv2/).

1. No menu de navegação, escolha **Clusters** e, depois, **Clusters** para exibir uma lista de seus clusters. 

1. Escolha seu cluster, como `examplecluster`, para exibir os detalhes do cluster. Em seguida, escolha a guia **Properties** para exibir as propriedades desse cluster. 

1. Na seção **Configurações do banco de dados**, escolha **Editar** e **Editar grupo de parâmetros** para exibir a janela de grupos de parâmetros. 

1. Para o **Grupos de parâmetros** escolha o grupo de parâmetros **wlmtutorial** que você criou anteriormente. 

1. Selecione **Salvar alterações** para associar o grupo de parâmetros. 

   O cluster é modificado com o grupo de parâmetros. Contudo, você precisa reinicializar o cluster para que as alterações também sejam aplicadas ao banco de dados.

1. Escolha seu cluster e, em seguida, selecione **Reinicializar** para **Ações**. 

Depois que o cluster for reinicializado, seu status retornará para **Available (Disponível)**. 

## Seção 3: Rotear consultas para filas com base em grupos de usuários e grupos de consultas
<a name="tutorial-wlm-routing-queries-to-queues"></a>

Agora, o cluster está associado a um novo grupo de parâmetros e o WLM está configurado. Em seguida, execute algumas consultas para ver como o Amazon Redshift roteia as consultas em filas para processamento.

### Etapa 1: Visualizar a configuração da fila de consulta no banco de dados
<a name="tutorial-wlm-view-query-config"></a>

Primeiro, verifique se o banco de dados tem a configuração do WLM esperada.

#### Como visualizar a configuração da fila de consultas
<a name="how-to-wlm-view-query-config"></a>

1. Abra RSQL e execute a consulta a seguir. A consulta usa a visualização WLM\$1QUEUE\$1STATE\$1VW criada em [Etapa 1: Criar a visualização WLM\$1QUEUE\$1STATE\$1VW](#tutorial-wlm-create-queue-state-view). Se já tiver uma sessão conectada ao banco de dados antes da reinicialização do cluster, é necessário reconectar.

   ```
   select * from wlm_queue_state_vw;
   ```

   Este é um resultado de exemplo.

   ```
   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
   ```

   Compare esses resultados com os resultados recebidos por você em [Etapa 1: Criar a visualização WLM\$1QUEUE\$1STATE\$1VW](#tutorial-wlm-create-queue-state-view). Observe que agora existem duas filas adicionais. Agora a fila 1 é a fila do grupo de consultas de teste, e a fila 2 é a fila do grupo de usuários administradores.

   Agora a fila 3 é a padrão. A última fila na lista sempre é a fila padrão. Essa é a fila para a qual consultas são roteadas por padrão caso nenhum grupo de usuários ou de consultas seja especificado em uma consulta.

1. Execute a consulta a seguir para confirmar que a consulta agora é executada na fila 3.

   ```
   select * from wlm_query_state_vw;
   ```

   Este é um resultado de exemplo.

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

### Etapa 2: Executar uma consulta usando a fila de grupos de consultas
<a name="tutorial-wlm-query-group"></a>

#### Como executar uma consulta usando a fila de grupos de consultas
<a name="how-to-wlm-query-group"></a>

1. Execute a consulta a seguir a fim de roteá-la para o grupo de consultas `test`.

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

1. Na outra janela RSQL, execute a consulta a seguir.

   ```
   select * from wlm_query_state_vw;
   ```

   Este é um resultado de exemplo.

   ```
   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
   ```

   A consulta foi roteada para o grupo de consultas de teste, que é a fila 1 agora.

1. Selecione tudo na visualização de estado da fila.

   ```
   select * from wlm_queue_state_vw;
   ```

   Você verá um resultado semelhante ao seguinte.

   ```
   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
   ```

1. Agora redefina o grupo de consultas e reexecute a consulta longa:

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

1. Execute as consultas em relação às visualizações para ver os resultados.

   ```
   select * from wlm_queue_state_vw;
   select * from wlm_query_state_vw;
   ```

   Estes são resultados de exemplo.

   ```
   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
   ```

   O resultado deve ser a consulta em execução na fila 3 novamente.

### Etapa 3: Criar um grupo e um usuário de banco de dados
<a name="tutorial-wlm-create-db-user-and-group"></a>

Para executar todas as consultas nessa fila, você precisa criar o grupo de usuários no banco de dados e adicionar um usuário ao grupo. Depois, faça logon com o RSQL usando as credenciais do novo usuário e execute consultas. É necessário executar consultas como um superusuário, como usuário administrador, para criar usuários de banco de dados.

#### Como criar um usuário do banco de dados e um grupo de usuários
<a name="how-to-wlm-create-db-user-and-group"></a>

1. No banco de dados, crie um nome do usuário do banco de dados `adminwlm` executando o comando a seguir em uma janela RSQL.

   ```
   create user adminwlm createuser password '123Admin';
   ```

1. Em seguida, execute os comandos a seguir para criar o novo grupo de usuários e adicionar o novo usuário `adminwlm` a ele.

   ```
   create group admin;
   alter group admin add user adminwlm;
   ```

### Etapa 4: Executar uma consulta usando a fila de grupos de usuários
<a name="tutorial-wlm-user-group-query"></a>

Na sequência, execute uma consulta e roteie-a para a fila do grupo de usuários. Você faz isso quando quiser rotear a consulta para uma fila configurada para processar o tipo de consulta que deseja executar.

#### Como executar uma consulta usando a fila de grupos de usuários
<a name="how-to-wlm-user-group-query"></a>

1. Na janela RSQL 2, execute as consultas a seguir a fim de alternar para a conta `adminwlm` e executar uma consulta desse usuário.

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

1. Na janela RSQL 1, execute a consulta a seguir para ver a fila de consultas para a qual as consultas são roteadas.

   ```
   select * from wlm_query_state_vw;
   select * from wlm_queue_state_vw;
   ```

   Estes são resultados de exemplo.

   ```
   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
   ```

   A fila em que essa consulta foi executada está na fila 2, a fila de usuários `admin`. Sempre que você executar consultas conectado como esse usuário, elas serão executadas na fila 2, a menos que especifique um grupo de consultas diferente a ser usado. A fila escolhida depende das regras de atribuição de fila. Para obter mais informações, consulte [Regras de atribuição de fila do WLM](cm-c-wlm-queue-assignment-rules.md). 

1. Agora execute a consulta a seguir na janela RSQL 2.

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

1. Na janela RSQL 1, execute a consulta a seguir para ver a fila de consultas para a qual as consultas são roteadas.

   ```
   select * from wlm_queue_state_vw;
   select * from wlm_query_state_vw;
   ```

   Estes são resultados de exemplo.

   ```
   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
   ```

1. Quando terminar, redefina o grupo de consultas.

   ```
   reset query_group;
   ```

## Seção 4: Usar wlm\$1query\$1slot\$1count para substituir temporariamente o nível de simultaneidade em uma fila
<a name="tutorial-wlm-query-slot-count"></a>

Às vezes, os usuários podem precisar temporariamente de mais recursos para uma consulta específica. Em caso afirmativo, elas poderão usar a definição de configuração wlm\$1query\$1slot\$1count para substituir temporariamente a maneira como os slots são alocados em uma fila de consultas. *Slots* são unidades de memória e CPU usadas para processar consultas. Convém substituir a contagem de slots quando você tiver consultas ocasionais utilizando muitos recursos no cluster, como acontece quando você realiza uma operação VACUUM no banco de dados. 

Você poderá perceber que os usuários geralmente precisarão definir wlm\$1query\$1slot\$1count para determinados tipos de consultas. Se esse for o caso, considerar ajustar a configuração de WLM e conceder aos usuários uma fila mais adequada às necessidades de suas consultas. Para obter mais informações sobre como substituir temporariamente o nível de simultaneidade usando a contagem de slots, consulte [wlm\$1query\$1slot\$1count](r_wlm_query_slot_count.md).

### Etapa 1: Substituir o nível de simultaneidade usando wlm\$1query\$1slot\$1count
<a name="tutorial-wlm-override-slot-count"></a>

Para fins deste tutorial, executamos a mesma consulta SELECT demorada. Ela é executada como o usuário `adminwlm` utilizando wlm\$1query\$1slot\$1count para aumentar o número de slots disponíveis para a consulta.

#### Como substituir o nível de simultaneidade usando wlm\$1query\$1slot\$1count
<a name="how-to-wlm-override-slot-count"></a>

1. Aumente o limite na consulta para verificar se você tem tempo suficiente para consultar a visualização WLM\$1QUERY\$1STATE\$1VW e ver um resultado. 

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

1. Agora, consulte WLM\$1QUERY\$1STATE\$1VW com o usuário administrador para ver como a consulta está sendo executada.

   ```
   select * from wlm_query_state_vw;
   ```

   Este é um resultado de exemplo.

   ```
   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
   ```

   A contagem de slots para a consulta é 3. Essa contagem significa que a consulta está usando todos os três slots para processar a consulta, alocando todos os recursos na fila para essa consulta.

1. Agora execute a consulta a seguir.

   ```
   select * from WLM_QUEUE_STATE_VW;
   ```

   Este é um resultado de exemplo.

   ```
   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
   ```

   A definição de configuração wlm\$1query\$1slot\$1count é válida somente para a sessão atual. Se a sessão expirar, ou outro usuário executar uma consulta, a configuração do WLM será usada.

1. Redefina a contagem de slots e reexecute o teste.

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

   Estes são resultados de exemplo.

   ```
   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
   ```

### Etapa 2: Executar consultas em sessões diferentes
<a name="tutorial-wlm-run-queries-from-different-sessions"></a>

Em seguida, execute consultas em sessões diferentes.

#### Como executar consultas em sessões diferentes
<a name="how-to-wlm-run-queries-from-different-sessions"></a>

1. Nas janelas RSQL 1 e 2, execute o seguinte para usar o grupo de consultas de teste.

   ```
   set query_group to test;
   ```

1. Na janela RSQL 1, execute a consulta demorada a seguir.

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

1. Enquanto a consulta demorada ainda estiver em execução na janela RSQL 1, execute o seguinte. Esses comandos aumentam a contagem de slots a fim de usar todos os slots para a fila e começa a executar a consulta demorada.

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

1. Abra uma terceira janela RSQL e consulte as visualizações para ver os resultados.

   ```
   select * from wlm_queue_state_vw;
   select * from wlm_query_state_vw;
   ```

   Estes são resultados de exemplo.

   ```
   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
   ```

   Observe que a primeira consulta usa um dos slots alocados à fila 1 para executar a consulta. Além disso, observe que há uma consulta que está aguardando na fila (onde `queued` é `1` e `state` é `QueuedWaiting`). Depois que a primeira consulta for concluída, a segunda será executada. Essa execução acontece porque ambas as consultas são roteadas para o grupo de consultas `test`, e a segunda consulta deve aguardar slots suficientes para começar o processamento.

## Seção 5: Limpar os recursos
<a name="tutorial-wlm-cleaning-up-resources"></a>

O cluster continua acumulando cobranças enquanto está em execução. Ao concluir este tutorial, retorne seu ambiente ao estado anterior seguindo as etapas em [Encontrar recursos adicionais e redefinir seu ambiente](https://docs.aws.amazon.com/redshift/latest/gsg/rs-gsg-clean-up-tasks.html) no *Guia de conceitos básicos do Amazon Redshift*.

Para obter mais informações sobre WLM, consulte [Gerenciamento do workload](cm-c-implementing-workload-management.md).