Amazon Redshift tidak akan lagi mendukung pembuatan Python UDFs baru mulai Patch 198. Python yang ada UDFs akan terus berfungsi hingga 30 Juni 2026. Untuk informasi lebih lanjut, lihat [posting blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). 

Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Menerapkan manual WLM
<a name="cm-c-defining-query-queues"></a>

Dengan WLM manual, Anda dapat mengelola kinerja sistem dan pengalaman pengguna Anda dengan memodifikasi konfigurasi WLM untuk membuat antrian terpisah untuk kueri yang berjalan lama dan kueri jangka pendek.

Saat pengguna menjalankan kueri di Amazon Redshift, kueri dirutekan ke antrian kueri. Setiap antrian kueri berisi sejumlah slot kueri. Setiap antrian dialokasikan sebagian dari memori cluster yang tersedia. Memori antrian dibagi di antara slot kueri antrian. Anda dapat mengaktifkan Amazon Redshift untuk mengelola konkurensi kueri dengan WLM otomatis. Untuk informasi selengkapnya, lihat [Menerapkan WLM otomatis](automatic-wlm.md).

Atau Anda dapat mengonfigurasi properti WLM untuk setiap antrian kueri. Anda melakukannya untuk menentukan cara memori dialokasikan di antara slot dan bagaimana kueri dapat diarahkan ke antrian tertentu saat runtime. Anda juga dapat mengonfigurasi properti WLM untuk membatalkan kueri yang berjalan lama.

Secara default, Amazon Redshift mengonfigurasi antrian kueri berikut:
+  **Satu antrian superuser** 

  Antrian superuser hanya disediakan untuk pengguna super dan tidak dapat dikonfigurasi. Gunakan antrian ini hanya ketika Anda perlu menjalankan kueri yang memengaruhi sistem atau untuk tujuan pemecahan masalah. Misalnya, gunakan antrean ini saat Anda perlu membatalkan kueri pengguna yang sudah berjalan lama atau menambahkan pengguna ke database. Jangan menggunakannya untuk melakukan kueri rutin. Antrian tidak muncul di konsol, tetapi muncul di tabel sistem dalam database sebagai antrian kelima. Untuk menjalankan kueri dalam antrean superuser, pengguna harus login sebagai superuser, dan harus menjalankan kueri menggunakan grup kueri yang telah `superuser` ditentukan sebelumnya.
+  **Satu antrian pengguna default** 

  Antrian default awalnya dikonfigurasi untuk menjalankan lima kueri secara bersamaan. Bila Anda menggunakan WLM manual, Anda dapat mengubah properti konkurensi, batas waktu, dan alokasi memori untuk antrian default, tetapi Anda tidak dapat menentukan grup pengguna atau grup kueri. Antrian default harus antrian terakhir dalam konfigurasi WLM. Setiap kueri yang tidak dirutekan ke antrian lain berjalan dalam antrian default. 

