Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Datenbankzugriff mithilfe der rollenbasierten Zugriffskontrolle
Mithilfe der *rollenbasierten Zugriffskontrolle (RBAC) in Amazon DocumentDB (mit MongoDB-Kompatibilität) können Sie den Zugriff auf* die Aktionen einschränken, die Benutzer an Datenbanken ausführen können. Bei RBAC werden einem Benutzer eine oder mehrere Rollen gewährt. Diese Rollen bestimmen die Operationen, die ein Benutzer mit Datenbankressourcen ausführen kann. Amazon DocumentDB unterstützt derzeit sowohl integrierte Rollen, die auf Datenbankebene beschränkt sind, wie z. B.,,,,,,`read`,,,`readWrite`,, `readAnyDatabase``clusterAdmin`, als auch benutzerdefinierte Rollen, die auf bestimmte Aktionen beschränkt werden können, und granulare Ressourcen wie Sammlungen, die auf Ihre Anforderungen zugeschnitten sind.
Zu den häufigsten Anwendungsfällen für RBAC gehören die Durchsetzung der geringsten Rechte durch die Erstellung von Benutzern mit schreibgeschütztem Zugriff auf die Datenbanken oder Sammlungen in einem Cluster sowie mandantenfähige Anwendungsdesigns, die es einem einzelnen Benutzer ermöglichen, auf eine bestimmte Datenbank oder Sammlung in einem Cluster zuzugreifen.
**Anmerkung**
Allen neuen Benutzern, die vor dem **26. März 2020** erstellt wurden, wurden die `dbAdminAnyDatabase`-, `readWriteAnyDatabase`- und `clusterAdmin`-Rollen erteilt. Es wird empfohlen, alle vorhandenen Benutzer neu zu bewerten und die Rollen nach Bedarf zu ändern, um die geringstmöglichen Berechtigungen für Ihre Cluster zu erzwingen.
**Topics**
+ [
## RBAC-Konzepte
](#role_based_access_control-concepts)
+ [
## Erste Schritte mit den integrierten RBAC-Rollen
](#role_based_access_control-getting_started)
+ [
## Erste Schritte mit benutzerdefinierten RBAC-Rollen
](#w2aac29c29c15)
+ [
## Als Benutzer eine Verbindung zu Amazon DocumentDB herstellen
](#role_based_access_control-connecting_as_user)
+ [
## Allgemeine Befehle
](#role_based_access_control-common_commands)
+ [
## Funktionelle Unterschiede
](#role_based_access_control-functional_differences)
+ [
## Einschränkungen
](#role_based_access_control-limits)
+ [
## Datenbankzugriff mithilfe der rollenbasierten Zugriffskontrolle
](#role_based_access_control-built_in_roles)
## RBAC-Konzepte
Im Folgenden finden Sie wichtige Begriffe und Konzepte zur rollenbasierten Zugriffssteuerung. Weitere Informationen zu Amazon DocumentDB DocumentDB-Benutzern finden Sie unter[Amazon DocumentDB DocumentDB-Benutzer verwalten](security.managing-users.md).
+ **Benutzer** — Eine einzelne Entität, die sich bei der Datenbank authentifizieren und Operationen ausführen kann.
+ **Passwort** — Ein Geheimnis, das zur Authentifizierung des Benutzers verwendet wird.
+ **Rolle** — Autorisiert einen Benutzer, Aktionen an einer oder mehreren Datenbanken durchzuführen.
+ **Admin-Datenbank** — Die Datenbank, in der Benutzer gespeichert sind und für die sie autorisiert sind.
+ **Datenbank (`db`)** — Der Namespace innerhalb von Clustern, der Sammlungen zum Speichern von Dokumenten enthält.
Der folgende Befehl erstellt einen Benutzer mit Namen `sample-user`.
```
db.createUser({user: "sample-user", pwd: "abc123", roles: [{role: "read", db: "sample-database"}]})
```
In diesem Beispiel:
+ `user: "sample-user"`— Gibt den Benutzernamen an.
+ `pwd: "abc123"`— Zeigt das Benutzerkennwort an.
+ `role: "read", "db: "sample-database"`— Zeigt an, dass der Benutzer Leseberechtigungen für haben `sample-user` wird`sample-database`.
![\[Codebeispiel, das einen „createUser“-Befehl anzeigt, der Benutzername, Passwort und Berechtigungen angibt.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/rbac-createuser-command.png)
Das folgende Beispiel zeigt die Ausgabe, nachdem Sie den Benutzer `sample-user` mit `db.getUser(sample-user)` erhalten. In diesem Beispiel befindet sich der Benutzer `sample-user` in der Datenbank `admin`, besitzt jedoch die „read“-Rolle für die Datenbank `sample-database`.
![\[Codeausgabebeispiel, das das Ergebnis des Befehls createUser zeigt, der die neue Benutzer-ID, die Admin-Datenbank, der der neue Benutzer zugewiesen ist, und die auf den Benutzer angewendeten Rollenberechtigungen definiert.\]](http://docs.aws.amazon.com/de_de/documentdb/latest/developerguide/images/rbac-createuser-output-json.png)
Wenn Sie beim Erstellen von Benutzern das `db` Feld bei der Angabe der Rolle weglassen, ordnet Amazon DocumentDB die Rolle implizit der Datenbank zu, für die die Verbindung hergestellt wird. Wenn Ihre Verbindung beispielsweise für die Datenbank `sample-database` hergestellt wird und Sie den folgenden Befehl ausführen, wird der Benutzer `sample-user` in der Datenbank `admin` erstellt und verfügt über `readWrite`-Berechtigungen für die Datenbank `sample-database`.
```
db.createUser({user: "sample-user", pwd: "abc123", roles: ["readWrite"]})
```
Die Ausgabe dieser Operation sieht in etwa folgendermaßen aus.
```
{
"user":"sample-user",
"roles":[
{
"db":"sample-database",
"role":"readWrite"
}
]
}
```
Wenn Sie Benutzer mit Rollen erstellen, die über alle Datenbanken hinweg erfasst sind (z. B. `readAnyDatabase`), müssen Sie sich beim Erstellen des Benutzers entweder im Kontext der Datenbank `admin` befinden oder beim Erstellen des Benutzers explizit die Datenbank für die Rolle angeben. Um Befehle für die Datenbank `admin` auszugeben, können Sie den Befehl `use admin` verwenden. Weitere Informationen finden Sie unter [Allgemeine Befehle](#role_based_access_control-common_commands).
## Erste Schritte mit den integrierten RBAC-Rollen
Um Ihnen den Einstieg in die rollenbasierte Zugriffssteuerung zu erleichtern, führen Sie in diesem Abschnitt ein Beispielszenario zum Erzwingen der geringstmöglichen Berechtigungen durch das Erstellen von Rollen für drei Benutzer mit unterschiedlichen Auftragsfunktionen durch.
+ `user1` ist ein neuer Manager, der in der Lage sein muss, alle Datenbanken in einem Cluster anzuzeigen und darauf zuzugreifen.
+ `user2` ist ein neuer Mitarbeiter, der Zugriff auf nur eine Datenbank, `sample-database-1`, in demselben Cluster benötigt.
+ `user3` ist ein vorhandener Mitarbeiter, der im selben Cluster eine andere Datenbank, `sample-database-2`, anzeigen und darauf zugreifen muss, auf die er vorher keinen Zugriff hatten.
Zu einem späteren Zeitpunkt verlassen sowohl `user1` als auch `user2` das Unternehmen, so dass ihr Zugang widerrufen werden muss.
Um Benutzer zu erstellen und Rollen zu erteilen, muss der Benutzer, mit dem Sie sich beim Cluster authentifizieren, über eine zugeordnete Rolle verfügen, die Aktionen für `createUser` und `grantRole` ausführen kann. Zum Beispiel können die Rollen `admin` und `userAdminAnyDatabase` beide solche Fähigkeiten gewähren. Informationen zu Aktionen pro Rolle finden Sie unter [Datenbankzugriff mithilfe der rollenbasierten Zugriffskontrolle](#role_based_access_control-built_in_roles).
**Anmerkung**
In Amazon DocumentDB werden alle Benutzer- und Rollenoperationen (z. B.`create`,`get`,`drop`, `grant``revoke`, usw.) implizit in der `admin` Datenbank ausgeführt, unabhängig davon, ob Sie Befehle für die `admin` Datenbank ausgeben oder nicht.
Um zunächst zu verstehen, was die aktuellen Benutzer und Rollen im Cluster sind, können Sie den Befehl `show users` ausführen, wie im folgenden Beispiel. Sie sehen zwei Benutzer `serviceadmin` und den Hauptbenutzer für den Cluster. Diese beiden Benutzer sind immer vorhanden und können nicht gelöscht werden. Weitere Informationen finden Sie unter [Amazon DocumentDB DocumentDB-Benutzer verwalten](security.managing-users.md).
```
show users
```
Erstellen Sie für `user1` eine Rolle mit Lese- und Schreibzugriff auf alle Datenbanken im gesamten Cluster mit dem folgenden Befehl.
```
db.createUser({user: "user1", pwd: "abc123", roles: [{role: "readWriteAnyDatabase", db: "admin"}]})
```
Die Ausgabe dieser Operation sieht in etwa folgendermaßen aus.
```
{
"user":"user1",
"roles":[
{
"role":"readWriteAnyDatabase",
"db":"admin"
}
]
}
```
Erstellen Sie für `user2` eine Rolle mit schreibgeschütztem Zugriff auf die Datenbank `sample-database-1` mit dem folgenden Befehl.
```
db.createUser({user: "user2", pwd: "abc123", roles: [{role: "read", db: "sample-database-1"}]})
```
Die Ausgabe dieser Operation sieht in etwa folgendermaßen aus.
```
{
"user":"user2",
"roles":[
{
"role":"read",
"db":"sample-database-1"
}
]
}
```
Um das Szenario zu simulieren, dass `user3` ein vorhandener Benutzer ist, erstellen Sie zuerst den Benutzer `user3` und weisen Sie dann `user3` eine neue Rolle zu.
```
db.createUser({user: "user3", pwd: "abc123", roles: [{role: "readWrite", db: "sample-database-1"}]})
```
Die Ausgabe dieser Operation sieht in etwa folgendermaßen aus.
```
{
"user":"user3",
"roles":[
{
"role":"readWrite",
"db":"sample-database-1"
}
]
}
```
Nachdem der Benutzer `user3` erstellt wurde, weisen Sie `user3` die `read`-Rolle für `sample-database-2` zu.
```
db.grantRolesToUser("user3", [{role: "read", db: "sample-database-2"}])
```
Schließlich verlassen sowohl `user1` als auch `user2` das Unternehmen und ihr Zugriff auf den Cluster muss widerrufen werden. Sie können dies tun, indem Sie die Benutzer wie folgt löschen.
```
db.dropUser("user1")
db.dropUser("user2")
```
Um sicherzustellen, dass alle Benutzer über die entsprechenden Rollen verfügen, können Sie alle Benutzer mit dem folgenden Befehl auflisten.
```
show users
```
Die Ausgabe dieser Operation sieht in etwa folgendermaßen aus.
```
{
"_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"
}
]
}
```
## Erste Schritte mit benutzerdefinierten RBAC-Rollen
Um Ihnen den Einstieg in benutzerdefinierte Rollen zu erleichtern, führt Sie dieser Abschnitt durch ein Beispielszenario zur Durchsetzung der geringsten Rechte durch die Erstellung von Rollen für drei Benutzer mit unterschiedlichen Aufgabenfunktionen.
In diesem Beispiel gilt Folgendes:
+ `user1` ist ein neuer Manager, der in der Lage sein muss, alle Datenbanken in einem Cluster anzuzeigen und darauf zuzugreifen.
+ `user2`ist ein neuer Mitarbeiter, der nur die Aktion „Suchen“ für nur eine Datenbank im selben Cluster benötigt. `sample-database-1`
+ `user3`ist ein vorhandener Mitarbeiter, der eine bestimmte Sammlung (Spalte 2) in einer anderen Datenbank, auf `sample-database-2` die er zuvor keinen Zugriff hatte, im selben Cluster anzeigen und darauf zugreifen muss.
+ Erstellen Sie für `user1` eine Rolle mit Lese- und Schreibzugriff auf alle Datenbanken im gesamten Cluster mit dem folgenden Befehl.
```
db.createUser(
{
user: "user1", pwd: "abc123",
roles: [{role: "readWriteAnyDatabase", db: "admin"}]
}
)
```
Die Ausgabe dieser Operation sieht in etwa folgendermaßen aus.
```
{
"user":"user1",
"roles":[
{
"role":"readWriteAnyDatabase",
"db":"admin"
}
]
}
```
Erstellen Sie für `user2` mit dem folgenden Befehl eine Rolle mit Find-Rechten für alle Sammlungen in der Datenbank`sample-database-1`. Beachten Sie, dass diese Rolle sicherstellen würde, dass alle zugehörigen Benutzer nur Suchabfragen ausführen können.
```
db.createRole(
{
role: "findRole",
privileges: [
{
resource: {db: "sample-database-1", collection: ""}, actions: ["find"]
}],
roles: []
}
)
```
Die Ausgabe dieser Operation sieht in etwa folgendermaßen aus.
```
{
"role":"findRole",
"privileges":[
{
"resource":{
"db":"sample-database-1",
"collection":""
},
"actions":[
"find"
]
}
],
"roles":[
]
}
```
Erstellen Sie als Nächstes den Benutzer (`user2`) und fügen Sie dem Benutzer die kürzlich erstellte Rolle `findRole` hinzu.
```
db.createUser(
{
user: "user2",
pwd: "abc123",
roles: []
})
db.grantRolesToUser("user2",["findRole"])
```
Um das `user3` Szenario eines vorhandenen Benutzers zu simulieren, erstellen Sie zuerst den Benutzer `user3` und dann eine neue Rolle namens CollectionRole, der wir im nächsten Schritt zuweisen werden. `user3`
Jetzt können Sie eine neue Rolle zuweisen. `user3` Diese neue Rolle ermöglicht es `user3` Ihnen, eine bestimmte Sammlung einzufügen, zu aktualisieren, zu löschen und Zugriff auf diese zu finden. `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: []
}
)
```
Die Ausgabe dieser Operation sieht in etwa folgendermaßen aus.
```
{
"role":"collectionRole",
"privileges":[
{
"resource":{
"db":"sample-database-2",
"collection":"col2"
},
"actions":[
"find",
"update",
"insert",
"remove"
]
}
],
"roles":[
]
}
```
Nachdem der Benutzer erstellt `user3` wurde, können Sie ihm `user3` die Rolle `collectionFind` zuweisen.
```
db.grantRolesToUser("user3",["collectionRole"])
```
Schließlich verlassen sowohl `user1` als auch `user2` das Unternehmen und ihr Zugriff auf den Cluster muss widerrufen werden. Sie können dies tun, indem Sie die Benutzer wie folgt löschen.
```
db.dropUser("user1")
db.dropUser("user2")
```
Um sicherzustellen, dass alle Benutzer über die entsprechenden Rollen verfügen, können Sie alle Benutzer mit dem folgenden Befehl auflisten.
```
show users
```
Die Ausgabe dieser Operation sieht in etwa folgendermaßen aus.
```
{
"_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"
}
]
}
```
## Als Benutzer eine Verbindung zu Amazon DocumentDB herstellen
Wenn Sie eine Verbindung zu einem Amazon DocumentDB-Cluster herstellen, stellen Sie eine Verbindung im Kontext einer bestimmten Datenbank her. Wenn Sie in der Verbindungszeichenfolge keine Datenbank angeben, werden Sie standardmäßig automatisch im Kontext der Datenbank `test` mit dem Cluster verbunden. Alle Befehle auf Sammlungsebene wie `insert` und `find` werden für Sammlungen in der Datenbank `test` ausgegeben.
Um die Datenbank zu sehen, in der Sie sich befinden, oder — mit anderen Worten — Befehle für die Sie ausführen, verwenden Sie den `db` Befehl in der Mongo-Shell wie folgt.
Abfrage:
```
db
```
Ausgabe:
```
test
```
Obwohl sich die Standardverbindung möglicherweise im Kontext der Datenbank `test` befindet, bedeutet dies nicht unbedingt, dass der Benutzer, der der Verbindung zugeordnet ist, berechtigt ist, Aktionen für die Datenbank `test` auszuführen. Wenn Sie sich im vorangegangenen Beispielszenario als Benutzer `user3` authentifizieren, der die `readWrite`-Rolle für die Datenbank `sample-database-1` besitzt, ist der Standardkontext Ihrer Verbindung die Datenbank `test`. Wenn Sie jedoch versuchen, ein Dokument in eine Sammlung in der Datenbank `test` einzufügen, erhalten Sie die Fehlermeldung *Autorisierungsfehler*. Dies liegt daran, dass dieser Benutzer nicht berechtigt ist, diesen Befehl in dieser Datenbank auszuführen, wie unten gezeigt.
Abfrage:
```
db
```
Ausgabe:
```
test
```
Abfrage:
```
db.col.insert({x:1})
```
Ausgabe:
```
WriteCommandError({ "ok" : 0, "code" : 13, "errmsg" : "Authorization failure" })
```
Wenn Sie den Kontext Ihrer Verbindung zur Datenbank `sample-database-1` ändern, können Sie in die Sammlung schreiben, für die der Benutzer die Berechtigung dazu hat.
Abfrage:
```
use sample-database-1
```
Ausgabe:
```
switched to db sample-database-1
```
Abfrage:
```
db.col.insert({x:1})
```
Ausgabe:
```
WriteResult({ "nInserted" : 1})
```
Wenn Sie sich bei einem Cluster mit einem bestimmten Benutzer authentifizieren, können Sie die Datenbank auch in der Verbindungszeichenfolge angeben. Dadurch entfällt die Notwendigkeit, den Befehl `use` auszuführen, nachdem der Benutzer in der Datenbank `admin` authentifiziert wurde.
Die folgende Verbindungszeichenfolge authentifiziert den Benutzer für die Datenbank `admin`, aber der Kontext der Verbindung wird für die Datenbank `sample-database-1` verwendet.
```
mongo "mongodb://user3:abc123@sample-cluster.node.us-east-1.docdb.amazonaws.com:27017/sample-database-2"
```
## Allgemeine Befehle
Dieser Abschnitt enthält Beispiele für häufig verwendete Befehle, die die rollenbasierte Zugriffskontrolle in Amazon DocumentDB verwenden. Sie müssen sich im Kontext der Datenbank `admin` befinden, um Benutzer und Rollen zu erstellen und zu ändern. Sie können den Befehl `use admin` verwenden, um zur Datenbank `admin` zu wechseln.
**Anmerkung**
Änderungen an den Benutzern und Rollen erfolgen implizit in der Datenbank `admin`. Wenn Sie Benutzer mit Rollen erstellen, die über alle Datenbanken hinweg erfasst sind (z. B. `readAnyDatabase`), müssen Sie sich beim Erstellen des Benutzers entweder im Kontext der Datenbank `admin` befinden (d. h. `use admin`) oder beim Erstellen des Benutzers explizit die Datenbank für die Rolle angeben (wie in Beispiel 2 in diesem Abschnitt gezeigt).
**Beispiel 1**: Erstellen Sie einen Benutzer mit `read` Rolle für die Datenbank. `foo`
```
db.createUser({user: "readInFooBar", pwd: "abc123", roles: [{role: "read", db: "foo"}]})
```
Die Ausgabe dieser Operation sieht in etwa folgendermaßen aus.
```
{
"user":"readInFooBar",
"roles":[
{
"role":"read",
"db":"foo"
}
]
}
```
**Beispiel 2**: Erstellen Sie einen Benutzer mit Lesezugriff auf alle Datenbanken.
```
db.createUser({user: "readAllDBs", pwd: "abc123", roles: [{role: "readAnyDatabase", db: "admin"}]})
```
Die Ausgabe dieser Operation sieht in etwa folgendermaßen aus.
```
{
"user":"readAllDBs",
"roles":[
{
"role":"readAnyDatabase",
"db":"admin"
}
]
}
```
**Beispiel 3**: Erteilen Sie einem vorhandenen Benutzer eine `read` Rolle in einer neuen Datenbank.
```
db.grantRolesToUser("readInFooBar", [{role: "read", db: "bar"}])
```
**Beispiel 4**: Aktualisieren Sie die Rolle eines Benutzers.
```
db.updateUser("readInFooBar", {roles: [{role: "read", db: "foo"}, {role: "read", db: "baz"}]})
```
**Beispiel 5**: Widerrufen Sie einem Benutzer den Zugriff auf eine Datenbank.
```
db.revokeRolesFromUser("readInFooBar", [{role: "read", db: "baz"}])
```
**Beispiel 6**: Beschreiben Sie eine integrierte Rolle.
```
db.getRole("read", {showPrivileges:true})
```
Die Ausgabe dieser Operation sieht in etwa folgendermaßen aus.
```
{
"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"
]
}
}
```
**Beispiel 7**: Einen Benutzer aus dem Cluster löschen.
```
db.dropUser("readInFooBar")
```
Die Ausgabe dieser Operation sieht in etwa folgendermaßen aus.
```
true
```
**Beispiel 8**: Erstellen Sie eine Rolle mit Lese- und Schreibzugriff auf eine bestimmte Sammlung
```
db.createRole(
{
role: "collectionRole",
privileges: [
{
resource: {db: "sample-database-2", collection: "col2"}, actions: ["find", "update", "insert", "remove"]
}],
roles: []
}
)
```
Die Ausgabe dieser Operation sieht in etwa folgendermaßen aus.
```
{
"role":"collectionRole",
"privileges":[
{
"resource":{
"db":"sample-database-2",
"collection":"col2"
},
"actions":[
"find",
"update",
"insert",
"remove"
]
}
],
"roles":[
]
}
```
**Beispiel 9**: Erstellen Sie einen Benutzer und weisen Sie ihm eine benutzerdefinierte Rolle zu
```
db.createUser(
{
user: "user3",
pwd: "abc123",
roles: []
})
db.grantRolesToUser("user3",["collectionRole"])
```
**Beispiel 10**: Erteilen Sie einer benutzerdefinierten Rolle zusätzliche Rechte
```
db.grantPrivilegesToRole(
"collectionRole",
[
{
resource: { db: "sample-database-1", collection: "col1" },
actions: ["find", "update", "insert", "remove"]
}
]
)
```
**Beispiel 11**: Entfernen Sie Rechte aus einer benutzerdefinierten Rolle
```
db.revokePrivilegesFromRole(
"collectionRole",
[
{
resource: { db: "sample-database-1", collection: "col2" },
actions: ["find", "update", "insert", "remove"]
}
]
)
```
**Beispiel 12**: Aktualisieren Sie eine bestehende benutzerdefinierte Rolle
```
db.updateRole(
"collectionRole",
{
privileges: [
{
resource: {db: "sample-database-3", collection: "sample-collection-3"}, actions: ["find", "update", "insert", "remove"]
}],
roles: []
}
)
```
## Funktionelle Unterschiede
In Amazon DocumentDB werden Benutzer- und Rollendefinitionen in der `admin` Datenbank gespeichert und Benutzer werden anhand der `admin` Datenbank authentifiziert. Diese Funktionalität unterscheidet sich von der MongoDB Community Edition, ist aber konsistent mit MongoDB Atlas.
Amazon DocumentDB unterstützt auch Change-Streams, die eine zeitlich geordnete Abfolge von Änderungsereignissen bereitstellen, die in den Sammlungen Ihres Clusters auftreten. Die `listChangeStreams` Aktion wird auf Clusterebene (d. h. auf alle Datenbanken) angewendet, und die `modifyChangeStreams` Aktion kann auf Datenbank- und Clusterebene angewendet werden.
## Einschränkungen
Die folgende Tabelle enthält die Grenzwerte für die rollenbasierte Zugriffskontrolle in Amazon DocumentDB.
****
| Description | Limit |
| --- | --- |
| Anzahl Benutzer pro Cluster | 1000 |
| Anzahl der Rollen, die einem Benutzer zugeordnet sind | 1000 |
| Anzahl der benutzerdefinierten Rollen | 100 |
| Anzahl der Ressourcen, die mit einer Berechtigung verknüpft sind | 100 |
## Datenbankzugriff mithilfe der rollenbasierten Zugriffskontrolle
Mit der rollenbasierten Zugriffssteuerung können Sie einen Benutzer erstellen und ihm eine oder mehrere Rollen erteilen, um zu bestimmen, welche Operationen der Benutzer in einer Datenbank oder einem Cluster ausführen kann.
Im Folgenden finden Sie eine Liste der integrierten Rollen, die derzeit in Amazon DocumentDB unterstützt werden.
**Anmerkung**
In Amazon DocumentDB 4.0 und 5.0 können die `ListDatabase` Befehle `ListCollection` und optional die `authorizedDatabases` Parameter `authorizedCollections` und verwenden, um die Sammlungen und Datenbanken aufzulisten, auf die der Benutzer zugreifen darf, wobei er die jeweiligen `listDatabase` Rollen `listCollections` und benötigt. Außerdem haben Benutzer jetzt die Möglichkeit, ihre eigenen Cursor zu beenden, ohne die `KillCursor` Rolle zu benötigen.
------
#### [ Database user ]
****
| Rollenname | Description | Aktionen |
| --- | --- | --- |
| read | Gewährt einem Benutzer Lesezugriff auf die angegebene Datenbank. | `[changeStreams](https://docs.aws.amazon.com//documentdb/latest/developerguide/change_streams.html)` `collStats` `dbStats` `find` `killCursors` `listIndexes` `listCollections` |
| readWrite | Gewährt dem Benutzer Lese- und Schreibzugriff auf die angegebene Datenbank. | Alle Aktionen von `read`-Berechtigungen. `createCollection` `dropCollection` `createIndex` `dropIndex` `insert` `killCursors` `listIndexes` `listCollections` `remove` `update` |
------
#### [ Cluster user ]
****
| Rollenname | Description | Aktionen |
| --- | --- | --- |
| readAnyDatabase | Gewährt einem Benutzer Lesezugriff auf alle Datenbanken im Cluster. | Alle Aktionen von `read`-Berechtigungen. `listChangeStreams` `listDatabases` |
| readWriteAnyDatabase | Gewährt einem Benutzer Lese- und Schreibzugriff auf alle Datenbanken im Cluster. | Alle Aktionen von `readWrite`-Berechtigungen. `listChangeStreams` `listDatabases` |
| userAdminAnyDatabase | Gewährt einem Benutzer die Möglichkeit, die Rollen oder Berechtigungen, die ein Benutzer hat, der angegebenen Datenbank zuzuweisen und zu ändern. | `changeCustomData` `changePassword` `createUser` `dropRole` `dropUser` `grantRole` `listDatabases` `revokeRole` `viewRole` `viewUser` |
| dbAdminAnyDatabase | Gewährt einem Benutzer die Möglichkeit, Datenbankverwaltungsrollen für jede angegebene Datenbank auszuführen. | Alle Aktionen von `dbAdmin`-Berechtigungen. `dropCollection` `listDatabases` `listChangeStreams` `modifyChangeStreams` |
------
#### [ Superuser ]
****
| Rollenname | Description | Aktionen |
| --- | --- | --- |
| root | Gewährt einem Benutzer Zugriff auf die Ressourcen und Operationen aller folgenden Rollen zusammen: readWriteAnyDatabase, dbAdminAnyDatabase, userAdminAnyDatabase, clusterAdmin, restore und backup. | Alle Aktionen von `readWriteAnyDatabase`, `dbAdminAnyDatabase`, `userAdminAnyDatabase`, `clusterAdmin`, `restore` und `backup`. |
------
#### [ Database administrator ]
****
| Rollenname | Description | Aktionen |
| --- | --- | --- |
| dbAdmin | Gewährt einem Benutzer die Möglichkeit, administrative Aufgaben für die angegebene Datenbank auszuführen. | `bypassDocumentValidation` `collMod` `collStats` `createCollection` `createIndex` `dropCollection` `dropDatabase` `dropIndex` `dbStats` `find` `killCursors` `listIndexes` `listCollections` `modifyChangeStreams` |
| dbOwner | Gewährt einem Benutzer die Möglichkeit, alle administrativen Aufgaben für die angegebenen Datenbank auszuführen, indem die Rollen dbAdmin und readWrite kombiniert werden. | Alle Aktionen von `dbAdmin` und `readWrite`. |
------
#### [ Cluster administrator ]
****
| Name der Rolle | Description | Aktionen |
| --- | --- | --- |
| clusterAdmin | Gewährt einem Benutzer den größtmöglichen Zugriff auf die Cluster-Verwaltung durch Kombination der Rollen clusterManager, clusterMonitor und hostManager. | Alle Aktionen von `clusterManager`, `clusterMonitor` und `hostManager`. `listChangeStreams` `dropDatabase` `modifyChangeStreams` |
| clusterManager | Gewährt einem Benutzer die Möglichkeit, Verwaltungs- und Überwachungsaktionen für den angegebenen Cluster durchzuführen. | `listChangeStreams` `listSessions` `modifyChangeStreams` `replSetGetConfig` |
| clusterMonitor | Gewährt einem Benutzer die Möglichkeit, schreibgeschützten Zugriff auf Überwachungstools zu haben. | `collStats` `dbStats` `find` `getParameter` `hostInfo` `indexStats` `killCursors` `listChangeStreams` `listCollections` `listDatabases` `listIndexes` `listSessions` `replSetGetConfig` `serverStatus` `top` |
| hostManager | Gewährt einem Benutzer die Möglichkeit, Server zu überwachen und zu verwalten. | `auditConfigure` `killCursors` `killAnyCursor` `killAnySession` `killop` |
------
#### [ Backup administrator ]
****
| Rollenname | Description | Aktionen |
| --- | --- | --- |
| backup | Gewährt einem Benutzer den erforderlichen Zugriff zum Sichern von Daten. | `getParameter` `insert` `find` `listChangeStreams` `listCollections` `listDatabases` `listIndexes` `update` |
| restore | Gewährt einem Benutzer den erforderlichen Zugriff zum Wiederherstellen von Daten. | `bypassDocumentValidation` `changeCustomData` `changePassword` `collMod` `createCollection` `createIndex` `createUser` `dropCollection` `dropRole` `dropUser` `getParameter` `grantRole` `find` `insert` `listCollections` `modifyChangeStreams` `revokeRole` `remove` `viewRole` `viewUser` `update` |
------