Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Akses database menggunakan Kontrol Akses Berbasis Peran
Anda dapat membatasi akses ke tindakan yang dapat dilakukan pengguna pada basis data menggunakan *kontrol akses berbasis peran* (RBAC) di Amazon DocumentDB (dengan kompatibilitas MongoDB). RBAC bekerja dengan memberikan satu atau lebih peran kepada pengguna. Peran ini menentukan operasi yang dapat dilakukan pengguna pada sumber daya database. Amazon DocumentDB saat ini mendukung kedua peran bawaan yang dicakup pada tingkat database, `read` seperti,,, `readWrite` `readAnyDatabase``clusterAdmin`, dan peran yang ditentukan pengguna yang dapat dicakup untuk tindakan tertentu dan sumber daya terperinci seperti koleksi berdasarkan kebutuhan Anda.
Kasus penggunaan umum untuk RBAC termasuk menerapkan hak istimewa paling sedikit dengan membuat pengguna dengan akses hanya-baca ke database atau koleksi dalam klaster, dan desain aplikasi multi-penyewa yang memungkinkan satu pengguna mengakses database atau koleksi tertentu dalam sebuah cluster.
**catatan**
Semua pengguna baru yang dibuat sebelum **26 Maret 2020** telah diberikan peran `dbAdminAnyDatabase`, `readWriteAnyDatabase`, dan `clusterAdmin`. Disarankan bahwa Anda mengevaluasi kembali semua pengguna yang ada dan mengubah peran seperlunya untuk menerapkan hak istimewa terendah untuk klaster Anda.
**Topics**
+ [Konsep RBAC](#role_based_access_control-concepts)
+ [Memulai dengan peran bawaan RBAC](#role_based_access_control-getting_started)
+ [Memulai dengan peran yang ditentukan pengguna RBAC](#w2aac29c29c15)
+ [Menghubungkan ke Amazon DocumentDB sebagai Pengguna](#role_based_access_control-connecting_as_user)
+ [Perintah umum](#role_based_access_control-common_commands)
+ [Perbedaan fungsional](#role_based_access_control-functional_differences)
+ [Batas](#role_based_access_control-limits)
+ [Akses database menggunakan Kontrol Akses Berbasis Peran](#role_based_access_control-built_in_roles)
## Konsep RBAC
Berikut ini adalah istilah dan konsep penting yang berkaitan dengan kontrol akses berbasis peran. Untuk informasi lebih lanjut tentang pengguna Amazon DocumentDB, lihat [Mengelola pengguna Amazon DocumentDB](security.managing-users.md).
+ **Pengguna** — Entitas individu yang dapat mengautentikasi ke basis data dan melakukan operasi.
+ **Kata Sandi** — Rahasia yang digunakan untuk mengautentikasi pengguna.
+ **Peran** — Mengotorisasi pengguna untuk melakukan tindakan pada satu atau lebih basis data.
+ **Basis Data Admin** — Basis data di mana pengguna disimpan dan diberi otorisasi terhadapnya.
+ **Basis Data (`db`)** — Namespace di dalam klaster yang berisi koleksi untuk menyimpan dokumen.
Perintah berikut ini membuat pengguna yang bernama `sample-user`.
```
db.createUser({user: "sample-user", pwd: "abc123", roles: [{role: "read", db: "sample-database"}]})
```
Dalam contoh ini:
+ `user: "sample-user"` — Mengindikasikan nama pengguna.
+ `pwd: "abc123"` — Mengindikasikan kata sandi pengguna.
+ `role: "read", "db: "sample-database"` — Mengindikasikan bahwa pengguna `sample-user` akan memiliki izin baca di `sample-database`.
![\[Contoh kode yang menunjukkan perintah createUser mengindikasikan nama pengguna, kata sandi, dan izin.\]](http://docs.aws.amazon.com/id_id/documentdb/latest/developerguide/images/rbac-createuser-command.png)
Contoh berikut ini menunjukkan keluaram setelah Anda mendapatkan `sample-user` pengguna dengan `db.getUser(sample-user)`. Dalam contoh ini, `sample-user` pengguna berada di basis data `admin` tetapi memiliki peran baca untuk `sample-database` basis data.
![\[Contoh keluaran kode yang menunjukkan hasil perintah createUser yang mendefinisikan ID pengguna baru, database admin yang ditetapkan pengguna baru, dan izin peran yang diterapkan pada pengguna.\]](http://docs.aws.amazon.com/id_id/documentdb/latest/developerguide/images/rbac-createuser-output-json.png)
Saat membuat pengguna, jika Anda menghilangkan bidang `db` saat menentukan peran, Amazon DocumentDB akan secara implisit mengaitkan peran tersebut ke basis data tempat koneksi diterbitkan. Sebagai contoh, jika koneksi Anda dikeluarkan terhadap `sample-database` basis data dan Anda menjalankan perintah berikut ini, `sample-user` pengguna akan dibuat dalam basis data `admin` dan akan memiliki izin `readWrite` ke `sample-database` basis data.
```
db.createUser({user: "sample-user", pwd: "abc123", roles: ["readWrite"]})
```
Keluaran dari operasi ini terlihat seperti berikut ini.
```
{
"user":"sample-user",
"roles":[
{
"db":"sample-database",
"role":"readWrite"
}
]
}
```
Membuat pengguna dengan peran yang tercakup di semua basis data (sebagai contoh, `readAnyDatabase`) mengharuskan Anda untuk berada dalam konteks basis data `admin` saat membuat pengguna, maupun Anda secara eksplisit menyatakan basis data untuk peran saat membuat pengguna. Untuk mengeluarkan perintah terhadap basis data `admin`, Anda dapat menggunakan `use admin` perintah. Untuk informasi selengkapnya, lihat [Perintah umum](#role_based_access_control-common_commands).
## Memulai dengan peran bawaan RBAC
Untuk membantu Anda memulai kontrol akses berbasis peran, bagian ini memandu Anda melalui skenario contoh untuk menerapkan hak istimewa terendah dengan membuat peran untuk tiga pengguna dengan fungsi pekerjaan yang berbeda.
+ `user1` adalah manajer baru yang perlu dapat melihat dan mengakses semua basis data dalam klaster.
+ `user2` adalah karyawan baru yang memerlukan akses hanya ke satu basis data, `sample-database-1`, di klaster yang sama.
+ `user3` adalah karyawan yang sudah ada yang perlu melihat dan mengakses basis data yang berbeda, `sample-database-2` yang tidak mereka miliki aksesnya sebelumnya, dalam klaster yang sama.
Pada suatu saat, keduanya `user1` dan `user2` meninggalkan perusahaan dan akses mereka harus dicabut.
Untuk membuat pengguna dan memberikan peran, pengguna yang Anda autentikasi ke klaster harus memiliki peran yang berkaitan yang dapat melakukan tindakan untuk `createUser` dan `grantRole`. Sebagai contoh, peran `admin` dan `userAdminAnyDatabase` keduanya dapat memberikan kemampuan semacam itu, sebagai contoh. Untuk tindakan sesuai peran, lihat [Akses database menggunakan Kontrol Akses Berbasis Peran](#role_based_access_control-built_in_roles).
**catatan**
Di Amazon DocumentDB, semua pengguna dan operasi peran (sebagai contoh, `create`, `get`, `drop`, `grant`, `revoke`, dll.) secara implisit dilakukan dalam basis data `admin` baik Anda mengeluarkan perintah terhadap basis data `admin` ataupun tidak.
Pertama, untuk memahami siapa pengguna saat ini dan perannya dalam klaster, Anda dapat menjalankan perintah `show users`, sebagaimana dalam contoh berikut. Anda akan melihat dua pengguna, `serviceadmin` dan pengguna utama untuk cluster. Kedua pengguna tersebut selalu ada dan tidak dapat dihapus. Untuk informasi selengkapnya, lihat [Mengelola pengguna Amazon DocumentDB](security.managing-users.md).
```
show users
```
Untuk `user1`, buat peran dengan akses baca dan tulis untuk semua basis data di seluruh klaster dengan perintah berikut ini.
```
db.createUser({user: "user1", pwd: "abc123", roles: [{role: "readWriteAnyDatabase", db: "admin"}]})
```
Keluaran dari operasi ini terlihat seperti berikut ini.
```
{
"user":"user1",
"roles":[
{
"role":"readWriteAnyDatabase",
"db":"admin"
}
]
}
```
Untuk `user2`, buat peran dengan akses hanya-baca ke `sample-database-1` basis data dengan perintah berikut ini.
```
db.createUser({user: "user2", pwd: "abc123", roles: [{role: "read", db: "sample-database-1"}]})
```
Keluaran dari operasi ini terlihat seperti berikut ini.
```
{
"user":"user2",
"roles":[
{
"role":"read",
"db":"sample-database-1"
}
]
}
```
Untuk menyimulasikan skenario bahwa `user3` adalah pengguna yang sudah ada, pertama buat `user3` pengguna, dan kemudian tetapkan peran baru ke `user3`.
```
db.createUser({user: "user3", pwd: "abc123", roles: [{role: "readWrite", db: "sample-database-1"}]})
```
Keluaran dari operasi ini terlihat seperti berikut ini.
```
{
"user":"user3",
"roles":[
{
"role":"readWrite",
"db":"sample-database-1"
}
]
}
```
Sekarang setelah `user3` pengguna telah dibuat, tetapkan `user3` peran `read` ke `sample-database-2`.
```
db.grantRolesToUser("user3", [{role: "read", db: "sample-database-2"}])
```
Terakhir, `user1` dan `user2` meninggalkan perusahaan dan akses mereka ke klaster harus dicabut. Anda bisa melakukannya dengan menghapus pengguna, sebagai berikut.
```
db.dropUser("user1")
db.dropUser("user2")
```
Untuk memastikan bahwa semua pengguna memiliki peran yang tepat, Anda dapat mendaftar semua pengguna dengan perintah berikut ini.
```
show users
```
Output dari operasi ini akan terlihat seperti berikut.
```
{
"_id":"serviceadmin",
"user":"serviceadmin",
"db":"admin",
"roles":[
{
"db":"admin",
"role":"root"
}
]
}
{
"_id":"master-user",
"user":"master-user",
"db":"admin",
"roles":[
{
"db":"admin",
"role":"root"
}
]
}
{
"_id":"user3",
"user":"user3",
"db":"admin",
"roles":[
{
"db":"sample-database-2",
"role":"read"
},
{
"db":"sample-database-1",
"role":"readWrite"
}
]
}
```
## Memulai dengan peran yang ditentukan pengguna RBAC
Untuk membantu Anda memulai dengan peran yang ditentukan pengguna, bagian ini memandu Anda melalui skenario contoh penerapan hak istimewa paling sedikit dengan membuat peran untuk tiga pengguna dengan fungsi pekerjaan yang berbeda.
Dalam contoh ini, berikut ini berlaku:
+ `user1` adalah manajer baru yang perlu dapat melihat dan mengakses semua basis data dalam klaster.
+ `user2`adalah karyawan baru yang hanya membutuhkan tindakan 'temukan' untuk hanya satu database,`sample-database-1`, di cluster yang sama.
+ `user3`adalah karyawan yang sudah ada yang perlu melihat dan mengakses koleksi tertentu, col2 dalam database yang berbeda, `sample-database-2` yang sebelumnya tidak mereka akses, di cluster yang sama.
+ Untuk `user1`, buat peran dengan akses baca dan tulis untuk semua basis data di seluruh klaster dengan perintah berikut ini.
```
db.createUser(
{
user: "user1", pwd: "abc123",
roles: [{role: "readWriteAnyDatabase", db: "admin"}]
}
)
```
Output dari operasi ini akan terlihat seperti berikut.
```
{
"user":"user1",
"roles":[
{
"role":"readWriteAnyDatabase",
"db":"admin"
}
]
}
```
Untuk`user2`, buat peran dengan hak istimewa 'temukan' untuk semua koleksi dalam database `sample-database-1` dengan perintah berikut. Perhatikan bahwa peran ini akan memastikan bahwa setiap pengguna terkait hanya dapat menjalankan kueri find.
```
db.createRole(
{
role: "findRole",
privileges: [
{
resource: {db: "sample-database-1", collection: ""}, actions: ["find"]
}],
roles: []
}
)
```
Output dari operasi ini akan terlihat seperti berikut.
```
{
"role":"findRole",
"privileges":[
{
"resource":{
"db":"sample-database-1",
"collection":""
},
"actions":[
"find"
]
}
],
"roles":[
]
}
```
Selanjutnya, buat user (`user2`) dan lampirkan peran yang baru dibuat `findRole` ke pengguna.
```
db.createUser(
{
user: "user2",
pwd: "abc123",
roles: []
})
db.grantRolesToUser("user2",["findRole"])
```
Untuk mensimulasikan skenario yang `user3` merupakan pengguna yang sudah ada, pertama buat pengguna`user3`, dan kemudian buat peran baru yang disebut CollectionRole yang akan kita lakukan pada langkah berikutnya. `user3`
Sekarang Anda dapat menetapkan peran baru. `user3` Peran baru ini akan memungkinkan `user3` untuk dapat menyisipkan, memperbarui, menghapus, dan menemukan akses ke satu koleksi tertentu col2 di`sample-database-2`.
```
db.createUser(
{
user: "user3",
pwd: "abc123",
roles: []
})
db.createRole(
{
role: "collectionRole",
privileges: [
{
resource: {db: "sample-database-2", collection: "col2"}, actions: ["find", "update", "insert", "remove"]
}],
roles: []
}
)
```
Output dari operasi ini akan terlihat seperti berikut.
```
{
"role":"collectionRole",
"privileges":[
{
"resource":{
"db":"sample-database-2",
"collection":"col2"
},
"actions":[
"find",
"update",
"insert",
"remove"
]
}
],
"roles":[
]
}
```
Sekarang pengguna `user3` telah dibuat, Anda dapat memberikan peran `user3` tersebut`collectionFind`.
```
db.grantRolesToUser("user3",["collectionRole"])
```
Terakhir, `user1` dan `user2` meninggalkan perusahaan dan akses mereka ke klaster harus dicabut. Anda bisa melakukannya dengan menghapus pengguna, sebagai berikut.
```
db.dropUser("user1")
db.dropUser("user2")
```
Untuk memastikan bahwa semua pengguna memiliki peran yang tepat, Anda dapat mendaftar semua pengguna dengan perintah berikut ini.
```
show users
```
Keluaran dari operasi ini terlihat seperti berikut ini.
```
{
"_id":"serviceadmin",
"user":"serviceadmin",
"db":"admin",
"roles":[
{
"db":"admin",
"role":"root"
}
]
}
{
"_id":"master-user",
"user":"master-user",
"db":"admin",
"roles":[
{
"db":"admin",
"role":"root"
}
]
}
{
"_id":"user3",
"user":"user3",
"db":"admin",
"roles":[
{
"db":"admin",
"role":"collectionRole"
}
]
}
```
## Menghubungkan ke Amazon DocumentDB sebagai Pengguna
Saat menghubungkan ke klaster Amazon DocumentDB, Anda terhubung dalam konteks basis data tertentu. Secara default, jika Anda tidak menentukan basis data dalam string koneksi Anda, Anda secara otomatis terhubung ke klaster dalam konteks basis data `test`. Semua perintah tingkat koleksi seperti `insert` dan `find` dikeluarkan terhadap koleksi di basis data `test`.
Untuk melihat basis data dalam konteks Anda dari atau — dengan kata lain — mengeluarkan perintah padanya, gunakan perintah `db` dalam mongo shell, sebagai berikut.
Kueri:
```
db
```
Output:
```
test
```
Meskipun koneksi default mungkin dalam konteks basis data `test`, hal ini tidak selalu berarti bahwa pengguna yang berkaitan dengan koneksi diotorisasi untuk melakukan tindakan pada basis data `test`. Dalam skenario contoh sebelumnya, jika Anda mengautentikasi sebagai `user3` pengguna, yang memiliki peran `readWrite` untuk basis data `sample-database-1`, konteks default koneksi Anda adalah basis data `test`. Namun demikian, jika Anda mencoba untuk memasukkan dokumen ke koleksi pada basis data `test`, Anda akan menerima pesan kesalahan *Kegagalan otorisasi*. Hal ini karena pengguna tersebut tidak diotorisasi untuk melakukan perintah tersebut pada database tersebut, sebagaimana ditunjukkan di bawah ini.
Kueri:
```
db
```
Output:
```
test
```
Kueri:
```
db.col.insert({x:1})
```
Output:
```
WriteCommandError({ "ok" : 0, "code" : 13, "errmsg" : "Authorization failure" })
```
Jika Anda mengubah konteks koneksi Anda ke basis data `sample-database-1`, Anda dapat menulis ke koleksi di mana pengguna memiliki otorisasi untuk melakukannya.
Kueri:
```
use sample-database-1
```
Output:
```
switched to db sample-database-1
```
Kueri:
```
db.col.insert({x:1})
```
Output:
```
WriteResult({ "nInserted" : 1})
```
Ketika Anda mengautentikasi ke klaster dengan pengguna tertentu, Anda juga dapat menentukan basis data dalam string koneksi. Dengan melakukannya akan menghilangkan kebutuhan untuk melakukan perintah `use` setelah pengguna telah diautentikasi ke basis data `admin`.
String koneksi berikut mengautentikasi pengguna terhadap basis data `admin`, tetapi konteks koneksi akan melawan basis data `sample-database-1`.
```
mongo "mongodb://user3:abc123@sample-cluster.node.us-east-1.docdb.amazonaws.com:27017/sample-database-2"
```
## Perintah umum
Bagian ini menyediakan contoh perintah umum menggunakan kontrol akses berbasis peran di Amazon DocumentDB. Anda harus berada dalam konteks basis data `admin` untuk membuat dan memodifikasi pengguna dan peran. Anda dapat menggunakan perintah `use admin` untuk beralih ke basis data `admin`.
**catatan**
Modifikasi untuk pengguna dan peran secara implisit akan terjadi di basis data `admin`. Membuat pengguna dengan peran yang tercakup di semua basis data (sebagai contoh, `readAnyDatabase`) mensyaratkan bahwa Anda dalam konteks basis data `admin` (yaitu, `use admin`) saat membuat pengguna, maupun Anda secara eksplisit menyatakan basis data untuk peran saat membuat pengguna (sebagaimana ditunjukkan dalam Contoh 2 di bagian ini).
**Contoh 1**: Buat pengguna dengan `read` peran untuk database`foo`.
```
db.createUser({user: "readInFooBar", pwd: "abc123", roles: [{role: "read", db: "foo"}]})
```
Keluaran dari operasi ini terlihat seperti berikut ini.
```
{
"user":"readInFooBar",
"roles":[
{
"role":"read",
"db":"foo"
}
]
}
```
**Contoh 2**: Buat pengguna dengan akses baca di semua database.
```
db.createUser({user: "readAllDBs", pwd: "abc123", roles: [{role: "readAnyDatabase", db: "admin"}]})
```
Keluaran dari operasi ini terlihat seperti berikut ini.
```
{
"user":"readAllDBs",
"roles":[
{
"role":"readAnyDatabase",
"db":"admin"
}
]
}
```
**Contoh 3**: Berikan `read` peran kepada pengguna yang sudah ada di database baru.
```
db.grantRolesToUser("readInFooBar", [{role: "read", db: "bar"}])
```
**Contoh 4**: Perbarui peran pengguna.
```
db.updateUser("readInFooBar", {roles: [{role: "read", db: "foo"}, {role: "read", db: "baz"}]})
```
**Contoh 5**: Mencabut akses ke database untuk pengguna.
```
db.revokeRolesFromUser("readInFooBar", [{role: "read", db: "baz"}])
```
**Contoh 6**: Jelaskan peran bawaan.
```
db.getRole("read", {showPrivileges:true})
```
Keluaran dari operasi ini terlihat seperti berikut ini.
```
{
"role":"read",
"db":"sample-database-1",
"isBuiltin":true,
"roles":[
],
"inheritedRoles":[
],
"privileges":[
{
"resource":{
"db":"sample-database-1",
"collection":""
},
"actions":[
"changeStream",
"collStats",
"dbStats",
"find",
"killCursors",
"listCollections",
"listIndexes"
]
}
],
"inheritedPrivileges":[
{
"resource":{
"db":"sample-database-1",
"collection":""
},
"actions":[
"changeStream",
"collStats",
"dbStats",
"find",
"killCursors",
"listCollections",
"listIndexes"
]
}
}
```
**Contoh 7**: Jatuhkan pengguna dari cluster.
```
db.dropUser("readInFooBar")
```
Output dari operasi ini akan terlihat seperti berikut.
```
true
```
**Contoh 8**: Buat peran dengan akses baca dan tulis ke koleksi tertentu
```
db.createRole(
{
role: "collectionRole",
privileges: [
{
resource: {db: "sample-database-2", collection: "col2"}, actions: ["find", "update", "insert", "remove"]
}],
roles: []
}
)
```
Output dari operasi ini akan terlihat seperti berikut.
```
{
"role":"collectionRole",
"privileges":[
{
"resource":{
"db":"sample-database-2",
"collection":"col2"
},
"actions":[
"find",
"update",
"insert",
"remove"
]
}
],
"roles":[
]
}
```
**Contoh 9**: Buat pengguna dan tetapkan peran yang ditentukan pengguna
```
db.createUser(
{
user: "user3",
pwd: "abc123",
roles: []
})
db.grantRolesToUser("user3",["collectionRole"])
```
**Contoh 10**: Berikan hak istimewa tambahan untuk peran yang ditentukan pengguna
```
db.grantPrivilegesToRole(
"collectionRole",
[
{
resource: { db: "sample-database-1", collection: "col1" },
actions: ["find", "update", "insert", "remove"]
}
]
)
```
**Contoh 11**: Hapus hak istimewa dari peran yang ditentukan pengguna
```
db.revokePrivilegesFromRole(
"collectionRole",
[
{
resource: { db: "sample-database-1", collection: "col2" },
actions: ["find", "update", "insert", "remove"]
}
]
)
```
**Contoh 12**: Perbarui peran yang ditentukan pengguna yang sudah ada
```
db.updateRole(
"collectionRole",
{
privileges: [
{
resource: {db: "sample-database-3", collection: "sample-collection-3"}, actions: ["find", "update", "insert", "remove"]
}],
roles: []
}
)
```
## Perbedaan fungsional
Di Amazon DocumentDB, definisi pengguna dan peran disimpan dalam basis data `admin` dan pengguna diautentikasi terhadap basis data `admin`. Fungsionalitas ini berbeda dari Edisi Komunitas MongoDB, tetapi konsisten dengan MongoDB Atlas.
Amazon DocumentDB juga mendukung perubahan pengaliran, yang menyediakan urutan sesuai waktu dari peristiwa perubahan yang terjadi di dalam koleksi klaster Anda. Tindakan `listChangeStreams` diterapkan pada tingkat klaster (yaitu, di semua basis data), dan tindakan `modifyChangeStreams` dapat diterapkan pada tingkat basis data dan tingkat klaster.
## Batas
Tabel berikut berisi batasan untuk Kontrol Akses Berbasis Peran di Amazon DocumentDB.
****
| Deskripsi | Kuota |
| --- | --- |
| Jumlah pengguna per klaster | 1000 |
| Jumlah peran yang berkaitan dengan pengguna | 1000 |
| Jumlah peran yang ditentukan pengguna | 100 |
| Jumlah sumber daya yang terkait dengan hak istimewa | 100 |
## Akses database menggunakan Kontrol Akses Berbasis Peran
Dengan kontrol akses berbasis peran, Anda dapat membuat pengguna dan memberikan satu atau lebih peran untuk menentukan operasi apa yang dapat dilakukan pengguna dalam basis data atau klaster.
Berikut ini adalah daftar peran built-in yang saat ini didukung di Amazon DocumentDB.
**catatan**
Di Amazon DocumentDB 4.0 dan 5.0, `ListCollection` perintah `ListDatabase` dan secara opsional dapat menggunakan `authorizedCollections` parameter `authorizedDatabases` dan untuk mencantumkan koleksi dan database yang diizinkan pengguna untuk mengakses dengan memerlukan `listCollections` peran dan masing-masing. `listDatabase` Juga, pengguna sekarang memiliki kemampuan untuk menghilangkan kursor mereka sendiri tanpa memerlukan peran `KillCursor`.
------
#### [ Database user ]
****
| Nama peran | Deskripsi | Tindakan |
| --- | --- | --- |
| read | Memberikan kepada pengguna akses baca ke basis data yang ditetapkan. | `[changeStreams](https://docs.aws.amazon.com//documentdb/latest/developerguide/change_streams.html)` `collStats` `dbStats` `find` `killCursors` `listIndexes` `listCollections` |
| readWrite | Memberikan kepada pengguna akses baca dan tulis ke basis data yang ditetapkan. | Semua tindakan dari izin `read`. `createCollection` `dropCollection` `createIndex` `dropIndex` `insert` `killCursors` `listIndexes` `listCollections` `remove` `update` |
------
#### [ Cluster user ]
****
| Nama peran | Deskripsi | Tindakan |
| --- | --- | --- |
| readAnyDatabase | Memberikan kepada pengguna akses baca ke semua basis data dalam klaster. | Semua tindakan dari izin `read`. `listChangeStreams` `listDatabases` |
| readWriteAnyDatabase | Memberikan kepada pengguna akses baca dan tulis ke semua basis data dalam klaster. | Semua tindakan dari izin `readWrite`. `listChangeStreams` `listDatabases` |
| userAdminAnyDatabase | Memberikan kepada pengguna kemampuan untuk menetapkan dan memodifikasi peran atau hak istimewa yang dimiliki setiap pengguna untuk basis data yang ditetapkan. | `changeCustomData` `changePassword` `createUser` `dropRole` `dropUser` `grantRole` `listDatabases` `revokeRole` `viewRole` `viewUser` |
| dbAdminAnyDatabase | Memberikan kepada pengguna kemampuan untuk melakukan peran administrasi basis data pada setiap basis data yang ditetapkan. | Semua tindakan dari izin `dbAdmin`. `dropCollection` `listDatabases` `listChangeStreams` `modifyChangeStreams` |
------
#### [ Superuser ]
****
| Nama peran | Deskripsi | Tindakan |
| --- | --- | --- |
| root | Memberikan kepada pengguna akses ke sumber daya dan operasi dari semua gabungan peran berikut ini: readWriteAnyDatabase, dbAdminAnyDatabase, userAdminAnyDatabase, clusterAdmin, restore, dan backup. | Semua tindakan dari `readWriteAnyDatabase`, `dbAdminAnyDatabase`, `userAdminAnyDatabase`, `clusterAdmin`, `restore`, dan `backup`. |
------
#### [ Database administrator ]
****
| Nama peran | Deskripsi | Tindakan |
| --- | --- | --- |
| dbAdmin | Memberikan kepada pengguna kemampuan untuk melakukan tugas administratif pada basis data yang ditetapkan. | `bypassDocumentValidation` `collMod` `collStats` `createCollection` `createIndex` `dropCollection` `dropDatabase` `dropIndex` `dbStats` `find` `killCursors` `listIndexes` `listCollections` `modifyChangeStreams` |
| dbOwner | Memberikan kepada pengguna kemampuan untuk melakukan tugas administratif pada basis data yang ditetapkan dengan menggabungkan peran dbAdmin dan readWrite. | Semua tindakan dari `dbAdmin` dan `readWrite`. |
------
#### [ Cluster administrator ]
****
| Nama peran | Deskripsi | Tindakan |
| --- | --- | --- |
| clusterAdmin | Memberikan kepada pengguna akses manajemen klaster terbesar dengan menggabungkan peran clusterManager, clusterMonitor, dan hostManager. | Semua tindakan dari `clusterManager`, `clusterMonitor`, dan `hostManager`. `listChangeStreams` `dropDatabase` `modifyChangeStreams` |
| clusterManager | Memberikan kepada pengguna kemampuan untuk mengambil tindakan manajemen dan pemantauan pada klaster yang ditetapkan. | `listChangeStreams` `listSessions` `modifyChangeStreams` `replSetGetConfig` |
| clusterMonitor | Memberikan kepada pengguna kemampuan untuk memiliki akses hanya-baca ke alat pemantauan. | `collStats` `dbStats` `find` `getParameter` `hostInfo` `indexStats` `killCursors` `listChangeStreams` `listCollections` `listDatabases` `listIndexes` `listSessions` `replSetGetConfig` `serverStatus` `top` |
| hostManager | Memberikan kepada pengguna kemampuan untuk memantau dan mengelola server. | `auditConfigure` `killCursors` `killAnyCursor` `killAnySession` `killop` |
------
#### [ Backup administrator ]
****
| Nama peran | Deskripsi | Tindakan |
| --- | --- | --- |
| backup | Memberikan kepada pengguna akses yang diperlukan untuk mencadangkan data. | `getParameter` `insert` `find` `listChangeStreams` `listCollections` `listDatabases` `listIndexes` `update` |
| restore | Memberikan kepada pengguna akses yang diperlukan untuk memulihkan data. | `bypassDocumentValidation` `changeCustomData` `changePassword` `collMod` `createCollection` `createIndex` `createUser` `dropCollection` `dropRole` `dropUser` `getParameter` `grantRole` `find` `insert` `listCollections` `modifyChangeStreams` `revokeRole` `remove` `viewRole` `viewUser` `update` |
------