Antrian kueri didefinisikan dalam konfigurasi WLM. Konfigurasi WLM adalah parameter yang dapat diedit (`wlm_json_configuration`) dalam grup parameter, yang dapat dikaitkan dengan satu atau lebih cluster. Untuk informasi selengkapnya, lihat [Mengonfigurasi Manajemen Beban Kerja di Panduan Manajemen](https://docs.aws.amazon.com/redshift/latest/mgmt/workload-mgmt-config.html) *Amazon Redshift*. 

Anda dapat menambahkan antrian kueri tambahan ke konfigurasi WLM default, hingga total delapan antrian pengguna. Anda dapat mengonfigurasi berikut ini untuk setiap antrian kueri: 
+ Mode penskalaan konkurensi 
+ Tingkat konkurensi 
+ Grup pengguna 
+ Grup kueri 
+ Persen memori WLM untuk digunakan
+ Batas waktu WLM
+ Antrian kueri WLM melompat
+ Aturan pemantauan kueri

## Mode penskalaan konkurensi
<a name="concurrency-scaling-mode"></a>

Saat penskalaan konkurensi diaktifkan, Amazon Redshift secara otomatis menambahkan kapasitas klaster tambahan saat Anda membutuhkannya untuk memproses peningkatan kueri baca dan tulis bersamaan. Pengguna melihat data terbaru, apakah kueri berjalan di cluster utama atau pada cluster penskalaan konkurensi. 

Anda mengelola kueri mana yang dikirim ke cluster penskalaan konkurensi dengan mengonfigurasi antrian WLM. Saat Anda mengaktifkan penskalaan konkurensi untuk antrian, kueri yang memenuhi syarat akan dikirim ke klaster penskalaan konkurensi alih-alih menunggu dalam antrian. Untuk informasi selengkapnya, lihat [Penskalaan konkurensi](concurrency-scaling.md).

## Tingkat konkurensi
<a name="cm-c-defining-query-queues-concurrency-level"></a>

Kueri dalam antrian berjalan secara bersamaan hingga mencapai jumlah slot kueri WLM, atau tingkat *konkurensi*, yang ditentukan untuk antrian tersebut. Pertanyaan selanjutnya kemudian menunggu dalam antrian.

**catatan**  
Tingkat konkurensi WLM berbeda dari jumlah koneksi pengguna bersamaan yang dapat dibuat ke cluster. Untuk informasi selengkapnya, lihat [Menghubungkan ke Cluster](https://docs.aws.amazon.com/redshift/latest/mgmt/connecting-to-cluster.html) di Panduan *Manajemen Pergeseran Merah Amazon*.

**Dalam konfigurasi WLM otomatis, yang direkomendasikan, level konkurensi diatur ke Otomatis.** Amazon Redshift secara dinamis mengalokasikan memori ke kueri, yang kemudian menentukan berapa banyak yang akan dijalankan secara bersamaan. Ini didasarkan pada sumber daya yang diperlukan untuk kueri berjalan dan antrian. Auto WLM tidak dapat dikonfigurasi. Untuk informasi selengkapnya, lihat [Menerapkan WLM otomatis](automatic-wlm.md). 

Dalam konfigurasi WLM manual, Amazon Redshift secara statis mengalokasikan jumlah memori tetap untuk setiap antrian. Memori antrian dibagi secara merata di antara slot kueri. Sebagai ilustrasi, jika antrian dialokasikan 20% dari memori cluster dan memiliki 10 slot, setiap kueri dialokasikan 2% dari memori cluster. Alokasi memori tetap tetap terlepas dari jumlah kueri yang berjalan secara bersamaan. Karena alokasi memori tetap ini, kueri yang berjalan sepenuhnya dalam memori ketika jumlah slot adalah 5 mungkin menulis hasil antara ke disk jika jumlah slot ditingkatkan menjadi 20. Dalam hal ini, setiap bagian kueri dari memori antrian dikurangi dari 1/5 menjadi 1/20. Disk tambahan I/O dapat menurunkan kinerja. 

Jumlah slot maksimum di semua antrian yang ditentukan pengguna adalah 50. Ini membatasi total slot untuk semua antrian, termasuk antrian default. Satu-satunya antrian yang tidak tunduk pada batas adalah antrian superuser yang dicadangkan.

Secara default, antrian WLM manual memiliki tingkat konkurensi 5. Beban kerja Anda mungkin mendapat manfaat dari tingkat konkurensi yang lebih tinggi dalam kasus-kasus tertentu, seperti berikut ini:
+ Jika banyak kueri kecil dipaksa untuk menunggu kueri yang berjalan lama, buat antrian terpisah dengan jumlah slot yang lebih tinggi dan tetapkan kueri yang lebih kecil ke antrian itu. Antrian dengan tingkat konkurensi yang lebih tinggi memiliki lebih sedikit memori yang dialokasikan untuk setiap slot kueri, tetapi kueri yang lebih kecil membutuhkan lebih sedikit memori.
**catatan**  
Jika Anda mengaktifkan akselerasi kueri pendek (SQA), WLM secara otomatis memprioritaskan kueri pendek daripada kueri yang berjalan lebih lama, sehingga Anda tidak memerlukan antrian terpisah untuk kueri singkat untuk sebagian besar alur kerja. Untuk informasi selengkapnya, lihat [Akselerasi kueri pendek](wlm-short-query-acceleration.md). 
+ Jika Anda memiliki beberapa kueri yang masing-masing mengakses data pada satu irisan, siapkan antrian WLM terpisah untuk menjalankan kueri tersebut secara bersamaan. Amazon Redshift menetapkan kueri bersamaan ke irisan terpisah, yang memungkinkan beberapa kueri berjalan secara paralel pada beberapa irisan. Misalnya, jika kueri adalah agregat sederhana dengan predikat pada kunci distribusi, data untuk kueri terletak pada satu irisan. 

### Contoh WLM manual
<a name="cm-c-defining-query-queues-concurrency-level-example"></a>

 Contoh ini adalah skenario WLM manual sederhana untuk menunjukkan bagaimana slot dan memori dapat dialokasikan. Anda menerapkan WLM manual dengan tiga antrian, yaitu sebagai berikut: 
+ *antrian konsumsi data* — Ini disiapkan untuk menelan data. Ini dialokasikan 20% dari memori cluster dan memiliki 5 slot. Selanjutnya, 5 kueri dapat berjalan secara bersamaan dalam antrian dan masing-masing dialokasikan 4% dari memori.
+ *antrian data-scientist* — Ini dirancang untuk kueri intensif memori. Ini dialokasikan 40% dari memori cluster dan memiliki 5 slot. Selanjutnya, 5 kueri dapat berjalan secara bersamaan dan masing-masing dialokasikan 8% dari memori.
+ *antrian default* — Ini dirancang untuk sebagian besar pengguna dalam organisasi. Ini termasuk grup penjualan dan akuntansi yang biasanya memiliki kueri berjalan pendek atau menengah yang tidak rumit. Ini dialokasikan 40% dari memori cluster dan memiliki 40 slot. 40 kueri dapat berjalan secara bersamaan dalam antrian ini, dengan setiap kueri dialokasikan 1% dari memori. Ini adalah jumlah maksimum slot yang dapat dialokasikan untuk antrian ini karena di antara semua antrian batasnya adalah 50.

Jika Anda menjalankan WLM otomatis dan beban kerja Anda memerlukan lebih dari 15 kueri untuk dijalankan secara paralel, sebaiknya aktifkan penskalaan konkurensi. Ini karena meningkatkan jumlah slot kueri di atas 15 dapat menciptakan pertengkaran untuk sumber daya sistem dan membatasi keseluruhan throughput dari satu cluster. Dengan penskalaan konkurensi, Anda dapat menjalankan ratusan kueri secara paralel, hingga sejumlah cluster penskalaan konkurensi yang dikonfigurasi. Jumlah cluster penskalaan konkurensi dikendalikan oleh. [max\$1concurrency\$1scaling\$1clusters](r_max_concurrency_scaling_clusters.md) Untuk informasi selengkapnya tentang penskalaan konkurensi, lihat. [Penskalaan konkurensi](concurrency-scaling.md) 

Untuk informasi selengkapnya, lihat [Peningkatan kinerja kueri](query-performance-improvement-opportunities.md). 

## Grup pengguna
<a name="cm-c-defining-query-queues-user-groups"></a>

Anda dapat menetapkan satu set grup pengguna ke antrian dengan menentukan setiap nama grup pengguna atau dengan menggunakan wildcard. Ketika anggota grup pengguna yang terdaftar menjalankan kueri, kueri tersebut berjalan dalam antrean yang sesuai. Tidak ada batasan yang ditetapkan pada jumlah grup pengguna yang dapat ditetapkan ke antrian. Untuk informasi selengkapnya, lihat [Menetapkan kueri ke antrian berdasarkan grup pengguna](cm-c-executing-queries.md#cm-c-executing-queries-assigning-queries-to-queues-based-on-user-groups). 

## Peran pengguna
<a name="cm-c-defining-query-queues-user-roles"></a>

Anda dapat menetapkan satu set peran pengguna ke antrian dengan menentukan setiap nama peran pengguna atau dengan menggunakan wildcard. Ketika anggota dari peran pengguna yang terdaftar menjalankan kueri, kueri tersebut berjalan dalam antrean yang sesuai. Tidak ada batasan yang ditetapkan pada jumlah peran pengguna yang dapat ditetapkan ke antrian. Untuk informasi selengkapnya, lihat [Menetapkan kueri ke antrian berdasarkan peran pengguna](cm-c-executing-queries.md#cm-c-executing-queries-assigning-queries-to-queues-based-on-user-roles). 

## Grup kueri
<a name="cm-c-defining-query-queues-query-groups"></a>

Anda dapat menetapkan satu set grup kueri ke antrian dengan menentukan setiap nama grup kueri atau dengan menggunakan wildcard. Grup kueri hanyalah sebuah label. Saat runtime, Anda dapat menetapkan label grup kueri ke serangkaian kueri. Setiap kueri yang ditetapkan ke grup kueri terdaftar berjalan dalam antrean yang sesuai. Tidak ada batasan yang ditetapkan untuk jumlah grup kueri yang dapat ditetapkan ke antrian. Untuk informasi selengkapnya, lihat [Menetapkan kueri ke grup kueri](cm-c-executing-queries.md#cm-c-executing-queries-assigning-a-query-to-a-query-group). 

## Wildcard
<a name="wlm-wildcards"></a>

Jika wildcard diaktifkan dalam konfigurasi antrian WLM, Anda dapat menetapkan grup pengguna dan grup kueri ke antrian baik secara individual atau dengan menggunakan wildcard bergaya shell Unix. Pencocokan pola tidak peka huruf besar/kecil. 

Misalnya, karakter wildcard '\$1' cocok dengan sejumlah karakter. Jadi, jika Anda menambahkan `dba_*` ke daftar grup pengguna untuk antrian, setiap kueri yang dijalankan pengguna yang termasuk dalam grup dengan nama yang dimulai dengan `dba_` ditetapkan ke antrian tersebut. Contohnya adalah `dba_admin` atau`DBA_primary`,. Yang '?' karakter wildcard cocok dengan karakter tunggal apa pun. Jadi, jika antrian menyertakan grup pengguna`dba?1`, maka grup pengguna bernama `dba11` dan `dba21` cocok, tetapi `dba12` tidak cocok. 

Wildcard dimatikan secara default.

## Persen memori WLM untuk digunakan
<a name="wlm-memory-percent"></a>

Dalam konfigurasi WLM otomatis, persen memori diatur ke. **auto** Untuk informasi selengkapnya, lihat [Menerapkan WLM otomatis](automatic-wlm.md). 

Dalam konfigurasi WLM manual, untuk menentukan jumlah memori yang tersedia yang dialokasikan ke kueri, Anda dapat mengatur parameter. `WLM Memory Percent to Use` Secara default, setiap antrian yang ditentukan pengguna dialokasikan porsi yang sama dari memori yang tersedia untuk kueri yang ditentukan pengguna. Misalnya, jika Anda memiliki empat antrian yang ditentukan pengguna, setiap antrian dialokasikan 25 persen dari memori yang tersedia. Antrian superuser memiliki memori yang dialokasikan sendiri dan tidak dapat dimodifikasi. Untuk mengubah alokasi, Anda menetapkan persentase integer memori untuk setiap antrian, hingga total 100 persen. Memori yang tidak teralokasi dikelola oleh Amazon Redshift dan dapat diberikan sementara ke antrian jika antrian meminta memori tambahan untuk diproses. 

Misalnya, jika Anda mengonfigurasi empat antrian, Anda dapat mengalokasikan memori sebagai berikut: 20 persen, 30 persen, 15 persen, 15 persen. Sisanya 20 persen tidak dialokasikan dan dikelola oleh layanan.

## Batas waktu WLM
<a name="wlm-timeout"></a>

WLM timeout (`max_execution_time`) tidak digunakan lagi. Sebagai gantinya, buat aturan pemantauan kueri (QMR) menggunakan `query_execution_time` untuk membatasi waktu eksekusi yang telah berlalu untuk kueri. Untuk informasi selengkapnya, lihat [Aturan pemantauan kueri WLM](cm-c-wlm-query-monitoring-rules.md). 

Untuk membatasi jumlah waktu kueri dalam antrian WLM tertentu diizinkan untuk digunakan, Anda dapat mengatur nilai batas waktu WLM untuk setiap antrian. Parameter batas waktu menentukan jumlah waktu, dalam milidetik, Amazon Redshift menunggu kueri berjalan sebelum membatalkan atau melompati kueri. Batas waktu didasarkan pada waktu eksekusi kueri dan tidak termasuk waktu yang dihabiskan menunggu dalam antrian. 

WLM mencoba untuk melompat [CREATE TABLE AS](r_CREATE_TABLE_AS.md) (CTAS) pernyataan dan query read-only, seperti pernyataan SELECT. Kueri yang tidak dapat dilewati dibatalkan. Untuk informasi selengkapnya, lihat [Antrian kueri WLM melompat](wlm-queue-hopping.md).

Batas waktu WLM tidak berlaku untuk kueri yang telah mencapai status kembali. Untuk melihat status kueri, lihat tabel [STV\$1WLM\$1QUERY\$1STATE](r_STV_WLM_QUERY_STATE.md) sistem. Pernyataan COPY dan operasi pemeliharaan, seperti ALTER, ANALISIS dan VACUUM, tidak tunduk pada batas waktu WLM.

Fungsi batas waktu WLM mirip dengan parameter konfigurasi. [statement\$1timeout](r_statement_timeout.md) Perbedaannya adalah, di mana parameter `statement_timeout` konfigurasi berlaku untuk seluruh cluster, batas waktu WLM khusus untuk antrian tunggal dalam konfigurasi WLM. 

Jika juga [statement\$1timeout](r_statement_timeout.md) ditentukan, yang lebih rendah dari statement\$1timeout dan WLM timeout (max\$1execution\$1time) digunakan. 

## Aturan pemantauan kueri
<a name="wlm-query-monitoring-rules"></a>

Aturan pemantauan kueri menentukan batas kinerja berbasis metrik untuk antrian WLM dan menentukan tindakan apa yang harus diambil ketika kueri melampaui batas-batas tersebut. Misalnya, untuk antrian yang didedikasikan untuk kueri berjalan pendek, Anda dapat membuat aturan yang membatalkan kueri yang berjalan selama lebih dari 60 detik. Untuk melacak kueri yang dirancang dengan buruk, Anda mungkin memiliki aturan lain yang mencatat kueri yang berisi loop bersarang. Untuk informasi selengkapnya, lihat [Aturan pemantauan kueri WLM](cm-c-wlm-query-monitoring-rules.md).

# Antrian kueri WLM melompat
<a name="wlm-queue-hopping"></a>

Dengan Amazon Redshift, Anda dapat mengelola konkurensi beban kerja dan alokasi sumber daya dengan mengaktifkan lompatan antrian kueri WLM (Manajemen Beban Kerja). Fitur ini memungkinkan kueri untuk sementara “melompat” dari antrian yang ditetapkan ke antrian prioritas yang lebih tinggi ketika sumber daya tersedia, meningkatkan kinerja kueri secara keseluruhan dan pemanfaatan sistem. Bagian berikut memberikan panduan terperinci tentang mengonfigurasi dan memanfaatkan lompatan antrian kueri WLM di Amazon Redshift.

Kueri dapat dilewati karena [batas waktu WLM](cm-c-defining-query-queues.md#wlm-timeout) atau tindakan hop [Query Monitoring Rule (QMR](cm-c-wlm-query-monitoring-rules.md#cm-c-wlm-defining-query-monitoring-rules)). Anda hanya dapat melompati kueri dalam konfigurasi WLM manual. 

Saat kueri di-hop, WLM mencoba merutekan kueri ke antrian pencocokan berikutnya berdasarkan aturan penetapan antrian [WLM](cm-c-wlm-queue-assignment-rules.md). Jika kueri tidak cocok dengan definisi antrian lainnya, kueri dibatalkan. Itu tidak ditetapkan ke antrian default. 

## Tindakan batas waktu WLM
<a name="wlm-queue-hopping-summary"></a>

Tabel berikut merangkum perilaku berbagai jenis kueri dengan batas waktu WLM.

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/redshift/latest/dg/wlm-queue-hopping.html)

## Antrian batas waktu WLM melompat
<a name="wlm-timeout-queue-hopping"></a>

WLM melompati jenis kueri berikut saat waktunya habis:
+ Kueri hanya-baca, seperti pernyataan SELECT, yang berada dalam status WLM. `running` Untuk menemukan status WLM dari kueri, lihat kolom STATE pada tabel [STV\$1WLM\$1QUERY\$1STATE](r_STV_WLM_QUERY_STATE.md) sistem. 
+ CREATE TABLE AS (CTAS) pernyataan. WLM queue hopping mendukung pernyataan CTAS yang ditentukan pengguna dan yang dihasilkan sistem. 
+ SELECT INTO pernyataan.

Kueri yang tidak tunduk pada batas waktu WLM terus berjalan di antrean asli hingga selesai. Jenis kueri berikut tidak tunduk pada batas waktu WLM:
+ pernyataan COPY
+ Operasi pemeliharaan, seperti ALTER, ANALISIS dan VACUUM
+ Kueri hanya-baca, seperti pernyataan SELECT, yang telah mencapai status WLM. `returning` Untuk menemukan status WLM dari kueri, lihat kolom STATE pada tabel [STV\$1WLM\$1QUERY\$1STATE](r_STV_WLM_QUERY_STATE.md) sistem. 

Kueri yang tidak memenuhi syarat untuk melewati batas waktu WLM dibatalkan saat waktu habis. Jenis kueri berikut ini tidak memenuhi syarat untuk melewati batas waktu WLM:
+ INSERT, UPDATE, dan DELETE pernyataan
+ Pernyataan BONGKAR
+ Fungsi yang ditentukan pengguna () UDFs

## Batas waktu WLM ditugaskan kembali dan memulai ulang kueri
<a name="wlm-timeout-reassigned-and-restarted-queries"></a>

Ketika kueri dilompat dan tidak ada antrian yang cocok ditemukan, kueri dibatalkan.

Saat kueri dilompat dan antrian yang cocok ditemukan, WLM mencoba menetapkan ulang kueri ke antrian baru. Jika kueri tidak dapat ditetapkan kembali, kueri akan dimulai ulang dalam antrian baru, seperti yang dijelaskan berikut.

Kueri dipindahkan hanya jika semua hal berikut benar:
+ Antrian yang cocok ditemukan.
+ Antrian baru memiliki slot gratis yang cukup untuk menjalankan kueri. Kueri mungkin memerlukan beberapa slot jika [wlm\$1query\$1slot\$1count](r_wlm_query_slot_count.md) parameter disetel ke nilai yang lebih besar dari 1.
+ Antrian baru memiliki setidaknya memori sebanyak yang tersedia seperti yang digunakan kueri saat ini. 

Jika kueri dipindahkan, kueri terus dijalankan dalam antrian baru. Hasil antara dipertahankan, sehingga ada efek minimal pada total waktu eksekusi. 

Jika kueri tidak dapat ditetapkan kembali, kueri dibatalkan dan dimulai ulang dalam antrian baru. Hasil menengah dihapus. Kueri menunggu dalam antrian, kemudian mulai berjalan ketika slot yang cukup tersedia.

## Tindakan hop QMR
<a name="qmr-hop-action-queue-hopping"></a>

Tabel berikut merangkum perilaku berbagai jenis kueri dengan tindakan hop QMR.

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/redshift/latest/dg/wlm-queue-hopping.html)

Untuk mengetahui apakah kueri yang di-hop oleh QMR telah ditetapkan kembali, dimulai ulang, atau dibatalkan, kueri tabel log sistem. [STL\$1WLM\$1RULE\$1ACTION](r_STL_WLM_RULE_ACTION.md)

## Tindakan hop QMR ditugaskan kembali dan memulai ulang kueri
<a name="qmr-hop-action-reassigned-and-restarted-queries"></a>

Ketika kueri dilompat dan tidak ada antrian yang cocok ditemukan, kueri dibatalkan.

Saat kueri dilompat dan antrian yang cocok ditemukan, WLM mencoba menetapkan ulang kueri ke antrian baru. Jika kueri tidak dapat ditetapkan ulang, kueri akan dimulai ulang dalam antrian baru atau melanjutkan eksekusi dalam antrian asli, seperti yang dijelaskan berikut.

Kueri dipindahkan hanya jika semua hal berikut benar:
+ Antrian yang cocok ditemukan.
+ Antrian baru memiliki slot gratis yang cukup untuk menjalankan kueri. Kueri mungkin memerlukan beberapa slot jika [wlm\$1query\$1slot\$1count](r_wlm_query_slot_count.md) parameter disetel ke nilai yang lebih besar dari 1.
+ Antrian baru memiliki setidaknya memori sebanyak yang tersedia seperti yang digunakan kueri saat ini. 

Jika kueri dipindahkan, kueri terus dijalankan dalam antrian baru. Hasil antara dipertahankan, sehingga ada efek minimal pada total waktu eksekusi. 

Jika kueri tidak dapat ditetapkan ulang, kueri akan dimulai ulang atau melanjutkan eksekusi dalam antrean asli. Jika kueri dimulai ulang, kueri dibatalkan dan dimulai ulang dalam antrian baru. Hasil menengah dihapus. Kueri menunggu dalam antrian, kemudian memulai eksekusi ketika slot yang cukup tersedia.

# Tutorial: Mengkonfigurasi antrian manajemen beban kerja manual (WLM)
<a name="tutorial-configuring-workload-management"></a>

Dengan Amazon Redshift, Anda dapat mengonfigurasi antrian manajemen beban kerja manual (WLM) untuk memprioritaskan dan mengalokasikan sumber daya untuk berbagai jenis kueri dan pengguna. Antrian WLM manual memungkinkan Anda untuk mengontrol memori dan pengaturan konkurensi untuk antrian tertentu, memastikan bahwa beban kerja kritis menerima sumber daya yang diperlukan sambil mencegah kueri prioritas rendah memonopoli sistem. Bagian berikut memandu Anda melalui proses pembuatan dan konfigurasi antrian WLM manual di Amazon Redshift untuk memenuhi persyaratan manajemen beban kerja Anda. 

## Ikhtisar
<a name="tutorial-wlm-overview"></a>

Kami merekomendasikan untuk mengonfigurasi manajemen beban kerja otomatis (WLM) di Amazon Redshift. Untuk informasi lebih lanjut tentang WLM otomatis, lihat. [Manajemen beban kerja](cm-c-implementing-workload-management.md) Namun, jika Anda memerlukan beberapa antrian WLM, tutorial ini memandu Anda melalui proses mengonfigurasi manajemen beban kerja manual (WLM) di Amazon Redshift. Dengan mengonfigurasi WLM manual, Anda dapat meningkatkan kinerja kueri dan alokasi sumber daya di cluster Anda.

Amazon Redshift merutekan kueri pengguna ke antrian untuk diproses. WLM mendefinisikan bagaimana kueri tersebut diarahkan ke antrian. Secara default, Amazon Redshift memiliki dua antrian yang tersedia untuk kueri: satu untuk pengguna super, dan satu untuk pengguna. Antrian superuser tidak dapat dikonfigurasi dan hanya dapat memproses satu kueri pada satu waktu. Anda harus memesan antrian ini hanya untuk tujuan pemecahan masalah. Antrian pengguna dapat memproses hingga lima kueri sekaligus, tetapi Anda dapat mengonfigurasinya dengan mengubah tingkat konkurensi antrian jika diperlukan. 

Ketika Anda memiliki beberapa pengguna yang menjalankan kueri terhadap database, Anda mungkin menemukan konfigurasi lain menjadi lebih efisien. Misalnya, jika beberapa pengguna menjalankan operasi intensif sumber daya, seperti VACUUM, ini mungkin berdampak negatif pada kueri yang kurang intensif, seperti laporan. Anda dapat mempertimbangkan untuk menambahkan antrian tambahan dan mengonfigurasinya untuk beban kerja yang berbeda. 

**Perkiraan waktu:** 75 menit

**Perkiraan biaya:** 50 sen

### Prasyarat
<a name="tutorial-wlm-prereq"></a>

Anda memerlukan klaster Amazon Redshift, database TICKIT sampel, dan alat klien Amazon Redshift RSQL. Jika Anda belum menyiapkan ini, buka [Panduan Memulai Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/gsg/new-user.html) dan [Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/rsql-query-tool.html) RSQL. 

### Bagian-bagian
<a name="tutorial-wlm-steps"></a>
+ [Bagian 1: Memahami perilaku pemrosesan antrian default](#tutorial-wlm-understanding-default-processing)
+ [Bagian 2: Memodifikasi konfigurasi antrian kueri WLM](#tutorial-wlm-modifying-wlm-configuration)
+ [Bagian 3: Merutekan kueri ke antrian berdasarkan grup pengguna dan grup kueri](#tutorial-wlm-routing-queries-to-queues)
+ [Bagian 4: Menggunakan wlm\$1query\$1slot\$1count untuk sementara mengganti level konkurensi dalam antrian](#tutorial-wlm-query-slot-count)
+ [Bagian 5: Membersihkan sumber daya Anda](#tutorial-wlm-cleaning-up-resources)

## Bagian 1: Memahami perilaku pemrosesan antrian default
<a name="tutorial-wlm-understanding-default-processing"></a>

Sebelum Anda mulai mengonfigurasi WLM manual, ada baiknya memahami perilaku default pemrosesan antrian di Amazon Redshift. Di bagian ini, Anda membuat dua tampilan database yang mengembalikan informasi dari beberapa tabel sistem. Kemudian Anda menjalankan beberapa kueri pengujian untuk melihat bagaimana kueri dirutekan secara default. Untuk informasi selengkapnya tentang tabel sistem, lihat[Tabel sistem dan tampilan referensi](cm_chap_system-tables.md). 

### Langkah 1: Buat tampilan WLM\$1QUEUE\$1STATE\$1VW
<a name="tutorial-wlm-create-queue-state-view"></a>

Pada langkah ini, Anda membuat tampilan yang disebut WLM\$1QUEUE\$1STATE\$1VW. Tampilan ini mengembalikan informasi dari tabel sistem berikut.
+ [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)

Anda menggunakan tampilan ini sepanjang tutorial untuk memantau apa yang terjadi pada antrian setelah Anda mengubah konfigurasi WLM. Tabel berikut menjelaskan data bahwa tampilan WLM\$1QUEUE\$1STATE\$1VW mengembalikan. 

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

#### Untuk membuat tampilan WLM\$1QUEUE\$1STATE\$1VW
<a name="how-to-wlm-create-queue-state-view"></a>

1. Buka [Amazon Redshift RSQL](https://docs.aws.amazon.com/redshift/latest/mgmt/rsql-query-tool.html) dan sambungkan ke database sampel TICKIT Anda. Jika Anda tidak memiliki database ini, lihat[Prasyarat](#tutorial-wlm-prereq).

1. Jalankan query berikut untuk membuat tampilan 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. Jalankan kueri berikut untuk melihat informasi yang berisi tampilan.

   ```
   select * from wlm_queue_state_vw;
   ```

   Berikut ini adalah contoh hasil.

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

### Langkah 2: Buat tampilan WLM\$1QUERY\$1STATE\$1VW
<a name="tutorial-wlm-create-query-state-view"></a>

Pada langkah ini, Anda membuat tampilan yang disebut WLM\$1QUERY\$1STATE\$1VW. Tampilan ini mengembalikan informasi dari tabel [STV\$1WLM\$1QUERY\$1STATE](r_STV_WLM_QUERY_STATE.md) sistem.

Anda menggunakan tampilan ini di seluruh tutorial untuk memantau kueri yang sedang berjalan. Tabel berikut menjelaskan data bahwa tampilan WLM\$1QUERY\$1STATE\$1VW mengembalikan.

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

#### Untuk membuat tampilan WLM\$1QUERY\$1STATE\$1VW
<a name="how-to-wlm-create-query-state-view"></a>

1. Di RSQL, jalankan query berikut untuk membuat tampilan 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. Jalankan kueri berikut untuk melihat informasi yang berisi tampilan.

   ```
   select * from wlm_query_state_vw;
   ```

   Berikut ini adalah contoh hasil.

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

### Langkah 3: Jalankan kueri uji
<a name="tutorial-wlm-run-test-queries"></a>

Pada langkah ini, Anda menjalankan kueri dari beberapa koneksi di RSQL dan meninjau tabel sistem untuk menentukan bagaimana kueri dirutekan untuk diproses. 

Untuk langkah ini, Anda memerlukan dua jendela RSQL yang terbuka: 
+ Di jendela RSQL 1, Anda menjalankan kueri yang memantau keadaan antrian dan kueri menggunakan tampilan yang sudah Anda buat dalam tutorial ini.
+ Di jendela RSQL 2, Anda menjalankan kueri yang berjalan lama untuk mengubah hasil yang Anda temukan di jendela RSQL 1.

#### Untuk menjalankan kueri pengujian
<a name="how-to-wlm-run-test-queries"></a>

1. Buka dua jendela RSQL. Jika Anda sudah memiliki satu jendela terbuka, Anda hanya perlu membuka jendela kedua. Anda dapat menggunakan akun pengguna yang sama untuk kedua koneksi ini.

1. Di jendela RSQL 1, jalankan query berikut.

   ```
   select * from wlm_query_state_vw;
   ```

   Berikut ini adalah contoh hasil.

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

   Kueri ini mengembalikan hasil referensial diri. Kueri yang sedang berjalan adalah pernyataan SELECT dari tampilan ini. Kueri pada tampilan ini selalu mengembalikan setidaknya satu hasil. Bandingkan hasil ini dengan hasil yang terjadi setelah memulai kueri yang berjalan lama di langkah berikutnya.

1. Di jendela RSQL 2, jalankan kueri dari database sampel TICKIT. Kueri ini harus berjalan sekitar satu menit sehingga Anda memiliki waktu untuk menjelajahi hasil tampilan WLM\$1QUEUE\$1STATE\$1VW dan tampilan WLM\$1QUERY\$1STATE\$1VW yang Anda buat sebelumnya. Dalam beberapa kasus, Anda mungkin menemukan bahwa kueri tidak berjalan cukup lama bagi Anda untuk menanyakan kedua tampilan. Dalam kasus ini, Anda dapat meningkatkan nilai filter `l.listid ` untuk membuatnya berjalan lebih lama.
**catatan**  
Untuk mengurangi waktu eksekusi kueri dan meningkatkan kinerja sistem, Amazon Redshift menyimpan hasil jenis kueri tertentu dalam memori pada node pemimpin. Ketika hasil caching diaktifkan, kueri berikutnya berjalan lebih cepat. Untuk mencegah kueri berjalan dengan cepat, nonaktifkan caching hasil untuk sesi saat ini.

   Untuk mematikan caching hasil untuk sesi saat ini, atur [enable\$1result\$1cache\$1for\$1session](r_enable_result_cache_for_session.md) parameter ke`off`, seperti yang ditunjukkan berikut.

   ```
   set enable_result_cache_for_session to off;
   ```

   Di jendela RSQL 2, jalankan query berikut.

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

1. Di jendela RSQL 1, kueri WLM\$1QUEUE\$1STATE\$1VW dan WLM\$1QUERY\$1STATE\$1VW dan bandingkan hasilnya dengan hasil sebelumnya.

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

   Berikut ini adalah contoh hasil.

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

Perhatikan perbedaan berikut antara kueri Anda sebelumnya dan hasil di langkah ini:
+ Ada dua baris sekarang di WLM\$1QUERY\$1STATE\$1VW. Salah satu hasilnya adalah kueri referensi mandiri untuk menjalankan operasi SELECT pada tampilan ini. Hasil kedua adalah kueri yang berjalan lama dari langkah sebelumnya.
+ Kolom eksekusi di WLM\$1QUEUE\$1STATE\$1VW telah meningkat dari 1 menjadi 2. Entri kolom ini berarti bahwa ada dua query yang berjalan dalam antrian.
+ Kolom yang dieksekusi bertambah setiap kali Anda menjalankan kueri dalam antrian.

Tampilan WLM\$1QUEUE\$1STATE\$1VW berguna untuk mendapatkan tampilan keseluruhan antrian dan berapa banyak kueri yang sedang diproses di setiap antrian. Tampilan WLM\$1QUERY\$1STATE\$1VW berguna untuk mendapatkan tampilan yang lebih rinci dari kueri individual yang sedang berjalan.

## Bagian 2: Memodifikasi konfigurasi antrian kueri WLM
<a name="tutorial-wlm-modifying-wlm-configuration"></a>

Sekarang setelah Anda memahami cara kerja antrian secara default, Anda dapat mempelajari cara mengonfigurasi antrian kueri menggunakan WLM manual. Di bagian ini, Anda membuat dan mengkonfigurasi grup parameter baru untuk cluster Anda. Anda membuat dua antrian pengguna tambahan dan mengonfigurasinya untuk menerima kueri berdasarkan grup pengguna kueri atau label grup kueri. Setiap kueri yang tidak dirutekan ke salah satu dari dua antrian ini dirutekan ke antrian default saat runtime.

**Untuk membuat konfigurasi WLM manual dalam grup parameter**

1. Masuk ke Konsol Manajemen AWS dan buka konsol Amazon Redshift di. [https://console.aws.amazon.com/redshiftv2/](https://console.aws.amazon.com/redshiftv2/)

1. Pada menu navigasi, pilih **Konfigurasi**, lalu pilih **Manajemen beban kerja untuk menampilkan halaman Manajemen** **beban kerja**. 

1. Pilih **Buat** untuk menampilkan jendela **Buat grup parameter**. 

1. Masukkan **WLMTutorial** untuk kedua **nama grup Parameter** dan **Deskripsi**, lalu pilih **Buat** untuk membuat grup parameter. 
**catatan**  
**Nama grup Parameter** dikonversi ke semua format huruf kecil saat dibuat. 

1. Pada halaman **Manajemen beban kerja**, pilih grup parameter **wlmtutorial** untuk menampilkan halaman detail dengan tab untuk **Parameter** dan Manajemen Beban **Kerja**. 

1. Konfirmasikan bahwa Anda berada di tab **Manajemen beban kerja**, lalu pilih **Ganti mode WLM** untuk menampilkan jendela Pengaturan **Konkurensi**. 

1. Pilih **Manual WLM**, lalu pilih **Simpan** untuk beralih ke WLM manual. 

1. Pilih **Edit antrian beban kerja**. 

1. Pilih **Tambahkan antrian** dua kali untuk menambahkan dua antrian. **Sekarang ada tiga antrian: **Antrian 1, Antrian** **2, dan antrian Default**.** 

1. Masukkan informasi untuk setiap antrian sebagai berikut: 
   + Untuk **Antrian 1**, masukkan **30** untuk **Memori (%)**, **2** untuk **Concurrency di main**, dan **test** untuk grup **Query**. Biarkan pengaturan lain dengan nilai defaultnya.
   + Untuk **Antrian 2**, masukkan **40** untuk **Memori (%)**, **3** untuk **Konkurensi di main**, dan **admin** untuk grup **Pengguna**. Biarkan pengaturan lain dengan nilai defaultnya.
   + Tetapkan **Concurrency pada nilai utama** untuk antrian default ke nilai yang lebih besar dari atau sama dengan 1. Jangan membuat perubahan lain pada **antrian Default**. WLM menetapkan memori yang tidak terisi ke antrian default. 

1. Pilih **Simpan** untuk menyimpan pengaturan Anda. 

Selanjutnya, kaitkan grup parameter yang memiliki konfigurasi WLM manual dengan cluster.

**Untuk mengaitkan grup parameter dengan konfigurasi WLM manual dengan cluster**

1. Masuk ke Konsol Manajemen AWS dan buka konsol Amazon Redshift di. [https://console.aws.amazon.com/redshiftv2/](https://console.aws.amazon.com/redshiftv2/)

1. Pada menu navigasi, pilih **Cluster**, lalu pilih **Cluster** untuk menampilkan daftar cluster Anda. 

1. Pilih cluster Anda, seperti `examplecluster` untuk menampilkan detail cluster. Kemudian pilih tab **Properties** untuk menampilkan properti cluster itu. 

1. Di bagian **Konfigurasi database**, pilih **Edit**, **Edit grup parameter** untuk menampilkan jendela grup parameter. 

1. Untuk **grup Parameter** pilih grup **wlmtutorial** parameter yang sebelumnya Anda buat. 

1. Pilih **Simpan perubahan** untuk mengaitkan grup parameter. 

   Cluster dimodifikasi dengan grup parameter yang diubah. Namun, Anda perlu me-reboot cluster agar perubahan juga diterapkan ke database.

1. Pilih klaster Anda, lalu pilih **Reboot** for **Actions**. 

**Setelah cluster di-boot ulang, statusnya kembali ke Available.** 

## Bagian 3: Merutekan kueri ke antrian berdasarkan grup pengguna dan grup kueri
<a name="tutorial-wlm-routing-queries-to-queues"></a>

Sekarang Anda memiliki cluster Anda terkait dengan grup parameter baru dan Anda telah mengkonfigurasi WLM. Selanjutnya, jalankan beberapa kueri untuk melihat bagaimana Amazon Redshift merutekan kueri ke antrian untuk diproses.

### Langkah 1: Lihat konfigurasi antrian kueri dalam database
<a name="tutorial-wlm-view-query-config"></a>

Pertama, verifikasi bahwa database memiliki konfigurasi WLM yang Anda harapkan.

#### Untuk melihat konfigurasi antrian kueri
<a name="how-to-wlm-view-query-config"></a>

1. Buka RSQL dan jalankan query berikut. Kueri menggunakan tampilan WLM\$1QUEUE\$1STATE\$1VW yang Anda buat. [Langkah 1: Buat tampilan WLM\$1QUEUE\$1STATE\$1VW](#tutorial-wlm-create-queue-state-view) Jika Anda sudah memiliki sesi yang terhubung ke database sebelum cluster reboot, Anda perlu menyambung kembali.

   ```
   select * from wlm_queue_state_vw;
   ```

   Berikut ini adalah contoh hasil.

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

   Bandingkan hasil ini dengan hasil yang Anda terima[Langkah 1: Buat tampilan WLM\$1QUEUE\$1STATE\$1VW](#tutorial-wlm-create-queue-state-view). Perhatikan bahwa sekarang ada dua antrian tambahan. Antrian 1 sekarang menjadi antrian untuk grup kueri pengujian, dan antrean 2 adalah antrian untuk grup pengguna admin.

   Antrian 3 sekarang menjadi antrian default. Antrian terakhir dalam daftar selalu antrian default. Itulah antrian ke mana kueri dirutekan secara default jika tidak ada grup pengguna atau grup kueri yang ditentukan dalam kueri.

1. Jalankan kueri berikut untuk mengonfirmasi bahwa kueri Anda sekarang berjalan dalam antrian 3.

   ```
   select * from wlm_query_state_vw;
   ```

   Berikut ini adalah contoh hasil.

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

### Langkah 2: Jalankan kueri menggunakan antrian grup kueri
<a name="tutorial-wlm-query-group"></a>

#### Untuk menjalankan kueri menggunakan antrian grup kueri
<a name="how-to-wlm-query-group"></a>

1. Jalankan query berikut untuk merutekan ke grup `test` query.

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

1. Dari jendela RSQL lainnya, jalankan query berikut.

   ```
   select * from wlm_query_state_vw;
   ```

   Berikut ini adalah contoh hasil.

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

   Kueri dirutekan ke grup kueri uji, yang sekarang merupakan antrian 1.

1. Pilih semua dari tampilan status antrian.

   ```
   select * from wlm_queue_state_vw;
   ```

   Anda melihat hasil yang mirip dengan berikut ini.

   ```
   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. Sekarang, atur ulang grup kueri dan jalankan kueri panjang lagi:

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

1. Jalankan kueri terhadap tampilan untuk melihat hasilnya.

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

   Berikut ini adalah contoh hasil.

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

   Hasilnya seharusnya kueri sekarang berjalan dalam antrian 3 lagi.

### Langkah 3: Buat pengguna database dan grup
<a name="tutorial-wlm-create-db-user-and-group"></a>

Sebelum Anda dapat menjalankan kueri apa pun dalam antrian ini, Anda perlu membuat grup pengguna dalam database dan menambahkan pengguna ke grup. Kemudian Anda masuk dengan RSQL menggunakan kredensi pengguna baru dan menjalankan kueri. Anda perlu menjalankan kueri sebagai superuser, seperti pengguna admin, untuk membuat pengguna database.

#### Untuk membuat pengguna database baru dan grup pengguna
<a name="how-to-wlm-create-db-user-and-group"></a>

1. Dalam database, buat pengguna database baru bernama `adminwlm` dengan menjalankan perintah berikut di jendela RSQL.

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

1. Kemudian, jalankan perintah berikut untuk membuat grup pengguna baru dan menambahkan `adminwlm` pengguna baru Anda ke dalamnya.

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

### Langkah 4: Jalankan kueri menggunakan antrian grup pengguna
<a name="tutorial-wlm-user-group-query"></a>

Selanjutnya Anda menjalankan kueri dan mengarahkannya ke antrian grup pengguna. Anda melakukan ini ketika Anda ingin merutekan kueri Anda ke antrian yang dikonfigurasi untuk menangani jenis kueri yang ingin Anda jalankan.

#### Untuk menjalankan kueri menggunakan antrean grup pengguna
<a name="how-to-wlm-user-group-query"></a>

1. Di jendela RSQL 2, jalankan kueri berikut untuk beralih ke `adminwlm` akun dan menjalankan kueri sebagai pengguna tersebut.

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

1. Di jendela RSQL 1, jalankan kueri berikut untuk melihat antrian kueri yang dialihkan ke kueri.

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

   Berikut ini adalah contoh hasil.

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

   Antrian tempat kueri ini dijalankan adalah antrian 2, antrian `admin` pengguna. Setiap kali Anda menjalankan kueri yang masuk sebagai pengguna ini, mereka berjalan dalam antrian 2 kecuali Anda menentukan grup kueri yang berbeda untuk digunakan. Antrian yang dipilih tergantung pada aturan penetapan antrian. Untuk informasi selengkapnya, lihat [Aturan penetapan antrian WLM](cm-c-wlm-queue-assignment-rules.md). 

1. Sekarang jalankan query berikut dari jendela RSQL 2.

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

1. Di jendela RSQL 1, jalankan kueri berikut untuk melihat antrian kueri yang dialihkan ke kueri.

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

   Berikut ini adalah contoh hasil.

   ```
   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. Setelah selesai, setel ulang grup kueri.

   ```
   reset query_group;
   ```

## Bagian 4: Menggunakan wlm\$1query\$1slot\$1count untuk sementara mengganti level konkurensi dalam antrian
<a name="tutorial-wlm-query-slot-count"></a>

Terkadang, pengguna mungkin sementara membutuhkan lebih banyak sumber daya untuk kueri tertentu. Jika demikian, mereka dapat menggunakan pengaturan konfigurasi wlm\$1query\$1slot\$1count untuk mengganti sementara cara slot dialokasikan dalam antrian kueri. *Slot* adalah unit memori dan CPU yang digunakan untuk memproses kueri. Anda dapat mengganti jumlah slot ketika Anda memiliki kueri sesekali yang mengambil banyak sumber daya di cluster, seperti ketika Anda melakukan operasi VACUUM dalam database. 

Anda mungkin menemukan bahwa pengguna sering perlu mengatur wlm\$1query\$1slot\$1count untuk jenis kueri tertentu. Jika demikian, pertimbangkan untuk menyesuaikan konfigurasi WLM dan memberi pengguna antrian yang lebih sesuai dengan kebutuhan kueri mereka. Untuk informasi lebih lanjut tentang mengesampingkan sementara level konkurensi dengan menggunakan jumlah slot, lihat. [wlm\$1query\$1slot\$1count](r_wlm_query_slot_count.md)

### Langkah 1: Ganti level konkurensi menggunakan wlm\$1query\$1slot\$1count
<a name="tutorial-wlm-override-slot-count"></a>

Untuk keperluan tutorial ini, kami menjalankan query SELECT yang sudah berjalan lama. Kami menjalankannya sebagai `adminwlm` pengguna menggunakan wlm\$1query\$1slot\$1count untuk meningkatkan jumlah slot yang tersedia untuk kueri.

#### Untuk mengganti level konkurensi menggunakan wlm\$1query\$1slot\$1count
<a name="how-to-wlm-override-slot-count"></a>

1. Tingkatkan batas kueri untuk memastikan bahwa Anda memiliki cukup waktu untuk menanyakan tampilan WLM\$1QUERY\$1STATE\$1VW dan melihat hasilnya. 

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

1. Sekarang, kueri WLM\$1QUERY\$1STATE\$1VW dengan pengguna admin untuk melihat bagaimana kueri berjalan.

   ```
   select * from wlm_query_state_vw;
   ```

   Berikut ini adalah contoh hasil.

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

   Perhatikan bahwa jumlah slot untuk kueri adalah 3. Hitungan ini berarti bahwa kueri menggunakan ketiga slot untuk memproses kueri, mengalokasikan semua sumber daya dalam antrian ke kueri itu.

1. Sekarang, jalankan query berikut.

   ```
   select * from WLM_QUEUE_STATE_VW;
   ```

   Berikut ini adalah contoh hasil.

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

   Pengaturan konfigurasi wlm\$1query\$1slot\$1count hanya berlaku untuk sesi saat ini. Jika sesi itu kedaluwarsa, atau pengguna lain menjalankan kueri, konfigurasi WLM digunakan.

1. Setel ulang jumlah slot dan jalankan kembali tes.

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

   Berikut ini adalah contoh hasil.

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

### Langkah 2: Jalankan kueri dari sesi yang berbeda
<a name="tutorial-wlm-run-queries-from-different-sessions"></a>

Selanjutnya, jalankan kueri dari sesi yang berbeda.

#### Untuk menjalankan kueri dari sesi yang berbeda
<a name="how-to-wlm-run-queries-from-different-sessions"></a>

1. Di jendela RSQL 1 dan 2, jalankan berikut ini untuk menggunakan kelompok kueri uji.

   ```
   set query_group to test;
   ```

1. Di jendela RSQL 1, jalankan kueri yang berjalan lama berikut.

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

1. Karena kueri yang berjalan lama masih berjalan di jendela RSQL 1, jalankan yang berikut ini. Perintah ini meningkatkan jumlah slot untuk menggunakan semua slot untuk antrian dan kemudian mulai menjalankan kueri yang berjalan lama.

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

1. Buka jendela RSQL ketiga dan kueri tampilan untuk melihat hasilnya.

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

   Berikut ini adalah contoh hasil.

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

   Perhatikan bahwa kueri pertama menggunakan salah satu slot yang dialokasikan untuk antrian 1 untuk menjalankan kueri. Selain itu, perhatikan bahwa ada satu kueri yang menunggu dalam antrian (di mana `queued` `1` dan di `state` mana`QueuedWaiting`). Setelah kueri pertama selesai, yang kedua mulai berjalan. Eksekusi ini terjadi karena kedua kueri dirutekan ke grup `test` kueri, dan kueri kedua harus menunggu slot yang cukup untuk mulai diproses.

## Bagian 5: Membersihkan sumber daya Anda
<a name="tutorial-wlm-cleaning-up-resources"></a>

Cluster Anda terus bertambah biaya selama itu berjalan. Setelah Anda menyelesaikan tutorial ini, kembalikan lingkungan Anda ke keadaan sebelumnya dengan mengikuti langkah-langkah di [Temukan Sumber Daya Tambahan dan Atur Ulang Lingkungan Anda di Panduan](https://docs.aws.amazon.com/redshift/latest/gsg/rs-gsg-clean-up-tasks.html) *Memulai Pergeseran Merah Amazon*.

Untuk informasi lebih lanjut tentang WLM, lihat. [Manajemen beban kerja](cm-c-implementing-workload-management.md)