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.
# Ressourcenbasierte Richtlinien für Aurora DSQL
Verwenden Sie ressourcenbasierte Richtlinien für Aurora DSQL, um den Zugriff auf Ihre Cluster mithilfe von JSON-Richtliniendokumenten einzuschränken oder zu gewähren, die direkt mit Ihren Clusterressourcen verknüpft sind. Diese Richtlinien bieten eine detaillierte Kontrolle darüber, wer unter welchen Bedingungen auf Ihren Cluster zugreifen kann.
Aurora DSQL-Cluster sind standardmäßig über das öffentliche Internet zugänglich, wobei die IAM-Authentifizierung die primäre Sicherheitskontrolle ist. Mithilfe ressourcenbasierter Richtlinien können Sie Zugriffsbeschränkungen hinzufügen, insbesondere um den Zugriff über das öffentliche Internet zu blockieren.
Ressourcenbasierte Richtlinien arbeiten mit identitätsbasierten IAM-Richtlinien zusammen. AWS bewertet beide Arten von Richtlinien, um die endgültigen Berechtigungen für jede Zugriffsanfrage auf Ihren Cluster zu ermitteln. Standardmäßig sind Aurora DSQL-Cluster innerhalb eines Kontos zugänglich. Wenn ein IAM-Benutzer oder eine IAM-Rolle über Aurora DSQL-Berechtigungen verfügt, kann er auf Cluster zugreifen, ohne dass eine ressourcenbasierte Richtlinie angehängt ist.
**Anmerkung**
Änderungen an ressourcenbasierten Richtlinien sind letztlich konsistent und werden in der Regel innerhalb einer Minute wirksam.
*Weitere Informationen zu den Unterschieden zwischen identitätsbasierten und ressourcenbasierten Richtlinien finden Sie unter [Identitätsbasierte Richtlinien und ressourcenbasierte Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html) im IAM-Benutzerhandbuch.*
## Wann sollten ressourcenbasierte Richtlinien verwendet werden
Ressourcenbasierte Richtlinien sind in diesen Szenarien besonders nützlich:
+ *Netzwerkbasierte Zugriffskontrolle* — Beschränken Sie den Zugriff auf der Grundlage der VPC oder IP-Adresse, von der Anfragen stammen, oder blockieren Sie den öffentlichen Internetzugang vollständig. Verwenden Sie Bedingungsschlüssel wie `aws:SourceVpc` und`aws:SourceIp`, um den Netzwerkzugriff zu kontrollieren.
+ *Mehrere Teams oder Anwendungen* — Gewähren Sie mehreren Teams oder Anwendungen Zugriff auf denselben Cluster. Anstatt einzelne IAM-Richtlinien für jeden Prinzipal zu verwalten, definieren Sie Zugriffsregeln nur einmal im Cluster.
+ *Komplexer bedingter Zugriff* — Steuern Sie den Zugriff auf der Grundlage mehrerer Faktoren wie Netzwerkattributen, Anforderungskontext und Benutzerattributen. Sie können mehrere Bedingungen in einer einzigen Richtlinie kombinieren.
+ *Zentralisierte Sicherheitssteuerung* — Ermöglichen Sie es Cluster-Besitzern, den Zugriff mithilfe einer vertrauten AWS Richtliniensyntax zu kontrollieren, die sich in Ihre bestehenden Sicherheitspraktiken einfügt.
**Anmerkung**
Kontoübergreifender Zugriff wird für ressourcenbasierte Aurora DSQL-Richtlinien noch nicht unterstützt, wird aber in future Versionen verfügbar sein.
Wenn jemand versucht, eine Verbindung zu Ihrem Aurora DSQL-Cluster herzustellen, AWS bewertet Ihre ressourcenbasierte Richtlinie als Teil des Autorisierungskontextes zusammen mit allen relevanten IAM-Richtlinien, um festzustellen, ob die Anfrage zugelassen oder abgelehnt werden soll.
Ressourcenbasierte Richtlinien können Prinzipalen Zugriff gewähren, die sich innerhalb desselben Kontos wie der Cluster befinden. AWS Bei Clustern mit mehreren Regionen hat jeder regionale Cluster seine eigene ressourcenbasierte Richtlinie, die bei Bedarf regionsspezifische Zugriffskontrollen ermöglicht.
**Anmerkung**
Bedingungskontextschlüssel können je nach Region variieren (z. B. VPC IDs).
**Topics**
+ [Wann sollte dies verwendet werden?](#rbp-when-to-use)
+ [Mit Richtlinien erstellen](rbp-create-cluster.md)
+ [Richtlinien hinzufügen und bearbeiten](rbp-attach-policy.md)
+ [Richtlinie anzeigen](rbp-view-policy.md)
+ [Richtlinie entfernen](rbp-remove-policy.md)
+ [Beispiele für Richtlinien](rbp-examples.md)
+ [Blockieren des öffentlichen Zugriffs](rbp-block-public-access.md)
+ [API-Operationen](rbp-api-operations.md)
# Cluster mit ressourcenbasierten Richtlinien erstellen
Sie können beim Erstellen eines neuen Clusters ressourcenbasierte Richtlinien anhängen, um sicherzustellen, dass die Zugriffskontrollen von Anfang an vorhanden sind. Jedem Cluster kann eine einzelne Inline-Richtlinie direkt an den Cluster angehängt werden.
## AWS Management-Konsole
**Um bei der Clustererstellung eine ressourcenbasierte Richtlinie hinzuzufügen**
1. Melden Sie sich bei der AWS Management Console an und öffnen Sie die Aurora DSQL-Konsole unter [https://console.aws.amazon.com/dsql/](https://console.aws.amazon.com/dsql).
1. Wählen Sie **Cluster erstellen**.
1. Konfigurieren Sie Ihren Clusternamen, Ihre Tags und Einstellungen für mehrere Regionen nach Bedarf.
1. Suchen Sie im Abschnitt **Clustereinstellungen** nach der Option **Ressourcenbasierte Richtlinie**.
1. Aktivieren Sie die Option **Ressourcenbasierte Richtlinie hinzufügen**.
1. Geben Sie Ihr Richtliniendokument im JSON-Editor ein. Um beispielsweise den öffentlichen Internetzugang zu blockieren:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Principal": {
"AWS": "*"
},
"Resource": "*",
"Action": [
"dsql:DbConnect",
"dsql:DbConnectAdmin"
],
"Condition": {
"Null": {
"aws:SourceVpc": "true"
}
}
}
]
}
```
1. Sie können die Option **Aussage bearbeiten** oder **Neue Erklärung hinzufügen** verwenden, um Ihre Richtlinie zu erstellen.
1. Schließen Sie die verbleibende Clusterkonfiguration ab und wählen Sie **Create cluster** aus.
## AWS CLI
Verwenden Sie den `--policy` Parameter beim Erstellen eines Clusters, um eine Inline-Richtlinie anzuhängen:
```
aws dsql create-cluster --policy '{
"Version": "2012-10-17",
"Statement": [{
"Effect": "Deny",
"Principal": {"AWS": "*"},
"Resource": "*",
"Action": ["dsql:DbConnect", "dsql:DbConnectAdmin"],
"Condition": {
"StringNotEquals": { "aws:SourceVpc": "vpc-123456" }
}
}]
}'
```
## AWS SDKs
------
#### [ Python ]
```
import boto3
import json
client = boto3.client('dsql')
policy = {
"Version": "2012-10-17",
"Statement": [{
"Effect": "Deny",
"Principal": {"AWS": "*"},
"Resource": "*",
"Action": ["dsql:DbConnect", "dsql:DbConnectAdmin"],
"Condition": {
"StringNotEquals": { "aws:SourceVpc": "vpc-123456" }
}
}]
}
response = client.create_cluster(
policy=json.dumps(policy)
)
print(f"Cluster created: {response['identifier']}")
```
------
#### [ Java ]
```
import software.amazon.awssdk.services.dsql.DsqlClient;
import software.amazon.awssdk.services.dsql.model.CreateClusterRequest;
import software.amazon.awssdk.services.dsql.model.CreateClusterResponse;
DsqlClient client = DsqlClient.create();
String policy = """
{
"Version": "2012-10-17",
"Statement": [{
"Effect": "Deny",
"Principal": {"AWS": "*"},
"Resource": "*",
"Action": ["dsql:DbConnect", "dsql:DbConnectAdmin"],
"Condition": {
"StringNotEquals": { "aws:SourceVpc": "vpc-123456" }
}
}]
}
""";
CreateClusterRequest request = CreateClusterRequest.builder()
.policy(policy)
.build();
CreateClusterResponse response = client.createCluster(request);
System.out.println("Cluster created: " + response.identifier());
```
------
# Hinzufügen und Bearbeiten ressourcenbasierter Richtlinien für Cluster
## AWS Management-Konsole
**Um einem vorhandenen Cluster eine ressourcenbasierte Richtlinie hinzuzufügen**
1. Melden Sie sich bei der AWS Management Console an und öffnen Sie die Aurora DSQL-Konsole unter [https://console.aws.amazon.com/dsql/](https://console.aws.amazon.com/dsql).
1. Wählen Sie Ihren Cluster aus der Cluster-Liste aus, um die Cluster-Detailseite zu öffnen.
1. Wählen Sie die Registerkarte **Berechtigungen**.
1. Wählen Sie im Abschnitt **Ressourcenbasierte Richtlinie die** Option Richtlinie **hinzufügen** aus.
1. Geben Sie Ihr Richtliniendokument im JSON-Editor ein. Sie können die Option **Erklärung bearbeiten** oder **Neue Erklärung hinzufügen** verwenden, um Ihre Richtlinie zu erstellen.
1. Wählen Sie **Richtlinie hinzufügen** aus.
**Um eine bestehende ressourcenbasierte Richtlinie zu bearbeiten**
1. Melden Sie sich bei der AWS Management Console an und öffnen Sie die Aurora DSQL-Konsole unter [https://console.aws.amazon.com/dsql/](https://console.aws.amazon.com/dsql).
1. Wählen Sie Ihren Cluster aus der Cluster-Liste aus, um die Cluster-Detailseite zu öffnen.
1. Wählen Sie die Registerkarte **Berechtigungen**.
1. **Wählen Sie im Abschnitt **Ressourcenbasierte Richtlinie die** Option Bearbeiten aus.**
1. Ändern Sie das Richtliniendokument im JSON-Editor. Sie können die Option **Erklärung bearbeiten** oder **Neue Erklärung hinzufügen** verwenden, um Ihre Richtlinie zu aktualisieren.
1. Wählen Sie **Änderungen speichern ** aus.
## AWS CLI
Verwenden Sie den `put-cluster-policy` Befehl, um eine neue Richtlinie anzuhängen oder eine bestehende Richtlinie auf einem Cluster zu aktualisieren:
```
aws dsql put-cluster-policy --identifier your_cluster_id --policy '{
"Version": "2012-10-17",
"Statement": [{
"Effect": "Deny",
"Principal": {"AWS": "*"},
"Resource": "*",
"Action": ["dsql:DbConnect", "dsql:DbConnectAdmin"],
"Condition": {
"Null": { "aws:SourceVpc": "true" }
}
}]
}'
```
## AWS SDKs
------
#### [ Python ]
```
import boto3
import json
client = boto3.client('dsql')
policy = {
"Version": "2012-10-17",
"Statement": [{
"Effect": "Deny",
"Principal": {"AWS": "*"},
"Resource": "*",
"Action": ["dsql:DbConnect", "dsql:DbConnectAdmin"],
"Condition": {
"Null": {"aws:SourceVpc": "true"}
}
}]
}
response = client.put_cluster_policy(
identifier='your_cluster_id',
policy=json.dumps(policy)
)
```
------
#### [ Java ]
```
import software.amazon.awssdk.services.dsql.DsqlClient;
import software.amazon.awssdk.services.dsql.model.PutClusterPolicyRequest;
DsqlClient client = DsqlClient.create();
String policy = """
{
"Version": "2012-10-17",
"Statement": [{
"Effect": "Deny",
"Principal": {"AWS": "*"},
"Resource": "*",
"Action": ["dsql:DbConnect", "dsql:DbConnectAdmin"],
"Condition": {
"Null": {"aws:SourceVpc": "true"}
}
}]
}
""";
PutClusterPolicyRequest request = PutClusterPolicyRequest.builder()
.identifier("your_cluster_id")
.policy(policy)
.build();
client.putClusterPolicy(request);
```
------
# Ressourcenbasierte Richtlinien anzeigen
Sie können sich die ressourcenbasierten Richtlinien ansehen, die Ihren Clustern zugeordnet sind, um sich über die aktuellen Zugriffskontrollen zu informieren.
## AWS Management-Konsole
**Um ressourcenbasierte Richtlinien anzuzeigen**
1. Melden Sie sich bei der AWS Management Console an und öffnen Sie die Aurora DSQL-Konsole unter [https://console.aws.amazon.com/dsql/](https://console.aws.amazon.com/dsql).
1. Wählen Sie Ihren Cluster aus der Cluster-Liste aus, um die Cluster-Detailseite zu öffnen.
1. Wählen Sie die Registerkarte **Berechtigungen**.
1. Sehen Sie sich die beigefügte Richtlinie im **Abschnitt Ressourcenbasierte Richtlinie** an.
## AWS CLI
Verwenden Sie den `get-cluster-policy` Befehl, um die ressourcenbasierte Richtlinie eines Clusters anzuzeigen:
```
aws dsql get-cluster-policy --identifier your_cluster_id
```
## AWS SDKs
------
#### [ Python ]
```
import boto3
import json
client = boto3.client('dsql')
response = client.get_cluster_policy(
identifier='your_cluster_id'
)
# Parse and pretty-print the policy
policy = json.loads(response['policy'])
print(json.dumps(policy, indent=2))
```
------
#### [ Java ]
```
import software.amazon.awssdk.services.dsql.DsqlClient;
import software.amazon.awssdk.services.dsql.model.GetClusterPolicyRequest;
import software.amazon.awssdk.services.dsql.model.GetClusterPolicyResponse;
DsqlClient client = DsqlClient.create();
GetClusterPolicyRequest request = GetClusterPolicyRequest.builder()
.identifier("your_cluster_id")
.build();
GetClusterPolicyResponse response = client.getClusterPolicy(request);
System.out.println("Policy: " + response.policy());
```
------
# Entfernen ressourcenbasierter Richtlinien
Sie können ressourcenbasierte Richtlinien aus Clustern entfernen, um die Zugriffskontrollen zu ändern.
**Wichtig**
Wenn Sie alle ressourcenbasierten Richtlinien aus einem Cluster entfernen, wird der Zugriff vollständig durch identitätsbasierte IAM-Richtlinien gesteuert.
## AWS Management-Konsole
**Um eine ressourcenbasierte Richtlinie zu entfernen**
1. Melden Sie sich bei der AWS Management Console an und öffnen Sie die Aurora DSQL-Konsole unter [https://console.aws.amazon.com/dsql/](https://console.aws.amazon.com/dsql).
1. Wählen Sie Ihren Cluster aus der Cluster-Liste aus, um die Cluster-Detailseite zu öffnen.
1. Wählen Sie die Registerkarte **Berechtigungen**.
1. **Wählen Sie im Abschnitt **Ressourcenbasierte Richtlinie die** Option Löschen aus.**
1. Geben Sie im Bestätigungsdialogfeld ein, **confirm** um den Löschvorgang zu bestätigen.
1. Wählen Sie **Löschen** aus.
## AWS CLI
Verwenden Sie den `delete-cluster-policy` Befehl, um eine Richtlinie aus einem Cluster zu entfernen:
```
aws dsql delete-cluster-policy --identifier your_cluster_id
```
## AWS SDKs
------
#### [ Python ]
```
import boto3
client = boto3.client('dsql')
response = client.delete_cluster_policy(
identifier='your_cluster_id'
)
print("Policy deleted successfully")
```
------
#### [ Java ]
```
import software.amazon.awssdk.services.dsql.DsqlClient;
import software.amazon.awssdk.services.dsql.model.DeleteClusterPolicyRequest;
DsqlClient client = DsqlClient.create();
DeleteClusterPolicyRequest request = DeleteClusterPolicyRequest.builder()
.identifier("your_cluster_id")
.build();
client.deleteClusterPolicy(request);
System.out.println("Policy deleted successfully");
```
------
# Allgemeine Beispiele für ressourcenbasierte Richtlinien
Diese Beispiele zeigen gängige Muster für die Steuerung des Zugriffs auf Ihre Aurora DSQL-Cluster. Sie können diese Muster kombinieren und ändern, um Ihre spezifischen Zugriffsanforderungen zu erfüllen.
## Sperren Sie den öffentlichen Internetzugang
Diese Richtlinie blockiert Verbindungen zu Ihren Aurora DSQL-Clustern aus dem öffentlichen Internet (ohne VPC). Die Richtlinie legt nicht fest, von welcher VPC Kunden eine Verbindung herstellen können, sondern nur, dass sie sich von einer VPC aus verbinden müssen. Um den Zugriff auf eine bestimmte VPC zu beschränken, verwenden Sie ihn `aws:SourceVpc` zusammen mit dem `StringEquals` Bedingungsoperator.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Principal": {
"AWS": "*"
},
"Resource": "*",
"Action": [
"dsql:DbConnect",
"dsql:DbConnectAdmin"
],
"Condition": {
"Null": {
"aws:SourceVpc": "true"
}
}
}
]
}
```
**Anmerkung**
In diesem Beispiel wird nur `aws:SourceVpc` nach VPC-Verbindungen gesucht. Die Schlüssel `aws:VpcSourceIp` und `aws:SourceVpce` Condition bieten zusätzliche Granularität, sind aber für die grundlegende reine VPC-Zugriffskontrolle nicht erforderlich.
Verwenden Sie stattdessen diese Richtlinie, um eine Ausnahme für bestimmte Rollen bereitzustellen:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "DenyAccessFromOutsideVPC",
"Effect": "Deny",
"Principal": {
"AWS": "*"
},
"Resource": "*",
"Action": [
"dsql:DbConnect",
"dsql:DbConnectAdmin"
],
"Condition": {
"Null": {
"aws:SourceVpc": "true"
},
"StringNotEquals": {
"aws:PrincipalArn": [
"arn:aws:iam::123456789012:role/ExceptionRole",
"arn:aws:iam::123456789012:role/AnotherExceptionRole"
]
}
}
}
]
}
```
## Beschränken Sie den Zugriff auf die AWS Organisation
Diese Richtlinie schränkt den Zugriff auf Prinzipale innerhalb einer Organisation ein AWS :
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Principal": {
"AWS": "*"
},
"Action": [
"dsql:DbConnect",
"dsql:DbConnectAdmin"
],
"Resource": "arn:aws:dsql:us-east-1:123456789012:cluster/mydsqlclusterid0123456789a",
"Condition": {
"StringNotEquals": {
"aws:PrincipalOrgID": "o-exampleorgid"
}
}
}
]
}
```
## Beschränken Sie den Zugriff auf eine bestimmte Organisationseinheit
Diese Richtlinie schränkt den Zugriff auf Prinzipale innerhalb einer bestimmten Organisationseinheit (OU) in einer AWS Organisation ein und bietet so eine detailliertere Kontrolle als der organisationsweite Zugriff:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Principal": {
"AWS": "*"
},
"Action": [
"dsql:DbConnect"
],
"Resource": "arn:aws:dsql:us-east-1:123456789012:cluster/mydsqlclusterid0123456789a",
"Condition": {
"StringNotLike": {
"aws:PrincipalOrgPaths": "o-exampleorgid/r-examplerootid/ou-exampleouid/*"
}
}
}
]
}
```
## Clusterrichtlinien für mehrere Regionen
Bei Clustern mit mehreren Regionen unterhält jeder regionale Cluster seine eigene Ressourcenpolitik, die regionsspezifische Kontrollen ermöglicht. Hier ist ein Beispiel mit unterschiedlichen Richtlinien pro Region:
*US-Ost-1-Politik:*
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Principal": {
"AWS": "*"
},
"Resource": "*",
"Action": [
"dsql:DbConnect"
],
"Condition": {
"StringNotEquals": {
"aws:SourceVpc": "vpc-east1-id"
},
"Null": {
"aws:SourceVpc": "true"
}
}
}
]
}
```
*US-Ost-2-Politik:*
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "*"
},
"Resource": "*",
"Action": [
"dsql:DbConnect"
],
"Condition": {
"StringEquals": {
"aws:SourceVpc": "vpc-east2-id"
}
}
}
]
}
```
**Anmerkung**
Die Schlüssel für den Bedingungskontext können zwischen diesen variieren AWS-Regionen (z. B. VPC IDs).
# Blockieren des öffentlichen Zugriffs mit ressourcenbasierten Richtlinien in Aurora DSQL
Block Public Access (BPA) ist eine Funktion, die das Anhängen von ressourcenbasierten Richtlinien, die öffentlichen Zugriff auf Ihre Aurora DSQL-Cluster über Ihre Konten gewähren, identifiziert und verhindert. AWS Mit BPA können Sie den öffentlichen Zugriff auf Ihre Aurora DSQL-Ressourcen verhindern. BPA führt während der Erstellung oder Änderung einer ressourcenbasierten Richtlinie Prüfungen durch und hilft Ihnen, Ihre Sicherheitslage mit Aurora DSQL zu verbessern.
BPA analysiert mittels [Automated Reasoning](https://aws.amazon.com/what-is/automated-reasoning/) den durch Ihre ressourcenbasierte Richtlinie gewährten Zugriff und warnt Sie, wenn solche Berechtigungen zum Zeitpunkt der Verwaltung einer ressourcenbasierten Richtlinie gefunden werden. Bei der Analyse wird der Zugriff über alle ressourcenbasierten Richtlinienanweisungen, Aktionen und die in Ihren Richtlinien verwendeten Bedingungsschlüssel überprüft.
**Wichtig**
BPA trägt zum Schutz Ihrer Ressourcen bei, indem verhindert wird, dass öffentlicher Zugriff über die ressourcenbasierten Richtlinien gewährt wird, die direkt mit Ihren Aurora DSQL-Ressourcen wie Clustern verknüpft sind. Überprüfen Sie zusätzlich zur Aktivierung von BPA sorgfältig die folgenden Richtlinien, um sicherzustellen, dass sie keinen öffentlichen Zugriff gewähren:
Identitätsbasierte Richtlinien, die mit zugehörigen AWS Principals verknüpft sind (z. B. IAM-Rollen)
Ressourcenbasierte Richtlinien, die mit zugehörigen AWS Ressourcen verknüpft sind (z. B. AWS Key Management Service (KMS) -Schlüssel)
Sie müssen sicherstellen, dass der [Prinzipal](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html) keinen `*`-Eintrag enthält oder dass keiner der angegebenen Bedingungsschlüssel den Zugriff der Prinzipale auf die Ressource einschränkt. Wenn die ressourcenbasierte Richtlinie AWS kontenübergreifend öffentlichen Zugriff auf Ihren Cluster gewährt, blockiert Aurora DSQL Sie daran, die Richtlinie zu erstellen oder zu ändern, bis die Spezifikation in der Richtlinie korrigiert und als nicht öffentlich eingestuft wurde.
Sie können eine Richtlinie als nicht öffentlich festlegen, indem Sie einen oder mehrere Prinzipale im `Principal`-Block angeben. Im folgenden Beispiel für eine ressourcenbasierte Richtlinie wird der öffentliche Zugriff blockiert, indem zwei Prinzipale angegeben werden.
```
{
"Effect": "Allow",
"Principal": {
"AWS": [
"123456789012",
"111122223333"
]
},
"Action": "dsql:*",
"Resource": "arn:aws:dsql:us-east-1:123456789012:cluster/cluster-id"
}
```
Richtlinien, die den Zugriff durch die Angabe bestimmter Bedingungsschlüssel einschränken, gelten ebenfalls nicht als öffentlich. Neben der Auswertung des in der ressourcenbasierten Richtlinie angegebenen Prinzipals werden die folgenden [vertrauenswürdigen Bedingungsschlüssel](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) verwendet, um die Auswertung einer ressourcenbasierten Richtlinie für den nicht öffentlichen Zugriff abzuschließen:
+ `aws:PrincipalAccount`
+ `aws:PrincipalArn`
+ `aws:PrincipalOrgID`
+ `aws:PrincipalOrgPaths`
+ `aws:SourceAccount`
+ `aws:SourceArn`
+ `aws:SourceVpc`
+ `aws:SourceVpce`
+ `aws:UserId`
+ `aws:PrincipalServiceName`
+ `aws:PrincipalServiceNamesList`
+ `aws:PrincipalIsAWSService`
+ `aws:Ec2InstanceSourceVpc`
+ `aws:SourceOrgID`
+ `aws:SourceOrgPaths`
Damit eine ressourcenbasierte Richtlinie nicht öffentlich ist, dürfen die Werte für den Amazon-Ressourcennamen (ARN) und Zeichenfolgenschlüssel außerdem keine Platzhalter oder Variablen enthalten. Wenn Ihre ressourcenbasierte Richtlinie den `aws:PrincipalIsAWSService`-Schlüssel verwendet, müssen Sie sicherstellen, dass Sie den Schlüsselwert auf „true“ gesetzt haben.
Die folgende Richtlinie grenzt den Zugriff auf den Benutzer `Ben` im angegebenen Konto ein. Aufgrund dieser Bedingung ist der `Principal` eingeschränkt und wird als nicht öffentlich betrachtet.
```
{
"Effect": "Allow",
"Principal": {
"AWS": "*"
},
"Action": "dsql:*",
"Resource": "arn:aws:dsql:us-east-1:123456789012:cluster/cluster-id",
"Condition": {
"StringEquals": {
"aws:PrincipalArn": "arn:aws:iam::123456789012:user/Ben"
}
}
}
```
Das folgende Beispiel für eine nicht öffentliche ressourcenbasierte Richtlinie schränkt `sourceVPC` auf die Verwendung des `StringEquals`-Operators ein.
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "*"
},
"Action": "dsql:*",
"Resource": "arn:aws:dsql:us-east-1:123456789012:cluster/cluster-id",
"Condition": {
"StringEquals": {
"aws:SourceVpc": [
"vpc-91237329"
]
}
}
}
]
}
```
# Aurora DSQL API-Operationen und ressourcenbasierte Richtlinien
Ressourcenbasierte Richtlinien in Aurora DSQL steuern den Zugriff auf bestimmte API-Operationen. In den folgenden Abschnitten sind alle Aurora DSQL-API-Operationen nach Kategorien geordnet aufgeführt, mit Angabe, welche Operationen ressourcenbasierte Richtlinien unterstützen.
Die Spalte *Unterstützt RBP* gibt an, ob der API-Vorgang einer ressourcenbasierten Richtlinienbewertung unterzogen wird, wenn eine Richtlinie an den Cluster angehängt wird.
## Tag APIs
| API-Operation | Description | Unterstützt RBP |
| --- | --- | --- |
| [ListTagsForResource](https://docs.aws.amazon.com/aurora-dsql/latest/APIReference/API_ListTagsForResource.html) | Listet die Tags für eine Aurora DSQL-Ressource auf | Ja |
| [TagResource](https://docs.aws.amazon.com/aurora-dsql/latest/APIReference/API_TagResource.html) | Fügt einer Aurora DSQL-Ressource Tags hinzu | Ja |
| [UntagResource](https://docs.aws.amazon.com/aurora-dsql/latest/APIReference/API_UntagResource.html) | Entfernt Tags aus einer Aurora DSQL-Ressource | Ja |
## Cluster-Verwaltung APIs
| API-Operation | Description | Unterstützt RBP |
| --- | --- | --- |
| [CreateCluster](https://docs.aws.amazon.com/aurora-dsql/latest/APIReference/API_CreateCluster.html) | Erstellt einen Cluster | Nein |
| [DeleteCluster](https://docs.aws.amazon.com/aurora-dsql/latest/APIReference/API_DeleteCluster.html) | Löscht einen Cluster | Ja |
| [GetCluster](https://docs.aws.amazon.com/aurora-dsql/latest/APIReference/API_GetCluster.html) | Ruft Informationen über einen Cluster ab | Ja |
| [GetVpcEndpointServiceName](https://docs.aws.amazon.com/aurora-dsql/latest/APIReference/API_GetVpcEndpointServiceName.html) | Ruft den VPC-Endpunktdienstnamen für einen Cluster ab | Ja |
| [ListClusters](https://docs.aws.amazon.com/aurora-dsql/latest/APIReference/API_ListClusters.html) | Listet Cluster in Ihrem Konto auf | Nein |
| [UpdateCluster](https://docs.aws.amazon.com/aurora-dsql/latest/APIReference/API_UpdateCluster.html) | Aktualisiert die Konfiguration eines Clusters | Ja |
## Eigenschaft für mehrere Regionen APIs
| API-Operation | Description | Unterstützt RBP |
| --- | --- | --- |
| [AddPeerCluster](https://docs.aws.amazon.com/aurora-dsql/latest/APIReference/API_AddPeerCluster.html) | Fügt einer Konfiguration mit mehreren Regionen einen Peer-Cluster hinzu | Ja |
| [PutMultiRegionProperties](https://docs.aws.amazon.com/aurora-dsql/latest/APIReference/API_PutMultiRegionProperties.html) | Legt Eigenschaften für mehrere Regionen für einen Cluster fest | Ja |
| [PutWitnessRegion](https://docs.aws.amazon.com/aurora-dsql/latest/APIReference/API_PutWitnessRegion.html) | Legt die Zeugenregion für einen Cluster mit mehreren Regionen fest | Ja |
## Ressourcenbasierte Richtlinie APIs
| API-Operation | Description | Unterstützt RBP |
| --- | --- | --- |
| [DeleteClusterPolicy](https://docs.aws.amazon.com/aurora-dsql/latest/APIReference/API_DeleteClusterPolicy.html) | Löscht die ressourcenbasierte Richtlinie aus einem Cluster | Ja |
| [GetClusterPolicy](https://docs.aws.amazon.com/aurora-dsql/latest/APIReference/API_GetClusterPolicy.html) | Ruft die ressourcenbasierte Richtlinie für einen Cluster ab | Ja |
| [PutClusterPolicy](https://docs.aws.amazon.com/aurora-dsql/latest/APIReference/API_PutClusterPolicy.html) | Erstellt oder aktualisiert die ressourcenbasierte Richtlinie für einen Cluster | Ja |
## AWS Fault Injection Service APIs
| API-Operation | Description | Unterstützt RBP |
| --- | --- | --- |
| [InjectError](https://docs.aws.amazon.com/aurora-dsql/latest/APIReference/API_InjectError.html) | Fügt Fehler beim Testen von Fehlerinjektionen ein | Nein |
## Backup und Wiederherstellung APIs
| API-Operation | Description | Unterstützt RBP |
| --- | --- | --- |
| [GetBackupJob](https://docs.aws.amazon.com/aurora-dsql/latest/APIReference/API_GetBackupJob.html) | Ruft Informationen über einen Backup-Job ab | Nein |
| [GetRestoreJob](https://docs.aws.amazon.com/aurora-dsql/latest/APIReference/API_GetRestoreJob.html) | Ruft Informationen über einen Wiederherstellungsauftrag ab | Nein |
| [StartBackupJob](https://docs.aws.amazon.com/aurora-dsql/latest/APIReference/API_StartBackupJob.html) | Startet einen Backup-Job für einen Cluster | Ja |
| [StartRestoreJob](https://docs.aws.amazon.com/aurora-dsql/latest/APIReference/API_StartRestoreJob.html) | Startet einen Wiederherstellungsauftrag aus einem Backup | Nein |
| [StopBackupJob](https://docs.aws.amazon.com/aurora-dsql/latest/APIReference/API_StopBackupJob.html) | Stoppt einen laufenden Backup-Job | Nein |
| [StopRestoreJob](https://docs.aws.amazon.com/aurora-dsql/latest/APIReference/API_StopRestoreJob.html) | Stoppt einen laufenden Wiederherstellungsauftrag | Nein |