Indeks MongoDB adalah kunci untuk mendapatkan kinerja yang konsisten pada koleksi MongoDB yang besar. Tapi MongoDB memperingatkan itu. Jadi berapa banyak yang "terlalu banyak"?
Kesimpulan yang disajikan dalam artikel ini adalah hasil percobaan N=1. Mereka tidak dijamin benar di semua mesin dan lingkungan. Selain itu, saya tidak berbicara untuk MongoDB, kesimpulan ini tidak mewakili pedoman resmi MongoDB
Apa itu Indeks?
Misalkan Anda menjalankan kueri berikut menggunakan Mongoose
const users = await User.find[{ lastName: 'Smith' }];Tanpa indeks apa pun, MongoDB harus menelusuri setiap dokumen dalam koleksi users dan memeriksa apakah ia memiliki properti lastName yang sama dengan string 'Smith'
Jika Anda memiliki 10 pengguna, memindai seluruh koleksi tidak menjadi masalah. Jika Anda memiliki 10 juta pengguna, memindai seluruh koleksi mungkin menjadi masalah jika Anda harus sering menjalankan kueri ini
Indeks pada lastName memberi tahu MongoDB untuk menyimpan daftar dokumen dengan properti lastName, mirip dengan Peta JavaScript atau peta hash dalam bahasa lain. Saat Anda melakukan kueri dengan lastName, alih-alih memindai seluruh koleksi, MongoDB cukup melihat indeks
Misalnya, Anda memiliki 120 ribu dokumen dengan nama depan dan nama belakang yang sama, lalu 1 dokumen dengan nama belakang berbeda. Tanpa indeks, ada penundaan yang nyata dalam menemukan dokumen dengan nama belakang yang berbeda
Tetapi dengan indeks, kueri yang sama dijalankan hampir secara instan
Kapan Anda Membutuhkan Indeks?
Dalam pengalaman saya, indeks tidak berguna untuk koleksi kecil. Saya berpendapat bahwa jika koleksi memiliki kurang dari 10 ribu dokumen, indeks tidak memberi Anda banyak manfaat. Itu karena pemindaian koleksi hampir seketika pada 10k koleksi dokumen, dengan asumsi database tidak dalam beban tinggi
Dengan indeks, kueri secara signifikan lebih cepat dalam persentase, tetapi tidak secara absolut. Jika titik akhir API hanya mengeksekusi kueri lastName ini, saya tidak akan repot mengindeks lastName untuk mempercepat titik akhir API kecuali jumlah pengguna bertambah mendekati 100 ribu
Aturan umum saya saat membangun API. jika koleksi memiliki kurang dari 10k dokumen, jangan repot-repot mengindeks. Jika koleksi memiliki lebih dari 100 ribu dokumen, pastikan kueri umum menggunakan indeks
Contoh Terlalu Banyak Indeks
Indeks memang bagus, tetapi terlalu banyak indeks dapat menyebabkan penulisan lebih lambat. Itu karena MongoDB juga perlu memperbarui indeks saat Anda memperbarui dokumen
Misalnya, Anda memiliki 1000 properti yang diindeks, dan Anda mengirim updateOne[] yang memperbarui semua 1000 properti yang diindeks sekaligus. Pembaruan itu bisa 30% lebih cepat tanpa indeks
Bagaimana kinerja berubah saat Anda men-tweak jumlah indeks users0?
Hal yang perlu diperhatikan di sini adalah jika Anda memiliki 100 indeks atau kurang, penalti kinerja untuk penulisan sangat minim. Jika koleksi Anda memiliki 5 indeks, kinerja tulis Anda tidak akan terlalu terpengaruh jika Anda menambahkan indeks ke-6. Performa tulis hanya mulai menurun secara nyata ketika Anda harus memperbarui ratusan indeks saat menulis
Perhatikan bahwa contoh ini mengasumsikan bahwa indeks Anda sesuai dengan RAM. Jika indeks Anda tidak sesuai dengan RAM, Anda mungkin dikenakan penalti kinerja yang lebih tinggi untuk indeks tambahan
Bergerak
MongoDB memiliki kinerja yang luar biasa, dan saya tidak akan membuat aplikasi di atas yang lain. Dengan menerapkan beberapa pola desain skema, berhati-hati dengan operasi lambat yang diketahui, dan menyiapkan indeks yang tepat, Anda dapat dengan mudah menangani koleksi yang berisi puluhan juta dokumen. Di Booster, setiap sen dari pendapatan tahunan $50 juta+ kami disalurkan melalui satu klaster MongoDB yang tidak di-shard yang berjalan di VM cloud sederhana - semuanya berkat strategi pengindeksan yang baik
Ingin menjadi ahli MongoDB tim Anda? . Itu berarti Anda dapat mempelajari apa yang perlu Anda ketahui untuk membuat aplikasi full-stack siap produksi dengan Node. js dan MongoDB dalam beberapa hari. Dapatkan salinan Anda
Perbedaan antara aplikasi Anda yang cepat, responsif, dan penskalaan dengan benar seringkali bergantung pada cara Anda menggunakan indeks di database. MongoDB tidak berbeda, kinerjanya [dan keseluruhan kinerja aplikasi Anda] sangat bergantung pada mendapatkan jumlah indeks yang tepat pada hal yang benar. Satu atau dua indeks sederhana dapat mempercepat pengambilan data dari MongoDB jutaan kali lipat untuk tabel jutaan catatan. Tetapi pada saat yang sama memiliki terlalu banyak indeks pada koleksi besar dapat menyebabkan penurunan besar-besaran dalam kinerja secara keseluruhan. Anda perlu mendapatkan indeks Anda dengan benar
Untuk blog ini, kita akan berbicara tentang memiliki terlalu banyak indeks dan membantu Anda menemukan indeks duplikat dan tidak terpakai. Jika Anda tertarik untuk mengetahui apakah Anda memerlukan indeks tambahan atau jika kueri Anda menggunakan indeks, saya sarankan membaca artikel Percona sebelumnya tentang penyetelan kueri [Bagian 1 & Bagian 2 dari seri itu]
Jadi, indeks sangat bagus untuk mendapatkan kueri yang lebih cepat. Berapa banyak indeks yang harus saya buat pada koleksi?
Masalah Kinerja Umum
Setelah menganalisis banyak lingkungan MongoDB yang berbeda, saya dapat memberikan daftar berikut yang meringkas kesalahan umum yang saya lihat
- Tidak membuat indeks sama sekali, selain _id kunci utama yang dibuat oleh desain
- Saya tidak bercanda – saya telah melihat database tanpa indeks buatan pengguna, yang membuat pemilik terkejut karena server kelebihan beban dan/atau kueri menjadi sangat lambat
- Mengindeks koleksi secara berlebihan
- Beberapa pengembang biasanya membuat banyak indeks tanpa alasan tertentu atau hanya untuk menguji kueri. Kemudian mereka lupa untuk menjatuhkannya
- Dalam beberapa kasus, ukuran semua indeks lebih besar dari data. Ini tidak bagus;
Saya tidak mempertimbangkan kasus pertama. Saya akan membahas yang kedua
Berapa Banyak Indeks yang Anda Butuhkan dalam Koleksi
Itu tergantung - itu jawaban yang tepat. Pada dasarnya, itu tergantung pada beban kerja aplikasi Anda. Anda harus mempertimbangkan aturan berikut saat mengindeks koleksi
- Buat indeks sebanyak mungkin untuk aplikasi Anda
- Jangan membuat banyak indeks
Apa? . Nah, kita bisa meringkas hanya dalam satu aturan sederhana
- Anda perlu membuat semua indeks yang benar-benar dibutuhkan aplikasi Anda untuk menyelesaikan kueri yang paling sering. Tidak satu lagi, tidak kurang satu pun
Itu dia
Pro dan Kontra Pengindeksan
Keuntungan besar dari indeks adalah memungkinkan kueri, pembaruan, dan penghapusan berjalan secepat mungkin jika digunakan. [Setiap pembaruan atau penghapusan juga perlu melakukan langkah pencarian terlebih dahulu]. Lebih banyak indeks dalam koleksi dapat menguntungkan beberapa kueri
Sayangnya, indeks membutuhkan kerja ekstra untuk MongoDB. Setiap kali Anda menjalankan penulisan, semua indeks harus diperbarui. Nilai-nilai baru disimpan atau dijatuhkan ke dalam struktur B-Tree, beberapa pemisahan atau penggabungan diperlukan, dan ini membutuhkan waktu
Masalah utama adalah bahwa "lebih banyak indeks yang Anda miliki dalam koleksi, semakin lambat semua penulisan"
Koleksi yang sangat besar dengan hanya 10 atau 15 indeks dapat menyebabkan penurunan performa yang signifikan untuk penulisan. Juga, ingat bahwa indeks harus disalin ke dalam cache WiredTiger. Lebih banyak indeks juga menyiratkan lebih banyak tekanan untuk cache memori. Tekanan kemudian dapat menyebabkan lebih banyak pengusiran dan kelambatan cache
Contoh bagusnya adalah ketika saya bekerja dengan pelanggan beberapa minggu yang lalu kami menemukan 12 indeks tambahan pada koleksi yang tidak mereka perlukan. Koleksinya sekitar 80GB; . Mereka memiliki beban tulis yang relevan berdasarkan beberapa penyisipan dan pembaruan yang sering dilakukan setiap saat. Membersihkan indeks ini meningkatkan waktu eksekusi kueri tulis rata-rata sebesar 25-30 persen. Peningkatan yang diamati untuk kasus nyata ini tidak akan menjadi jumlah kuantitatif yang sama dalam kasus lain, tetapi yang pasti semakin sedikit indeks yang Anda miliki, semakin cepat semua penulisan akan dilakukan.
Kita perlu menemukan semacam keseimbangan. membuat lebih banyak indeks, tetapi tidak sebanyak itu
Cara Mengurangi Over-Indexing
Sangat mudah untuk mengatakannya. jatuhkan semua indeks yang tidak Anda butuhkan
Ada dua hal yang dapat Anda lakukan untuk mengidentifikasi indeks yang akan dijatuhkan
- Periksa duplikatnya
- Periksa indeks yang tidak digunakan
Untuk menjatuhkan indeks, Anda perlu menjalankan sesuatu seperti berikut ini
Kerang1
db. koleksi saya. dropIndex["nama_indeks"]
Temukan Indeks Duplikat
Indeks duplikat bisa berupa indeks dengan definisi yang persis sama dengan indeks lain yang sudah ada dalam koleksi. Untungnya, MongoDB dapat memeriksa ini dan tidak diizinkan membuat indeks semacam itu
Mari kita lakukan pengujian menggunakan koleksi sederhana tanpa indeks
Kerang1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
rs_test. UTAMA> db. tes. temukan[]
{ "_id" . ObjectId["60521309d7268c122c7cd630"], "name" : "corrado", "usia" . 49 }
{ "_id" . ObjectId["60521313d7268c122c7cd631"], "name" : "simone", "usia" . 12 }
{ "_id" . ObjectId["6052131cd7268c122c7cd632"], "name" : "gabriele", "umur" . 19 }
{ "_id" . ObjectId["60521323d7268c122c7cd633"], "name" : "luca", "umur" . 14 }
{ "_id" . ObjectId["60521328d7268c122c7cd634"], "name" : "lucia", "umur" . 49 }
# buat indeks pada bidang nama
rs_test. UTAMA> db. tes. createIndex[ { nama. 1 } ]
{
"dibuatKoleksiOtomatis" . salah,
"numIndexesBefore" . 1,
"numIndexesAfter" . 2,
"commitQuorum" . "memilih Anggota",
"oke" . 1,
"$clusterTime" . {
"clusterTime" . Stempel waktu[1615991942, 5],
"tanda tangan" . {
"hash" . BinData[0,"],
"keyId" . NumberLong["6890926313742270469"]
}
},
"Waktu Operasi" . Stempel waktu[1615991942, 5]
}
# periksa indeks tersedia
rs_test. UTAMA> db. tes. getIndex[]
[
{
"v" . 2,
"kunci" . {
"_id" . 1
},
"nama" . "_id_"
},
{
"v" . 2,
"kunci" . {
"nama" . 1
},
"nama" . "nama_1"
}
]
# coba buat lagi indeks yang sama
rs_test. UTAMA> db. tes. createIndex[ { nama. 1 } ]
{
"numIndexesBefore" . 2,
"numIndexesAfter" . 2,
"catatan" . "semua indeks sudah ada",
"oke" . 1,
"$clusterTime" . {
"clusterTime" . Stempel waktu[1615991942, 5],
"tanda tangan" . {
"hash" . BinData[0,"],
"keyId" . NumberLong["6890926313742270469"]
}
},
"Waktu Operasi" . Stempel waktu[1615991942, 5]
}
# hebat, MongoDB dapat mendeteksi indeks yang sudah ada
# mari kita coba untuk melihat apakah Anda dapat membuat indeks yang sama dengan nama yang berbeda
rs_test. UTAMA> db. tes. createIndex[ { nama. 1 }, { nama . : "this_is_a_different_index_name" } ]
{
"Waktu Operasi" . Stempel waktu[1615991981, 1],
"oke" . 0,
"errmsg" . "Indeks dengan nama. this_is_a_different_index_name sudah ada dengan nama yang berbeda",
"kode" . 85,
"codeName" . "IndexOptionsConflict",
"$clusterTime" . {
"clusterTime" . Stempel waktu[1615991981, 1],
"tanda tangan" . {
"hash" . BinData[0,"],
"keyId" . NumberLong["6890926313742270469"]
}
}
}
# bahkan dalam hal ini MongoDB tidak mengizinkan pembuatan indeks
MongoDB kemudian cukup pintar untuk menghindari pembuatan indeks duplikat. Tapi bagaimana dengan pembuatan indeks yang merupakan awalan kiri dari indeks yang ada?
Kerang1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
# mari kita jatuhkan indeks sebelumnya yang telah kita buat
rs_test. UTAMA> db. tes. dropIndex[ "nama_1" ]
{
"nIndexesWas" . 2,
"oke" . 1,
"$clusterTime" . {
"clusterTime" . Stempel waktu[1615993029, 1],
"tanda tangan" . {
"hash" . BinData[0,"],
"keyId" . NumberLong["6890926313742270469"]
}
},
"Waktu Operasi" . Stempel waktu[1615993029, 1]
}
# periksa indeks. Hanya _id yang tersedia
rs_test. UTAMA> db. tes. getIndex[]
[ { "v" . 2, "kunci" . { "_id" . 1 }, "nama" : "_id_" } ]
# buat indeks majemuk
rs_test. UTAMA> db. tes. createIndex[ { nama. 1, umur. 1 } ]
{
"dibuatKoleksiOtomatis" . salah,
"numIndexesBefore" . 1,
"numIndexesAfter" . 2,
"commitQuorum" . "memilih Anggota",
"oke" . 1,
"$clusterTime" . {
"clusterTime" . Stempel waktu[1615993054, 5],
"tanda tangan" . {
"hash" . BinData[0,"],
"keyId" . NumberLong["6890926313742270469"]
}
},
"Waktu Operasi" . Stempel waktu[1615993054, 5]
}
# buat indeks lain yang merupakan awalan paling kiri dari indeks majemuk
rs_test. UTAMA> db. tes. createIndex[ { nama. 1 } ]
{
"dibuatKoleksiOtomatis" . salah,
"numIndexesBefore" . 2,
"numIndexesAfter" . 3,
"commitQuorum" . "memilih Anggota",
"oke" . 1,
"$clusterTime" . {
"clusterTime" . Stempel waktu[1615993060, 5],
"tanda tangan" . {
"hash" . BinData[0,"],
"keyId" . NumberLong["6890926313742270469"]
}
},
"Waktu Operasi" . Stempel waktu[1615993060, 5]
}
# periksa indeks
rs_test. UTAMA> db. tes. getIndex[]
[
{
"v" . 2,
"kunci" . {
"_id" . 1
},
"nama" . "_id_"
},
{
"v" . 2,
"kunci" . {
"nama" . 1,
"usia" . 1
},
"nama" . "nama_1_umur_1"
},
{
"v" . 2,
"kunci" . {
"nama" . 1
},
"nama" . "nama_1"
}
]
Kami juga menganggap indeks awalan paling kiri sebagai duplikat
Untuk memanfaatkan indeks majemuk MongoDB tidak perlu menggunakan semua bidang indeks itu, awalan paling kiri sudah cukup. Misalnya indeks pada [A,B,C] dapat digunakan untuk memenuhi kombinasi [A], [A,B], [A,B,C] tetapi tidak [B] atau [B,C]. Akibatnya, jika saya memiliki dua indeks berbeda, satu di [A, B, C] dan satu lagi di [A, B], yang kedua adalah duplikat karena yang pertama dapat digunakan dengan cara yang sama untuk menyelesaikan kueri dengan
Kemudian, temukan semua indeks duplikat dan jatuhkan karena tidak berguna. Berhati-hatilah dan periksa apakah aplikasi Anda tidak menggunakan petunjuk [] pada indeks yang akan Anda jatuhkan
Untuk menghindari pemeriksaan manual semua koleksi untuk menemukan duplikatnya, saya berikan di sini kode javascript untuk itu
Kerang1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
var ldb = db. adminCommand[ { daftarDatabase. 1 } ];
untuk [ i = 0; i