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.
# Sicherung Ihrer Amazon Neptune Neptune-Datenbank
Cloud-Sicherheit hat höchste AWS Priorität. Als AWS Kunde profitieren Sie von einer Rechenzentrums- und Netzwerkarchitektur, die darauf ausgelegt sind, die Anforderungen der sicherheitssensibelsten Unternehmen zu erfüllen.
Sicherheit ist eine gemeinsame Verantwortung von Ihnen AWS und Ihnen. Das [Modell der geteilten Verantwortung](https://aws.amazon.com/compliance/shared-responsibility-model/) beschreibt dies als Sicherheit *der* Cloud und Sicherheit *in* der Cloud:
+ **Sicherheit der Cloud** — AWS ist verantwortlich für den Schutz der Infrastruktur, die AWS Dienste in der AWS Cloud ausführt. AWS bietet Ihnen auch Dienste, die Sie sicher nutzen können. Auditoren von Drittanbietern testen und überprüfen die Effektivität unserer Sicherheitsmaßnahmen im Rahmen der [AWS -Compliance-Programme](https://aws.amazon.com/compliance/programs/) regelmäßig. Informationen zu den für Amazon Neptune geltenden Compliance-Programmen finden Sie unter [Im Rahmen des Compliance-Programms zugelassene -Services](https://aws.amazon.com/compliance/services-in-scope/).
+ **Sicherheit in der Cloud** — Ihre Verantwortung richtet sich nach dem AWS Dienst, den Sie nutzen. Sie sind auch für andere Faktoren verantwortlich, etwa für die Vertraulichkeit Ihrer Daten, für die Anforderungen Ihres Unternehmens und für die geltenden Gesetze und Vorschriften.
Diese Dokumentation hilft Ihnen, zu verstehen, wie Sie das Modell der geteilten Verantwortung bei der Verwendung von Neptune anwenden. Die folgenden Themen zeigen Ihnen, wie Sie Neptune zur Erfüllung Ihrer Sicherheits- und Compliance-Ziele konfigurieren können. Sie lernen auch, wie Sie andere AWS Dienste nutzen können, die Ihnen helfen, Ihre Neptune-Ressourcen zu überwachen und zu sichern.
**Topics**
+ [Upgrades des Amazon Neptune Neptune-Betriebssystems](security-os-upgrades.md)
+ [Schutz von Daten in Ihrer Amazon Neptune Neptune-Datenbank](data-protection.md)
+ [Authentifizieren Sie Ihre Amazon Neptune Neptune-Datenbank mit AWS Identity and Access Management](iam-auth.md)
+ [Aktivierung der IAM-Datenbankauthentifizierung in Amazon Neptune](iam-auth-enable.md)
+ [Mit Authentifizierung eine Verbindung zu Ihrer Amazon Neptune Neptune-Datenbank herstellen AWS Identity and Access Management](iam-auth-connecting.md)
+ [Verwaltung des Zugriffs auf Amazon Neptune Neptune-Datenbanken mithilfe von IAM-Richtlinien](security-iam-access-manage.md)
+ [Verwenden von serviceverknüpften Rollen für Amazon Neptune](security-iam-service-linked-roles.md)
+ [Temporäre Anmeldeinformationen verwenden, um eine Verbindung zu Amazon Neptune herzustellen](iam-auth-temporary-credentials.md)
+ [Protokollierung und Überwachung von Nutzung und Leistung in Amazon Neptune](security-monitoring.md)
+ [Amazon Neptune- und Schnittstellen-VPC-Endpunkte ()AWS PrivateLink](vpc-interface-endpoints.md)
+ [Überlegungen zur Einhaltung von Vorschriften für Amazon Neptune](neptune-compliance.md)
+ [Aufbau robuster und katastrophentoleranter Amazon Neptune Neptune-Bereitstellungen](disaster-recovery-resiliency.md)
# Upgrades des Amazon Neptune Neptune-Betriebssystems
Amazon Neptune sorgt durch regelmäßige Betriebssystem-Upgrades für kontinuierliche Verbesserungen der Datenbankleistung, Sicherheit und Stabilität. Diese Upgrades werden nach einem strukturierten Aktualisierungsprozess sowohl auf Neptune Databases als auch auf Neptune Analytics angewendet. Amazon Neptune veröffentlicht mindestens einmal pro Monat Betriebssystem-Upgrades.
Neptune Database OS-Updates, für die keine Ausfallzeiten erforderlich sind, werden während des Wartungsfensters automatisch angewendet. Bestimmte Betriebssystemupdates (z. B. ein Upgrade der Kernelversion) erfordern einen Neustart der Instanz. Diese Updates sind optional und haben kein festes Datum, an dem sie angewendet werden sollen. Wenn Sie diese Updates jedoch nicht installieren, werden sie möglicherweise irgendwann erforderlich und werden während des Wartungsfensters Ihrer Instanz automatisch angewendet.
**Neptune Analytics** — Die Betriebssystem-Upgrades von Neptune Analytics sind nahtlos und erfordern keine Kundenaktion. Diese Updates werden automatisch und ohne Ausfallzeiten im Hintergrund angewendet.
Um Sicherheit und Compliance zu gewährleisten, empfehlen wir Ihnen, alle von Amazon Neptune bereitgestellten Updates während Ihres Wartungsfensters routinemäßig zu installieren. Wenn Sie bei allen optionalen und obligatorischen Updates auf dem Laufenden bleiben, können Sie wichtige Sicherheitspatches integrieren und die Einhaltung verschiedener Compliance-Verpflichtungen sicherstellen. Veraltete Betriebssystemversionen können zur Nichteinhaltung gesetzlicher Anforderungen führen.
## Minimierung der Ausfallzeiten für Betriebssystem-Upgrades, die einen Neustart erfordern
Für Betriebssystem-Upgrades, die einen Neustart erfordern, empfehlen wir, dass Sie zuerst die Reader-Instances in einem Cluster und dann die Writer-Instanz aktualisieren, um die Verfügbarkeit Ihres Clusters zu maximieren. Es wird nicht empfohlen, die Reader- und Writer-Instanzen gleichzeitig zu aktualisieren, da es bei einem Failover zu längeren Ausfallzeiten kommen könnte.
## Betriebssystem-Upgrades auf Ihre Neptune-DB-Instance anwenden
Neptune-DB-Instances erfordern gelegentlich Betriebssystemupdates. Amazon Neptune aktualisiert das Betriebssystem auf eine neuere Version, um die Datenbankleistung und die allgemeine Sicherheitslage der Kunden zu verbessern. In der Regel dauern die Updates etwa 10 Minuten. Betriebssystemupdates ändern nicht die DB-Engine-Version oder die DB-Instance-Klasse einer DB-Instance.
Um benachrichtigt zu werden, wenn ein neues optionales Update verfügbar ist, können Sie es `RDS-EVENT-0230` in der Kategorie Sicherheitspatching-Ereignisse abonnieren. Informationen zum Abonnieren von Amazon Neptune Neptune-Veranstaltungen finden Sie unter [Neptune-Ereignisbenachrichtigung abonnieren](https://docs.aws.amazon.com//neptune/latest/userguide/events-subscribing.html).
**Wichtig**
Ihre Amazon Neptune DB-Instance wird während des Betriebssystem-Upgrades offline geschaltet. Sie können die Cluster-Ausfallzeiten minimieren, indem Sie einen Cluster mit mehreren Instanzen einrichten. Wenn Sie keinen Cluster mit mehreren Instanzen haben, können Sie vorübergehend einen erstellen, indem Sie sekundäre Instanzen hinzufügen, um diese Wartung durchzuführen, und dann die zusätzlichen Reader-Instances löschen, sobald die Wartung abgeschlossen ist (es fallen reguläre Gebühren für die sekundäre Instanz an).
Sie können die AWS-Managementkonsole oder die AWS CLI verwenden, um festzustellen, ob ein Update verfügbar ist.
### Mit dem AWS-Managementkonsole
Um festzustellen, ob ein Update verfügbar ist, verwenden Sie AWS-Managementkonsole:
1. [Melden Sie sich bei der AWS Management Console an und öffnen Sie die Amazon Neptune Neptune-Konsole zu Hausehttps://console.aws.amazon.com/neptune/.](https://console.aws.amazon.com/neptune/home)
1. Wählen Sie im Navigationsbereich **Clusters** und dann die Instance aus.
1. Wählen Sie **Wartung** aus.
1. Suchen Sie im Abschnitt **Ausstehende Wartung** nach dem Betriebssystem-Update.
![\[Ein Bild, das den AWS-Managementkonsole Wartungsbereich und ein verfügbares Betriebssystem-Update zeigt.\]](http://docs.aws.amazon.com/de_de/neptune/latest/userguide/images/consoleForOSUpgrades.png)
Sie können das Betriebssystem-Update auswählen und im Bereich **Ausstehende **Wartung auf **Jetzt anwenden** oder Beim nächsten Wartungsfenster**** anwenden klicken. Wenn der Wartungswert **„Nächstes Fenster“** lautet, verschieben Sie die Wartungsarbeiten, indem Sie „Upgrade **aufschieben**“ wählen. Sie können eine Wartungsaktion nicht verschieben, wenn sie bereits gestartet wurde.
Alternativ können Sie die Instanz aus einer Liste von Clustern auswählen, indem Sie im Navigationsbereich auf **Cluster** klicken und im Menü **Aktionen** die Option **Jetzt anwenden** **oder Beim nächsten Wartungsfenster** anwenden auswählen.
### Verwenden der AWS CLI
Rufen Sie den `describe-pending-maintenance-actions` folgenden Befehl auf, um festzustellen AWS CLI, ob ein Update mit dem verfügbar ist:
```
aws neptune describe-pending-maintenance-actions
```
```
{
"ResourceIdentifier": "arn:aws:rds:us-east-1:123456789012:db:myneptune",
"PendingMaintenanceActionDetails": [
{
"Action": "system-update",
"Description": "New Operating System update is available"
}
]
}
```
Rufen Sie den `apply-pending-maintenance-action` folgenden Befehl auf, um die Betriebssystemupdates anzuwenden:
```
aws neptune apply-pending-maintenance-action \
--apply-action system-update \
--resource-identifier (ARN of your DB instance) \
--opt-in-type immediate
```
# Schutz von Daten in Ihrer Amazon Neptune Neptune-Datenbank
Das AWS [Modell](https://aws.amazon.com/compliance/shared-responsibility-model/) der gilt für den Datenschutz in Amazon Neptune. Wie in diesem Modell beschrieben, AWS ist verantwortlich für den Schutz der globalen Infrastruktur, auf der alle Systeme laufen. AWS Cloud Sie sind dafür verantwortlich, die Kontrolle über Ihre in dieser Infrastruktur gehosteten Inhalte zu behalten. Sie sind auch für die Sicherheitskonfiguration und die Verwaltungsaufgaben für die von Ihnen verwendeten AWS-Services verantwortlich. Weitere Informationen zum Datenschutz finden Sie unter [Häufig gestellte Fragen zum Datenschutz](https://aws.amazon.com/compliance/data-privacy-faq/). Informationen zum Datenschutz in Europa finden Sie im Blog-Beitrag [AWS -Modell der geteilten Verantwortung und in der DSGVO](https://aws.amazon.com/blogs/security/the-aws-shared-responsibility-model-and-gdpr/) im *AWS -Sicherheitsblog*.
Aus Datenschutzgründen empfehlen wir, dass Sie AWS-Konto Anmeldeinformationen schützen und einzelne Benutzer mit AWS IAM Identity Center oder AWS Identity and Access Management (IAM) einrichten. So erhält jeder Benutzer nur die Berechtigungen, die zum Durchführen seiner Aufgaben erforderlich sind. Außerdem empfehlen wir, die Daten mit folgenden Methoden schützen:
+ Verwenden Sie für jedes Konto die Multi-Faktor-Authentifizierung (MFA).
+ Wird verwendet SSL/TLS , um mit AWS Ressourcen zu kommunizieren. Wir benötigen TLS 1.2 und empfehlen TLS 1.3.
+ Richten Sie die API und die Protokollierung von Benutzeraktivitäten mit ein AWS CloudTrail. Informationen zur Verwendung von CloudTrail Pfaden zur Erfassung von AWS Aktivitäten finden Sie unter [Arbeiten mit CloudTrail Pfaden](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-trails.html) im *AWS CloudTrail Benutzerhandbuch*.
+ Verwenden Sie AWS Verschlüsselungslösungen zusammen mit allen darin enthaltenen Standardsicherheitskontrollen AWS-Services.
+ Verwenden Sie erweiterte verwaltete Sicherheitsservices wie Amazon Macie, die dabei helfen, in Amazon S3 gespeicherte persönliche Daten zu erkennen und zu schützen.
+ Wenn Sie für den Zugriff AWS über eine Befehlszeilenschnittstelle oder eine API FIPS 140-3-validierte kryptografische Module benötigen, verwenden Sie einen FIPS-Endpunkt. Weitere Informationen über verfügbare FIPS-Endpunkte finden Sie unter [Federal Information Processing Standard (FIPS) 140-3](https://aws.amazon.com/compliance/fips/).
Wir empfehlen dringend, in Freitextfeldern, z. B. im Feld **Name**, keine vertraulichen oder sensiblen Informationen wie die E-Mail-Adressen Ihrer Kunden einzugeben. Dazu gehört auch, wenn Sie mit Neptune oder anderen AWS-Services über die Konsole AWS CLI, API oder arbeiten. AWS SDKs Alle Daten, die Sie in Tags oder Freitextfelder eingeben, die für Namen verwendet werden, können für Abrechnungs- oder Diagnoseprotokolle verwendet werden. Wenn Sie eine URL für einen externen Server bereitstellen, empfehlen wir dringend, keine Anmeldeinformationen zur Validierung Ihrer Anforderung an den betreffenden Server in die URL einzuschließen.
**Wichtig**
TLS 1.3 wird nur für Neptune Engine-Version 1.3.2.0 und höher unterstützt.
Sie verwenden AWS veröffentlichte API-Aufrufe, um Neptune über das Netzwerk zu verwalten. Clients müssen Transport Layer Security (TLS) 1.2 oder höher mit Suiten für eine starke Verschlüsselung unterstützen, wie in [Verbindungen zu Neptune-Datenbanken verschlüsseln](security-ssl.md) beschrieben. Die meisten modernen Systeme wie Java 7 und höher unterstützen diese Modi.
In den folgenden Abschnitten wird beschrieben, wie Neptune-Daten geschützt werden.
**Topics**
+ [Schützen Sie Ihre Amazon Neptune Neptune-Datenbank mit Amazon VPC](security-vpc.md)
+ [Verschlüsseln von Verbindungen zu Ihrer Amazon Neptune Neptune-Datenbank mit SSL/HTTPS](security-ssl.md)
+ [Verschlüsselung ruhender Daten in Ihrer Amazon Neptune Neptune-Datenbank](encrypt.md)
# Schützen Sie Ihre Amazon Neptune Neptune-Datenbank mit Amazon VPC
Ein Amazon Neptune Neptune-DB-Cluster kann *nur* in einer Amazon Virtual Private Cloud (Amazon VPC) erstellt werden, und seine Endpunkte sind innerhalb dieser VPC zugänglich, normalerweise von einer Amazon Elastic Compute Cloud (Amazon EC2) -Instance aus, die in dieser VPC ausgeführt wird. Alternativ kann über einen öffentlichen Endpunkt darauf zugegriffen werden. Weitere Informationen zu öffentlichen Endpunkten finden Sie unter Öffentliche Endpunkte von [Neptune](neptune-public-endpoints.md).
Sie können Ihre Neptune-Daten schützen, indem Sie den Zugriff auf die VPC einschränken, in der sich Ihr Neptune-DB-Cluster befindet, wie in [Verbindung zu einem Amazon Neptune Neptune-Cluster herstellen](get-started-connecting.md) beschrieben.
# Verschlüsseln von Verbindungen zu Ihrer Amazon Neptune Neptune-Datenbank mit SSL/HTTPS
Amazon Neptune erlaubt nur Secure Sockets Layer (SSL) -Verbindungen über HTTPS zu beliebigen Instances oder Cluster-Endpunkten.
Neptune benötigt mindestens TLS Version 1.2 und verwendet die folgenden starken Verschlüsselungssammlungen:
+ `TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256`
+ `TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384`
+ `TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256`
+ `TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384`
Ab der Neptune-Engine-Version 1.3.2.0 unterstützt Neptune TLS Version 1.3 mit den folgenden Verschlüsselungssammlungen:
+ TLS\$1AES\$1128\$1GCM\$1 SHA256
+ TLS AES 256 GCM SHA384
Auch wenn HTTP-Verbindungen in früheren Engine-Versionen zulässig waren, müssen alle DB-Cluster, die eine neue DB-Cluster-Parametergruppe verwenden, standardmäßig SSL verwenden. *Um Ihre Daten zu schützen, unterstützen Neptune-Endpunkte in Engine-Version `1.0.4.0` und höher ausschließlich HTTPS-Anfragen.* Weitere Informationen finden Sie unter [Herstellen von Verbindungen mit einer Neptune-DB-Instance über den HTTP-REST-Endpunkt](access-graph-sparql-http-rest.md).
Neptune stellt automatisch SSL-Zertifikate für Ihre Neptune-DB-Instances bereit. Sie müssen keine Zertifikate anfordern. Die Zertifikate werden bereitgestellt, wenn Sie eine neue Instance erstellen.
Neptune weist den Instanzen in Ihrem Konto für jede Region ein einzelnes Wildcard-SSL-Zertifikat zu. AWS Das Zertifikat enthält Einträge für die Clusterendpunkte, die schreibgeschützten Clusterendpunkte und die Instance-Endpunkte.
**Zertifikatdetails**
Die folgenden Einträge sind im bereitgestellten Zertifikat enthalten:
+ Cluster-Endpunkt – `*.cluster-a1b2c3d4wxyz.region.neptune.amazonaws.com`
+ Schreibgeschützter Endpunkt – `*.cluster-ro-a1b2c3d4wxyz.region.neptune.amazonaws.com`
+ Instance-Endpunkte – `*.a1b2c3d4wxyz.region.neptune.amazonaws.com`
Nur die hier aufgelisteten Einträge werden unterstützt.
**Proxyverbindungen**
Die Zertifikate unterstützen nur die im vorherigen Abschnitt aufgeführten Hostnamen.
Wenn Sie einen Load Balancer oder einen Proxyserver (z. B. HAProxy) verwenden, müssen Sie die SSL-Terminierung verwenden und Ihr eigenes SSL-Zertifikat auf dem Proxyserver haben.
SSL-Passthrough funktioniert nicht, da die bereitgestellten SSL-Zertifikate nicht mit dem Hostnamen des Proxy-Servers übereinstimmen.
**CA-Stammzertifikate**
Die Zertifikate für Neptune-Instances werden normalerweise mittels des lokalen Vertrauensspeichers des Betriebssystems oder SDK (z. B. des Java-SDK) validiert.
Wenn Sie ein Stammzertifikat manuell bereitstellen müssen, können Sie das [Amazon-CA-Stammzertifikat](https://www.amazontrust.com/repository/AmazonRootCA1.pem) im PEM-Format aus dem [Amazon Trust Services Policy Repository](https://www.amazontrust.com/repository/) herunterladen.
**Weitere Informationen**
Weitere Informationen zum Herstellen von Verbindungen mit Neptune-Endpunkten über SSL siehe [Einrichten der Gremlin-Konsole zum Herstellen einer Verbindung mit einer Neptune-DB-Instance](access-graph-gremlin-console.md) und [Herstellen von Verbindungen mit einer Neptune-DB-Instance über den HTTP-REST-Endpunkt](access-graph-sparql-http-rest.md).
# Verschlüsselung ruhender Daten in Ihrer Amazon Neptune Neptune-Datenbank
Verschlüsselte Neptune-Instances bieten eine zusätzliche Datenschutzebene, da Sie Ihre Daten vor nicht autorisierten Zugriffen auf den zugrunde liegenden Speicher schützen. Sie können mithilfe der Neptune-Verschlüsselung den Datenschutz für Ihre in der Cloud bereitgestellten Anwendungen erhöhen. Sie können es auch verwenden, um die Compliance-Anforderungen für die Verschlüsselung zu erfüllen. data-at-rest
[Um die Schlüssel zu verwalten, die zum Verschlüsseln und Entschlüsseln Ihrer Neptune-Ressourcen verwendet werden, verwenden Sie ().AWS Key Management ServiceAWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/) AWS KMS kombiniert sichere, hochverfügbare Hardware und Software, um ein für die Cloud skaliertes Schlüsselverwaltungssystem bereitzustellen. Mithilfe AWS KMS können Sie Verschlüsselungsschlüssel erstellen und die Richtlinien definieren, die steuern, wie diese Schlüssel verwendet werden können. AWS KMS unterstützt AWS CloudTrail, sodass Sie die Verwendung von Schlüsseln überprüfen können, um sicherzustellen, dass die Schlüssel ordnungsgemäß verwendet werden. Sie können Ihre AWS KMS Schlüssel in Kombination mit Neptune und unterstützten AWS Diensten wie Amazon Simple Storage Service (Amazon S3), Amazon Elastic Block Store (Amazon EBS) und Amazon Redshift verwenden. *Eine Liste der Dienste, die diese Unterstützung bieten AWS KMS, finden Sie unter [How AWS Services Use AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/services.html) im Developer Guide.AWS Key Management Service *
Für eine verschlüsselte Neptune-Instance werden alle Protokolle, Sicherungen und Snapshots verschlüsselt.
## Aktivieren der Verschlüsselung für eine Neptune-DB-Instance
Um die Verschlüsslung für eine neue Neptune-DB-Instance zu aktivieren, wählen Sie Yes (Ja) im Abschnitt **Verschlüsselung aktivieren** in der Neptune-Konsole aus. Informationen zum Erstellen einer Neptune-DB-Instance finden Sie unter [Einen Amazon Neptune Neptune-Cluster erstellen](get-started-create-cluster.md).
Wenn Sie eine verschlüsselte Neptune-DB-Instance erstellen, können Sie auch die AWS KMS Schlüssel-ID für Ihren Verschlüsselungsschlüssel angeben. Wenn Sie keine AWS KMS Schlüssel-ID angeben, verwendet Neptune Ihren standardmäßigen Amazon RDS-Verschlüsselungsschlüssel (`aws/rds`) für Ihre neue Neptune-DB-Instance. AWS KMS erstellt Ihren Standard-Verschlüsselungsschlüssel für Neptune für Ihr AWS Konto. Ihr AWS Konto hat für jede AWS Region einen anderen Standard-Verschlüsselungsschlüssel.
Nach dem Erstellen einer verschlüsselten Neptune-DB-Instance können Sie den Verschlüsselungsschlüssel für diese Instance nicht mehr ändern. Sie müssen daher die Anforderungen für Ihren Verschlüsselungsschlüssel definieren, bevor Sie Ihre verschlüsselte Neptune-DB-Instance erstellen.
Sie können den Amazon-Ressourcennamen (ARN) eines Schlüssels aus einem anderen Konto verwenden, um eine Neptune-DB-Instance zu verschlüsseln. Wenn Sie eine Neptune-DB-Instance mit demselben AWS Konto erstellen, dem der AWS KMS Verschlüsselungsschlüssel gehört, der zum Verschlüsseln dieser neuen Neptune-DB-Instance verwendet wird, kann die AWS KMS Schlüssel-ID, die Sie übergeben, der Schlüsselalias und nicht der ARN des AWS KMS Schlüssels sein.
**Wichtig**
Wenn Neptune keinen Zugriff auf den Verschlüsselungsschlüssel einer Neptune-DB-Instance mehr hat (wenn z. B. der Neptune-Zugriff auf einen Schlüssel widerrufen wird), wird die verschlüsselte DB-Instance auf den Beendigungsstatus festgelegt und kann nur noch aus einer Sicherung wiederhergestellt werden. Wir empfehlen nachdrücklich, stets Sicherungen für verschlüsselte Neptune-DB-Instances aktiviertzu lassen, um sich vor dem Verlust verschlüsselter Daten in Ihren Datenbanken zu schützen.
## Wichtige Berechtigungen für die Aktivierung der Verschlüsselung
Der IAM-Benutzer oder die IAM-Rolle, der/die eine verschlüsselte Neptune-DB-Instance erstellt, muss mindestens über die folgenden Berechtigungen für den KMS-Schlüssel verfügen:
+ `"kms:Encrypt"`
+ `"kms:Decrypt"`
+ `"kms:GenerateDataKey"`
+ `"kms:ReEncryptTo"`
+ `"kms:GenerateDataKeyWithoutPlaintext"`
+ `"kms:CreateGrant"`
+ `"kms:ReEncryptFrom"`
+ `"kms:DescribeKey"`
Dies ist ein Beispiel für eine Schlüsselrichtlinie mit den notwendigen Berechtigungen:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "key-consolepolicy-3",
"Statement": [
{
"Sid": "Allow use of the key for Neptune",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::123456789012:role/NeptuneFullAccess"
},
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:GenerateDataKey",
"kms:ReEncryptTo",
"kms:GenerateDataKeyWithoutPlaintext",
"kms:CreateGrant",
"kms:ReEncryptFrom",
"kms:DescribeKey"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:ViaService": "rds.us-east-1.amazonaws.com"
}
}
},
{
"Sid": "Deny use of the key for non Neptune",
"Effect": "Deny",
"Principal": {
"AWS": "arn:aws:iam::123456789012:role/NeptuneFullAccess"
},
"Action": [
"kms:*"
],
"Resource": "*",
"Condition": {
"StringNotEquals": {
"kms:ViaService": "rds.us-east-1.amazonaws.com"
}
}
}
]
}
```
------
+ Die erste Anweisung bietet Zugriff auf alle AWS KMS APIs für diese Rolle erforderlichen Funktionen, die auf den RDS Service Principal beschränkt sind.
+ Mit der zweiten Anweisung wird die Sicherheit weiter verschärft, indem sie erzwingt, dass dieser Schlüssel von dieser Rolle für keinen anderen Dienst verwendet werden kann. AWS
Sie könnten die `createGrant`-Berechtigungen weiter einschränken, indem Sie Folgendes hinzufügen:
```
"Condition": {
"Bool": {
"kms:GrantIsForAWSResource": true
}
}
```
## Einschränkungen der Neptune-Verschlüsselung
Die folgenden Einschränkungen gelten für verschlüsselte Neptune-Cluster:
+ Sie können unverschlüsselte DB-Cluster nicht in verschlüsselte DB-Cluster konvertieren.
Sie können jedoch einen unverschlüsselten DB-Cluster-Snapshot als verschlüsselten DB-Cluster wiederherstellen. Geben Sie dazu einen KMS-Verschlüsselungsschlüssel an, wenn Sie aus einem unverschlüsselten DB-Cluster-Snapshot wiederherstellen.
+ Sie können unverschlüsselte DB-Instances nicht in verschlüsselte DB-Instances konvertieren. Sie können die Verschlüsselung für eine DB-Instance nur während der Erstellung aktivieren.
+ Verschlüsselte DB-Instances können so nicht geändert werden, dass die Verschlüsselung deaktiviert wird.
+ Es ist nicht möglich, eine verschlüsselte Read Replica einer unverschlüsselten DB-Instance oder eine unverschlüsselte Read Replica einer verschlüsselten DB-Instance zu erstellen.
+ Verschlüsselte Read Replicas müssen mit demselben Schlüssel verschlüsselt sein wie die Quell-DB-Instance.
# Authentifizieren Sie Ihre Amazon Neptune Neptune-Datenbank mit AWS Identity and Access Management
AWS Identity and Access Management (IAM) hilft einem Administrator, den Zugriff auf AWS-Service Ressourcen sicher zu kontrollieren. AWS IAM-Administratoren steuern, wer für die Verwendung von Neptune-Ressourcen *authentifiziert* (angemeldet) und *autorisiert* (berechtigt) werden kann. IAM ist ein Programm AWS-Service , das Sie ohne zusätzliche Kosten nutzen können.
Sie können AWS Identity and Access Management (IAM) verwenden, um sich bei Ihrer Neptune-DB-Instance oder Ihrem DB-Cluster zu authentifizieren. Wenn die IAM-Datenbankauthentifizierung aktiviert ist, muss jede Anfrage mit Signature Version 4 signiert werden. AWS
AWS Signature Version 4 fügt Authentifizierungsinformationen zu AWS Anfragen hinzu. Aus Sicherheitsgründen müssen alle Anfragen an Neptune-DB-Cluster mit aktivierter IAM-Authentifizierung mit einem Zugriffsschlüssel signiert werden. Dieser Schlüssel besteht aus einer Zugriffsschlüssel-ID und einem geheimen Zugriffsschlüssel. Die Authentifizierung wird extern über IAM-Richtlinien verwaltet.
Neptune authentifiziert sich bei der Verbindung und überprüft bei WebSockets Verbindungen regelmäßig die Berechtigungen, um sicherzustellen, dass der Benutzer weiterhin Zugriff hat.
**Anmerkung**
Das Widerrufen, Löschen oder Rotieren von Anmeldeinformationen in Verbindung mit IAM-Benutzern wird nicht empfohlen, da dies keine bereits geöffneten Verbindungen beendet.
Es gibt Beschränkungen für die Anzahl gleichzeitiger WebSocket Verbindungen pro Datenbankinstanz und für die Dauer, die eine Verbindung bestehen kann. Weitere Informationen finden Sie unter [WebSockets Grenzwerte](limits.md#limits-websockets).
## Die Nutzung von IAM ist von Ihrer Rolle abhängig
Die Art und Weise, wie Sie AWS Identity and Access Management (IAM) verwenden, hängt von der Arbeit ab, die Sie in Neptune ausführen.
**Service-Benutzer** – Wenn Sie den Neptune-Service zur Ausführung von Aufgaben verwenden, stellt Ihnen Ihr Administrator die nötigen Anmeldeinformationen und Berechtigungen für die Nutzung der Neptune-Datenebene bereit. Wenn Sie einen umfangreicheren Zugriff benötigen, kann Ihnen Wissen über die Zugriffsverwaltung helfen, die richtigen Berechtigungen bei Ihrem Administrator anzufordern.
**Service-Administrator** – Wenn Sie in Ihrem Unternehmen für Neptune-Ressourcen verantwortlich sind, haben Sie wahrscheinlich Zugriff auf Neptune-Verwaltungsaktionen über die [Neptune-Verwaltungs-API](api.md). Möglicherweise ermitteln Sie auch, welche Neptune-Datenzugriffsaktionen und Ressourcen Service-Benutzer benötigen, um ihre Arbeit zu erledigen. Ein IAM-Administrator kann anschließend IAM-Richtlinien anwenden, um die Berechtigungen Ihrer Service-Benutzer zu ändern.
**IAM-Administrator** – Wenn Sie IAM-Administrator sind, müssen Sie IAM-Richtlinien für die Verwaltung und den Datenzugriff in Neptune verfassen. Beispiele für identitätsbasierte Neptune-Richtlinien, die Sie in verwenden können, finden Sie unter [Verwenden verschiedener Arten von IAM-Richtlinien für die Steuerung des Zugriffs auf Neptune](security-iam-access-manage.md#iam-auth-policy).
## Authentifizieren mit Identitäten
Authentifizierung ist die Art und Weise, wie Sie sich AWS mit Ihren Identitätsdaten anmelden. Sie müssen sich als IAM-Benutzer authentifizieren oder eine IAM-Rolle annehmen. Root-Benutzer des AWS-Kontos
Sie können sich als föderierte Identität anmelden, indem Sie Anmeldeinformationen aus einer Identitätsquelle wie AWS IAM Identity Center (IAM Identity Center), Single Sign-On-Authentifizierung oder Anmeldeinformationen verwenden. Google/Facebook Weitere Informationen zum Anmelden finden Sie unter [So melden Sie sich bei Ihrem AWS-Konto an](https://docs.aws.amazon.com/signin/latest/userguide/how-to-sign-in.html) im *Benutzerhandbuch für AWS-Anmeldung *.
AWS Bietet für den programmatischen Zugriff ein SDK und eine CLI zum kryptografischen Signieren von Anfragen. Weitere Informationen finden Sie unter [AWS Signature Version 4 for API requests](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv.html) im *IAM-Benutzerhandbuch*.
### AWS-Konto Root-Benutzer
Wenn Sie einen erstellen AWS-Konto, beginnen Sie mit einer Anmeldeidentität, dem sogenannten AWS-Konto *Root-Benutzer*, der vollständigen Zugriff auf alle AWS-Services Ressourcen hat. Wir raten ausdrücklich davon ab, den Root-Benutzer für Alltagsaufgaben zu verwenden. Eine Liste der Aufgaben, für die Sie sich als Root-Benutzer anmelden müssen, finden Sie unter [Tasks that require root user credentials](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks) im *IAM-Benutzerhandbuch*.
### IAM-Benutzer und -Gruppen
Ein *[IAM-Benutzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html)* ist eine Identität mit bestimmten Berechtigungen für eine einzelne Person oder Anwendung. Wir empfehlen die Verwendung temporärer Anmeldeinformationen anstelle von IAM-Benutzern mit langfristigen Anmeldeinformationen. Weitere Informationen finden Sie im *IAM-Benutzerhandbuch* unter [Erfordern, dass menschliche Benutzer für den Zugriff AWS mithilfe temporärer Anmeldeinformationen einen Verbund mit einem Identitätsanbieter](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-users-federation-idp) verwenden müssen.
Eine [https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html) spezifiziert eine Sammlung von IAM-Benutzern und erleichtert die Verwaltung von Berechtigungen für große Gruppen von Benutzern. Weitere Informationen finden Sie unter [Anwendungsfälle für IAM-Benutzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/gs-identities-iam-users.html) im *IAM-Benutzerhandbuch*.
### IAM-Rollen
Eine *[IAM-Rolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html)* ist eine Identität mit spezifischen Berechtigungen, die temporäre Anmeldeinformationen bereitstellt. Sie können eine Rolle übernehmen, indem Sie [von einer Benutzer- zu einer IAM-Rolle (Konsole) wechseln](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-console.html) AWS CLI oder einen AWS API-Vorgang aufrufen. Weitere Informationen finden Sie unter [Methoden, um eine Rolle zu übernehmen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage-assume.html) im *IAM-Benutzerhandbuch*.
IAM-Rollen sind nützlich für den Verbundbenutzer-Zugriff, temporäre IAM-Benutzerberechtigungen, kontoübergreifenden Zugriff, serviceübergreifenden Zugriff und Anwendungen, die auf Amazon EC2 laufen. Weitere Informationen finden Sie unter [Kontoübergreifender Ressourcenzugriff in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-cross-account-resource-access.html) im *IAM-Benutzerhandbuch*.
# Aktivierung der IAM-Datenbankauthentifizierung in Amazon Neptune
Standardmäßig ist die IAM-Datenbankauthentifizierung deaktiviert, wenn Sie einen Amazon–Neptune-DB-Cluster erstellen. Sie können die IAM-Datenbank-Authentifizierung mithilfe der AWS-Managementkonsole aktivieren (oder wieder deaktivieren).
Befolgen Sie zum Erstellen eines neuen Neptune-DB-Clusters mit IAM-Authentifizierung über die Konsole die Anweisungen für die Erstellung eines Neptune-DB-Clusters in [Starten eines Neptune-DB-Clusters mit dem AWS-Managementkonsole](manage-console-launch-console.md).
Klicken Sie auf der zweiten Seite des Generierungsprozesses für **Enable IAM DB Authentication (IAM-DB-Authentifizierung aktivieren)** auf **Yes (Ja)**.
**So aktivieren oder deaktivieren Sie die IAM-Authentifizierung für eine vorhandene DB-Instance oder einen vorhandenen DB-Cluster**
1. [Melden Sie sich bei der AWS Management Console an und öffnen Sie die Amazon Neptune Neptune-Konsole zu Hausehttps://console.aws.amazon.com/neptune/.](https://console.aws.amazon.com/neptune/home)
1. Klicken Sie im Navigationsbereich auf **Cluster**.
1. Wählen Sie den Neptune-DB-Cluster aus, den Sie ändern möchten, und dann **Cluster-Aktionen** aus. Wählen Sie **Cluster ändern** aus.
1. Wählen Sie im Abschnitt **Datenbankoptionen** für **IAM-DB-Authentifizierung** entweder die Option **IAM-DB-Autorisierung aktivieren** oder **Nein** (zum Deaktivieren) aus. Klicken Sie nun auf **Weiter**.
1. Wählen Sie **Sofort anwenden** aus, um die Änderungen sofort anzuwenden.
1. Wählen Sie **Cluster bearbeiten** aus.
# Mit Authentifizierung eine Verbindung zu Ihrer Amazon Neptune Neptune-Datenbank herstellen AWS Identity and Access Management
Für Amazon Neptune Neptune-Ressourcen, für die die IAM-DB-Authentifizierung aktiviert ist, müssen alle HTTP-Anfragen mit AWS Signature Version 4 signiert werden. Allgemeine Informationen zum Signieren von Anfragen mit AWS Signature Version 4 finden Sie unter [Signieren AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-signing.html) von API-Anfragen.
AWS Signature Version 4 ist der Prozess zum Hinzufügen von Authentifizierungsinformationen zu AWS Anfragen. Aus Sicherheitsgründen AWS müssen die meisten Anfragen mit einem Zugriffsschlüssel signiert werden, der aus einer Zugriffsschlüssel-ID und einem geheimen Zugriffsschlüssel besteht.
**Anmerkung**
Wenn Sie temporäre Anmeldeinformationen verwenden, laufen diese nach einem angegebenen Intervall ab, *, einschließlich des Sitzungs-Tokens*.
Sie müssen Ihren Sitzungs-Token aktualisieren, wenn Sie neue Anmeldeinformationen anfragen. Weitere Informationen finden Sie unter [Verwenden temporärer Sicherheitsanmeldedaten, um Zugriff auf AWS Ressourcen anzufordern](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html).
**Wichtig**
Der Zugriff auf Neptune mittels einer IAM-basierten Authentifizierung setzt voraus, dass Sie HTTP-Anforderungen erstellen und diese selbst signieren.
**So funktioniert Signature Version 4**
1. Sie erstellen eine kanonische Anforderung.
1. Sie verwenden die kanonische Anfrage und einige andere Informationen, um eine zu erstellen. string-to-sign
1. Sie verwenden Ihren AWS geheimen Zugriffsschlüssel, um einen Signaturschlüssel abzuleiten, und verwenden dann diesen Signaturschlüssel und dann, um eine Signatur string-to-sign zu erstellen.
1. Fügen Sie diese Signatur der HTTP-Anforderung in einem Header oder als Abfragezeichenfolgeparameter hinzu.
Wenn Neptune die Anforderung empfängt, werden die gleichen Schritte ausgeführt, die Sie zum Berechnen der Signatur durchgeführt haben. Neptune vergleicht dann die berechnete Signatur mit der Signatur, die Sie mit der Anforderung gesendet haben. Wenn die Signaturen übereinstimmen, wird die Anforderung verarbeitet. Wenn die Signaturen nicht übereinstimmen, wird die Anforderung abgelehnt.
Allgemeine Informationen zum Signieren von Anfragen mit AWS Signature Version 4 finden Sie unter [Signaturprozess für Signature Version 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) in der *Allgemeine AWS-Referenz*.
Die folgenden Abschnitte enthalten Beispiele, die zeigen, wie signierte Anforderungen an die Gremlin- und SPARQL-Endpunkte einer Neptune-DB-Instance mit aktivierter IAM-Authentifizierung gesendet werden.
**Topics**
+ [Voraussetzungen für die Verbindung von Amazon Neptune Neptune-Datenbanken mithilfe der IAM-Authentifizierung](iam-auth-connect-prerq.md)
+ [Herstellen einer Verbindung zu Amazon Neptune Neptune-Datenbanken mithilfe der IAM-Authentifizierung über die Befehlszeile](iam-auth-connect-command-line.md)
+ [Herstellen einer Verbindung zu Amazon Neptune Neptune-Datenbanken mithilfe der IAM-Authentifizierung mit der Gremlin-Konsole](iam-auth-connecting-gremlin-console.md)
+ [Herstellen einer Verbindung zu Amazon Neptune Neptune-Datenbanken mithilfe von IAM mit Gremlin Java](iam-auth-connecting-gremlin-java.md)
+ [Herstellen einer Verbindung zu Amazon Neptune Neptune-Datenbanken mithilfe der IAM-Authentifizierung mit Java und SPARQL](iam-auth-connecting-sparql-java.md)
+ [Herstellen einer Verbindung zu Amazon Neptune Neptune-Datenbanken mithilfe der IAM-Authentifizierung mit SPARQL und Node.js](iam-auth-connecting-sparql-node.md)
+ [Herstellen einer Verbindung zu Amazon Neptune Neptune-Datenbanken mithilfe der IAM-Authentifizierung mit Python](iam-auth-connecting-python.md)
+ [Herstellen einer Verbindung zu Amazon Neptune Neptune-Datenbanken mithilfe der IAM-Authentifizierung mit Gremlin Python](gremlin-python-iam-auth.md)
+ [Herstellen einer Verbindung zu Amazon Neptune Neptune-Datenbanken mithilfe der IAM-Authentifizierung mit Gremlin JavaScript](gremlin-javascript-iam-auth.md)
+ [Herstellen einer Verbindung zu Amazon Neptune Neptune-Datenbanken mithilfe der IAM-Authentifizierung mit Gremlin Go](gremlin-go-iam-auth.md)
+ [Herstellen einer Verbindung zu Amazon Neptune Neptune-Datenbanken mithilfe der IAM-Authentifizierung mit Gremlin .NET](gremlin-dotnet-iam-auth.md)
# Voraussetzungen für die Verbindung von Amazon Neptune Neptune-Datenbanken mithilfe der IAM-Authentifizierung
Im Folgenden finden Sie Anweisungen zum Installieren von Apache Maven und Java 8 auf einer Amazon-EC2-Instance. Dies ist für die Beispiele für die Authentifizierung mit Amazon Neptune Signature Version 4 erforderlich.
**So installieren Sie Apache Maven und Java 8 auf Ihrer EC2-Instance**
1. Stellen Sie eine Verbindung mit Ihrer Amazon–EC2-Instance über einen SSH-Client her.
1. Installieren Sie Apache Maven auf Ihrer EC2-Instance. Wenn Sie Amazon Linux 2023 (bevorzugt) verwenden, verwenden Sie:
```
sudo dnf update -y
sudo dnf install maven -y
```
Wenn Sie Amazon Linux 2 verwenden, laden Sie die neueste Binärdatei von [https://maven.apache.org/download.cgi herunter:](https://maven.apache.org/download.cgi:)
```
sudo yum remove maven -y
wget https://dlcdn.apache.org/maven/maven-3/ /binaries/apache-maven--bin.tar.gz
sudo tar -xzf apache-maven--bin.tar.gz -C /opt/
sudo ln -sf /opt/apache-maven- /opt/maven
echo 'export MAVEN_HOME=/opt/maven' >> ~/.bashrc
echo 'export PATH=$MAVEN_HOME/bin:$PATH' >> ~/.bashrc
source ~/.bashrc
```
1. Die Gremlin-Bibliotheken erfordern Java 8. Geben Sie Folgendes ein, um Java 8 auf Ihrer EC2-Instance zu installieren.
```
sudo yum install java-1.8.0-devel
```
1. Geben Sie Folgendes ein, um Java 8 als Standard-Laufzeit Ihrer EC2-Instance festzulegen.
```
sudo /usr/sbin/alternatives --config java
```
Wenn Sie dazu aufgefordert werden, geben Sie die Nummer für Java 8 ein.
1. Geben Sie Folgendes ein, um Java 8 als Standard-Compiler Ihrer EC2-Instance festzulegen.
```
sudo /usr/sbin/alternatives --config javac
```
Wenn Sie dazu aufgefordert werden, geben Sie die Nummer für Java 8 ein.
# Herstellen einer Verbindung zu Amazon Neptune Neptune-Datenbanken mithilfe der IAM-Authentifizierung über die Befehlszeile
Die Verwendung eines Befehlszeilentools zum Senden von Abfragen an Ihren Neptune-DB-Cluster ist von Vorteil, wie in vielen Beispielen in dieser Dokumentation gezeigt wird. Das Tool [curl](https://curl.haxx.se/) ist eine hervorragende Option für die Kommunikation mit Neptune-Endpunkten, wenn die IAM-Authentifizierung nicht aktiviert ist.
**Um Ihre Daten zu schützen, sollte jedoch die IAM-Authentifizierung aktiviert werden.**
Wenn die IAM-Authentifizierung aktiviert ist, muss jede Anforderung mit [Signature Version 4 (Sig4)](https://docs.aws.amazon.com/general/latest/gr/signing-aws-api-requests.html) signiert werden. Das externe Befehlszeilen-Tool [awscurl](https://github.com/okigan/awscurl) verwendet dieselbe Syntax wie `curl` und kann Abfragen mithilfe der Sig4-Signierung signieren. Im folgenden Abschnitt zu [Verwenden von `awscurl`](#iam-auth-connect-awscurl) wird die sichere Verwendung von `awscurl` mit temporären Anmeldeinformationen beschrieben.
## Einrichten eines Befehlszeilen-Tools für die Verwendung von HTTPS
Neptune setzt voraus, dass alle Verbindungen HTTPS verwenden. Jedes Befehlszeilen-Tool wie `curl` oder `awscurl` benötigt Zugriff auf entsprechende Zertifikate, um HTTPS verwenden zu können. Solange `curl` oder `awscurl` die entsprechenden Zertifikate finden kann, werden HTTPS-Verbindungen wie HTTP-Verbindungen behandelt, ohne dass zusätzliche Parameter benötigt werden. Die Beispiele in dieser Dokumentation basieren auf diesem Szenario.
Informationen zum Abruf dieser Zertifikate und ihrer korrekten Formatierung als CA-Speicher, den `curl` verwenden kann, finden Sie unter [SSL-Zertifikat-Verifizierung](https://curl.haxx.se/docs/sslcerts.html) in der `curl`-Dokumentation.
Sie können den Speicherort des CA-Zertifikatspeichers anschließend mittels der `CURL_CA_BUNDLE`-Umgebungsvariable speichern. Unter Windows sucht `curl` automatisch in einer Datei mit dem Namen `curl-ca-bundle.crt` danach. Es sucht zunächst in demselben Verzeichnis wie `curl.exe` und anschließend an anderer Stelle im Pfad. Weitere Informationen finden Sie unter [SSL Certificate Verification](https://curl.haxx.se/docs/sslcerts.html).
## Verwenden von `awscurl` mit temporären Anmeldeinformationen für sichere Verbindungen zu DB-Clustern mit aktivierter IAM-Authentifizierung
Das Tool [awscurl](https://github.com/okigan/awscurl) verwendet dieselbe Syntax wie`curl`, benötigt jedoch auch zusätzliche Informationen:
+ **`--access_key`** – Gültiger Zugriffsschlüssel. Wenn nicht mit diesem Parameter angegeben, muss er in der Umgebungsvariablen `AWS_ACCESS_KEY_ID` oder in einer Konfigurationsdatei angegeben werden.
+ **`--secret_key`** – Gültiger Geheimschlüssel, der dem Zugriffsschlüssel entspricht Wenn nicht mit diesem Parameter angegeben, muss er in der Umgebungsvariablen `AWS_SECRET_ACCESS_KEY` oder in einer Konfigurationsdatei angegeben werden.
+ **`--security_token`** – Gültiges Sitzungstoken. Wenn nicht mit diesem Parameter angegeben, muss er in der Umgebungsvariablen `AWS_SECURITY_TOKEN` oder in einer Konfigurationsdatei angegeben werden.
In der Vergangenheit war es üblich, persistente Anmeldeinformationen mit `awscurl` zu verwenden, z. B. IAM-Benutzeranmeldeinformationen oder sogar Root-Anmeldeinformationen. Dies wird jedoch nicht empfohlen. [Generieren Sie stattdessen temporäre Anmeldeinformationen mit einem der [AWS Security Token Service (STS)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html) oder einem ihrer APIs Wrapper.AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/sts/index.html)
Sie sollten die Werte `AccessKeyId`, `SecretAccessKey` und `SessionToken`, die vom STS-Aufruf zurückgegeben werden, in entsprechenden Umgebungsvariablen in Ihrer Shell-Sitzung platzieren und nicht in einer Konfigurationsdatei. Wenn die Shell beendet wird, werden die Anmeldeinformationen automatisch verworfen, anders als bei einer Konfigurationsdatei. Sie sollten auch keine längere Dauer für die temporären Anmeldeinformationen anfordern als wahrscheinlich benötigt.
Das folgende Beispiel zeigt die Schritte, die Sie in einer Linux-Shell ausführen könnten, um mittels [sts assume-role](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role) temporäre, für eine halbe Stunde gültige Anmeldeinformationen zu erhalten und sie dann in Umgebungsvariablen zu platzieren, in denen `awscurl` sie finden kann:
```
aws sts assume-role \
--duration-seconds 1800 \
--role-arn "arn:aws:iam::(account-id):role/(rolename)" \
--role-session-name AWSCLI-Session > $output
AccessKeyId=$(echo $output | jq '.Credentials''.AccessKeyId')
SecretAccessKey=$(echo $output | jq '.Credentials''.SecretAccessKey')
SessionToken=$(echo $output | jq '.Credentials''.SessionToken')
export AWS_ACCESS_KEY_ID=$AccessKeyId
export AWS_SECRET_ACCESS_KEY=$SecretAccessKey
export AWS_SESSION_TOKEN=$SessionToken
```
Sie könnten dann `awscurl` verwenden, um eine signierte Anforderung ähnlich dieser an Ihren DB-Cluster zu senden:
```
awscurl (your cluster endpoint):8182/status \
--region us-east-1 \
--service neptune-db
```
# Herstellen einer Verbindung zu Amazon Neptune Neptune-Datenbanken mithilfe der IAM-Authentifizierung mit der Gremlin-Konsole
Um über die Gremlin-Konsole mit Signature Version 4-Authentifizierung eine Verbindung zu Amazon Neptune herzustellen, schließen Sie einen Sigv4-Signaturer `requestInterceptor()` an die durch den Befehl hergestellte Verbindung an. `:remote` Dazu müssen Sie das `Cluster` Objekt manuell konfigurieren und es dann an den Befehl übergeben. `:remote`
Beachten Sie, dass sich dies deutlich von der typischen Situation unterscheidet, in der für den Befehl `:remote` eine Konfigurationsdatei benötigt wird, um die Verbindung herzustellen. Der Ansatz mit einer Konfigurationsdatei funktioniert nicht, da `requestInterceptor()` programmgesteuert festgelegt werden muss und daher die Konfiguration nicht aus einer Datei laden kann.
**Anmerkung**
Die folgenden Beispiele verwenden`requestInterceptor()`, was in TinkerPop 3.6.6 eingeführt wurde. Wenn Sie eine frühere TinkerPop Version als 3.6.6 (aber 3.5.5 oder höher) verwenden, verwenden Sie `handshakeInterceptor()` statt `requestInterceptor()` in den folgenden Codebeispielen.
Die folgenden Voraussetzungen sind erforderlich:
+ Sie müssen die nötigen IAM-Anmeldeinformationen zum Signieren der Anforderungen besitzen. Weitere Informationen finden Sie [unter Verwenden der standardmäßigen Anbieterkette für Anmeldeinformationen](https://docs.aws.amazon.com//sdk-for-java/latest/developer-guide/credentials-chain.html) im AWS SDK für Java Entwicklerhandbuch.
+ Sie müssen eine Version der Gremlin-Konsole installieren, die mit der Version der Neptune-Engine kompatibel ist, die von Ihrem DB-Cluster verwendet wird.
Wenn Sie temporäre Anmeldeinformationen verwenden, laufen diese nach einem bestimmten Intervall ab, ebenso wie das Sitzungstoken. Sie müssen Ihr Sitzungstoken daher aktualisieren, wenn Sie neue Anmeldeinformationen anfordern. Weitere Informationen finden Sie im IAM-Benutzerhandbuch [unter Verwenden temporärer Sicherheitsanmeldedaten, um Zugriff auf AWS Ressourcen anzufordern](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html).
Hilfe zum Herstellen von Verbindungen über SSL/TLS finden Sie unter [SSL/TLS-Konfiguration](access-graph-gremlin-java.md#access-graph-gremlin-java-ssl).
**Connect die Gremlin-Konsole mit Sig4-Signatur**
1. Starten Sie die Gremlin-Konsole:
```
$ bin/gremlin.sh
```
1. Installieren Sie bei der Eingabeaufforderung `gremlin>` die `amazon-neptune-sigv4-signer`-Bibliothek. (Sie müssen dies nur einmal für die Konsole ausführen):
```
:install com.amazonaws amazon-neptune-sigv4-signer 2.4.0
```
[Wenn Sie bei diesem Schritt auf Probleme stoßen, kann es hilfreich sein, die [TinkerPop Dokumentation](https://tinkerpop.apache.org/docs/current/reference/#gremlin-applications) zur Grape-Konfiguration zu lesen.](http://docs.groovy-lang.org/latest/html/documentation/grape.html)
**Anmerkung**
Wenn Sie einen HTTP-Proxy verwenden, können bei diesem Schritt Fehler auftreten, durch die der `:install`-Befehl nicht abgeschlossen wird. Führen Sie zur Problembehebung die folgenden Befehle aus, um der Konsole den Proxy mitzuteilen:
```
System.setProperty("https.proxyHost", "(the proxy IP address)")
System.setProperty("https.proxyPort", "(the proxy port)")
```
1. Importieren Sie die Klasse, die für die Verarbeitung der Signierung erforderlich ist, in `requestInterceptor()`:
```
:import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider
:import com.amazonaws.neptune.auth.NeptuneNettyHttpSigV4Signer
```
1. Wenn Sie temporäre Anmeldeinformationen verwenden, müssen Sie auch Ihr Sitzungstoken wie folgt angeben:
```
System.setProperty("aws.sessionToken","(your session token)")
```
1. Wenn Sie Ihre Kontoanmeldeinformationen nicht anderweitig eingerichtet haben, können Sie sie wie folgt zuweisen:
```
System.setProperty("aws.accessKeyId","(your access key)")
System.setProperty("aws.secretKey","(your secret key)")
```
1. Konstruieren Sie das `Cluster`-Objekt manuell, um eine Verbindung zu Neptune herzustellen:
```
cluster = Cluster.build("(host name)") \
.enableSsl(true) \
.requestInterceptor { r -> \
def sigV4Signer = new NeptuneNettyHttpSigV4Signer("(Amazon region)", \
DefaultCredentialsProvider.create()); \
sigV4Signer.signRequest(r); \
return r; } \
.create()
```
Hilfe bei der Suche nach dem Hostnamen einer Neptune-DB-Instance finden Sie unter [Verbinden mit Amazo-Neptune-Endpunkten](feature-overview-endpoints.md).
1. Stellen Sie die `:remote`-Verbindung mithilfe des Variablennamens des `Cluster`-Objekts im vorherigen Schritt her:
```
:remote connect tinkerpop.server cluster
```
1. Geben Sie den folgenden Befehl ein, um zum Remote-Modus zu wechseln. Dies sendet alle Gremlin-Abfragen an die Remote-Verbindung.
```
:remote console
```
# Herstellen einer Verbindung zu Amazon Neptune Neptune-Datenbanken mithilfe von IAM mit Gremlin Java
Hier ist ein Beispiel dafür, wie Sie mithilfe der Gremlin-Java-API mit Sig4-Signatur eine Verbindung zu Neptune herstellen können (es werden allgemeine Kenntnisse über die Verwendung von Maven vorausgesetzt). In diesem Beispiel wird die [Amazon Neptune SigV4 Signer-Bibliothek](https://github.com/aws/amazon-neptune-sigv4-signer) verwendet, um das Signieren von Anfragen zu unterstützen. Definieren Sie zunächst die Abhängigkeiten als Teil der Datei `pom.xml`:
**Anmerkung**
Die folgenden Beispiele verwenden`requestInterceptor()`, was in 3.6.6 eingeführt wurde. TinkerPop Wenn Sie eine frühere TinkerPop Version als 3.6.6 (aber 3.5.5 oder höher) verwenden, verwenden Sie `handshakeInterceptor()` statt `requestInterceptor()` in den folgenden Codebeispielen.
```
com.amazonaws
amazon-neptune-sigv4-signer
3.1.0
```
Der Amazon Neptune SigV4 Signer unterstützt beide Versionen 1.x und 2.x des Java SDK. AWS In den folgenden Beispielen wird 2.x verwendet, wobei es sich um eine Instanz handelt. `DefaultCredentialsProvider` `software.amazon.awssdk.auth.credentials.AwsCredentialsProvider` Wenn Sie von 1.x auf 2.x aktualisieren, lesen Sie die [Änderungen des Credentials-Providers](https://docs.aws.amazon.com//sdk-for-java/latest/developer-guide/migration-client-credentials.html) in der Dokumentation zum AWS SDK for Java 2.x.
```
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import com.amazonaws.neptune.auth.NeptuneNettyHttpSigV4Signer;
import com.amazonaws.neptune.auth.NeptuneSigV4SignerException;
...
System.setProperty("aws.accessKeyId","your-access-key");
System.setProperty("aws.secretKey","your-secret-key");
...
Cluster cluster = Cluster.build((your cluster))
.enableSsl(true)
.requestInterceptor( r ->
{
try {
NeptuneNettyHttpSigV4Signer sigV4Signer =
new NeptuneNettyHttpSigV4Signer("(your region)", DefaultCredentialsProvider.create());
sigV4Signer.signRequest(r);
} catch (NeptuneSigV4SignerException e) {
throw new RuntimeException("Exception occurred while signing the request", e);
}
return r;
}
).create();
try {
Client client = cluster.connect();
client.submit("g.V().has('code','IAD')").all().get();
} catch (Exception e) {
throw new RuntimeException("Exception occurred while connecting to cluster", e);
}
```
## Kontenübergreifende IAM-Authentifizierung
[Amazon Neptune unterstützt die kontoübergreifende IAM-Authentifizierung mithilfe von Rollenübernahme, manchmal auch als Rollenverkettung bezeichnet.](https://docs.aws.amazon.com//neptune/latest/userguide/bulk-load-tutorial-chain-roles.html#bulk-load-tutorial-chain-cross-account) So gewähren Sie Zugriff auf einen Neptune-Cluster von einer Anwendung aus, die in einem anderen AWS Konto gehostet wird:
+ Erstellen Sie einen neuen IAM-Benutzer oder eine neue IAM-Rolle im AWS Anwendungskonto mit einer Vertrauensrichtlinie, die es dem Benutzer oder der Rolle ermöglicht, eine andere IAM-Rolle anzunehmen. Weisen Sie diese Rolle dem Computer zu, der die Anwendung hostet (EC2-Instance, Lambda-Funktion, ECS-Task usw.).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "assumeRolePolicy",
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::111122223333:role/role-name"
}
]
}
```
------
+ Erstellen Sie eine neue IAM-Rolle im AWS Neptune-Datenbankkonto, die den Zugriff auf die Neptune-Datenbank und die Rollenübernahme vom IAM-Benutzer/der Rolle des Anwendungskontos ermöglicht. Verwenden Sie eine Vertrauensrichtlinie von:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": [
"(ARN of application account IAM user or role)"
]
},
"Action": "sts:AssumeRole",
"Condition": {}
}
]
}
```
------
+ Verwenden Sie das folgende Codebeispiel als Anleitung zur Verwendung dieser beiden Rollen, um der Anwendung den Zugriff auf Neptune zu ermöglichen. In diesem Beispiel wird die Rolle des Anwendungskontos [DefaultCredentialProviderChain](https://docs.aws.amazon.com//sdk-for-java/v1/developer-guide/credentials.html)beim Erstellen des übernommen. `STSclient` Das `STSclient` wird dann über das verwendet`STSAssumeRoleSessionCredentialsProvider`, um die im AWS Neptune-Datenbankkonto gehostete Rolle zu übernehmen.
```
public static void main( String[] args )
{
/*
* Establish an STS client from the application account.
*/
AWSSecurityTokenService client = AWSSecurityTokenServiceClientBuilder
.standard()
.build();
/*
* Define the role ARN that you will be assuming in the database account where the Neptune cluster resides.
*/
String roleArnToAssume = "arn:aws:iam::012345678901:role/CrossAccountNeptuneRole";
String crossAccountSessionName = "cross-account-session-" + UUID.randomUUID();
/*
* Change the Credentials Provider in the SigV4 Signer to use the STSAssumeRole Provider and provide it
* with both the role to be assumed, the original STS client, and a session name (which can be
* arbitrary.)
*/
Cluster cluster = Cluster.build()
.addContactPoint("neptune-cluster.us-west-2.neptune.amazonaws.com")
.enableSsl(true)
.port(8182)
.requestInterceptor( r ->
{
try {
NeptuneNettyHttpSigV4Signer sigV4Signer =
// new NeptuneNettyHttpSigV4Signer("us-west-2", DefaultCredentialsProvider.create());
new NeptuneNettyHttpSigV4Signer(
"us-west-2",
new STSAssumeRoleSessionCredentialsProvider
.Builder(roleArnToAssume, crossAccountSessionName)
.withStsClient(client)
.build());
sigV4Signer.signRequest(r);
} catch (NeptuneSigV4SignerException e) {
throw new RuntimeException("Exception occurred while signing the request", e);
}
return r;
}
).create();
GraphTraversalSource g = traversal().withRemote(DriverRemoteConnection.using(cluster));
/* whatever application code is necessary */
cluster.close();
}
```
# Herstellen einer Verbindung zu Amazon Neptune Neptune-Datenbanken mithilfe der IAM-Authentifizierung mit Java und SPARQL
In diesem Abschnitt wird gezeigt, wie Sie mithilfe von RDF4 J oder Apache Jena mit Signature Version 4-Authentifizierung eine Verbindung zu Neptune herstellen.
**Voraussetzungen**
+ Java 8 oder höher.
+ Apache Maven 3.3 oder höher.
Weitere Informationen zum Installieren dieser Voraussetzungen auf einer EC2-Instance mit Amazon Linux finden Sie unter [Voraussetzungen für die Verbindung von Amazon Neptune Neptune-Datenbanken mithilfe der IAM-Authentifizierung](iam-auth-connect-prerq.md).
+ IAM-Anmeldeinformationen zum Signieren der Anfragen. Weitere Informationen finden Sie unter [Verwenden der Standard-Anbieterkette für Anmeldeinformationen](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/credentials.html#credentials-default) im *AWS SDK für Java -Entwicklerhandbuch*.
**Anmerkung**
Wenn Sie temporäre Anmeldeinformationen verwenden, laufen diese nach einem angegebenen Intervall ab, *, einschließlich des Sitzungs-Tokens*.
Sie müssen Ihren Sitzungs-Token aktualisieren, wenn Sie neue Anmeldeinformationen anfragen. Weitere Informationen finden Sie im [*IAM-Benutzerhandbuch* unter Verwenden temporärer Sicherheitsanmeldedaten zur Anforderung des Zugriffs auf AWS Ressourcen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html).
+ Wählen Sie für die Variable `SERVICE_REGION` eine der folgenden Einstellungen aus, um die Region Ihrer Neptune-DB-Instance anzugeben:
+ USA Ost (Nord-Virginia): `us-east-1`
+ USA Ost (Ohio): `us-east-2`
+ USA West (Nordkalifornien): `us-west-1`
+ USA West (Oregon): `us-west-2`
+ Kanada (Zentral): `ca-central-1`
+ Kanada West (Calgary): `ca-west-1`
+ Südamerika (São Paulo): `sa-east-1`
+ Europa (Stockholm): `eu-north-1`
+ Europa (Spanien): `eu-south-2`
+ Europa (Irland): `eu-west-1`
+ Europa (London): `eu-west-2`
+ Europa (Paris): `eu-west-3`
+ Europa (Frankfurt): `eu-central-1`
+ Naher Osten (Bahrain): `me-south-1`
+ Naher Osten (VAE): `me-central-1`
+ Israel (Tel Aviv): `il-central-1`
+ Afrika (Kapstadt): `af-south-1`
+ Asien-Pazifik (Hongkong): `ap-east-1`
+ Asien-Pazifik (Tokio): `ap-northeast-1`
+ Asien-Pazifik (Seoul): `ap-northeast-2`
+ Asien-Pazifik (Osaka): `ap-northeast-3`
+ Asien-Pazifik (Singapur): `ap-southeast-1`
+ Asien-Pazifik (Sydney): `ap-southeast-2`
+ Asien-Pazifik (Jakarta): `ap-southeast-3`
+ Asien-Pazifik (Melbourne): `ap-southeast-4`
+ Asien-Pazifik (Malaysia): `ap-southeast-5`
+ Asien-Pazifik (Mumbai): `ap-south-1`
+ Asien-Pazifik (Hyderabad): `ap-south-2`
+ China (Peking): `cn-north-1`
+ China (Ningxia): `cn-northwest-1`
+ AWS GovCloud (US-West): `us-gov-west-1`
+ AWS GovCloud (US-Ost): `us-gov-east-1`
**Um eine Verbindung zu Neptune mit RDF4 J oder Apache Jena mit Signature Version 4-Signatur herzustellen**
1. Klonen Sie das Beispiel-Repository von. GitHub
```
git clone https://github.com/aws/amazon-neptune-sparql-java-sigv4.git
```
1. Wechseln Sie in das geklonte Verzeichnis.
```
cd amazon-neptune-sparql-java-sigv4
```
1. Überprüfen Sie den Branch mit dem neuesten Tag auf die neueste Version des Projekts.
```
git checkout $(git describe --tags `git rev-list --tags --max-count=1`)
```
1. Geben Sie einen der folgenden Befehle ein, um den Beispielcode zu kompilieren und auszuführen.
*your-neptune-endpoint*Ersetzen Sie durch den Hostnamen oder die IP-Adresse Ihrer Neptune-DB-Instance. Der Standard-Port ist 8182.
**Anmerkung**
Informationen zum Ermitteln des Hostnamens Ihrer Neptune-DB-Instance finden Sie im Abschnitt [Verbinden mit Amazo-Neptune-Endpunkten](feature-overview-endpoints.md).
**Sonnenfinsternis J RDF4**
Geben Sie Folgendes ein, um das RDF4 J-Beispiel auszuführen.
```
mvn compile exec:java \
-Dexec.mainClass="com.amazonaws.neptune.client.rdf4j.NeptuneRdf4JSigV4Example" \
-Dexec.args="https://your-neptune-endpoint:portsparql region-name"
```
**Apache Jena**
Geben Sie Folgendes ein, um das Apache Jena-Beispiel auszuführen.
```
mvn compile exec:java \
-Dexec.mainClass="com.amazonaws.neptune.client.jena.NeptuneJenaSigV4Example" \
-Dexec.args="https://your-neptune-endpoint:port"
```
1. Informationen zum Anzeigen des Quellcodes für dieses Beispiel finden Sie in den Beispielen im `src/main/java/com/amazonaws/neptune/client/`-Verzeichnis.
Fügen Sie dem Abschnitt `` Ihrer `pom.xml` das `amazon-neptune-sigv4-signer` Maven-Paket hinzu, um den SigV4-Signaturtreiber in Ihrer eigenen Java-Anwendung zu verwenden. Es wird empfohlen, die Beispiele als Ausgangspunkt zu verwenden.
# Herstellen einer Verbindung zu Amazon Neptune Neptune-Datenbanken mithilfe der IAM-Authentifizierung mit SPARQL und Node.js
## Abfragen mithilfe der Signature V4-Signatur und des AWS SDK für Javascript V3
Hier ist ein Beispiel dafür, wie Sie mithilfe von Node.js mit Signature Version 4-Authentifizierung und dem AWS SDK für Javascript V3 eine Verbindung zu Neptune SPARQL herstellen:
```
const { HttpRequest } = require('@smithy/protocol-http');
const { fromNodeProviderChain } = require('@aws-sdk/credential-providers');
const { SignatureV4 } = require('@smithy/signature-v4');
const { Sha256 } = require('@aws-crypto/sha256-universal');
const https = require('https');
var region = 'us-west-2'; // e.g. us-west-1
var neptune_endpoint = 'your-Neptune-cluster-endpoint'; // like: 'cluster-id.region.neptune.amazonaws.com'
var query = `query=PREFIX rdf:
PREFIX class:
PREFIX resource:
PREFIX prop:
PREFIX objprop:
SELECT ?movies ?title WHERE {
?jel prop:name "James Earl Jones" .
?movies ?p2 ?jel .
?movies prop:title ?title
} LIMIT 10`;
runQuery(query);
function runQuery(q) {
var request = new HttpRequest({
hostname: neptune_endpoint,
port: 8182,
path: 'sparql',
body: encodeURI(query),
headers: {
'Content-Type': 'application/x-www-form-urlencoded',
'host': neptune_endpoint + ':8182',
},
method: 'POST',
});
const credentialProvider = fromNodeProviderChain();
let credentials = credentialProvider();
credentials.then(
(cred)=>{
var signer = new SignatureV4({credentials: cred, region: region, sha256: Sha256, service: 'neptune-db'});
signer.sign(request).then(
(req)=>{
var responseBody = '';
var sendreq = https.request(
{
host: req.hostname,
port: req.port,
path: req.path,
method: req.method,
headers: req.headers,
},
(res) => {
res.on('data', (chunk) => { responseBody += chunk; });
res.on('end', () => {
console.log(JSON.parse(responseBody));
});
});
sendreq.write(req.body);
sendreq.end();
}
);
},
(err)=>{
console.error(err);
}
);
}
```
## Abfragen mithilfe der Signature V4-Signatur und des AWS SDK für Javascript V2
Hier ist ein Beispiel dafür, wie Sie mithilfe von Node.js mit Signature Version 4-Authentifizierung und dem AWS SDK für Javascript V2 eine Verbindung zu Neptune SPARQL herstellen:
```
var AWS = require('aws-sdk');
var region = 'us-west-2'; // e.g. us-west-1
var neptune_endpoint = 'your-Neptune-cluster-endpoint'; // like: 'cluster-id.region.neptune.amazonaws.com'
var query = `query=PREFIX rdf:
PREFIX class:
PREFIX resource:
PREFIX prop:
PREFIX objprop:
SELECT ?movies ?title WHERE {
?jel prop:name "James Earl Jones" .
?movies ?p2 ?jel .
?movies prop:title ?title
} LIMIT 10`;
runQuery(query);
function runQuery(q) {
var endpoint = new AWS.Endpoint(neptune_endpoint);
endpoint.port = 8182;
var request = new AWS.HttpRequest(endpoint, region);
request.path += 'sparql';
request.body = encodeURI(query);
request.headers['Content-Type'] = 'application/x-www-form-urlencoded';
request.headers['host'] = neptune_endpoint;
request.method = 'POST';
var credentials = new AWS.CredentialProviderChain();
credentials.resolve((err, cred)=>{
var signer = new AWS.Signers.V4(request, 'neptune-db');
signer.addAuthorization(cred, new Date());
});
var client = new AWS.HttpClient();
client.handleRequest(request, null, function(response) {
console.log(response.statusCode + ' ' + response.statusMessage);
var responseBody = '';
response.on('data', function (chunk) {
responseBody += chunk;
});
response.on('end', function (chunk) {
console.log('Response body: ' + responseBody);
});
}, function(error) {
console.log('Error: ' + error);
});
}
```
# Herstellen einer Verbindung zu Amazon Neptune Neptune-Datenbanken mithilfe der IAM-Authentifizierung mit Python
Dieser Abschnitt zeigt ein in Python geschriebenes Beispielprogramm, das zeigt, wie Sie mit Signature Version 4 für Amazon Neptune arbeiten. Dieses Beispiel basiert auf Beispielen aus dem Abschnitt [Signaturprozess mit Signaturversion 4](https://docs.aws.amazon.com/general/latest/gr/sigv4-signed-request-examples.html) in der *Allgemeine Amazon Web Services-Referenz*.
Wenn Sie mit diesem Beispielprogramm arbeiten möchten, benötigen Sie Folgendes:
+ Python 3.x muss auf Ihrem Computer installiert sein (siehe [Python-Website](https://www.python.org/downloads/)). Diese Programme wurden mit Python 3.6 getestet.
+ Die [Python-Bibliothek mit Anforderungen](https://pypi.python.org/pypi/requests), die im Beispielskript verwendet wird, um Webanforderungen zu versenden. Eine praktische Methode zum Installieren von Python-Paketen ist der Einsatz von `pip`, das Pakete von der Python-Paketindexseite abruft. Sie können dann `requests` installieren, indem Sie in der Befehlszeile `pip install requests` ausführen.
+ Einen Zugriffsschlüssel (Zugriffsschlüssel-ID und geheimer Zugriffsschlüssel) in Umgebungsvariablen namens `AWS_ACCESS_KEY_ID` und `AWS_SECRET_ACCESS_KEY`. Als bewährte Methode empfehlen wir, Anmeldeinformationen *nicht* im Code einzubetten. Weitere Informationen finden Sie unter [Bewährte Methoden für AWS -Konten](https://docs.aws.amazon.com//accounts/latest/reference/best-practices.html) im *AWS -Kontenverwaltung -Referenzhandbuch*.
Die Region Ihres Neptune-DB-Clusters in einer Umgebungsvariablen mit dem Namen `SERVICE_REGION`.
Wenn Sie temporäre Anmeldeinformationen verwenden, müssen Sie `AWS_SESSION_TOKEN` zusätzlich zu `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` und `SERVICE_REGION` angeben.
**Anmerkung**
Wenn Sie temporäre Anmeldeinformationen verwenden, laufen diese nach einem angegebenen Intervall ab, *, einschließlich des Sitzungs-Tokens*.
Sie müssen Ihren Sitzungs-Token aktualisieren, wenn Sie neue Anmeldeinformationen anfragen. Weitere Informationen finden Sie unter [Verwenden von temporären Sicherheitsanmeldeinformationen zum Anfordern von Zugriff auf AWS -Ressourcen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html).
Das folgende Beispiel zeigt, wie Sie über Python signierte Anforderungen an Neptune senden. Die Anforderung ist entweder eine GET- oder POST-Anforderung. Die Authentifizierungsdaten werden über den `Authorization`-Abfrageheader weitergegeben.
Dieses Beispiel funktioniert auch als AWS Lambda Funktion. Weitere Informationen finden Sie unter [AWS Lambda für die Neptune-IAM-Authentifizierung einrichten](iam-auth-temporary-credentials.md#iam-auth-temporary-credentials-lambda).
**Erstellen signierter Anforderungen an Gremlin- und SPARQL-Neptune-Endpunkte**
1. Erstellen Sie eine neue Datei namens `neptunesigv4.py` und öffnen Sie diese in einem Text-Editor.
1. Kopieren Sie den folgenden Text und fügen Sie ihn in die Datei `neptunesigv4.py` ein.
```
# Amazon Neptune version 4 signing example (version v3)
# The following script requires python 3.6+
# (sudo yum install python36 python36-virtualenv python36-pip)
# => the reason is that we're using urllib.parse() to manually encode URL
# parameters: the problem here is that SIGV4 encoding requires whitespaces
# to be encoded as %20 rather than not or using '+', as done by previous/
# default versions of the library.
# See: https://docs.aws.amazon.com/general/latest/gr/sigv4_signing.html
import sys, datetime, hashlib, hmac
import requests # pip3 install requests
import urllib
import os
import json
from botocore.auth import SigV4Auth
from botocore.awsrequest import AWSRequest
from botocore.credentials import ReadOnlyCredentials
from types import SimpleNamespace
from argparse import RawTextHelpFormatter
from argparse import ArgumentParser
# Configuration. https is required.
protocol = 'https'
# The following lines enable debugging at httplib level (requests->urllib3->http.client)
# You will see the REQUEST, including HEADERS and DATA, and RESPONSE with HEADERS but without DATA.
#
# The only thing missing will be the response.body which is not logged.
#
# import logging
# from http.client import HTTPConnection
# HTTPConnection.debuglevel = 1
# logging.basicConfig()
# logging.getLogger().setLevel(logging.DEBUG)
# requests_log = logging.getLogger("requests.packages.urllib3")
# requests_log.setLevel(logging.DEBUG)
# requests_log.propagate = True
# Read AWS access key from env. variables. Best practice is NOT
# to embed credentials in code.
access_key = os.getenv('AWS_ACCESS_KEY_ID', '')
secret_key = os.getenv('AWS_SECRET_ACCESS_KEY', '')
region = os.getenv('SERVICE_REGION', '')
# AWS_SESSION_TOKEN is optional environment variable. Specify a session token only if you are using temporary
# security credentials.
session_token = os.getenv('AWS_SESSION_TOKEN', '')
### Note same script can be used for AWS Lambda (runtime = python3.6).
## Steps to use this python script for AWS Lambda
# 1. AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY and AWS_SESSION_TOKEN and AWS_REGION variables are already part of Lambda's Execution environment
# No need to set them up explicitly.
# 3. Create Lambda deployment package https://docs.aws.amazon.com/lambda/latest/dg/lambda-python-how-to-create-deployment-package.html
# 4. Create a Lambda function in the same VPC and assign an IAM role with neptune access
def lambda_handler(event, context):
# sample_test_input = {
# "host": "END_POINT:8182",
# "method": "GET",
# "query_type": "gremlin",
# "query": "g.V().count()"
# }
# Lambda uses AWS_REGION instead of SERVICE_REGION
global region
region = os.getenv('AWS_REGION', '')
host = event['host']
method = event['method']
query_type = event['query_type']
query = event['query']
return make_signed_request(host, method, query_type, query)
def validate_input(method, query_type):
# Supporting GET and POST for now:
if (method != 'GET' and method != 'POST'):
print('First parameter must be "GET" or "POST", but is "' + method + '".')
sys.exit()
# SPARQL UPDATE requires POST
if (method == 'GET' and query_type == 'sparqlupdate'):
print('SPARQL UPDATE is not supported in GET mode. Please choose POST.')
sys.exit()
def get_canonical_uri_and_payload(query_type, query, method):
# Set the stack and payload depending on query_type.
if (query_type == 'sparql'):
canonical_uri = '/sparql/'
payload = {'query': query}
elif (query_type == 'sparqlupdate'):
canonical_uri = '/sparql/'
payload = {'update': query}
elif (query_type == 'gremlin'):
canonical_uri = '/gremlin/'
payload = {'gremlin': query}
if (method == 'POST'):
payload = json.dumps(payload)
elif (query_type == 'openCypher'):
canonical_uri = '/openCypher/'
payload = {'query': query}
elif (query_type == "loader"):
canonical_uri = "/loader/"
payload = query
elif (query_type == "status"):
canonical_uri = "/status/"
payload = {}
elif (query_type == "gremlin/status"):
canonical_uri = "/gremlin/status/"
payload = {}
elif (query_type == "openCypher/status"):
canonical_uri = "/openCypher/status/"
payload = {}
elif (query_type == "sparql/status"):
canonical_uri = "/sparql/status/"
payload = {}
else:
print(
'Third parameter should be from ["gremlin", "sparql", "sparqlupdate", "loader", "status] but is "' + query_type + '".')
sys.exit()
## return output as tuple
return canonical_uri, payload
def make_signed_request(host, method, query_type, query):
service = 'neptune-db'
endpoint = protocol + '://' + host
print()
print('+++++ USER INPUT +++++')
print('host = ' + host)
print('method = ' + method)
print('query_type = ' + query_type)
print('query = ' + query)
# validate input
validate_input(method, query_type)
# get canonical_uri and payload
canonical_uri, payload = get_canonical_uri_and_payload(query_type, query, method)
# assign payload to data or params
data = payload if method == 'POST' else None
params = payload if method == 'GET' else None
# create request URL
request_url = endpoint + canonical_uri
# create and sign request
creds = SimpleNamespace(
access_key=access_key, secret_key=secret_key, token=session_token, region=region,
)
request = AWSRequest(method=method, url=request_url, data=data, params=params)
SigV4Auth(creds, service, region).add_auth(request)
r = None
# ************* SEND THE REQUEST *************
if (method == 'GET'):
print('++++ BEGIN GET REQUEST +++++')
print('Request URL = ' + request_url)
r = requests.get(request_url, headers=request.headers, verify=False, params=params)
elif (method == 'POST'):
print('\n+++++ BEGIN POST REQUEST +++++')
print('Request URL = ' + request_url)
if (query_type == "loader"):
request.headers['Content-type'] = 'application/json'
r = requests.post(request_url, headers=request.headers, verify=False, data=data)
else:
print('Request method is neither "GET" nor "POST", something is wrong here.')
if r is not None:
print()
print('+++++ RESPONSE +++++')
print('Response code: %d\n' % r.status_code)
response = r.text
r.close()
print(response)
return response
help_msg = '''
export AWS_ACCESS_KEY_ID=[MY_ACCESS_KEY_ID]
export AWS_SECRET_ACCESS_KEY=[MY_SECRET_ACCESS_KEY]
export AWS_SESSION_TOKEN=[MY_AWS_SESSION_TOKEN]
export SERVICE_REGION=[us-east-1|us-east-2|us-west-2|eu-west-1]
python version >=3.6 is required.
Examples: For help
python3 program_name.py -h
Examples: Queries
python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q status
python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q sparql/status
python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q sparql -d "SELECT ?s WHERE { ?s ?p ?o }"
python3 program_name.py -ho your-neptune-endpoint -p 8182 -a POST -q sparql -d "SELECT ?s WHERE { ?s ?p ?o }"
python3 program_name.py -ho your-neptune-endpoint -p 8182 -a POST -q sparqlupdate -d "INSERT DATA { }"
python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q gremlin/status
python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q gremlin -d "g.V().count()"
python3 program_name.py -ho your-neptune-endpoint -p 8182 -a POST -q gremlin -d "g.V().count()"
python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q openCypher/status
python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q openCypher -d "MATCH (n1) RETURN n1 LIMIT 1;"
python3 program_name.py -ho your-neptune-endpoint -p 8182 -a POST -q openCypher -d "MATCH (n1) RETURN n1 LIMIT 1;"
python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q loader -d '{"loadId": "68b28dcc-8e15-02b1-133d-9bd0557607e6"}'
python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q loader -d '{}'
python3 program_name.py -ho your-neptune-endpoint -p 8182 -a POST -q loader -d '{"source": "source", "format" : "csv", "failOnError": "fail_on_error", "iamRoleArn": "iam_role_arn", "region": "region"}'
Environment variables must be defined as AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY and SERVICE_REGION.
You should also set AWS_SESSION_TOKEN environment variable if you are using temporary credentials (ex. IAM Role or EC2 Instance profile).
Current Limitations:
- Query mode "sparqlupdate" requires POST (as per the SPARQL 1.1 protocol)
'''
def exit_and_print_help():
print(help_msg)
exit()
def parse_input_and_query_neptune():
parser = ArgumentParser(description=help_msg, formatter_class=RawTextHelpFormatter)
group_host = parser.add_mutually_exclusive_group()
group_host.add_argument("-ho", "--host", type=str)
group_port = parser.add_mutually_exclusive_group()
group_port.add_argument("-p", "--port", type=int, help="port ex. 8182, default=8182", default=8182)
group_action = parser.add_mutually_exclusive_group()
group_action.add_argument("-a", "--action", type=str, help="http action, default = GET", default="GET")
group_endpoint = parser.add_mutually_exclusive_group()
group_endpoint.add_argument("-q", "--query_type", type=str, help="query_type, default = status ", default="status")
group_data = parser.add_mutually_exclusive_group()
group_data.add_argument("-d", "--data", type=str, help="data required for the http action", default="")
args = parser.parse_args()
print(args)
# Read command line parameters
host = args.host
port = args.port
method = args.action
query_type = args.query_type
query = args.data
if (access_key == ''):
print('!!! ERROR: Your AWS_ACCESS_KEY_ID environment variable is undefined.')
exit_and_print_help()
if (secret_key == ''):
print('!!! ERROR: Your AWS_SECRET_ACCESS_KEY environment variable is undefined.')
exit_and_print_help()
if (region == ''):
print('!!! ERROR: Your SERVICE_REGION environment variable is undefined.')
exit_and_print_help()
if host is None:
print('!!! ERROR: Neptune DNS is missing')
exit_and_print_help()
host = host + ":" + str(port)
make_signed_request(host, method, query_type, query)
if __name__ == "__main__":
parse_input_and_query_neptune()
```
1. Navigieren Sie in einem Terminalfenster zum Speicherort der `neptunesigv4.py`-Datei.
1. Geben Sie die folgenden Befehle ein und ersetzen Sie den Zugriffsschlüssel, den geheimen Schlüssel und die Region mit den korrekten Werten.
```
export AWS_ACCESS_KEY_ID=MY_ACCESS_KEY_ID
export AWS_SECRET_ACCESS_KEY=MY_SECRET_ACCESS_KEY
export SERVICE_REGION=us-east-1 or us-east-2 or us-west-1 or us-west-2 or ca-central-1 or
ca-west-1 or sa-east-1 or eu-north-1 or eu-south-2 or eu-west-1 or eu-west-2 or eu-west-3 or
eu-central-1 or me-south-1 or me-central-1 or il-central-1 or af-south-1 or ap-east-1 or
ap-northeast-1 or ap-northeast-2 or ap-northeast-3 or ap-southeast-1 or ap-southeast-2 or
ap-southeast-3 or ap-southeast-4 or ap-southeast-5 or ap-south-1 or ap-south-2 or
cn-north-1 or cn-northwest-1 or
us-gov-east-1 or us-gov-west-1
```
Wenn Sie temporäre Anmeldeinformationen verwenden, müssen Sie `AWS_SESSION_TOKEN` zusätzlich zu `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` und `SERVICE_REGION` angeben.
```
export AWS_SESSION_TOKEN=MY_AWS_SESSION_TOKEN
```
**Anmerkung**
Wenn Sie temporäre Anmeldeinformationen verwenden, laufen diese nach einem angegebenen Intervall ab, *, einschließlich des Sitzungs-Tokens*.
Sie müssen Ihren Sitzungs-Token aktualisieren, wenn Sie neue Anmeldeinformationen anfragen. Weitere Informationen finden Sie unter [Verwenden von temporären Sicherheitsanmeldeinformationen zum Anfordern von Zugriff auf AWS -Ressourcen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html).
1. Geben Sie einen der folgenden Befehle ein, um eine signierte Anforderung an die Neptune-DB-Instance zu senden. Diese Beispiele verwenden Python Version 3.6.
**Endpunktstatus**
```
python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a GET -q status
```
**Gremlin**
```
python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a GET -q gremlin -d "g.V().count()"
python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a POST -q gremlin -d "g.V().count()"
```
**Gremlin-Status**
```
python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a GET -q gremlin/status
```
**SPARQL**
```
python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a GET -q sparql -d "SELECT ?s WHERE { ?s ?p ?o }"
```
**SPARQL UPDATE**
```
python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a POST -q sparqlupdate -d "INSERT DATA { }"
```
**SPARQL-Status**
```
python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a GET -q sparql/status
```
**openCypher**
```
python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a GET -q openCypher -d "MATCH (n1) RETURN n1 LIMIT 1;"
python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a POST -q openCypher -d "MATCH (n1) RETURN n1 LIMIT 1;"
```
**openCypher-Status**
```
python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a GET -q openCypher/status
```
**Loader**
```
python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a GET -q loader -d '{"loadId": "68b28dcc-8e15-02b1-133d-9bd0557607e6"}'
python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a GET -q loader -d '{}'
python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a POST -q loader -d '{"source": "source", "format" : "csv", "failOnError": "fail_on_error", "iamRoleArn": "iam_role_arn", "region": "region"}'
```
1. Die Syntax für die Ausführung des Python-Skripts lautet wie folgt:
```
python3.6 neptunesigv4.py -ho your-neptune-endpoint -p port -a GET|POST -q gremlin|sparql|sparqlupdate|loader|status -d "string0data"
```
SPARQL UPDATE benötigt `POST`.
# Herstellen einer Verbindung zu Amazon Neptune Neptune-Datenbanken mithilfe der IAM-Authentifizierung mit Gremlin Python
## -Übersicht
Dieses Handbuch zeigt, wie Sie mithilfe des Gremlin Python-Treibers, mit Signature Version 4-Authentifizierung und dem AWS SDK für Python (Boto3) eine Verbindung zu einer Amazon Neptune Neptune-Datenbank mit aktivierter IAM-Authentifizierung herstellen.
## Erstellen Sie eine grundlegende Verbindung
Verwenden Sie das folgende Codebeispiel als Anleitung zum Herstellen einer Basisverbindung mit der IAM-Authentifizierung mithilfe des Gremlin Python-Treibers.
```
from boto3 import Session
from botocore.auth import SigV4Auth
from botocore.awsrequest import AWSRequest
from gremlin_python.process.anonymous_traversal import traversal
from gremlin_python.driver.driver_remote_connection import DriverRemoteConnection
def main():
endpoint = 'your.cluster.endpoint.neptune.amazonaws.com'
conn_string = 'wss://' + endpoint + ':8182/gremlin'
default_region = 'us-east-1'
service = 'neptune-db'
credentials = Session().get_credentials()
if credentials is None:
raise Exception("No AWS credentials found")
creds = credentials.get_frozen_credentials()
# region set inside config profile or via AWS_DEFAULT_REGION environment variable will be loaded
region = Session().region_name if Session().region_name else default_region
request = AWSRequest(method='GET', url=conn_string, data=None)
SigV4Auth(creds, service, region).add_auth(request)
rc = DriverRemoteConnection(conn_string, 'g', headers=request.headers.items())
g = traversal().with_remote(rc)
# simple query to verify connection
count = g.V().count().next()
print('Vertex count: ' + str(count))
# cleanup
rc.close()
if __name__ == "__main__":
main()
```
# Herstellen einer Verbindung zu Amazon Neptune Neptune-Datenbanken mithilfe der IAM-Authentifizierung mit Gremlin JavaScript
## -Übersicht
Dieses Handbuch zeigt, wie Sie mithilfe des JavaScript Gremlin-Treibers, mit Signature Version 4-Authentifizierung und dem SDK für Javascript v3 eine Verbindung zu einer Amazon Neptune Neptune-Datenbank mit aktivierter IAM-Authentifizierung herstellen. AWS
## Voraussetzungen
+ Ein Amazon Neptune Neptune-Cluster mit aktivierter IAM-Authentifizierung.
+ Knoten 13 oder höher (siehe Minimalversionen für Gremlin JavaScript und [AWS SDK](https://docs.aws.amazon.com//AWSJavaScriptSDK/v3/latest/introduction/#release-cadence) für Javascript v3).
+ AWS konfigurierte Anmeldeinformationen (über Umgebungsvariablen, Datei mit gemeinsamen Anmeldeinformationen oder IAM-Rolle).
## Erstellen Sie eine Basisverbindung
Verwenden Sie das folgende Codebeispiel als Anleitung zum Herstellen einer Basisverbindung mit IAM-Authentifizierung mithilfe des JavaScript Gremlin-Treibers.
```
const { fromNodeProviderChain } = require('@aws-sdk/credential-providers');
const { getUrlAndHeaders } = require('gremlin-aws-sigv4/lib/utils');
const { loadConfig } = require("@smithy/node-config-provider");
const { NODE_REGION_CONFIG_FILE_OPTIONS, NODE_REGION_CONFIG_OPTIONS } = require("@smithy/config-resolver");
const gremlin = require('gremlin');
const DriverRemoteConnection = gremlin.driver.DriverRemoteConnection;
const traversal = gremlin.process.AnonymousTraversalSource.traversal;
const DEFAULT_REGION = 'us-east-1';
const getCredentials = async () => {
try {
// Loads the default credential provider chain
return await fromNodeProviderChain();
} catch (e) {
console.error("No credentials found", e);
throw e;
}
};
(main = async () => {
console.log('Starting');
const credentials = await getCredentials();
try {
// region set inside config profile or via AWS_REGION environment variable will be loaded
credentials['region'] = await loadConfig(NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS)();
} catch (e) {
credentials['region'] = DEFAULT_REGION
}
const connInfo = getUrlAndHeaders(
'you.cluster.endpoint.neptune.amazonaws.com',
'8182',
credentials,
'/gremlin',
'wss');
const dc = new DriverRemoteConnection(connInfo['url'], {headers: connInfo['headers']});
const g = traversal().withRemote(dc);
const query = g.V().limit(5).count();
const count = await query.next();
console.log("Vertex count: " + count.value);
await dc.close();
})
main();
```
# Herstellen einer Verbindung zu Amazon Neptune Neptune-Datenbanken mithilfe der IAM-Authentifizierung mit Gremlin Go
## -Übersicht
Dieses Handbuch zeigt, wie Sie mithilfe des Gremlin Go-Treibers, mit Signature Version 4-Authentifizierung und dem SDK für GO v2 eine Verbindung zu einer Amazon Neptune Neptune-Datenbank mit aktivierter IAM-Authentifizierung herstellen. AWS
## Voraussetzungen
+ Ein Amazon Neptune Neptune-Cluster mit aktivierter IAM-Authentifizierung.
+ Go 1.22 oder höher (siehe die unterstützten Mindestversionen für [Gremlin Go und [AWS SDK for Go](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2)](https://pkg.go.dev/github.com/apache/tinkerpop/gremlin-go/v3/driver) v2).
+ AWS konfigurierte Anmeldeinformationen (über Umgebungsvariablen, Datei mit gemeinsamen Anmeldeinformationen oder IAM-Rolle)
## Erstellen Sie eine Basisverbindung
Verwenden Sie das folgende Codebeispiel als Anleitung zum Herstellen einer Basisverbindung mit IAM-Authentifizierung mithilfe des Gremlin Go-Treibers.
```
package main
import (
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/config"
"net/http"
"strings"
"time"
gremlingo "github.com/apache/tinkerpop/gremlin-go/v3/driver"
v4 "github.com/aws/aws-sdk-go-v2/aws/signer/v4"
)
const emptyStringSHA256 = `e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855`
func main() {
neptuneEndpoint := "you.cluster.endpoint.neptune.amazonaws.com"
connString := "wss://" + neptuneEndpoint + ":8182/gremlin"
service := "neptune-db"
defaultRegion := "us-east-1"
// Create request to sign
req, err := http.NewRequest(http.MethodGet, connString, strings.NewReader(""))
if err != nil {
fmt.Println(err)
return
}
// Loads the default config with default credentials provider
// See https://github.com/aws/aws-sdk-go-v2 for additional docs on API usage
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
fmt.Println(err)
return
}
// Retrieve loaded credentials
cr, err := cfg.Credentials.Retrieve(context.TODO())
if err != nil {
fmt.Println(err)
return
}
region := defaultRegion
if cfg.Region != "" {
// region set inside config profile, or via AWS_REGION or AWS_DEFAULT_REGION environment variable will be loaded
region = cfg.Region
}
signer := v4.NewSigner()
// Sign request
err = signer.SignHTTP(context.TODO(), cr, req, emptyStringSHA256, service, "us-east-2", time.Now())
if err != nil {
fmt.Println(err)
return
}
// Pass the signed request header into gremlingo.HeaderAuthInfo()
driverRemoteConnection, err := gremlingo.NewDriverRemoteConnection(connString,
func(settings *gremlingo.DriverRemoteConnectionSettings) {
settings.TraversalSource = "g"
settings.AuthInfo = gremlingo.HeaderAuthInfo(req.Header)
// settings.TlsConfig = &tls.Config{InsecureSkipVerify: true} // Use this only if you're on a Mac running Go 1.18+ doing local dev. See https://github.com/golang/go/issues/51991
})
if err != nil {
fmt.Println(err)
return
}
// Cleanup
defer driverRemoteConnection.Close()
// Creating graph traversal
g := gremlingo.Traversal_().WithRemote(driverRemoteConnection)
// Query execution
count, err := g.V().Limit(5).Count().Next()
if err != nil {
fmt.Println(err)
return
}
fmt.Println("Vertex count:", *count)
}
```
## Dynamische Aktualisierung der Gremlin Go-Anmeldeinformationen
Gremlin Go ermöglicht DynamicAuth die Injektion eines Funktionszeigers zum Abrufen von Anmeldeinformationen und Generieren des Headers, wodurch verhindert wird, dass der Header bei lang andauernden Verbindungen abläuft.
```
package main
import (
"context"
"crypto/tls"
"fmt"
"github.com/aws/aws-sdk-go-v2/config"
"net/http"
"strings"
"time"
gremlingo "github.com/apache/tinkerpop/gremlin-go/v3/driver"
v4 "github.com/aws/aws-sdk-go-v2/aws/signer/v4"
)
const emptyStringSHA256 = `e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855`
func main() {
neptuneEndpoint := "you.cluster.endpoint.neptune.amazonaws.com"
connString := "wss://" + neptuneEndpoint + ":8182/gremlin"
service := "neptune-db"
defaultRegion := "us-east-1"
//Create the request to sign
req, err := http.NewRequest(http.MethodGet, connString, strings.NewReader(""))
if err != nil {
fmt.Println(err)
return
}
// Loads the default config with default credentials provider
// See https://github.com/aws/aws-sdk-go-v2 for additional docs on API usage
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
fmt.Println(err)
return
}
region := defaultRegion
if cfg.Region != "" {
// region set inside config profile, or via AWS_REGION or AWS_DEFAULT_REGION environment variable will be loaded
region = cfg.Region
}
signer := v4.NewSigner()
// This is the function that will be used for dynamic refreseh of credentials and signed headers
gen := func() gremlingo.AuthInfoProvider {
// Retrieve loaded credentials
cr, err := cfg.Credentials.Retrieve(context.TODO())
fmt.Println("AWS Credentials: ", cr)
if err != nil {
fmt.Println(err)
return
}
// Sign request
err = signer.SignHTTP(context.TODO(), cr, req, emptyStringSHA256, service, region, time.Now())
if err != nil {
fmt.Println(err)
return
}
fmt.Println(req.Header)
return gremlingo.HeaderAuthInfo(req.Header)
}
// Pass the function into gremlingo.NewDynamicAuth(), which will generate the AuthInfoProvider to pass into gremlingo.DriverRemoteConnectionSettings below
auth := gremlingo.NewDynamicAuth(gen)
driverRemoteConnection, err := gremlingo.NewDriverRemoteConnection(connString,
func(settings *gremlingo.DriverRemoteConnectionSettings) {
settings.TraversalSource = "g"
settings.AuthInfo = auth
// settings.TlsConfig = &tls.Config{InsecureSkipVerify: true} // Use this only if you're on a Mac running Go 1.18+ doing local dev. See https://github.com/golang/go/issues/51991
})
if err != nil {
fmt.Println(err)
return
}
// Cleanup
defer driverRemoteConnection.Close()
// Creating graph traversal
g := gremlingo.Traversal_().WithRemote(driverRemoteConnection)
// Query execution
count, err := g.V().Limit(5).Count().Next()
if err != nil {
fmt.Println(err)
return
}
fmt.Println("Vertex count:", *count)
}
```
# Herstellen einer Verbindung zu Amazon Neptune Neptune-Datenbanken mithilfe der IAM-Authentifizierung mit Gremlin .NET
## -Übersicht
Dieses Handbuch zeigt, wie Sie mithilfe des Gremlin.NET-Treibers, mit Signature Version 4-Authentifizierung und dem SDK for .NET v3 eine Verbindung zu einer Amazon Neptune Neptune-Datenbank mit aktivierter IAM-Authentifizierung herstellen. AWS
## Erstellen Sie eine Basisverbindung
[Um eine Verbindung mit Gremlin .NET herzustellen, verwenden Sie die `SigV4RequestSigner` Quelldatei aus der benutzerdefinierten Bibliothek https://github.com/aws/ amazon-neptune-gremlin-dotnet -sigv4.](https://github.com/aws/amazon-neptune-gremlin-dotnet-sigv4) Ein Beispiel für die Einrichtung eines Projekts befindet sich in [ https://github.com/aws/amazon-neptune-gremlin-dotnet-sigv4/ und wird im Folgenden wiedergegeben tree/main/example](https://github.com/aws/amazon-neptune-gremlin-dotnet-sigv4/tree/main/example).
Projektdatei:
```
Exe
netcoreapp8.0
```
Beispielprogramm:
```
using System;
using System.Collections.Generic;
using System.Net.WebSockets;
using System.Linq;
using System.Net.Http;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Web;
using Gremlin.Net;
using Gremlin.Net.Driver;
using Gremlin.Net.Driver.Remote;
using Gremlin.Net.Process;
using Gremlin.Net.Process.Traversal;
using Gremlin.Net.Structure;
using static Gremlin.Net.Process.Traversal.AnonymousTraversalSource;
using static Gremlin.Net.Process.Traversal.__;
using static Gremlin.Net.Process.Traversal.P;
using static Gremlin.Net.Process.Traversal.Order;
using static Gremlin.Net.Process.Traversal.Operator;
using static Gremlin.Net.Process.Traversal.Pop;
using static Gremlin.Net.Process.Traversal.Scope;
using static Gremlin.Net.Process.Traversal.TextP;
using static Gremlin.Net.Process.Traversal.Column;
using static Gremlin.Net.Process.Traversal.Direction;
using static Gremlin.Net.Process.Traversal.T;
using Amazon.Runtime.CredentialManagement;
using Amazon.Runtime;
using Amazon;
using Amazon.Util;
using Amazon.Neptune.Gremlin.Driver;
namespace NeptuneExample
{
class Program
{
static void Main(string[] args)
{
/*
Include your Neptune endpoint and port below.
*/
var neptune_host = "neptune-endpoint"; // ex: mycluster.cluster.us-east-1.neptune.amazonaws.com
var neptune_port = 8182;
var gremlinServer = new GremlinServer(neptune_host, neptune_port);
var gremlinClient = new GremlinClient(gremlinServer, webSocketConfiguration: new SigV4RequestSigner().signRequest(neptune_host, neptune_port));
var remoteConnection = new DriverRemoteConnection(gremlinClient);
var g = Traversal().WithRemote(remoteConnection);
/* Example code to pull the first 5 vertices in a graph. */
Console.WriteLine("Get List of Node Labels:");
Int32 limitValue = 5;
var output = g.V().Limit(limitValue).ToList();
foreach(var item in output) {
Console.WriteLine(item);
}
}
}
}
```
# Verwaltung des Zugriffs auf Amazon Neptune Neptune-Datenbanken mithilfe von IAM-Richtlinien
[IAM-Richtlinien](https://docs.aws.amazon.com/kms/latest/developerguide/iam-policies.html) sind JSON-Objekte, die Berechtigungen für die Verwendung von Aktionen und Ressourcen definieren.
Sie kontrollieren den Zugriff, AWS indem Sie Richtlinien erstellen und diese an Identitäten oder Ressourcen anhängen. AWS Eine Richtlinie definiert Berechtigungen, wenn sie mit einer Identität oder Ressource verknüpft sind. AWS bewertet diese Richtlinien, wenn ein Principal eine Anfrage stellt. Die meisten Richtlinien werden AWS als JSON-Dokumente gespeichert. Weitere Informationen zu JSON-Richtliniendokumenten finden Sie unter [Übersicht über JSON-Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json) im *IAM-Benutzerhandbuch*.
Mit Hilfe von Richtlinien legen Administratoren fest, wer Zugriff auf was hat, indem sie definieren, welches **Prinzipal** welche **Aktionen** auf welchen **Ressourcen**und unter welchen **Bedingungen**durchführen darf.
Standardmäßig haben Benutzer, Gruppen und Rollen keine Berechtigungen. Ein IAM-Administrator erstellt IAM-Richtlinien und fügt sie zu Rollen hinzu, die die Benutzer dann übernehmen können. IAM-Richtlinien definieren Berechtigungen unabhängig von der Methode, die zur Ausführung der Operation verwendet wird.
## Identitätsbasierte Richtlinien
Identitätsbasierte Richtlinien sind JSON-Berechtigungsrichtliniendokumente, die Sie einer Identität (Benutzer, Gruppe oder Rolle) anfügen können. Diese Richtlinien steuern, welche Aktionen Identitäten für welche Ressourcen und unter welchen Bedingungen ausführen können. Informationen zum Erstellen identitätsbasierter Richtlinien finden Sie unter [Definieren benutzerdefinierter IAM-Berechtigungen mit vom Kunden verwalteten Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) im *IAM-Benutzerhandbuch*.
Identitätsbasierte Richtlinien können *Inline-Richtlinien* (direkt in eine einzelne Identität eingebettet) oder *verwaltete Richtlinien* (eigenständige Richtlinien, die mit mehreren Identitäten verbunden sind) sein. Informationen dazu, wie Sie zwischen verwalteten und Inline-Richtlinien wählen, finden Sie unter [Choose between managed policies and inline policies](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-choosing-managed-or-inline.html) im *IAM-Benutzerhandbuch*.
## Verwendung von Service Control Policies (SCP) in Organisationen AWS
Servicesteuerungsrichtlinien (SCPs) sind JSON-Richtlinien, die die maximalen Berechtigungen für eine Organisation oder Organisationseinheit (OU) in [AWS Organizations](https://aws.amazon.com/organizations/)festlegen. AWS Organizations ist ein Dienst zur Gruppierung und zentralen Verwaltung mehrerer AWS Konten, die Ihrem Unternehmen gehören. Wenn Sie alle Funktionen in einer Organisation aktivieren, können Sie Richtlinien zur Servicesteuerung (SCPs) auf einige oder alle Ihre Konten anwenden. Das SCP schränkt die Berechtigungen für Entitäten in Mitgliedskonten ein, einschließlich der einzelnen AWS Root-Benutzer. Weitere Informationen zu Organizations und SCPs finden Sie unter [So SCPs arbeiten](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_about-scps.html) Sie im AWS Organizations Benutzerhandbuch.
Kunden, die Amazon Neptune in einem AWS Konto innerhalb eines AWS Unternehmens einsetzen, können so steuern SCPs , welche Konten Neptune verwenden können. Um den Zugriff auf Neptune innerhalb eines Mitgliedskontos zu gewährleisten, musst du Folgendes tun:
+ Erlaubt den Zugriff auf `rds:*` und `neptune-db:*` für Neptune-Datenbankoperationen. Weitere Informationen finden Sie unter [Warum sind Amazon RDS-Berechtigungen und Ressourcen für die Verwendung von Neptune Database erforderlich](https://aws.amazon.com/neptune/faqs/)? für Einzelheiten darüber, warum Amazon RDS-Berechtigungen für die Neptune-Datenbank erforderlich sind.
+ Erlauben Sie den Zugriff `neptune-graph:*` auf Neptune Analytics-Operationen.
## Für die Verwendung der Amazon-Neptune-Konsole erforderliche Berechtigungen
Damit Benutzer mit der Amazon-Neptune-Konsole arbeiten können, müssen sie einen Mindestsatz von Berechtigungen besitzen. Diese Berechtigungen ermöglichen Benutzern, die Neptune-Ressourcen für ihr AWS -Konto zu beschreiben und weitere verwandte Informationen bereitzustellen, einschließlich Informationen in den Bereichen Amazon-EC2-Sicherheit und -Netzwerk.
Wenn Sie eine IAM-Richtlinie erstellen, die strenger ist als die mindestens erforderlichen Berechtigungen, funktioniert die Konsole nicht wie vorgesehen für Benutzer mit dieser IAM-Richtlinie. Um sicherzustellen, dass diese Benutzer die Neptune-Konsole weiter verwenden können, müssen Sie ihnen die verwaltete Richtlinie `NeptuneReadOnlyAccess` anfügen, wie in [Verwenden AWS verwalteter Richtlinien für den Zugriff auf Amazon Neptune Neptune-Datenbanken](security-iam-access-managed-policies.md) beschrieben.
Sie müssen Benutzern, die nur die Amazon Neptune-API AWS CLI oder die Amazon Neptune Neptune-API aufrufen, keine Mindestberechtigungen für die Konsole gewähren.
## Anfügen einer IAM-Richtlinie an einen IAM-Benutzer
Um eine verwaltete oder benutzerdefinierte Richtlinie anzuwenden, fügen Sie diese an einen IAM-Benutzer an. Eine praktische Anleitung zu diesem Thema finden Sie unter [ Praktische Anleitung: Erstellen und Anfügen Ihrer ersten vom Kunden verwalteten Richtlinie](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_managed-policies.html) im *IAM-Benutzerhandbuch*.
Wenn Sie die praktischen Anleitung durchgehen, können Sie eine der in diesem Abschnitt aufgeführten Beispielrichtlinien als Ausgangsbasis verwenden und auf Ihre Bedürfnisse anpassen. Am Ende des Tutorials verfügen Sie über einen IAM-Benutzer mit einer angefügten Richtlinie, der die Aktion `neptune-db:*` verwenden kann.
**Wichtig**
Die Anwendung von Änderungen einer IAM-Richtlinie auf die angegebenen Neptune-Ressourcen kann bis zu 10 Minuten dauern.
IAM-Richtlinien, die auf einen Neptune-DB-Cluster angewendet werden, werden auf alle Instances in diesem Cluster angewendet.
## Verwenden verschiedener Arten von IAM-Richtlinien für die Steuerung des Zugriffs auf Neptune
Um Zugriff auf Neptune-Verwaltungsaktionen oder auf Daten in einem Neptune-DB-Cluster zu gewähren, fügen Sie einem IAM-Benutzer oder einer IAM-Rolle Richtlinien an. Informationen zum Anfügen einer IAM-Richtlinie an einen Benutzer finden Sie unter [Anfügen einer IAM-Richtlinie an einen IAM-Benutzer](#iam-auth-policy-attaching). Informationen zum Anfügen einer Richtlinie an eine Rolle finden Sie unter [Hinzufügen und Entfernen von IAM-Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) im *IAM-Benutzerhandbuch*.
Für den allgemeinen Zugriff auf Neptune können Sie eine der von Neptune [verwalteten Richtlinien](security-iam-access-managed-policies.md) verwenden. Um den Zugriff stärker einzuschränken, können Sie mithilfe der von Neptune unterstützten [administrativen Aktionen](neptune-iam-admin-actions.md) und [Ressourcen](iam-admin-resources.md) eine eigene benutzerdefinierte Richtlinie erstellen.
In einer benutzerdefinierten IAM-Richtlinie können Sie zwei verschiedene Arten von Richtlinienanweisungen verwenden, die verschiedene Zugriffsmodi auf einen Neptune-DB-Cluster steuern:
+ [Administrative Richtlinienanweisungen](iam-admin-policies.md) — Administrative Richtlinienanweisungen bieten Zugriff auf das [Neptune-Management APIs](api.md), mit dem Sie einen DB-Cluster und seine Instances erstellen, konfigurieren und verwalten.
Da Neptune Funktionalität mit Amazon RDS teilt, verwenden administrative Aktionen, Ressourcen und Bedingungsschlüssel in Neptune-Richtlinien standardmäßig das Präfix `rds:`.
+ [Datenzugriff-Richtlinienanweisungen](iam-data-access-policies.md) – Datenzugriff-Richtlinienanweisungen verwenden [Datenzugriffsaktionen](iam-dp-actions.md), [Ressourcen](iam-data-resources.md) und [Bedingungsschlüssel](iam-data-condition-keys.md#iam-neptune-condition-keys) zur Steuerung des Zugriffs auf die Daten in einem DB-Cluster.
Neptune-Datenzugriffsaktionen, -Ressourcen und -Bedingungsschlüssel verwenden das Präfix `neptune-db:`.
## Verwenden von IAM-Bedingungskontextschlüsseln in Amazon Neptune
Sie können Bedingungen in einer IAM-Richtlinienanweisung angeben, die den Zugriff auf Neptune steuert. Die Richtlinienanweisung ist nur wirksam, wenn die Bedingungen erfüllt werden.
Vielleicht möchten Sie, dass eine Richtlinienanweisung erst nach einem bestimmten Datum wirksam wird oder dass der Zugriff nur zulässig ist, wenn ein bestimmter Wert in der Anforderung enthalten ist.
Zum Ausdruck von Bedingungen verwenden Sie im [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html)-Element einer Richtlinienanweisung vordefinierte Bedingungsschlüssel zusammen mit [IAM-Bedingungs-Richtlinienoperatoren](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) wie „gleich“ oder „kleiner als“.
Wenn Sie mehrere `Condition`-Elemente in einer Anweisung oder mehrere Schlüssel in einem einzelnen `Condition`-Element angeben, wertet AWS diese mittels einer logischen `AND`-Operation aus. Wenn Sie mehrere Werte für einen einzelnen Bedingungsschlüssel angeben, AWS wertet die Bedingung mithilfe einer logischen Operation aus. `OR` Alle Bedingungen müssen erfüllt sein, bevor die Berechtigungen für die Anweisung erteilt werden.
Sie können auch Platzhaltervariablen verwenden, wenn Sie Bedingungen angeben. Beispielsweise können Sie einem IAM-Benutzer die Berechtigung für den Zugriff auf eine Ressource nur dann gewähren, wenn sie mit dessen IAM-Benutzernamen gekennzeichnet ist. Weitere Informationen finden Sie unter [IAM-Richtlinienelemente: Variablen und Tags](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_variables.html) im *IAM-Benutzerhandbuch*.
Der Datentyp eines Bedingungsschlüssels legt fest, welche Bedingungsoperatoren Sie für den Vergleich der Werte in der Anforderung mit den Werten in der Richtlinienanweisung verwenden können. Wenn Sie einen Bedingungsoperator verwenden, der nicht mit diesem Datentyp kompatibel ist, wird niemals eine Übereinstimmung ermittelt und die Richtlinienanweisung wird nie angewendet.
Neptune unterstützt andere Sätze von Bedingungsschlüsseln für administrative Richtlinienanweisungen als für Datenzugriffs-Richtlinienanweisungen:
+ [Bedingungsschlüssel für administrative Richtlinienanweisungen](iam-admin-condition-keys.md)
+ [Bedingungsschlüssel für Datenzugriff-Richtlinienanweisungen](iam-data-condition-keys.md#iam-neptune-condition-keys)
## Unterstützung für IAM-Richtlinien- und Zugriffssteuerungs-Features in Amazon Neptune
Die folgende Tabelle zeigt die IAM-Features, die Neptune für administrative Richtlinienanweisungen und Datenzugriff-Richtlinienanweisungen unterstützt:
**IAM-Features, die Sie mit Neptune verwenden können**
| IAM-Feature | Administrativ | Datenzugriff |
| --- | --- | --- |
| [Identitätsbasierte Richtlinien](#security_iam_access-manage-id-based-policies) | Ja | Ja |
| [Ressourcenbasierte Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html) | Nein | Nein |
| [Richtlinienaktionen](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_action.html) | Ja | Ja |
| [Richtlinienressourcen](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_resource.html) | Ja | Ja |
| [Globale Bedingungsschlüssel](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) | Ja | (eine Teilmenge) |
| [Tag-basierte Bedingungsschlüssel](iam-admin-condition-keys.md#iam-rds-tag-based-condition-keys) | Ja | Nein |
| [Zugriffskontrolllisten (ACLs)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/acls.html) | Nein | Nein |
| [Richtlinien zur Dienstkontrolle (SCPs)](#security_iam_access-manage-scp) | Ja | Ja |
| [Serviceverknüpfte Rollen](security-iam-service-linked-roles.md) | Ja | Nein |
## IAM-Richtlinien – Einschränkungen
Die Anwendung von Änderungen einer IAM-Richtlinie auf die angegebenen Neptune-Ressourcen kann bis zu 10 Minuten dauern.
IAM-Richtlinien, die auf einen Neptune-DB-Cluster angewendet werden, werden auf alle Instances in diesem Cluster angewendet.
Neptune unterstützt derzeit keine kontenübergreifende Zugriffskontrolle auf Datenebene. Die kontenübergreifende Zugriffskontrolle wird nur beim Massenladen und bei Verwendung von Rollenverkettung unterstützt. [Weitere Informationen finden Sie im Tutorial zum Laden mehrerer Dateien.](https://docs.aws.amazon.com//neptune/latest/userguide/bulk-load-tutorial-chain-roles.html#bulk-load-tutorial-chain-cross-account)
# Verwenden AWS verwalteter Richtlinien für den Zugriff auf Amazon Neptune Neptune-Datenbanken
AWS adressiert viele gängige Anwendungsfälle durch die Bereitstellung eigenständiger IAM-Richtlinien, die von erstellt und verwaltet werden. AWS Die verwalteten Richtlinien erteilen die erforderlichen Berechtigungen für viele häufige Anwendungsfälle, sodass Sie nicht mühsam ermitteln müssen, welche Berechtigungen erforderlich sind. Weitere Informationen finden Sie unter [AWS -verwaltete Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) im *IAM-Benutzerhandbuch*.
Die folgenden AWS verwalteten Richtlinien, die Sie Benutzern in Ihrem Konto zuordnen können, gelten für die Nutzung der Amazon Neptune Neptune-Verwaltung: APIs
+ **[NeptuneReadOnlyAccess](read-only-access-iam-managed-policy.md)**— Gewährt schreibgeschützten Zugriff auf alle Neptune-Ressourcen sowohl für administrative als auch für Datenzugriffszwecke im Root-Konto. AWS
+ **[NeptuneFullAccess](full-access-iam-managed-policy.md)**— Gewährt vollen Zugriff auf alle Neptune-Ressourcen sowohl für administrative als auch für Datenzugriffszwecke im Root-Konto. AWS Dies wird empfohlen, wenn Sie vollen Neptune-Zugriff über das AWS CLI oder SDK benötigen, aber nicht für AWS-Managementkonsole den Zugriff.
+ **[NeptuneConsoleFullAccess](console-full-access-iam-managed-policy.md)**— Gewährt vollen Zugriff im AWS Root-Konto auf alle administrativen Aktionen und Ressourcen von Neptune, jedoch nicht auf Datenzugriffsaktionen oder Ressourcen. Dies schließt zusätzliche Berechtigungen ein, um den Zugriff auf Neptune über die Konsole zu vereinfachen, einschließlich eingeschränkter IAM- und Amazon-EC2 (VPC)-Berechtigungen.
+ **[NeptuneGraphReadOnlyAccess ](graph-read-only-access-iam-managed-policy.md)**— Bietet schreibgeschützten Zugriff auf alle Amazon Neptune Analytics-Ressourcen zusammen mit Leseberechtigungen für abhängige Dienste
+ **[AWSServiceRoleForNeptuneGraphPolicy](aws-service-role-for-neptune-graph-policy.md)**— Ermöglicht Neptune Analytics-Grafiken zur Veröffentlichung von CloudWatch Betriebs- und Nutzungsmetriken und Protokollen.
Neptune-IAM-Rollen und -Richtlinien gewähren einen bestimmten Zugriff auf Amazon–RDS-Ressourcen, da Neptune für bestimmte Verwaltungs-Features operative Technologien mit Amazon RDS teilt. Dazu gehören administrative API-Berechtigungen, weswegen administrative Neptune-Aktionen das Präfix `rds:` haben.
## Aktualisierungen der von Neptune verwalteten Richtlinien AWS
Die folgende Tabelle listet die Aktualisierungen der von Neptune verwalteten Richtlinien ab dem Zeitpunkt auf, an dem Neptune mit der Verfolgung dieser Änderungen begonnen hat:
| Richtlinie | Description | Date |
| --- | --- | --- |
| AWS verwaltete Richtlinien für Amazon Neptune — Aktualisierung vorhandener Richtlinien | Die `NeptuneReadOnlyAcess` und die `NeptuneFullAccess` verwalteten Richtlinien enthalten jetzt `Sid` (Kontoausweis-ID) als Kennung in der Richtlinienerklärung. | 2024-01-22 |
| [NeptuneGraphReadOnlyAccess](read-only-access-iam-managed-policy.md)(veröffentlicht) | Diese Version bietet schreibgeschützten Zugriff auf Neptune-Analytics-Graphen und -Ressourcen. | 29.11.2023- |
| [AWSServiceRoleForNeptuneGraphPolicy](aws-service-role-for-neptune-graph-policy.md)(veröffentlicht) | Veröffentlicht, um Neptune Analytics-Graphen Zugriff auf die Veröffentlichung von Betriebs- und Nutzungsmetriken und Protokollen CloudWatch zu ermöglichen. Weitere Informationen finden Sie [unter Verwenden von serviceverknüpften Rollen (SLRs) in Neptune Analytics](https://docs.aws.amazon.com/neptune-analytics/latest/userguide/nan-service-linked-roles.html). | 2023-11-29 |
| [NeptuneConsoleFullAccess](console-full-access-iam-managed-policy.md)(Berechtigungen hinzugefügt) | Die hinzugefügten Berechtigungen bieten den gesamten benötigten Zugriff für die Interaktion mit Neptune-Analytics-Graphen. | 2023-11/29 |
| [NeptuneFullAccess](full-access-iam-managed-policy.md)(Berechtigungen hinzugefügt) | Datenzugriffsberechtigungen und Berechtigungen für eine neue globale Datenbank APIs hinzugefügt. | 28.07.2022 |
| [NeptuneConsoleFullAccess](console-full-access-iam-managed-policy.md)(Berechtigungen hinzugefügt) | Berechtigungen für eine neue globale Datenbank hinzugefügt APIs. | 2021-07-21 |
| Beginn der Verfolgung von Änderungen durch Neptune | Neptune begann, Änderungen an seinen AWS verwalteten Richtlinien zu verfolgen. | 21.07.2022 |
# Gewährung `NeptuneReadOnlyAccess` an Amazon Neptune Neptune-Datenbanken mithilfe verwalteter Richtlinien AWS
Die unten stehende [NeptuneReadOnlyAccess](https://console.aws.amazon.com/iam/home#policies/NeptuneReadOnlyAccess)verwaltete Richtlinie gewährt Lesezugriff auf alle Neptune-Aktionen und -Ressourcen sowohl für administrative als auch für Datenzugriffszwecke.
**Anmerkung**
Diese Richtlinie wurde am 21.07.2022 aktualisiert und umfasst nun schreibgeschützte Datenzugriffsberechtigungen und administrative Berechtigungen sowie Berechtigungen für globale Datenbankaktionen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowReadOnlyPermissionsForRDS",
"Effect": "Allow",
"Action": [
"rds:DescribeAccountAttributes",
"rds:DescribeCertificates",
"rds:DescribeDBClusterParameterGroups",
"rds:DescribeDBClusterParameters",
"rds:DescribeDBClusterSnapshotAttributes",
"rds:DescribeDBClusterSnapshots",
"rds:DescribeDBClusters",
"rds:DescribeDBEngineVersions",
"rds:DescribeDBInstances",
"rds:DescribeDBLogFiles",
"rds:DescribeDBParameterGroups",
"rds:DescribeDBParameters",
"rds:DescribeDBSubnetGroups",
"rds:DescribeEventCategories",
"rds:DescribeEventSubscriptions",
"rds:DescribeEvents",
"rds:DescribeGlobalClusters",
"rds:DescribeOrderableDBInstanceOptions",
"rds:DescribePendingMaintenanceActions",
"rds:DownloadDBLogFilePortion",
"rds:ListTagsForResource"
],
"Resource": "*"
},
{
"Sid": "AllowReadOnlyPermissionsForCloudwatch",
"Effect": "Allow",
"Action": [
"cloudwatch:GetMetricStatistics",
"cloudwatch:ListMetrics"
],
"Resource": "*"
},
{
"Sid": "AllowReadOnlyPermissionsForEC2",
"Effect": "Allow",
"Action": [
"ec2:DescribeAccountAttributes",
"ec2:DescribeAvailabilityZones",
"ec2:DescribeInternetGateways",
"ec2:DescribeSecurityGroups",
"ec2:DescribeSubnets",
"ec2:DescribeVpcAttribute",
"ec2:DescribeVpcs"
],
"Resource": "*"
},
{
"Sid": "AllowReadOnlyPermissionsForKMS",
"Effect": "Allow",
"Action": [
"kms:ListKeys",
"kms:ListRetirableGrants",
"kms:ListAliases",
"kms:ListKeyPolicies"
],
"Resource": "*"
},
{
"Sid": "AllowReadOnlyPermissionsForLogs",
"Effect": "Allow",
"Action": [
"logs:DescribeLogStreams",
"logs:GetLogEvents"
],
"Resource": [
"arn:aws:logs:*:*:log-group:/aws/rds/*:log-stream:*",
"arn:aws:logs:*:*:log-group:/aws/neptune/*:log-stream:*"
]
},
{
"Sid": "AllowReadOnlyPermissionsForNeptuneDB",
"Effect": "Allow",
"Action": [
"neptune-db:Read*",
"neptune-db:Get*",
"neptune-db:List*"
],
"Resource": [
"*"
]
}
]
}
```
------
# Gewährung `NeptuneFullAccess` an Amazon Neptune Neptune-Datenbanken mithilfe verwalteter Richtlinien AWS
Die unten stehende [NeptuneFullAccess](https://console.aws.amazon.com/iam/home#policies/NeptuneFullAccess)verwaltete Richtlinie gewährt vollen Zugriff auf alle Neptune-Aktionen und -Ressourcen, sowohl für administrative als auch für Datenzugriffszwecke. Sie wird empfohlen, wenn Sie vollen Zugriff über das AWS CLI oder über ein SDK benötigen, aber nicht über das. AWS-Managementkonsole
**Anmerkung**
Diese Richtlinie wurde am 21.07.2022 aktualisiert und umfasst vollständige Datenzugriffs- und administrative Berechtigungen sowie Berechtigungen für globale Datenbankaktionen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowNeptuneCreate",
"Effect": "Allow",
"Action": [
"rds:CreateDBCluster",
"rds:CreateDBInstance"
],
"Resource": [
"arn:aws:rds:*:*:*"
],
"Condition": {
"StringEquals": {
"rds:DatabaseEngine": [
"graphdb",
"neptune"
]
}
}
},
{
"Sid": "AllowManagementPermissionsForRDS",
"Effect": "Allow",
"Action": [
"rds:AddRoleToDBCluster",
"rds:AddSourceIdentifierToSubscription",
"rds:AddTagsToResource",
"rds:ApplyPendingMaintenanceAction",
"rds:CopyDBClusterParameterGroup",
"rds:CopyDBClusterSnapshot",
"rds:CopyDBParameterGroup",
"rds:CreateDBClusterEndpoint",
"rds:CreateDBClusterParameterGroup",
"rds:CreateDBClusterSnapshot",
"rds:CreateDBParameterGroup",
"rds:CreateDBSubnetGroup",
"rds:CreateEventSubscription",
"rds:CreateGlobalCluster",
"rds:DeleteDBCluster",
"rds:DeleteDBClusterEndpoint",
"rds:DeleteDBClusterParameterGroup",
"rds:DeleteDBClusterSnapshot",
"rds:DeleteDBInstance",
"rds:DeleteDBParameterGroup",
"rds:DeleteDBSubnetGroup",
"rds:DeleteEventSubscription",
"rds:DeleteGlobalCluster",
"rds:DescribeDBClusterEndpoints",
"rds:DescribeAccountAttributes",
"rds:DescribeCertificates",
"rds:DescribeDBClusterParameterGroups",
"rds:DescribeDBClusterParameters",
"rds:DescribeDBClusterSnapshotAttributes",
"rds:DescribeDBClusterSnapshots",
"rds:DescribeDBClusters",
"rds:DescribeDBEngineVersions",
"rds:DescribeDBInstances",
"rds:DescribeDBLogFiles",
"rds:DescribeDBParameterGroups",
"rds:DescribeDBParameters",
"rds:DescribeDBSecurityGroups",
"rds:DescribeDBSubnetGroups",
"rds:DescribeEngineDefaultClusterParameters",
"rds:DescribeEngineDefaultParameters",
"rds:DescribeEventCategories",
"rds:DescribeEventSubscriptions",
"rds:DescribeEvents",
"rds:DescribeGlobalClusters",
"rds:DescribeOptionGroups",
"rds:DescribeOrderableDBInstanceOptions",
"rds:DescribePendingMaintenanceActions",
"rds:DescribeValidDBInstanceModifications",
"rds:DownloadDBLogFilePortion",
"rds:FailoverDBCluster",
"rds:FailoverGlobalCluster",
"rds:ListTagsForResource",
"rds:ModifyDBCluster",
"rds:ModifyDBClusterEndpoint",
"rds:ModifyDBClusterParameterGroup",
"rds:ModifyDBClusterSnapshotAttribute",
"rds:ModifyDBInstance",
"rds:ModifyDBParameterGroup",
"rds:ModifyDBSubnetGroup",
"rds:ModifyEventSubscription",
"rds:ModifyGlobalCluster",
"rds:PromoteReadReplicaDBCluster",
"rds:RebootDBInstance",
"rds:RemoveFromGlobalCluster",
"rds:RemoveRoleFromDBCluster",
"rds:RemoveSourceIdentifierFromSubscription",
"rds:RemoveTagsFromResource",
"rds:ResetDBClusterParameterGroup",
"rds:ResetDBParameterGroup",
"rds:RestoreDBClusterFromSnapshot",
"rds:RestoreDBClusterToPointInTime",
"rds:StartDBCluster",
"rds:StopDBCluster"
],
"Resource": [
"*"
]
},
{
"Sid": "AllowOtherDepedentPermissions",
"Effect": "Allow",
"Action": [
"cloudwatch:GetMetricStatistics",
"cloudwatch:ListMetrics",
"ec2:DescribeAccountAttributes",
"ec2:DescribeAvailabilityZones",
"ec2:DescribeSecurityGroups",
"ec2:DescribeSubnets",
"ec2:DescribeVpcAttribute",
"ec2:DescribeVpcs",
"kms:ListAliases",
"kms:ListKeyPolicies",
"kms:ListKeys",
"kms:ListRetirableGrants",
"logs:DescribeLogStreams",
"logs:GetLogEvents",
"sns:ListSubscriptions",
"sns:ListTopics",
"sns:Publish"
],
"Resource": [
"*"
]
},
{
"Sid": "AllowPassRoleForNeptune",
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": "*",
"Condition": {
"StringEquals": {
"iam:passedToService": "rds.amazonaws.com"
}
}
},
{
"Sid": "AllowCreateSLRForNeptune",
"Effect": "Allow",
"Action": "iam:CreateServiceLinkedRole",
"Resource": "arn:aws:iam::*:role/aws-service-role/rds.amazonaws.com/AWSServiceRoleForRDS",
"Condition": {
"StringLike": {
"iam:AWSServiceName": "rds.amazonaws.com"
}
}
},
{
"Sid": "AllowDataAccessForNeptune",
"Effect": "Allow",
"Action": [
"neptune-db:*"
],
"Resource": [
"*"
]
}
]
}
```
------
# Gewährung `NeptuneConsoleFullAccess` mithilfe einer AWS verwalteten Richtlinie
Die unten stehende [NeptuneConsoleFullAccess](https://console.aws.amazon.com/iam/home#policies/NeptuneConsoleFullAccess)verwaltete Richtlinie gewährt vollen Zugriff auf alle Neptun-Aktionen und -Ressourcen für administrative Zwecke, jedoch nicht für Datenzugriffszwecke. Dies schließt zusätzliche Berechtigungen ein, um den Zugriff auf Neptune über die Konsole zu vereinfachen, einschließlich eingeschränkter IAM- und Amazon-EC2 (VPC)-Berechtigungen.
**Anmerkung**
Diese Richtlinie wurde am 29.11.2023 aktualisiert und umfasst nun auch die Berechtigungen, die für die Interaktion mit Neptune-Analytics-Graphen erforderlich sind.
Sie wurde am 21.07.2022 aktualisiert und umfasst nun auch Berechtigungen für globale Datenbankaktionen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowNeptuneCreate",
"Effect": "Allow",
"Action": [
"rds:CreateDBCluster",
"rds:CreateDBInstance"
],
"Resource": [
"arn:aws:rds:*:*:*"
],
"Condition": {
"StringEquals": {
"rds:DatabaseEngine": [
"graphdb",
"neptune"
]
}
}
},
{
"Sid": "AllowManagementPermissionsForRDS",
"Action": [
"rds:AddRoleToDBCluster",
"rds:AddSourceIdentifierToSubscription",
"rds:AddTagsToResource",
"rds:ApplyPendingMaintenanceAction",
"rds:CopyDBClusterParameterGroup",
"rds:CopyDBClusterSnapshot",
"rds:CopyDBParameterGroup",
"rds:CreateDBClusterParameterGroup",
"rds:CreateDBClusterSnapshot",
"rds:CreateDBParameterGroup",
"rds:CreateDBSubnetGroup",
"rds:CreateEventSubscription",
"rds:DeleteDBCluster",
"rds:DeleteDBClusterParameterGroup",
"rds:DeleteDBClusterSnapshot",
"rds:DeleteDBInstance",
"rds:DeleteDBParameterGroup",
"rds:DeleteDBSubnetGroup",
"rds:DeleteEventSubscription",
"rds:DescribeAccountAttributes",
"rds:DescribeCertificates",
"rds:DescribeDBClusterParameterGroups",
"rds:DescribeDBClusterParameters",
"rds:DescribeDBClusterSnapshotAttributes",
"rds:DescribeDBClusterSnapshots",
"rds:DescribeDBClusters",
"rds:DescribeDBEngineVersions",
"rds:DescribeDBInstances",
"rds:DescribeDBLogFiles",
"rds:DescribeDBParameterGroups",
"rds:DescribeDBParameters",
"rds:DescribeDBSecurityGroups",
"rds:DescribeDBSubnetGroups",
"rds:DescribeEngineDefaultClusterParameters",
"rds:DescribeEngineDefaultParameters",
"rds:DescribeEventCategories",
"rds:DescribeEventSubscriptions",
"rds:DescribeEvents",
"rds:DescribeOptionGroups",
"rds:DescribeOrderableDBInstanceOptions",
"rds:DescribePendingMaintenanceActions",
"rds:DescribeValidDBInstanceModifications",
"rds:DownloadDBLogFilePortion",
"rds:FailoverDBCluster",
"rds:ListTagsForResource",
"rds:ModifyDBCluster",
"rds:ModifyDBClusterParameterGroup",
"rds:ModifyDBClusterSnapshotAttribute",
"rds:ModifyDBInstance",
"rds:ModifyDBParameterGroup",
"rds:ModifyDBSubnetGroup",
"rds:ModifyEventSubscription",
"rds:PromoteReadReplicaDBCluster",
"rds:RebootDBInstance",
"rds:RemoveRoleFromDBCluster",
"rds:RemoveSourceIdentifierFromSubscription",
"rds:RemoveTagsFromResource",
"rds:ResetDBClusterParameterGroup",
"rds:ResetDBParameterGroup",
"rds:RestoreDBClusterFromSnapshot",
"rds:RestoreDBClusterToPointInTime"
],
"Effect": "Allow",
"Resource": [
"*"
]
},
{
"Sid": "AllowOtherDepedentPermissions",
"Action": [
"cloudwatch:GetMetricStatistics",
"cloudwatch:ListMetrics",
"ec2:AllocateAddress",
"ec2:AssignIpv6Addresses",
"ec2:AssignPrivateIpAddresses",
"ec2:AssociateAddress",
"ec2:AssociateRouteTable",
"ec2:AssociateSubnetCidrBlock",
"ec2:AssociateVpcCidrBlock",
"ec2:AttachInternetGateway",
"ec2:AttachNetworkInterface",
"ec2:CreateCustomerGateway",
"ec2:CreateDefaultSubnet",
"ec2:CreateDefaultVpc",
"ec2:CreateInternetGateway",
"ec2:CreateNatGateway",
"ec2:CreateNetworkInterface",
"ec2:CreateRoute",
"ec2:CreateRouteTable",
"ec2:CreateSecurityGroup",
"ec2:CreateSubnet",
"ec2:CreateVpc",
"ec2:CreateVpcEndpoint",
"ec2:CreateVpcEndpoint",
"ec2:DescribeAccountAttributes",
"ec2:DescribeAccountAttributes",
"ec2:DescribeAddresses",
"ec2:DescribeAvailabilityZones",
"ec2:DescribeAvailabilityZones",
"ec2:DescribeCustomerGateways",
"ec2:DescribeInstances",
"ec2:DescribeNatGateways",
"ec2:DescribeNetworkInterfaces",
"ec2:DescribePrefixLists",
"ec2:DescribeRouteTables",
"ec2:DescribeSecurityGroupReferences",
"ec2:DescribeSecurityGroups",
"ec2:DescribeSecurityGroups",
"ec2:DescribeSubnets",
"ec2:DescribeSubnets",
"ec2:DescribeVpcAttribute",
"ec2:DescribeVpcAttribute",
"ec2:DescribeVpcEndpoints",
"ec2:DescribeVpcs",
"ec2:DescribeVpcs",
"ec2:ModifyNetworkInterfaceAttribute",
"ec2:ModifySubnetAttribute",
"ec2:ModifyVpcAttribute",
"ec2:ModifyVpcEndpoint",
"iam:ListRoles",
"kms:ListAliases",
"kms:ListKeyPolicies",
"kms:ListKeys",
"kms:ListRetirableGrants",
"logs:DescribeLogStreams",
"logs:GetLogEvents",
"sns:ListSubscriptions",
"sns:ListTopics",
"sns:Publish"
],
"Effect": "Allow",
"Resource": [
"*"
]
},
{
"Sid": "AllowPassRoleForNeptune",
"Action": "iam:PassRole",
"Effect": "Allow",
"Resource": "*",
"Condition": {
"StringEquals": {
"iam:passedToService": "rds.amazonaws.com"
}
}
},
{
"Sid": "AllowCreateSLRForNeptune",
"Action": "iam:CreateServiceLinkedRole",
"Effect": "Allow",
"Resource": "arn:aws:iam::*:role/aws-service-role/rds.amazonaws.com/AWSServiceRoleForRDS",
"Condition": {
"StringLike": {
"iam:AWSServiceName": "rds.amazonaws.com"
}
}
},
{
"Sid": "AllowManagementPermissionsForNeptuneAnalytics",
"Effect": "Allow",
"Action": [
"neptune-graph:CreateGraph",
"neptune-graph:DeleteGraph",
"neptune-graph:GetGraph",
"neptune-graph:ListGraphs",
"neptune-graph:UpdateGraph",
"neptune-graph:ResetGraph",
"neptune-graph:CreateGraphSnapshot",
"neptune-graph:DeleteGraphSnapshot",
"neptune-graph:GetGraphSnapshot",
"neptune-graph:ListGraphSnapshots",
"neptune-graph:RestoreGraphFromSnapshot",
"neptune-graph:CreatePrivateGraphEndpoint",
"neptune-graph:GetPrivateGraphEndpoint",
"neptune-graph:ListPrivateGraphEndpoints",
"neptune-graph:DeletePrivateGraphEndpoint",
"neptune-graph:CreateGraphUsingImportTask",
"neptune-graph:GetImportTask",
"neptune-graph:ListImportTasks",
"neptune-graph:CancelImportTask"
],
"Resource": [
"arn:aws:neptune-graph:*:*:*"
]
},
{
"Sid": "AllowPassRoleForNeptuneAnalytics",
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": "*",
"Condition": {
"StringEquals": {
"iam:passedToService": "neptune-graph.amazonaws.com"
}
}
},
{
"Sid": "AllowCreateSLRForNeptuneAnalytics",
"Effect": "Allow",
"Action": "iam:CreateServiceLinkedRole",
"Resource": "arn:aws:iam::*:role/aws-service-role/neptune-graph.amazonaws.com/AWSServiceRoleForNeptuneGraph",
"Condition": {
"StringLike": {
"iam:AWSServiceName": "neptune-graph.amazonaws.com"
}
}
}
]
}
```
------
# Gewährung mithilfe einer verwalteten Richtlinie `NeptuneGraphReadOnlyAccess` AWS
Die unten stehende [NeptuneGraphReadOnlyAccess](https://console.aws.amazon.com/iam/home#policies/NeptuneGraphReadOnlyAccess)verwaltete Richtlinie bietet Lesezugriff auf alle Amazon Neptune Analytics-Ressourcen sowie Nur-Lese-Berechtigungen für abhängige Dienste.
Diese Richtlinie umfasst die folgenden Berechtigungen:
+ **Für Amazon EC2** — Rufen Sie Informationen über Subnetze VPCs, Sicherheitsgruppen und Availability Zones ab.
+ **Für AWS KMS** — Rufen Sie Informationen über KMS-Schlüssel und -Aliase ab.
+ **Für CloudWatch** — Ruft Informationen über CloudWatch Metriken ab.
+ **Für CloudWatch Logs** — Ruft Informationen über CloudWatch Log-Streams und Ereignisse ab.
**Anmerkung**
Diese Richtlinie wurde am 29.11.2023 veröffentlicht.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowReadOnlyPermissionsForNeptuneGraph",
"Effect": "Allow",
"Action": [
"neptune-graph:Get*",
"neptune-graph:List*",
"neptune-graph:Read*"
],
"Resource": "*"
},
{
"Sid": "AllowReadOnlyPermissionsForEC2",
"Effect": "Allow",
"Action": [
"ec2:DescribeVpcEndpoints",
"ec2:DescribeVpcAttribute",
"ec2:DescribeSecurityGroups",
"ec2:DescribeSubnets",
"ec2:DescribeVpcs",
"ec2:DescribeAvailabilityZones"
],
"Resource": "*"
},
{
"Sid": "AllowReadOnlyPermissionsForKMS",
"Effect": "Allow",
"Action": [
"kms:ListKeys",
"kms:ListAliases"
],
"Resource": "*"
},
{
"Sid": "AllowReadOnlyPermissionsForCloudwatch",
"Effect": "Allow",
"Action": [
"cloudwatch:GetMetricData",
"cloudwatch:ListMetrics",
"cloudwatch:GetMetricStatistics"
],
"Resource": "*"
},
{
"Sid": "AllowReadOnlyPermissionsForLogs",
"Effect": "Allow",
"Action": [
"logs:DescribeLogStreams",
"logs:GetLogEvents"
],
"Resource": [
"arn:aws:logs:*:*:log-group:/aws/neptune/*:log-stream:*"
]
}
]
}
```
------
# Zugriff auf den Neptun-Graphen gewähren mit `AWSServiceRoleForNeptuneGraphPolicy`
Die unten stehende [AWSServiceRoleForNeptuneGraphPolicy](https://console.aws.amazon.com/iam/home#policies/AWSServiceRoleForNeptuneGraphPolicy)verwaltete Richtlinie ermöglicht den Zugriff auf Diagramme zur Veröffentlichung von Betriebs- und CloudWatch Nutzungsmetriken und Protokollen. Siehe [nan-service-linked-roles](https://docs.aws.amazon.com/neptune-analytics/latest/userguide/nan-service-linked-roles.html).
**Anmerkung**
Diese Richtlinie wurde am 29.11.2023 veröffentlicht.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "GraphMetrics",
"Effect": "Allow",
"Action": [
"cloudwatch:PutMetricData"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"cloudwatch:namespace": [
"AWS/Neptune",
"AWS/Usage"
]
}
}
},
{
"Sid": "GraphLogGroup",
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup"
],
"Resource": [
"arn:aws:logs:*:*:log-group:/aws/neptune/*"
],
"Condition": {
"StringEquals": {
"aws:ResourceAccount": "${aws:PrincipalAccount}"
}
}
},
{
"Sid": "GraphLogEvents",
"Effect": "Allow",
"Action": [
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:DescribeLogStreams"
],
"Resource": [
"arn:aws:logs:*:*:log-group:/aws/neptune/*:log-stream:*"
],
"Condition": {
"StringEquals": {
"aws:ResourceAccount": "${aws:PrincipalAccount}"
}
}
}
]
}
```
------
# Anpassen des Zugriffs auf Amazon Neptune Neptune-Ressourcen mithilfe von IAM-Bedingungskontextschlüsseln
Sie können in den IAM-Richtlinien, die den Zugriff auf Neptune-Verwaltungsaktionen und -Ressourcen steuern, Bedingungen angeben. Die Richtlinienanweisung ist nur wirksam, wenn die Bedingungen erfüllt werden.
Vielleicht möchten Sie, dass eine Richtlinienanweisung erst nach einem bestimmten Datum wirksam wird oder dass der Zugriff nur zulässig ist, wenn ein bestimmter Wert in der API-Anforderung enthalten ist.
Zum Ausdruck von Bedingungen verwenden Sie im [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html)-Element einer Richtlinienanweisung vordefinierte Bedingungsschlüssel zusammen mit [IAM-Bedingungs-Richtlinienoperatoren](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) wie „gleich“ oder „kleiner als“.
Wenn Sie mehrere `Condition`-Elemente in einer Anweisung oder mehrere Schlüssel in einem einzelnen `Condition`-Element angeben, wertet AWS diese mittels einer logischen `AND`-Operation aus. Wenn Sie mehrere Werte für einen einzelnen Bedingungsschlüssel angeben, AWS wertet die Bedingung mithilfe einer logischen Operation aus. `OR` Alle Bedingungen müssen erfüllt sein, bevor die Berechtigungen für die Anweisung erteilt werden.
Sie können auch Platzhaltervariablen verwenden, wenn Sie Bedingungen angeben. Beispielsweise können Sie einem IAM-Benutzer die Berechtigung für den Zugriff auf eine Ressource nur dann gewähren, wenn sie mit dessen IAM-Benutzernamen gekennzeichnet ist. Weitere Informationen finden Sie unter [IAM-Richtlinienelemente: Variablen und Tags](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_variables.html) im *IAM-Benutzerhandbuch*.
Der Datentyp eines Bedingungsschlüssels legt fest, welche Bedingungsoperatoren Sie für den Vergleich der Werte in der Anforderung mit den Werten in der Richtlinienanweisung verwenden können. Wenn Sie einen Bedingungsoperator verwenden, der nicht mit diesem Datentyp kompatibel ist, wird niemals eine Übereinstimmung ermittelt und die Richtlinienanweisung wird nie angewendet.
**IAM-Bedingungsschlüssel für administrative Neptune-Richtlinienanweisungen**
+ [Globale Bedingungsschlüssel](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) — Sie können die meisten AWS globalen Bedingungsschlüssel in den administrativen Richtlinienerklärungen von Neptune verwenden.
+ [Dienstspezifische Bedingungsschlüssel](iam-admin-condition-keys.md) — Dies sind Schlüssel, die für bestimmte Dienste definiert sind. AWS Die Bedingungsschlüssel, die Neptune für administrative Richtlinienanweisungen unterstützt, werden in [IAM-Bedingungsschlüssel für die Verwaltung von Amazon Neptune](iam-admin-condition-keys.md) aufgelistet.
**IAM-Bedingungsschlüssel für Neptune-Datenzugriff-Richtlinienanweisungen**
+ [Globale Bedingungsschlüssel](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) – Die Teilmenge dieser Schlüssel, die Neptune in Datenzugriff-Richtlinienanweisungen unterstützt, werden in [AWS Globale Bedingungskontextschlüssel, die von Neptune in Datenzugriffspolitikanweisungen unterstützt werden](iam-data-condition-keys.md#iam-data-global-condition-keys) aufgelistet.
+ Servicespezifische Bedingungsschlüssel, die Neptune für Datenzugriff-Richtlinienanweisungen definiert, werden in [Bedingungsschlüssel](iam-data-condition-keys.md) aufgelistet.
# Erstellen von benutzerdefinierten IAM-Richtlinienerklärungen zur Verwaltung von Amazon Neptune
Mit administrativen Richtlinienanweisungen können Sie steuern, welche Aktionen ein IAM-Benutzer ausführen kann, um eine Neptune-Datenbank zu verwalten.
Eine administrative Neptune-Richtlinienanweisung gewährt Zugriff auf eine oder mehrere [administrative Aktionen](neptune-iam-admin-actions.md) und [administrative Ressourcen](iam-admin-resources.md), die von Neptune unterstützt werden. Sie können [Bedingungsschlüssel](iam-admin-condition-keys.md) auch verwenden, um die administrativen Berechtigungen spezifischer zu gestalten.
**Anmerkung**
Da Neptune Funktionalität mit Amazon RDS teilt, verwenden administrative Aktionen, Ressourcen und servicespezifische Bedingungsschlüssel in administrativen Richtlinienanweisungen standardmäßig das Präfix `rds:`.
**Topics**
+ [IAM-Aktionen zur Verwaltung von Amazon Neptune](neptune-iam-admin-actions.md)
+ [IAM-Ressourcentypen für die Verwaltung von Amazon Neptune](iam-admin-resources.md)
+ [IAM-Bedingungsschlüssel für die Verwaltung von Amazon Neptune](iam-admin-condition-keys.md)
+ [Erstellung von IAM-Verwaltungsrichtlinienerklärungen für Amazon Neptune](iam-admin-policy-examples.md)
# IAM-Aktionen zur Verwaltung von Amazon Neptune
Sie können die unten im `Action` Element einer IAM-Richtlinienerklärung aufgeführten administrativen Aktionen verwenden, um den Zugriff auf das [Neptune-Management](api.md) zu kontrollieren. APIs Wenn Sie eine Aktion in einer Richtlinie verwenden, erlauben oder verweigern Sie in der Regel den Zugriff auf die API-Operation oder den CLI-Befehl mit demselben Namen. Dabei kann es mitunter vorkommen, dass eine einzige Aktion den Zugriff auf mehr als eine Operation steuert. Alternativ erfordern einige Vorgänge mehrere verschiedene Aktionen.
Das Feld `Resource type` in der folgenden Liste gibt an, ob die einzelnen Aktionen jeweils Berechtigungen auf Ressourcenebene unterstützen. Wenn es keinen Wert in diesem Feld gibt, müssen Sie alle Ressourcen ("\$1") im `Resource`-Element Ihrer Richtlinienanweisung angeben. Wenn die Spalte einen Ressourcentyp enthält, können Sie einen Ressourcen-ARN dieses Typs in einer Anweisung mit dieser Aktion angeben. Die administrativen Neptune-Ressourcentypen sind auf [dieser Seite](iam-admin-resources.md) aufgelistet.
Erforderliche Ressourcen werden in der folgenden Liste mit einem Sternchen (\$1) gekennzeichnet. Wenn Sie einen Berechtigungs-ARN auf Ressourcenebene in einer Anweisung mit dieser Aktion angeben, muss er diesen Typ haben. Einige Aktionen unterstützen mehrere Ressourcentypen. Wenn ein Ressourcentyp optional ist (d. h. nicht mit einem Sternchen gekennzeichnet ist), müssen Sie ihn nicht angeben.
Weitere Informationen zu den hier aufgelisteten Feldern finden Sie unter [Aktionstabelle](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_actions-resources-contextkeys.html#actions_table) im [IAM-Benutzerhandbuch](https://docs.aws.amazon.com/IAM/latest/UserGuide/).
## rds: AddRoleTo DBCluster
`AddRoleToDBCluster` verknüpft eine IAM-Rolle mit einem Neptune-DB-Cluster.
*Zugriffsebene:* `Write`.
*Abhängige Aktionen:* `iam:PassRole`.
*Ressourcentyp:* [cluster](iam-admin-resources.md#neptune-cluster-resource) (erforderlich).
## rds: AddSourceIdentifierToSubscription
`AddSourceIdentifierToSubscription` fügt eine Quell-ID zu einem vorhandenen Neptune-Ereignisbenachrichtigungs-Abonnement hinzu.
*Zugriffsebene:* `Write`.
*Ressourcentyp:* [es](iam-admin-resources.md#neptune-es-resource) (erforderlich).
## rds: AddTagsToResource
`AddTagsToResource` verknüpft eine IAM-Rolle mit einem Neptune-DB-Cluster.
*Zugriffsebene:* `Write`.
*Ressourcentypen:*
+ [db](iam-admin-resources.md#neptune-db-resource)
+ [es](iam-admin-resources.md#neptune-es-resource)
+ [pg](iam-admin-resources.md#neptune-pg-resource)
+ [cluster-snapshot](iam-admin-resources.md#neptune-cluster-snapshot-resource)
+ [subgrp](iam-admin-resources.md#neptune-subgrp-resource)
*Bedingungsschlüssel:*
+ [als:RequestTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_RequestTag)
+ [war: TagKeys](iam-admin-condition-keys.md#admin-aws_TagKeys)
## rds: ApplyPendingMaintenanceAction
`ApplyPendingMaintenanceAction` wendet eine ausstehende Wartungsaktion auf eine Ressource an.
*Zugriffsebene:* `Write`.
*Ressourcentyp:* [db](iam-admin-resources.md#neptune-db-resource) (erforderlich).
## rds: kopieren DBCluster ParameterGroup
`Kopieren DBCluster ParameterGroup` kopiert die angegebene DB-Cluster-Parametergruppe.
*Zugriffsebene:* `Write`.
*Ressourcentyp:* [cluster-pg](iam-admin-resources.md#neptune-cluster-pg-resource) (erforderlich).
## RDS:Snapshot kopieren DBCluster
`DBClusterSnapshot kopieren` kopiert einen Snapshot eines DB-Clusters.
*Zugriffsebene:* `Write`.
*Ressourcentyp:* [cluster-snapshot](iam-admin-resources.md#neptune-cluster-snapshot-resource) (erforderlich).
## RDS:Gruppe DBParameter kopieren
`DBParameterGruppe kopieren` kopiert die angegebene DB-Parametergruppe.
*Zugriffsebene:* `Write`.
*Ressourcentyp:* [pg](iam-admin-resources.md#neptune-pg-resource) (erforderlich).
## RDS:erstellen DBCluster
`Erstellen DBCluster` erstellt einen neuen Neptune-DB-Cluster.
*Zugriffsebene:* `Tagging`.
*Abhängige Aktionen:* `iam:PassRole`.
*Ressourcentypen:*
+ [cluster](iam-admin-resources.md#neptune-cluster-resource) (erforderlich).
+ [cluster-pg](iam-admin-resources.md#neptune-cluster-pg-resource) (erforderlich).
+ [subgrp](iam-admin-resources.md#neptune-subgrp-resource) (erforderlich).
*Bedingungsschlüssel:*
+ [als:/RequestTag*tag-key*](iam-admin-condition-keys.md#admin-aws_RequestTag)
+ [war: TagKeys](iam-admin-condition-keys.md#admin-aws_TagKeys)
+ [neptun-Rds\$1 DatabaseEngine](iam-admin-condition-keys.md#admin-rds_DatabaseEngine)
## rds: erstellen DBCluster ParameterGroup
`Erstellen DBCluster ParameterGroup` erstellt eine neue DB-Cluster-Parametergruppe.
*Zugriffsebene:* `Tagging`.
*Ressourcentyp:* [cluster-pg](iam-admin-resources.md#neptune-cluster-pg-resource) (erforderlich).
*Bedingungsschlüssel:*
+ [als:/RequestTag*tag-key*](iam-admin-condition-keys.md#admin-aws_RequestTag)
+ [war: TagKeys](iam-admin-condition-keys.md#admin-aws_TagKeys)
## RDSDBCluster: Snapshot erstellen
`DBClusterSnapshot erstellen` erstellt einen Snapshot eines DB-Clusters.
*Zugriffsebene:* `Tagging`.
*Ressourcentypen:*
+ [cluster](iam-admin-resources.md#neptune-cluster-resource) (erforderlich).
+ [cluster-snapshot](iam-admin-resources.md#neptune-cluster-snapshot-resource) (erforderlich).
*Bedingungsschlüssel:*
+ [aws:/RequestTag*tag-key*](iam-admin-condition-keys.md#admin-aws_RequestTag)
+ [war: TagKeys](iam-admin-condition-keys.md#admin-aws_TagKeys)
## RDS: erstellen DBInstance
`Erstellen DBInstance` erstellt eine neue DB-Instance.
*Zugriffsebene:* `Tagging`.
*Abhängige Aktionen:* `iam:PassRole`.
*Ressourcentypen:*
+ [db](iam-admin-resources.md#neptune-db-resource) (erforderlich).
+ [pg](iam-admin-resources.md#neptune-pg-resource) (erforderlich).
+ [subgrp](iam-admin-resources.md#neptune-subgrp-resource) (erforderlich).
*Bedingungsschlüssel:*
+ [als:/RequestTag*tag-key*](iam-admin-condition-keys.md#admin-aws_RequestTag)
+ [war: TagKeys](iam-admin-condition-keys.md#admin-aws_TagKeys)
## RDSDBParameter: Gruppe erstellen
`DBParameterGruppe erstellen` erstellt eine neue DB-Parametergruppe.
*Zugriffsebene:* `Tagging`.
*Ressourcentyp:* [pg](iam-admin-resources.md#neptune-pg-resource) (erforderlich).
*Bedingungsschlüssel:*
+ [als:/RequestTag*tag-key*](iam-admin-condition-keys.md#admin-aws_RequestTag)
+ [war: TagKeys](iam-admin-condition-keys.md#admin-aws_TagKeys)
## RDSDBSubnet: Gruppe erstellen
`DBSubnetGruppe erstellen` erstellt eine neue DB-Subnetzgruppe.
*Zugriffsebene:* `Tagging`.
*Ressourcentyp:* [subgrp](iam-admin-resources.md#neptune-subgrp-resource) (erforderlich).
*Bedingungsschlüssel:*
+ [als:/RequestTag*tag-key*](iam-admin-condition-keys.md#admin-aws_RequestTag)
+ [war: TagKeys](iam-admin-condition-keys.md#admin-aws_TagKeys)
## rds: CreateEventSubscription
`CreateEventSubscription` erstellt ein Neptune-Ereignisbenachrichtigungs-Abonnement.
*Zugriffsebene:* `Tagging`.
*Ressourcentyp:* [es](iam-admin-resources.md#neptune-es-resource) (erforderlich).
*Bedingungsschlüssel:*
+ [als:RequestTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_RequestTag)
+ [war: TagKeys](iam-admin-condition-keys.md#admin-aws_TagKeys)
## RDS: löschen DBCluster
`Löschen DBCluster` löscht einen vorhandenen Neptune-DB-Cluster.
*Zugriffsebene:* `Write`.
*Ressourcentypen:*
+ [cluster](iam-admin-resources.md#neptune-cluster-resource) (erforderlich).
+ [cluster-snapshot](iam-admin-resources.md#neptune-cluster-snapshot-resource) (erforderlich).
## RDS:löschen DBCluster ParameterGroup
`Löschen DBCluster ParameterGroup` löscht eine angegebene DB-Cluster-Parametergruppe.
*Zugriffsebene:* `Write`.
*Ressourcentyp:* [cluster-pg](iam-admin-resources.md#neptune-cluster-pg-resource) (erforderlich).
## RDS:Snapshot löschen DBCluster
`DBClusterSchnappschuss löschen` löscht einen DB-Cluster-Snapshot.
*Zugriffsebene:* `Write`.
*Ressourcentyp:* [cluster-snapshot](iam-admin-resources.md#neptune-cluster-snapshot-resource) (erforderlich).
## RDS:löschen DBInstance
`Löschen DBInstance` löscht eine angegebene DB-Instance.
*Zugriffsebene:* `Write`.
*Ressourcentyp:* [db](iam-admin-resources.md#neptune-db-resource) (erforderlich).
## RDS:Gruppe löschen DBParameter
`DBParameterGruppe löschen`löscht eine angegebene Gruppe. DBParameter
*Zugriffsebene:* `Write`.
*Ressourcentyp:* [pg](iam-admin-resources.md#neptune-pg-resource) (erforderlich).
## rdsDBSubnet: Gruppe löschen
`DBSubnetGruppe löschen` löscht eine DB-Subnetzgruppe.
*Zugriffsebene:* `Write`.
*Ressourcentyp:* [subgrp](iam-admin-resources.md#neptune-subgrp-resource) (erforderlich).
## rds: DeleteEventSubscription
`DeleteEventSubscription` löscht ein Ereignisbenachrichtigungs-Abonnement.
*Zugriffsebene:* `Write`.
*Ressourcentyp:* [es](iam-admin-resources.md#neptune-es-resource) (erforderlich).
## rds: Beschreiben DBCluster ParameterGroups
`Beschreiben DBCluster ParameterGroups`gibt eine Liste von Beschreibungen zurück. DBCluster ParameterGroup
*Zugriffsebene:* `List`.
*Ressourcentyp:* [cluster-pg](iam-admin-resources.md#neptune-cluster-pg-resource) (erforderlich).
## RDS:Parameter beschreiben DBCluster
`Beschreiben Sie die DBCluster Parameter` gibt die detaillierte Parameterliste für eine bestimmte DB-Cluster-Parametergruppe zurück.
*Zugriffsebene:* `List`.
*Ressourcentyp:* [cluster-pg](iam-admin-resources.md#neptune-cluster-pg-resource) (erforderlich).
## RDS:Beschreiben DBCluster SnapshotAttributes
`Beschreiben DBCluster SnapshotAttributes` gibt eine Liste der Namen und Werte von DB-Cluster-Snapshot-Attributen für einen manuellen DB-Cluster-Snapshot zurück.
*Zugriffsebene:* `List`.
*Ressourcentyp:* [cluster-snapshot](iam-admin-resources.md#neptune-cluster-snapshot-resource) (erforderlich).
## RDS:Schnappschüsse beschreiben DBCluster
`Beschreiben Sie Schnappschüsse DBCluster` gibt Informationen zu DB-Cluster-Snapshots zurück.
*Zugriffsebene:* `Read`.
## RDS: Beschreiben DBClusters
`Beschreiben DBClusters` gibt Informationen zu einem bereitgestellten Neptune-DB-Cluster zurück.
*Zugriffsebene:* `List`.
*Ressourcentyp:* [cluster](iam-admin-resources.md#neptune-cluster-resource) (erforderlich).
## RDS:Versionen beschreiben DBEngine
`DBEngineVersionen beschreiben` gibt eine Liste der verfügbaren DB-Engines zurück.
*Zugriffsebene:* `List`.
*Ressourcentyp:* [pg](iam-admin-resources.md#neptune-pg-resource) (erforderlich).
## RDS:Beschreiben DBInstances
`Beschreiben DBInstances` gibt Informationen zu DB-Instances zurück.
*Zugriffsebene:* `List`.
*Ressourcentyp:* [es](iam-admin-resources.md#neptune-es-resource) (erforderlich).
## RDS:Gruppen beschreiben DBParameter
`Beschreiben Sie DBParameter Gruppen`gibt eine Liste von DBParameter Gruppenbeschreibungen zurück.
*Zugriffsebene:* `List`.
*Ressourcentyp:* [pg](iam-admin-resources.md#neptune-pg-resource) (erforderlich).
## RDS: Beschreiben DBParameters
`Beschreiben DBParameters` gibt die detaillierte Parameterliste für eine bestimmte DB-Parametergruppe zurück.
*Zugriffsebene:* `List`.
*Ressourcentyp:* [pg](iam-admin-resources.md#neptune-pg-resource) (erforderlich).
## RDS:Gruppen beschreiben DBSubnet
`Beschreiben Sie DBSubnet Gruppen`gibt eine Liste von DBSubnet Gruppenbeschreibungen zurück.
*Zugriffsebene:* `List`.
*Ressourcentyp:* [subgrp](iam-admin-resources.md#neptune-subgrp-resource) (erforderlich).
## rds: DescribeEventCategories
`DescribeEventCategories` gibt eine Liste der Kategorien für alle Ereignisquelltypen oder (wenn angegeben) für einen angegebenen Quelltyp zurück.
*Zugriffsebene:* `List`.
## rds: DescribeEventSubscriptions
`DescribeEventSubscriptions` listet alle Abonnementbeschreibungen für ein Kundenkonto auf.
*Zugriffsebene:* `List`.
*Ressourcentyp:* [es](iam-admin-resources.md#neptune-es-resource) (erforderlich).
## rds: DescribeEvents
`DescribeEvents` gibt Ereignisse für DB-Instances, DB-Sicherheitsgruppen und DB-Parametergruppen in den vergangenen 14 Tagen zurück.
*Zugriffsebene:* `List`.
*Ressourcentyp:* [es](iam-admin-resources.md#neptune-es-resource) (erforderlich).
## rds: DescribeOrderable DBInstance Optionen
`DescribeOrderableDBInstanceOptionen` gibt eine Liste der bestellbaren DB-Instance-Optionen für die angegebene Engine zurück.
*Zugriffsebene:* `List`.
## rds: DescribePendingMaintenanceActions
`DescribePendingMaintenanceActions` gibt eine Liste von Ressourcen (z. B. DB-Instances) zurück, für die mindestens eine Wartungsaktion aussteht.
*Zugriffsebene:* `List`.
*Ressourcentyp:* [db](iam-admin-resources.md#neptune-db-resource) (erforderlich).
## rds: DescribeValid DBInstance Änderungen
`DescribeValidDBInstanceÄnderungen` listet verfügbare Änderungen auf, die Sie für Ihre DB-Instance ausführen können
*Zugriffsebene:* `List`.
*Ressourcentyp:* [db](iam-admin-resources.md#neptune-db-resource) (erforderlich).
## rds: Failover DBCluster
`Failover DBCluster` erzwingt einen Failover für einen DB-Cluster.
*Zugriffsebene:* `Write`.
*Ressourcentyp:* [cluster](iam-admin-resources.md#neptune-cluster-resource) (erforderlich).
## rds: ListTagsForResource
`ListTagsForResource` listet alle Tags für eine Neptune-Ressource auf.
*Zugriffsebene:* `Read`.
*Ressourcentypen:*
+ [cluster-snapshot](iam-admin-resources.md#neptune-cluster-snapshot-resource)
+ [db](iam-admin-resources.md#neptune-db-resource)
+ [es](iam-admin-resources.md#neptune-es-resource)
+ [pg](iam-admin-resources.md#neptune-pg-resource)
+ [subgrp](iam-admin-resources.md#neptune-subgrp-resource)
## rds: ändern DBCluster
`Modifizieren DBCluster`
Ändert eine Einstellung für einen Neptune-DB-Cluster.
*Zugriffsebene:* `Write`.
*Abhängige Aktionen:* `iam:PassRole`.
*Ressourcentypen:*
+ [cluster](iam-admin-resources.md#neptune-cluster-resource) (erforderlich).
+ [cluster-pg](iam-admin-resources.md#neptune-cluster-pg-resource) (erforderlich).
## RDS:ändern DBCluster ParameterGroup
`Modifizieren DBCluster ParameterGroup` ändert die Parameter einer DB-Cluster-Parametergruppe.
*Zugriffsebene:* `Write`.
*Ressourcentyp:* [cluster-pg](iam-admin-resources.md#neptune-cluster-pg-resource) (erforderlich).
## RDS:ändern DBCluster SnapshotAttribute
`Modifizieren DBCluster SnapshotAttribute` fügt ein Attribut und Werte zu einem manuellen DB-Cluster-Snapshot hinzu oder entfernt ein Attribut und Werte aus diesem.
*Zugriffsebene:* `Write`.
*Ressourcentyp:* [cluster-snapshot](iam-admin-resources.md#neptune-cluster-snapshot-resource) (erforderlich).
## RDS:ändern DBInstance
`Modifizieren DBInstance` ändert Einstellungen für eine DB-Instance.
*Zugriffsebene:* `Write`.
*Abhängige Aktionen:* `iam:PassRole`.
*Ressourcentypen:*
+ [db](iam-admin-resources.md#neptune-db-resource) (erforderlich).
+ [pg](iam-admin-resources.md#neptune-pg-resource) (erforderlich).
## RDS:Gruppe ändern DBParameter
`DBParameterGruppe ändern` ändert die Parameter einer DB-Parametergruppe.
*Zugriffsebene:* `Write`.
*Ressourcentyp:* [pg](iam-admin-resources.md#neptune-pg-resource) (erforderlich).
## DBSubnetRDS:Gruppe ändern
`DBSubnetGruppe ändern` ändert eine vorhandene DB-Subnetzgruppe.
*Zugriffsebene:* `Write`.
*Ressourcentyp:* [subgrp](iam-admin-resources.md#neptune-subgrp-resource) (erforderlich).
## rds: ModifyEventSubscription
`ModifyEventSubscription` ändert ein vorhandenes Neptune-Ereignisbenachrichtigungs-Abonnement.
*Zugriffsebene:* `Write`.
*Ressourcentyp:* [es](iam-admin-resources.md#neptune-es-resource) (erforderlich).
## RDS: Neustart DBInstance
`Starten Sie neu DBInstance` startet den Datenbank-Engine-Service für die Instance neu.
*Zugriffsebene:* `Write`.
*Ressourcentyp:* [db](iam-admin-resources.md#neptune-db-resource) (erforderlich).
## rds: RemoveRoleFrom DBCluster
`RemoveRoleFromDBCluster`trennt eine AWS Identity and Access Management (IAM) -Rolle von einem Amazon Neptune Neptune-DB-Cluster.
*Zugriffsebene:* `Write`.
*Abhängige Aktionen:* `iam:PassRole`.
*Ressourcentyp:* [cluster](iam-admin-resources.md#neptune-cluster-resource) (erforderlich).
## rds: RemoveSourceIdentifierFromSubscription
`RemoveSourceIdentifierFromSubscription` entfernt eine Quell-ID aus einem vorhandenen Neptune-Ereignisbenachrichtigungs-Abonnement.
*Zugriffsebene:* `Write`.
*Ressourcentyp:* [es](iam-admin-resources.md#neptune-es-resource) (erforderlich).
## rds: RemoveTagsFromResource
`RemoveTagsFromResource` entfernt Metadaten-Tags aus einer Neptune-Ressource.
*Zugriffsebene:* `Tagging`.
*Ressourcentypen:*
+ [cluster-snapshot](iam-admin-resources.md#neptune-cluster-snapshot-resource)
+ [db](iam-admin-resources.md#neptune-db-resource)
+ [es](iam-admin-resources.md#neptune-es-resource)
+ [pg](iam-admin-resources.md#neptune-pg-resource)
+ [subgrp](iam-admin-resources.md#neptune-subgrp-resource)
*Bedingungsschlüssel:*
+ [als:RequestTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_RequestTag)
+ [war: TagKeys](iam-admin-condition-keys.md#admin-aws_TagKeys)
## RDS: Zurücksetzen DBCluster ParameterGroup
`Zurücksetzen DBCluster ParameterGroup` ändert die Parameter einer DB-Cluster-Parametergruppe auf den Standardwert zurück.
*Zugriffsebene:* `Write`.
*Ressourcentyp:* [cluster-pg](iam-admin-resources.md#neptune-cluster-pg-resource) (erforderlich).
## RDS:Gruppe zurücksetzen DBParameter
`DBParameterGruppe zurücksetzen`ändert die Parameter einer DB-Parametergruppe auf den Standardwert. engine/system
*Zugriffsebene:* `Write`.
*Ressourcentyp:* [pg](iam-admin-resources.md#neptune-pg-resource) (erforderlich).
## RDS: Wiederherstellen DBCluster FromSnapshot
`Wiederherstellen DBCluster FromSnapshot` erstellt einen neuen DB-Cluster aus einem DB-Cluster-Snapshot
*Zugriffsebene:* `Write`.
*Abhängige Aktionen:* `iam:PassRole`.
*Ressourcentypen:*
+ [cluster](iam-admin-resources.md#neptune-cluster-resource) (erforderlich).
+ [cluster-snapshot](iam-admin-resources.md#neptune-cluster-snapshot-resource) (erforderlich).
*Bedingungsschlüssel:*
+ [als:/RequestTag*tag-key*](iam-admin-condition-keys.md#admin-aws_RequestTag)
+ [war: TagKeys](iam-admin-condition-keys.md#admin-aws_TagKeys)
## RDS: Wiederherstellen DBCluster ToPointInTime
`Wiederherstellen DBCluster ToPointInTime` stellt einen DB-Cluster zu einem beliebigen Zeitpunkt her.
*Zugriffsebene:* `Write`.
*Abhängige Aktionen:* `iam:PassRole`.
*Ressourcentypen:*
+ [cluster](iam-admin-resources.md#neptune-cluster-resource) (erforderlich).
+ [subgrp](iam-admin-resources.md#neptune-subgrp-resource) (erforderlich).
*Bedingungsschlüssel:*
+ [als:/RequestTag*tag-key*](iam-admin-condition-keys.md#admin-aws_RequestTag)
+ [war: TagKeys](iam-admin-condition-keys.md#admin-aws_TagKeys)
## RDS: Start DBCluster
`Starten DBCluster` startet den angegebenen DB-Cluster.
*Zugriffsebene:* `Write`.
*Ressourcentyp:* [cluster](iam-admin-resources.md#neptune-cluster-resource) (erforderlich).
## RDS: Stopp DBCluster
`Stopp DBCluster` stoppt den angegebenen DB-Cluster.
*Zugriffsebene:* `Write`.
*Ressourcentyp:* [cluster](iam-admin-resources.md#neptune-cluster-resource) (erforderlich).
# IAM-Ressourcentypen für die Verwaltung von Amazon Neptune
Neptune unterstützt die Ressourcentypen in der folgenden Tabelle für die Verwendung im `Resource`-Element der administrativen IAM-Richtlinienanweisungen. Weitere Informationen zum `Resource`-Element finden Sie unter [IAM-JSON-Richtlinienelemente: Ressource](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_resource.html).
Die [Liste der Neptune-Verwaltungsaktionen](neptune-iam-admin-actions.md) identifiziert die Ressourcentypen, die für die einzelnen Aktionen angegeben werden können. Ein Ressourcentyp bestimmt auch, welche Bedingungsschlüssel Sie in einer Richtlinie einschließen können, wie in der letzten Spalte der Tabelle angegeben.
Die Spalte `ARN` in der folgenden Tabelle gibt das Format für den Amazon-Ressourcennamen (ARN) an, das Sie verwenden müssen, um Ressourcen dieses Typs zu referenzieren. Die Bestandteile mit vorangestelltem ` $ ` müssen durch die tatsächlichen Werte für das jeweilige Szenario ersetzt werden. Beispiel: Wenn Sie `$user-name` in einem ARN sehen, müssen Sie diese Zeichenfolge durch den tatsächlichen Namen eines IAM-Benutzers oder eine Richtlinienvariable ersetzen, die den Namen eines IAM-Benutzers enthält. [Weitere Informationen zu finden Sie unter IAM und. ARNs ARNs](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-arns) [Arbeiten mit administrativen Funktionen ARNs in Amazon Neptune](tagging-arns.md)
Die Spalte ` Condition Keys ` Bedingungsschlüssel gibt Bedingungskontextschlüssel an, die Sie nur dann in eine IAM-Richtlinienanweisung einfügen können, wenn sowohl diese Ressource als auch eine kompatible unterstützende Aktion in der Anweisung enthalten sind.
****
| Ressourcentypen | ARN | Bedingungsschlüssel |
| --- | --- | --- |
| `cluster` (ein DB-Cluster) | arn:partition:rds:region:account-id:cluster:instance-name | [aws:/ResourceTag*tag-key*](iam-admin-condition-keys.md#admin-aws_ResourceTag) [rds: Cluster-Tag/ *tag-key*](iam-admin-condition-keys.md#admin-rds_cluster-tag) |
| `cluster-pg` (eine DB-Cluster-Parametergruppe) | arn:partition:rds:region:account-id:cluster-pg:neptune-DBClusterParameterGroupName | [war:/ResourceTag*tag-key*](iam-admin-condition-keys.md#admin-aws_ResourceTag) |
| `cluster-snapshot` (ein DB-Cluster-Snapshot) | arn:partition:rds:region:account-id:cluster-snapshot:neptune-DBClusterSnapshotName | [aws:ResourceTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_ResourceTag) [rds:cluster-snapshot-tag/*tag-key*](iam-admin-condition-keys.md#admin-rds_cluster-snapshot-tag) |
| `db` (eine DB-Instance) | arn:partition:rds:region:account-id:db:neptune-DbInstanceName | [war:ResourceTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_ResourceTag) [rds: DatabaseClass](iam-admin-condition-keys.md#admin-rds_DatabaseClass) [rds: DatabaseEngine](iam-admin-condition-keys.md#admin-rds_DatabaseEngine) [rds: db-tag/ *tag-key*](iam-admin-condition-keys.md#admin-rds_db-tag) |
| `es` (ein Ereignisabonnement) | arn:partition:rds:region:account-id:es:neptune-CustSubscriptionId | [war:/ResourceTag*tag-key*](iam-admin-condition-keys.md#admin-aws_ResourceTag) [rds:es-tag/ *tag-key*](iam-admin-condition-keys.md#admin-rds_es-tag) |
| `pg` (eine DB-Parametergruppe) | arn:partition:rds:region:account-id:pg:neptune-ParameterGroupName | [war:/ResourceTag*tag-key*](iam-admin-condition-keys.md#admin-aws_ResourceTag) [rds: pg-tag/ *tag-key*](iam-admin-condition-keys.md#admin-rds_pg-tag) |
| `subgrp` (eine DB-Subnetzgruppe) | arn:partition:rds:region:account-id:subgrp:neptune-DBSubnetGroupName\$1 | [war:/ResourceTag*tag-key*](iam-admin-condition-keys.md#admin-aws_ResourceTag) [rds: subgrp-tag/ *tag-key*](iam-admin-condition-keys.md#admin-rds_subgrp-tag) |
# IAM-Bedingungsschlüssel für die Verwaltung von Amazon Neptune
[Mithilfe von Bedingungsschlüsseln](security-iam-access-manage.md#iam-using-condition-keys) können Sie Bedingungen in einer IAM-Richtlinienanweisung angeben, damit die Anweisung nur dann wirksam wird, wenn die Bedingungen erfüllt werden. Die Bedingungsschlüssel, die Sie in administrativen Richtlinienanweisungen in Neptune verwenden können, gehören den folgenden Kategorien an:
+ [Globale Bedingungsschlüssel](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) — Diese sind für die allgemeine Verwendung mit Diensten definiert. AWS AWS Die meisten können in den administrativen Richtlinienanweisungen in Neptune verwendet werden.
+ [Administrative Ressourceneigenschaft-Bedingungsschlüssel](#iam-rds-property-condition-keys) – Diese Schlüssel (wie [unten](#iam-rds-property-condition-keys) aufgelistet) basieren auf Eigenschaften von Verwaltungsressourcen.
+ [Tag-basierte Zugriffsbedingungsschlüssel](#iam-rds-tag-based-condition-keys) – Diese Schlüssel (wie [unten](#iam-rds-tag-based-condition-keys) aufgelistet) basieren auf [AWS Tags](https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html), die an Verwaltungsressourcen angefügt sind.
## Administrative Ressourceneigenschaft-Bedingungssschlüssel in Neptune
| Bedingungsschlüssel | Beschreibung | Typ |
| --- | --- | --- |
| rds:DatabaseClass | Filtert den Zugriff nach Typ der DB-Instance-Klasse | Zeichenfolge |
| rds:DatabaseEngine | Filtert den Zugriff nach dem Datenbank-Engine. Mögliche Werte finden Sie im Engine-Parameter in Create DBInstance API | Zeichenfolge |
| rds:DatabaseName | Filtert den Zugriff nach benutzerdefiniertem Name der Datenbank auf der DB-Instance | Zeichenfolge |
| rds:EndpointType | Filtert den Zugriff nach dem Typ des Endpunkts. Einer der folgenden Typen: READER, WRITER, CUSTOM. | Zeichenfolge |
| rds:Vpc | Filtert den Zugriff nach dem Wert, der angibt, ob die DB-Instance in einer Amazon Virtual Private Cloud (Amazon VPC) ausgeführt wird. Geben Sie true an, um anzuzeigen, dass die DB-Instance in einer Amazon-VPC ausgeführt wird. | Boolesch |
## Administrative Tag-basierte Bedingungsschlüssel
Amazon Neptune unterstützt die Angabe von Bedingungen in einer IAM-Richtlinie mit benutzerdefinierten Tags, um den Zugriff auf Neptune über die [Management-API-Referenz](api.md) zu steuern.
Wenn Sie beispielsweise Ihren DB-Instances ein Tag mit dem Namen `environment` und Werten wie `beta`, `staging` und `production` hinzufügen, können Sie anschließend eine Richtlinie erstellen, die den Zugriff auf die Instances anhand des Werts dieses Tags einschränkt.
**Wichtig**
Wenn Sie den Zugriff auf Ihre Neptune-Ressourcen mit Tags verwalten, muss der Zugriff auf die Tags geschützt werden. Sie können den Zugriff auf Tags einschränken, indem Sie Richtlinien für die Aktionen `AddTagsToResource` und `RemoveTagsFromResource` erstellen.
Beispielsweise könnten Sie die folgende Richtlinie verwenden, um das Hinzufügen oder Entfernen von Tags für alle Ressourcen abzulehnen. Anschließend könnten Sie Richtlinien erstellen, um bestimmten Benutzern das Hinzufügen oder Entfernen von Tags zu ermöglichen.
****
```
{ "Version":"2012-10-17",
"Statement":[
{ "Sid": "DenyTagUpdates",
"Effect": "Deny",
"Action": [
"rds:AddTagsToResource",
"rds:RemoveTagsFromResource"
],
"Resource":"*"
}
]
}
```
Die folgenden Tag-basierten Bedingungsschlüssel funktionieren nur mit administrativen Ressourcen in administrativen Richtlinienanweisungen.
**Administrative Tag-basierte Bedingungsschlüssel**
| Bedingungsschlüssel | Beschreibung | Typ |
| --- | --- | --- |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-requesttag](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-requesttag) | Filtert den Zugriff basierend auf dem Vorhandensein von Tag-Schlüssel-Wert-Paaren in der Anforderung. | Zeichenfolge |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-resourcetag](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-resourcetag) | Filtert den Zugriff basierend auf den Tag-Schlüssel-Wert-Paaren, die der Ressource angefügt sind. | Zeichenfolge |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keyss](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keyss) | Filtert den Zugriff basierend auf dem Vorhandensein von Tag-Schlüsseln in der Anforderung. | Zeichenfolge |
| rds:cluster-pg-tag/\$1\$1TagKey\$1 | Filtert den Zugriff nach dem Tag, das einer DB-Cluster-Parametergruppe angefügt ist. | Zeichenfolge |
| rds:cluster-snapshot-tag/\$1\$1TagKey\$1 | Filtert den Zugriff nach dem Tag, das einem DB-Cluster-Snapshot angefügt ist. | Zeichenfolge |
| rds:cluster-tag/\$1\$1TagKey\$1 | Filtert den Zugriff nach dem Tag, das einem DB-Cluster angefügt ist. | Zeichenfolge |
| rds:db-tag/\$1\$1TagKey\$1 | Filtert den Zugriff nach dem Tag, das einer DB-Instance angefügt ist. | Zeichenfolge |
| rds:es-tag/\$1\$1TagKey\$1 | Filtert den Zugriff nach dem Tag, das einem Ereignisabonnement angefügt ist. | Zeichenfolge |
| rds:pg-tag/\$1\$1TagKey\$1 | Filtert den Zugriff nach dem Tag, das einer DB-Parametergruppe angefügt ist. | Zeichenfolge |
| rds:req-tag/\$1\$1TagKey\$1 | Filtert den Zugriff nach dem Satz von Tag-Schlüsseln und -Werten, die zum Taggen einer Ressource verwendet werden können. | Zeichenfolge |
| rds:secgrp-tag/\$1\$1TagKey\$1 | Filtert den Zugriff nach dem Tag, das einer DB-Sicherheitsgruppe angefügt ist. | Zeichenfolge |
| rds:snapshot-tag/\$1\$1TagKey\$1 | Filtert den Zugriff nach dem Tag, das einem DB-Snapshot angefügt ist. | Zeichenfolge |
| rds:subgrp-tag/\$1\$1TagKey\$1 | Filtert den Zugriff nach dem Tag, das einer DB-Subnetzgruppe angefügt ist. | Zeichenfolge |
# Erstellung von IAM-Verwaltungsrichtlinienerklärungen für Amazon Neptune
## Beispiele für allgemeine administrative Richtlinien
Die folgenden Beispiele zeigen die Erstellung administrativer Neptune-Richtlinien, die Berechtigungen für verschiedene Verwaltungsaktionen in einem DB-Cluster gewähren.
### Richtlinie, die das Löschen einer angegebenen DB-Instance durch IAM-Benutzer verhindert
Dies ist ein Beispiel für eine Richtlinie, die das Löschen einer angegebenen Neptune-DB-Instance durch IAM-Benutzer verhindert:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DenyDeleteOneInstance",
"Effect": "Deny",
"Action": "rds:DeleteDBInstance",
"Resource": "arn:aws:rds:us-west-2:123456789012:db:my-instance-name"
}
]
}
```
------
### Richtlinie, die Berechtigungen zum Erstellen neuer DB-Instances gewährt
Dies ist ein Beispiel für eine Richtlinie, die IAM-Benutzern die Erstellung von DB-Instances in einem angegebenen Neptune-DB-Cluster erlaubt:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowCreateInstance",
"Effect": "Allow",
"Action": "rds:CreateDBInstance",
"Resource": "arn:aws:rds:us-west-2:123456789012:cluster:my-cluster"
}
]
}
```
------
### Richtlinie, die Berechtigungen zum Erstellen neuer DB-Instances gewährt, die eine bestimmte DB-Parametergruppe verwenden
Dies ist ein Beispiel für eine Richtlinie, die IAM-Benutzern die Erstellung von DB-Instances in einem angegebenen Neptune-DB-Cluster (hier`us-west-2`) mittels einer einzelnen angegebenen DB-Parametergruppe erlaubt.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowCreateInstanceWithPG",
"Effect": "Allow",
"Action": "rds:CreateDBInstance",
"Resource": [
"arn:aws:rds:us-west-2:123456789012:cluster:my-cluster",
"arn:aws:rds:us-west-2:123456789012:pg:my-instance-pg"
]
}
]
}
```
------
### Richtlinie, die Berechtigungen zum Beschreiben einer Ressource gewährt
Dies ist ein Beispiel für eine Richtlinie, die IAM-Benutzern die Beschreibung jeder Neptune-Ressource erlaubt.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowDescribe",
"Effect": "Allow",
"Action": "rds:Describe*",
"Resource": "*"
}
]
}
```
------
## Beispiele für Tag-basierte administrative Richtlinien
Die folgenden Beispiele zeigen die Erstellung administrativer Neptune-Richtlinien mit Tags, um die Berechtigungen für verschiedene Verwaltungsaktionen in einem DB-Cluster zu filtern.
### Beispiel 1: Gewähren von Berechtigungen für Aktionen für eine Ressource mit einem benutzerdefinierten Tag, das mehrere Werte annehmen kann
Die folgende Richtlinie erlaubt die Verwendung der `ModifyDBInstance`-, `CreateDBInstance`- oder `DeleteDBInstance`-API für jede DB-Instance, deren `env`-Tag auf `dev` oder `test` festgelegt ist:
------
#### [ JSON ]
****
```
{ "Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowDevTestAccess",
"Effect": "Allow",
"Action": [
"rds:ModifyDBInstance",
"rds:CreateDBInstance",
"rds:DeleteDBInstance"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"rds:db-tag/env": [
"dev",
"test"
],
"rds:DatabaseEngine": "neptune"
}
}
}
]
}
```
------
### Beispiel 2: Einschränken des Satzes von Tag-Schlüsseln und -Werten, mit denen ein Tag für eine Ressource erstellt werden kann
Diese Richtlinie verwendet einen `Condition`-Schlüssel, um das Hinzufügen eines Tags mit dem Schlüssel `env` und dem Wert `test`, `qa` oder `dev` zu einer Ressource zu erlauben:
------
#### [ JSON ]
****
```
{ "Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowTagAccessForDevResources",
"Effect": "Allow",
"Action": [
"rds:AddTagsToResource",
"rds:RemoveTagsFromResource"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"rds:req-tag/env": [
"test",
"qa",
"dev"
],
"rds:DatabaseEngine": "neptune"
}
}
}
]
}
```
------
### Beispiel 3: Gewährung des Vollzugriffs auf Neptune-Ressourcen basierend auf `aws:ResourceTag`
Die folgende Richtlinie ist dem ersten Beispiel oben ähnlich, verwendet jedoch stattdessen `aws:ResourceTag`:
------
#### [ JSON ]
****
```
{ "Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowFullAccessToDev",
"Effect": "Allow",
"Action": [
"rds:*"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/env": "dev",
"rds:DatabaseEngine": "neptune"
}
}
}
]
}
```
------
# Erstellen benutzerdefinierter IAM-Richtlinienerklärungen für den Zugriff auf Daten in Amazon Neptune
Neptune-Datenzugriff-Richtlinienanweisungen verwenden [Datenzugriffsaktionen](iam-dp-actions.md), [Ressourcen](iam-data-resources.md) und [Bedingungsschlüssel](iam-data-condition-keys.md#iam-neptune-condition-keys), denen jeweils das Präfix `neptune-db:` vorangestellt ist.
**Topics**
+ [Verwenden von Abfrageaktionen in Neptune-Datenzugriff-Richtlinienanweisungen](#iam-data-query-actions)
+ [IAM-Aktionen für den Datenzugriff in Amazon Neptune](iam-dp-actions.md)
+ [IAM-Ressourcentypen für den Zugriff auf Daten in Amazon Neptune](iam-data-resources.md)
+ [IAM-Bedingungsschlüssel für den Zugriff auf Daten in Amazon Neptune](iam-data-condition-keys.md)
+ [Erstellen von IAM-Datenzugriffsrichtlinien in Amazon Neptune](iam-data-access-examples.md)
## Verwenden von Abfrageaktionen in Neptune-Datenzugriff-Richtlinienanweisungen
Es gibt drei Neptune-Abfrageaktionen, die in Datenzugriff-Richtlinienanweisungen verwendet werden können, `ReadDataViaQuery`, `WriteDataViaQuery` und `DeleteDataViaQuery`. Eine bestimmte Abfrage benötigt möglicherweise Berechtigungen, um mehr als eine dieser Aktionen auszuführen, und es möglicherweise nicht immer offensichtlich, welche Kombination dieser Aktionen zulässig sein muss, um eine Abfrage auszuführen.
Neptune ermittelt vor der Ausführung einer Abfrage die Berechtigungen, die für die Ausführung der einzelnen Schritte der Abfrage erforderlich sind, und kombiniert diese zu einem vollständigen Satz der Berechtigungen, die für die Abfrage erforderlich sind. Beachten Sie, dass dieser vollständige Satz von Berechtigungen alle Aktionen enthält, die die Abfrage *möglicherweise* ausführt. Dabei handelt es sich nicht notwendigerweise um den Satz von Aktionen, den die Abfrage tatsächlich für Ihre Daten ausführt.
Das bedeutet, dass Sie Berechtigungen für alle Aktionen bereitstellen müssen, die die Abfrage möglicherweise ausführt, um die Ausführung einer bestimmten Abfrage zu ermöglichen, unabhängig davon, ob die Abfrage diese Aktionen tatsächlich ausführt oder nicht.
Dies sind einige Beispiele für Gremlin-Abfragen, die dies im Detail zeigen:
+
```
g.V().count()
```
`g.V()` und `count()` benötigen lediglich Lesezugriff, sodass die Abfrage insgesamt lediglich einen `ReadDataViaQuery`-Zugriff benötigt.
+
```
g.addV()
```
`addV()` muss überprüfen, ob ein Eckpunkt mit einer bestimmten ID vorhanden ist oder nicht, bevor ein neuer Eckpunkt eingefügt wird. Das bedeutet, dass die Abfrage einen `ReadDataViaQuery`- und einen `WriteDataViaQuery`-Zugriff benötigt.
+
```
g.V('1').as('a').out('created').addE('createdBy').to('a')
```
`g.V('1').as('a')` und `out('created')` benötigen lediglich Lesezugriff. `addE().from('a')` benötigt jedoch sowohl Lese- als auch Schreibzugriff, da `addE()` die Eckpunkte `to` und `from` lesen muss und prüfen muss, ob bereits eine Kante mit derselben ID vorhanden ist, bevor eine neue Kante hinzugefügt wird. Die Abfrage benötigt daher insgesamt einen `ReadDataViaQuery`- und einen `WriteDataViaQuery`-Zugriff.
+
```
g.V().drop()
```
`g.V()` benötigt lediglich Lesezugriff. `drop()` benötigt einen Lese- und Löschzugriff, da Eckpunkte oder Kanten vor dem Löschen gelesen werden müssen. Daher benötigt die Abfrage insgesamt einen `ReadDataViaQuery`- und einen `DeleteDataViaQuery`-Zugriff.
+
```
g.V('1').property(single, 'key1', 'value1')
```
`g.V('1')` benötigt lediglich Lesezugriff. `property(single, 'key1', 'value1')` benötigt jedoch einen Lese-, Schreib- und Löschzugriff. Hier werden im Schritt `property()` Schlüssel und Wert eingefügt, falls noch nicht im Eckpunkt vorhanden. Falls jedoch bereits vorhanden, wird der vorhandene Eigenschaftswert gelöscht und es wird ein neuer Wert eingefügt. Daher benötigt die Abfrage insgesamt einen `ReadDataViaQuery`-, `WriteDataViaQuery`- und `DeleteDataViaQuery`-Zugriff.
Jede Abfrage, die den Schritt `property()` enthält, benötigt `ReadDataViaQuery`-, `WriteDataViaQuery`- und `DeleteDataViaQuery`-Berechtigungen.
Dies sind einige openCypher-Beispiele:
+
```
MATCH (n)
RETURN n
```
Diese Abfrage liest alle Knoten in der Datenbank und gibt sie zurück. Hierfür wird lediglich ein `ReadDataViaQuery`-Zugriff benötigt.
+
```
MATCH (n:Person)
SET n.dept = 'AWS'
```
Diese Abfrage benötigt einen `ReadDataViaQuery`-, `WriteDataViaQuery`- und `DeleteDataViaQuery`-Zugriff. Sie liest alle Knoten mit der Bezeichnung 'Person' und fügt ihnen entweder eine neue Eigenschaft mit dem Schlüssel `dept` und dem Wert `AWS` hinzu oder (wenn die Eigenschaft `dept` bereits vorhanden ist) löscht den alten Wert und fügt stattdessen `AWS` ein. Wenn der festzulegende Wert `null` ist, löscht `SET` die Eigenschaft vollständig.
Da die `SET`-Klausel in einigen Fällen möglicherweise einen vorhandenen Wert löschen muss, benötigt sie **stets** `DeleteDataViaQuery`-, `ReadDataViaQuery`- und `WriteDataViaQuery`-Berechtigungen.
+
```
MATCH (n:Person)
DETACH DELETE n
```
Diese Abfrage benötigt `ReadDataViaQuery`- und `DeleteDataViaQuery`-Berechtigungen. Sie sucht alle Knoten mit der Bezeichnung `Person` und löscht sie zusammen mit den Kanten, die mit diesen Knoten verbunden sind, und allen zugehörigen Bezeichnungen und Eigenschaften.
+
```
MERGE (n:Person {name: 'John'})-[:knows]->(:Person {name: 'Peter'})
RETURN n
```
Diese Abfrage benötigt `ReadDataViaQuery`- und `WriteDataViaQuery`-Berechtigungen. Die `MERGE`-Klausel stimmt entweder mit einem angegebenen Muster überein oder erstellt es. Da ein Schreibvorgang erfolgen kann, wenn das Muster nicht übereinstimmt, sind Schreib- und Leseberechtigungen erforderlich.
# IAM-Aktionen für den Datenzugriff in Amazon Neptune
Beachten Sie, dass Neptun-Datenzugriffsaktionen das Präfix `neptune-db:` besitzen, während administrative Aktionen in Neptune das Präfix `rds:` besitzen.
Der Amazon-Ressourcenname (ARN) für eine Datenressource in IAM ist nicht mit dem ARN identisch, der dem Cluster bei der Erstellung zugeordnet wird. Sie müssen den ARN wie in [Angeben von Datenressourcen](iam-data-resources.md) beschrieben konstruieren. Eine solche Datenressource ARNs kann Platzhalter verwenden, um mehrere Ressourcen einzubeziehen.
Richtlinien für den Datenzugriff können auch den QueryLanguage Bedingungsschlüssel [neptune-db:](iam-data-condition-keys.md#iam-neptune-condition-keys) enthalten, um den Zugriff anhand der Abfragesprache einzuschränken.
Ab [Release: 1.2.0.0 (21.07.2022)](engine-releases-1.2.0.0.md) unterstützt Neptune die Einschränkung von Berechtigungen auf eine oder mehrere [bestimmte Neptune-Aktionen](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonneptune.html). Dies ermöglicht eine detailliertere Zugriffssteuerung als bisher möglich.
**Wichtig**
Die Anwendung von Änderungen einer IAM-Richtlinie auf die angegebenen Neptune-Ressourcen kann bis zu 10 Minuten dauern.
IAM-Richtlinien, die auf einen Neptune-DB-Cluster angewendet werden, werden auf alle Instances in diesem Cluster angewendet.
## *Abfragebasierte Datenzugriffsaktionen*
**Anmerkung**
Es ist nicht immer offensichtlich, welche Berechtigungen für die Ausführung einer bestimmten Abfrage benötigt werden, da Abfragen abhängig von den verarbeiteten Daten mehr als eine Aktion ausführen können. Weitere Informationen finden Sie unter [Verwenden von Abfrageaktionen](iam-data-access-policies.md#iam-data-query-actions).
## `neptune-db:ReadDataViaQuery`
`ReadDataViaQuery` ermöglicht Benutzern das Lesen von Daten aus der Neptune-Datenbank mittels Abfragen.
*Aktionsgruppen:* Schreibgeschützt, Lesen und Schreiben.
*Aktionskontextschlüssel:* `neptune-db:QueryLanguage`.
*Erforderliche Ressourcen:* Datenbank.
## `neptune-db:WriteDataViaQuery`
`WriteDataViaQuery` ermöglicht Benutzern das Schreiben von Daten zur Neptune-Datenbank mittels Abfragen.
*Aktionsgruppen:* Lesen und Schreiben.
*Aktionskontextschlüssel:* `neptune-db:QueryLanguage`.
*Erforderliche Ressourcen:* Datenbank.
## `neptune-db:DeleteDataViaQuery`
`DeleteDataViaQuery` ermöglicht Benutzern das Löschen von Daten aus der Neptune-Datenbank mittels Abfragen.
*Aktionsgruppen:* Lesen und Schreiben.
*Aktionskontextschlüssel:* `neptune-db:QueryLanguage`.
*Erforderliche Ressourcen:* Datenbank.
## `neptune-db:GetQueryStatus`
`GetQueryStatus` ermöglicht Benutzern die Prüfung des Status aller aktiven Abfragen.
*Aktionsgruppen:* Schreibgeschützt, Lesen und Schreiben.
*Aktionskontextschlüssel:* `neptune-db:QueryLanguage`.
*Erforderliche Ressourcen:* Datenbank.
## `neptune-db:GetStreamRecords`
`GetStreamRecords` ermöglicht Benutzern das Abrufen von Stream-Datensätzen aus Neptune.
*Aktionsgruppen:* Lesen und Schreiben.
*Aktionskontextschlüssel:* `neptune-db:QueryLanguage`.
*Erforderliche Ressourcen:* Datenbank.
## `neptune-db:CancelQuery`
`CancelQuery` ermöglicht Benutzern das Abbrechen von Abfragen.
*Aktionsgruppen:* Lesen und Schreiben.
*Erforderliche Ressourcen:* Datenbank.
## *Allgemeine Datenzugriffsaktionen*
## `neptune-db:GetEngineStatus`
`GetEngineStatus` ermöglicht Benutzern die Prüfung des Status der Neptune-Engine.
*Aktionsgruppen:* Schreibgeschützt, Lesen und Schreiben.
*Erforderliche Ressourcen:* Datenbank.
## `neptune-db:GetStatisticsStatus`
`GetStatisticsStatus` ermöglicht Benutzern die Prüfung des Status der Statistiken, die für die Datenbank gesammelt werden.
*Aktionsgruppen:* Schreibgeschützt, Lesen und Schreiben.
*Erforderliche Ressourcen:* Datenbank.
## `neptune-db:GetGraphSummary`
`GetGraphSummary` Die Diagrammübersichts-API ermöglicht Benutzern das Abrufen einer schreibgeschützten Übersicht über ein Diagramm.
*Aktionsgruppen:* Schreibgeschützt, Lesen und Schreiben.
*Erforderliche Ressourcen:* Datenbank.
## `neptune-db:ManageStatistics`
`ManageStatistics` ermöglicht Benutzern die Verwaltung der Erfassung von Statistiken für die Datenbank.
*Aktionsgruppen:* Lesen und Schreiben.
*Erforderliche Ressourcen:* Datenbank.
## `neptune-db:DeleteStatistics`
`DeleteStatistics` ermöglicht Benutzern das Löschen aller Statistiken in der Datenbank.
*Aktionsgruppen:* Lesen und Schreiben.
*Erforderliche Ressourcen:* Datenbank.
## `neptune-db:ResetDatabase`
`ResetDatabase` ermöglicht Benutzern das Abrufen des für eine Zurücksetzung benötigten Tokens und das Zurücksetzen der Neptune-Datenbank.
*Aktionsgruppen:* Lesen und Schreiben.
*Erforderliche Ressourcen:* Datenbank.
## *Massen-Loader-Datenzugriffsaktionen*
## `neptune-db:StartLoaderJob`
`StartLoaderJob` ermöglicht Benutzern das Starten eines Massen-Loader-Auftrags.
*Aktionsgruppen:* Lesen und Schreiben.
*Erforderliche Ressourcen:* Datenbank.
## `neptune-db:GetLoaderJobStatus`
`GetLoaderJobStatus` ermöglicht Benutzern das Prüfen des Status eines Massen-Loader-Auftrags.
*Aktionsgruppen:* Schreibgeschützt, Lesen und Schreiben.
*Erforderliche Ressourcen:* Datenbank.
## `neptune-db:ListLoaderJobs`
`ListLoaderJobs` ermöglicht Benutzern das Auflisten aller Massen-Loader-Aufträge.
*Aktionsgruppen:* Nur Auflistung, Schreibgeschützt, Lesen und Schreiben.
*Erforderliche Ressourcen:* Datenbank.
## `neptune-db:CancelLoaderJob`
`CancelLoaderJob` ermöglicht Benutzern das Abbrechen von Loader-Aufträgen.
*Aktionsgruppen:* Lesen und Schreiben.
*Erforderliche Ressourcen:* Datenbank.
## *Machine-Learning-Datenzugriffsaktionen*
## `neptune-db:StartMLDataProcessingJob`
`StartMLDataProcessingJob` ermöglicht Benutzern das Starten von Neptune-ML-Datenverarbeitungsaufträgen.
*Aktionsgruppen:* Lesen und Schreiben.
*Erforderliche Ressourcen:* Datenbank.
## `neptune-db:StartMLModelTrainingJob`
`StartMLModelTrainingJob` ermöglicht Benutzern das Starten von ML-Modelltrainingsaufträgen.
*Aktionsgruppen:* Lesen und Schreiben.
*Erforderliche Ressourcen:* Datenbank.
## `neptune-db:StartMLModelTransformJob`
`StartMLModelTransformJob` ermöglicht Benutzern das Starten von ML-Modelltransformierungsaufträgen.
*Aktionsgruppen:* Lesen und Schreiben.
*Erforderliche Ressourcen:* Datenbank.
## `neptune-db:CreateMLEndpoint`
`CreateMLEndpoint` ermöglicht Benutzer das Erstellen von Neptune-ML-Endpunkten.
*Aktionsgruppen:* Lesen und Schreiben.
*Erforderliche Ressourcen:* Datenbank.
## `neptune-db:GetMLDataProcessingJobStatus`
`GetMLDataProcessingJobStatus` ermöglicht Benutzern das Prüfen von Neptune-ML-Datenverarbeitungsaufträgen.
*Aktionsgruppen:* Schreibgeschützt, Lesen und Schreiben.
*Erforderliche Ressourcen:* Datenbank.
## `neptune-db:GetMLModelTrainingJobStatus`
`GetMLModelTrainingJobStatus` ermöglicht Benutzern das Prüfen des Status von Neptune-ML-Modelltrainingsaufträgen.
*Aktionsgruppen:* Schreibgeschützt, Lesen und Schreiben.
*Erforderliche Ressourcen:* Datenbank.
## `neptune-db:GetMLModelTransformJobStatus`
`GetMLModelTransformJobStatus` ermöglicht Benutzern das Prüfen des Status von Neptune-ML-Modelltransformierungsaufträgen.
*Aktionsgruppen:* Schreibgeschützt, Lesen und Schreiben.
*Erforderliche Ressourcen:* Datenbank.
## `neptune-db:GetMLEndpointStatus`
`GetMLEndpointStatus` ermöglicht Benutzern das Prüfen des Status von Neptune-ML-Endpunkten.
*Aktionsgruppen:* Schreibgeschützt, Lesen und Schreiben.
*Erforderliche Ressourcen:* Datenbank.
## `neptune-db:ListMLDataProcessingJobs`
`ListMLDataProcessingJobs` ermöglicht Benutzern das Auflisten aller Neptune-ML-Datenverarbeitungsaufträge.
*Aktionsgruppen:* Nur Auflistung, Schreibgeschützt, Lesen und Schreiben.
*Erforderliche Ressourcen:* Datenbank.
## `neptune-db:ListMLModelTrainingJobs`
`ListMLModelTrainingJobs` ermöglicht Benutzern das Auflisten aller Neptune-ML-Modelltrainingsaufträge.
*Aktionsgruppen:* Nur Auflistung, Schreibgeschützt, Lesen und Schreiben.
*Erforderliche Ressourcen:* Datenbank.
## `neptune-db:ListMLModelTransformJobs`
`ListMLModelTransformJobs` ermöglicht Benutzern das Auflisten aller Neptune-ML-Modelltransformierungsaufträge.
*Aktionsgruppen:* Nur Auflistung, Schreibgeschützt, Lesen und Schreiben.
*Erforderliche Ressourcen:* Datenbank.
## `neptune-db:ListMLEndpoints`
`ListMLEndpoints` ermöglicht Benutzern das Auflisten aller Neptune-ML-Endpunkte.
*Aktionsgruppen:* Nur Auflistung, Schreibgeschützt, Lesen und Schreiben.
*Erforderliche Ressourcen:* Datenbank.
## `neptune-db:CancelMLDataProcessingJob`
`CancelMLDataProcessingJob` ermöglicht Benutzern das Abbrechen von Neptune-ML-Datenverarbeitungsaufträgen.
*Aktionsgruppen:* Lesen und Schreiben.
*Erforderliche Ressourcen:* Datenbank.
## `neptune-db:CancelMLModelTrainingJob`
`CancelMLModelTrainingJob` ermöglicht Benutzern das Abbrechen von Neptune-ML-Modelltrainingsaufträgen.
*Aktionsgruppen:* Lesen und Schreiben.
*Erforderliche Ressourcen:* Datenbank.
## `neptune-db:CancelMLModelTransformJob`
`CancelMLModelTransformJob` ermöglicht Benutzern das Abbrechen von Neptune-ML-Modelltransformierungsaufträgen.
*Aktionsgruppen:* Lesen und Schreiben.
*Erforderliche Ressourcen:* Datenbank.
## `neptune-db:DeleteMLEndpoint`
`DeleteMLEndpoint` ermöglicht Benutzer das Löschen von Neptune-ML-Endpunkten.
*Aktionsgruppen:* Lesen und Schreiben.
*Erforderliche Ressourcen:* Datenbank.
# IAM-Ressourcentypen für den Zugriff auf Daten in Amazon Neptune
Datenressourcen besitzen wie Datenaktionen das Präfix `neptune-db:`.
In einer Neptune-Datenzugriffsrichtlinie geben Sie den DB-Cluster an, auf den Sie Zugriff gewähren, im ARN im folgenden Format an:
```
arn:aws:neptune-db:region:account-id:cluster-resource-id/*
```
Dieser Ressourcen-ARN enthält die folgenden Teile:
+ `region`ist die AWS Region für den Amazon Neptune DB-Cluster.
+ `account-id` ist die Nummer des AWS -Kontos für den DB-Cluster.
+ `cluster-resource-id` ist eine Ressourcen-ID für den DB-Cluster.
**Wichtig**
Die `cluster-resource-id` unterscheidet sich von der Cluster-ID. Um eine Cluster-Ressourcen-ID im Neptune zu finden AWS-Managementkonsole, suchen Sie im Abschnitt **Konfiguration** nach dem betreffenden DB-Cluster.
# IAM-Bedingungsschlüssel für den Zugriff auf Daten in Amazon Neptune
[Mithilfe von Bedingungsschlüsseln](security-iam-access-manage.md#iam-using-condition-keys) können Sie Bedingungen in einer IAM-Richtlinienanweisung angeben, damit die Anweisung nur dann wirksam wird, wenn die Bedingungen erfüllt werden.
Die Bedingungsschlüssel, die Sie in Datenzugriff-Richtlinienanweisungen in Neptune verwenden können, gehören den folgenden Kategorien an:
+ [Globale Bedingungsschlüssel](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) [— Die Teilmenge der AWS globalen Bedingungsschlüssel, die Neptune in Richtlinienerklärungen für den Datenzugriff unterstützt, ist unten aufgeführt.](#iam-data-global-condition-keys)
+ [Servicespezifische Bedingungsschlüssel](#iam-neptune-condition-keys) – Dies sind Schlüssel, die von Neptune speziell für die Verwendung in Datenzugriffs-Richtlinienanweisungen definiert werden. Derzeit gibt es nur eine Option, [neptune-db:](#neptune-db-query-language), die Zugriff nur gewährtQueryLanguage, wenn eine bestimmte Abfragesprache verwendet wird.
## AWS Globale Bedingungskontextschlüssel, die von Neptune in Datenzugriffspolitikanweisungen unterstützt werden
Die folgende Tabelle listet die Teilmenge der [globalen AWS -Bedingungskontextschlüssel](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) auf, die Amazon Neptune für die Verwendung in Datenzugriff-Richtlinienanweisungen unterstützt:
**Globale Bedingungsschlüssel, die Sie in Datenzugriff-Richtlinienanweisungen verwenden können**
| Bedingungsschlüssel | Beschreibung | Typ |
| --- | --- | --- |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-currenttime](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-currenttime) | Filtert den Zugriff nach aktuellen Datum und aktueller Uhrzeit der Anforderung. | String |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-epochtime](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-epochtime) | Filtert den Zugriff nach Datum und Uhrzeit der Anforderung ausgedrückt als UNIX-Epochenwert. | Numeric |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principalaccount](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principalaccount) | Filtert den Zugriff nach dem Konto, zu dem der anfordernde Prinzipal gehört. | String |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principalarn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principalarn) | Filtert den Zugriff nach dem ARN des Prinzipals, der die Anforderung gesendet hat. | String |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principalisawsservice](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principalisawsservice) | Erlaubt den Zugriff nur, wenn der Anruf direkt von einem AWS Dienstprinzipal getätigt wird. | Boolean |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principalorgid](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principalorgid) | Filtert den Zugriff nach der ID der Organisation in AWS Organizations, zu denen der anfragende Principal gehört. | String |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principalorgpaths](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principalorgpaths) | Filtert den Zugriff nach dem AWS Organisationspfad für den Prinzipal, der die Anfrage stellt. | String |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principaltag](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principaltag) | Filtert den Zugriff nach einem Tag, das dem anfordernden Prinzipal angefügt ist. | String |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principaltype](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principaltype) | Filtert den Zugriff nach dem Typ des Prinzipals, der die Anforderung sendet. | String |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-requestedregion](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-requestedregion) | Filtert den Zugriff nach der AWS Region, die in der Anfrage aufgerufen wurde. | String |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-securetransport](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-securetransport) | Gewährt den Zugriff nur, wenn die Anforderung über SSL gesendet wurde. | Boolean |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceip](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceip) | Filtert den Zugriff nach der IP-Adresse des Anforderers. | String |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-tokenissuetime](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-tokenissuetime) | Filtert den Zugriff nach Datum und Uhrzeit der Ausgabe temporärer Sicherheitsanmeldeinformationen. | String |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-useragent](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-useragent) | Filtert den Zugriff nach der Client-Anwendung des Anforderers. | String |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-userid](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-userid) | Filtert den Zugriff nach der Prinzipal–ID des Anforderers. | String |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-viaawsservice](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-viaawsservice) | Ermöglicht den Zugriff nur, wenn ein AWS Dienst die Anfrage in Ihrem Namen gestellt hat. | Boolean |
## Servicespezifische Neptune-Bedingungsschlüssel
Neptune unterstützt den folgenden servicespezifischen Bedingungsschlüssel für IAM-Richtlinien:
**Servicespezifische Neptune-Bedingungsschlüssel**
| Bedingungsschlüssel | Beschreibung | Typ |
| --- | --- | --- |
| neptune-db:QueryLanguage | Filtert den Datenzugriff nach der verwendeten Abfragesprache. Gültige Werte sind: `Gremlin`, `OpenCypher` und `Sparql`. Unterstützte Aktionen sind `ReadDataViaQuery`, `WriteDataViaQuery`, `DeleteDataViaQuery`, `GetQueryStatus` und `CancelQuery`. | String |
# Erstellen von IAM-Datenzugriffsrichtlinien in Amazon Neptune
[Die folgenden Beispiele zeigen, wie benutzerdefinierte IAM-Richtlinien erstellt werden, die eine differenzierte Zugriffskontrolle für Datenebene APIs und Aktionen verwenden, die in der Neptune Engine-Version 1.2.0.0 eingeführt wurde.](engine-releases-1.2.0.0.md)
## Beispiel für eine Richtlinie, die den uneingeschränkten Zugriff auf die Daten in einem Neptune-DB-Cluster ermöglicht
Das folgende Beispiel für eine Richtlinie ermöglicht IAM-Benutzern die Herstellung von Verbindungen mit Neptune-DB-Clustern mittels IAM-Datenbank-Authentifizierung und verwendet das Zeichen „`*`“, um alle verfügbaren Aktionen abzugleichen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "neptune-db:*",
"Resource": "arn:aws:neptune-db:us-east-1:123456789012:cluster-ABCD1234EFGH5678IJKL90MNOP/*"
}
]
}
```
------
Das vorhergehende Beispiel enthält einen Ressourcen-ARN in einem Format, das für die Neptune-IAM-Authentifizierung spezifisch ist. Informationen zum Konstruieren des ARN finden Sie unter [Angeben von Datenressourcen](iam-data-resources.md). Beachten Sie, dass der ARN für eine IAM-Autorisierung `Resource` nicht mit dem ARN identisch ist, der dem Cluster bei Erstellung zugewiesen wurde.
## Beispiel für eine Richtlinie, die einen schreibgeschützten Zugriff auf ein Neptune-DB-Cluster gewährt
Die folgende Richtlinie gewährt die Berechtigung für einen schreibgeschützten Vollzugriff auf Daten in einem Neptune-DB-Cluster:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect": "Allow",
"Action": [
"neptune-db:Read*",
"neptune-db:Get*",
"neptune-db:List*"
],
"Resource": "arn:aws:neptune-db:us-east-1:123456789012:cluster-ABCD1234EFGH5678IJKL90MNOP/*"
}
]
}
```
------
## Beispiel für eine Richtlinie, die jede Art von Zugriff auf ein Neptune-DB-Cluster ablehnt
Die IAM-Standardaktion ist die Ablehnung des Zugriffs auf einen DB-Cluster, wenn der *Effekt* `Allow` nicht gewährt wird. Die folgende Richtlinie verweigert jedoch jeglichen Zugriff auf einen DB-Cluster für ein bestimmtes AWS Konto und eine bestimmte Region, was dann Vorrang vor allen Auswirkungen hat. `Allow`
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": "neptune-db:*",
"Resource": "arn:aws:neptune-db:us-east-1:123456789012:cluster-ABCD1234EFGH5678IJKL90MNOP/*"
}
]
}
```
------
## Beispiel für eine Richtlinie, die Lesezugriff über Abfragen gewährt
Die folgende Richtlinie gewährt nur die Berechtigung zum Lesen aus einem Neptune-DB-Cluster über eine Abfrage:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "neptune-db:ReadDataViaQuery",
"Resource": "arn:aws:neptune-db:us-east-1:123456789012:cluster-ABCD1234EFGH5678IJKL90MNOP/*"
}
]
}
```
------
## Beispiel für eine Richtlinie, die nur Gremlin-Abfragen zulässt
Die folgende Richtlinie verwendet den Bedingungsschlüssel `neptune-db:QueryLanguage`, um die Berechtigung zu gewähren, Neptune nur mit der Gremlin-Abfragesprache abzufragen:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"neptune-db:ReadDataViaQuery",
"neptune-db:WriteDataViaQuery",
"neptune-db:DeleteDataViaQuery"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"neptune-db:QueryLanguage": "Gremlin"
}
}
}
]
}
```
------
## Beispiel für eine Richtlinie, die jeden Zugriff außer dem Zugriff auf die Neptune-ML-Modellverwaltung gewährt
Die folgende Richtlinie gewährt Vollzugriff auf alle Neptune-Diagrammoperationen außer Neptune-ML-Modellverwaltungs-Features:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect": "Allow",
"Action": [
"neptune-db:CancelLoaderJob",
"neptune-db:CancelQuery",
"neptune-db:DeleteDataViaQuery",
"neptune-db:DeleteStatistics",
"neptune-db:GetEngineStatus",
"neptune-db:GetLoaderJobStatus",
"neptune-db:GetQueryStatus",
"neptune-db:GetStatisticsStatus",
"neptune-db:GetStreamRecords",
"neptune-db:ListLoaderJobs",
"neptune-db:ManageStatistics",
"neptune-db:ReadDataViaQuery",
"neptune-db:ResetDatabase",
"neptune-db:StartLoaderJob",
"neptune-db:WriteDataViaQuery"
],
"Resource": "arn:aws:neptune-db:us-east-1:123456789012:cluster-ABCD1234EFGH5678IJKL90MNOP/*"
}
]
}
```
------
## Beispiel für eine Richtlinie, die Zugriff auf die Neptune-ML-Modellverwaltung gewährt
Diese Richtlinie gewährt Zugriff auf die Neptune-ML-Modellverwaltungs-Features:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect": "Allow",
"Action": [
"neptune-db:CancelMLDataProcessingJob",
"neptune-db:CancelMLModelTrainingJob",
"neptune-db:CancelMLModelTransformJob",
"neptune-db:CreateMLEndpoint",
"neptune-db:DeleteMLEndpoint",
"neptune-db:GetMLDataProcessingJobStatus",
"neptune-db:GetMLEndpointStatus",
"neptune-db:GetMLModelTrainingJobStatus",
"neptune-db:GetMLModelTransformJobStatus",
"neptune-db:ListMLDataProcessingJobs",
"neptune-db:ListMLEndpoints",
"neptune-db:ListMLModelTrainingJobs",
"neptune-db:ListMLModelTransformJobs",
"neptune-db:StartMLDataProcessingJob",
"neptune-db:StartMLModelTrainingJob",
"neptune-db:StartMLModelTransformJob"
],
"Resource": "arn:aws:neptune-db:us-east-1:123456789012:cluster-ABCD1234EFGH5678IJKL90MNOP/*"
}
]
}
```
------
## Beispiel für eine Richtlinie, die vollständigen Abfragezugriff gewährt
Die folgende Richtlinie gewährt Vollzugriff auf Neptune-Diagramm-Abfrageoperationen, jedoch nicht auf Features wie Fast Reset, Streams, Massen-Loader, Neptune-ML-Modellverwaltung usw.:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect": "Allow",
"Action": [
"neptune-db:ReadDataViaQuery",
"neptune-db:WriteDataViaQuery",
"neptune-db:DeleteDataViaQuery",
"neptune-db:GetEngineStatus",
"neptune-db:GetQueryStatus",
"neptune-db:CancelQuery"
],
"Resource": "arn:aws:neptune-db:us-east-1:123456789012:cluster-ABCD1234EFGH5678IJKL90MNOP/*"
}
]
}
```
------
## Beispiel für eine Richtlinie, die nur für Gremlin-Abfragen Vollzugriff gewährt
Die folgende Richtlinie gewährt Vollzugriff auf Neptune-Diagramm-Abfrageoperationen über die Gremlin-Abfragesprache, jedoch nicht auf Abfragen über andere Sprachen oder auf Features wie Fast Reset, Streams, Massen-Loader, Neptune-ML-Modellverwaltung usw.:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect": "Allow",
"Action": [
"neptune-db:ReadDataViaQuery",
"neptune-db:WriteDataViaQuery",
"neptune-db:DeleteDataViaQuery",
"neptune-db:GetEngineStatus",
"neptune-db:GetQueryStatus",
"neptune-db:CancelQuery"
],
"Resource": [
"arn:aws:neptune-db:us-east-1:123456789012:cluster-ABCD1234EFGH5678IJKL90MNOP/*"
],
"Condition": {
"StringEquals": {
"neptune-db:QueryLanguage":"Gremlin"
}
}
}
]
}
```
------
## Beispiel für eine Richtlinie, die Vollzugriff gewährt, ausgenommen Fast Reset
Die folgende Richtlinie gewährt Vollzugriff auf einen Neptune-DB-Cluster, ausgenommen bei Verwendung von Fast Reset:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "neptune-db:*",
"Resource": "arn:aws:neptune-db:us-east-1:123456789012:cluster-ABCD1234EFGH5678IJKL90MNOP/*"
},
{
"Effect": "Deny",
"Action": "neptune-db:ResetDatabase",
"Resource": "arn:aws:neptune-db:us-east-1:123456789012:cluster-ABCD1234EFGH5678IJKL90MNOP/*"
}
]
}
```
------
# Verwenden von serviceverknüpften Rollen für Amazon Neptune
[Amazon Neptune verwendet AWS Identity and Access Management (IAM) serviceverknüpfte Rollen.](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#iam-term-service-linked-role) Eine serviceverknüpfte Rolle ist eine spezielle IAM-Rolle, die direkt mit Neptune verknüpft ist. Dienstbezogene Rollen sind von Neptune vordefiniert und beinhalten alle Berechtigungen, die der Dienst benötigt, um andere AWS Dienste in Ihrem Namen aufzurufen.
**Wichtig**
Für bestimmte Verwaltungs-Features verwendet Amazon Neptune operative Technologien, die mit Amazon RDS geteilt werden. Dies umfasst die *serviceverknüpfte Rolle* und API-Verwaltungsberechtigungen.
Eine serviceverknüpfte Rolle vereinfacht das Einrichten von Neptune, da Sie die erforderlichen Berechtigungen nicht manuell hinzufügen müssen. Neptune definiert die Berechtigungen seiner serviceverknüpften Rollen. Wenn nicht anders definiert, kann Neptune nur seine Rollen übernehmen. Die definierten Berechtigungen umfassen die Vertrauens- und Berechtigungsrichtlinie. Diese Berechtigungsrichtlinie kann keinen anderen IAM-Entitäten zugewiesen werden.
Sie können die Rollen nur nach dem Löschen der zugehörigen Ressourcen löschen. Dies schützt Ihre Neptune-Ressourcen, da Sie nicht versehentlich die Berechtigung für den Zugriff auf die Ressourcen entfernen können.
**Informationen zu anderen Diensten, die dienstverknüpfte Rollen unterstützen, finden Sie unter [AWS Dienste, die mit IAM funktionieren](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html). Suchen Sie in der Spalte Serviceverknüpfte Rolle nach den Diensten, für die **Ja steht**.** Wählen Sie über einen Link **Ja** aus, um die Dokumentation zu einer serviceverknüpften Rolle für diesen Service anzuzeigen.
## Berechtigungen von serviceverknüpften Rollen für Neptune
Neptune verwendet die `AWSServiceRoleForRDS` serviceverknüpfte Rolle, damit Neptune und Amazon RDS AWS Dienste im Namen Ihrer Datenbank-Instances aufrufen können. Die serviceverknüpfte Rolle `AWSServiceRoleForRDS` vertraut dem Service `rds.amazonaws.com`, sodass dieser die Rolle annehmen kann.
Die Rollenberechtigungsrichtlinie erlaubt Neptune die Durchführung der folgenden Aktionen für die angegebenen Ressourcen:
+ Aktionen auf `ec2`:
+ `AssignPrivateIpAddresses`
+ `AuthorizeSecurityGroupIngress`
+ `CreateNetworkInterface`
+ `CreateSecurityGroup`
+ `DeleteNetworkInterface`
+ `DeleteSecurityGroup`
+ `DescribeAvailabilityZones`
+ `DescribeInternetGateways`
+ `DescribeSecurityGroups`
+ `DescribeSubnets`
+ `DescribeVpcAttribute`
+ `DescribeVpcs`
+ `ModifyNetworkInterfaceAttribute`
+ `RevokeSecurityGroupIngress`
+ `UnassignPrivateIpAddresses`
+ Aktionen auf `sns`:
+ `ListTopic`
+ `Publish`
+ Aktionen auf `cloudwatch`:
+ `PutMetricData`
+ `GetMetricData`
+ `CreateLogStream`
+ `PullLogEvents`
+ `DescribeLogStreams`
+ `CreateLogGroup`
**Anmerkung**
Sie müssen Berechtigungen konfigurieren, damit eine juristische Stelle von IAM (z. B. Benutzer, Gruppe oder Rolle) eine serviceverknüpfte Rolle erstellen, bearbeiten oder löschen kann. Möglicherweise erhalten Sie die folgende Fehlermeldung:
Unable to create the resource. Überprüfen Sie, ob Sie die Berechtigung haben, eine serviceverknüpfte Rolle zu erstellen. Andernfalls warten Sie und versuchen Sie es später noch einmal.
Wenn Sie diesen Fehler erhalten, überprüfen Sie, ob die folgenden Berechtigungen aktiviert sind:
```
{
"Action": "iam:CreateServiceLinkedRole",
"Effect": "Allow",
"Resource": "arn:aws:iam::*:role/aws-service-role/rds.amazonaws.com/AWSServiceRoleForRDS",
"Condition": {
"StringLike": {
"iam:AWSServiceName":"rds.amazonaws.com"
}
}
}
```
Weitere Informationen finden Sie unter [serviceverknüpfte Rollenberechtigungen](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#service-linked-role-permissions) im *IAM-Benutzerhandbuch*.
## Erstellen einer serviceverknüpften Rolle für Neptune
Sie müssen eine serviceverknüpfte Rolle nicht manuell erstellen. Wenn Sie eine Instance oder einen Cluster erstellen, erstellt Neptune die serviceverknüpfte Rolle für Sie.
**Wichtig**
Weitere Informationen finden Sie unter [In meinem IAM-Konto wird eine neue Rolle angezeigt](https://docs.aws.amazon.com/IAM/latest/UserGuide/troubleshoot_roles.html#troubleshoot_roles_new-role-appeared) im *IAM-Benutzerhandbuch*.
Wenn Sie diese serviceverknüpfte Rolle löschen und dann erneut erstellen müssen, können Sie die Rolle in Ihrem Konto mit demselben Verfahren neu anlegen. Neptune erstellt die serviceverknüpfte Rolle erneut für Sie, wenn Sie eine Instance oder einen Cluster erstellen.
## Bearbeiten einer serviceverknüpften Rolle für Neptune
Neptune erlaubt Ihnen nicht, die serviceverknüpfte Rolle `AWSServiceRoleForRDS` zu bearbeiten. Da möglicherweise verschiedene Entitäten auf die Rolle verweisen, kann der Rollenname nach dem Erstellen einer serviceverknüpften Rolle nicht mehr geändert werden. Sie können jedoch die Beschreibung der Rolle mit IAM bearbeiten. Weitere Informationen finden Sie unter [Bearbeiten einer serviceverknüpften Rolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#edit-service-linked-role) im *IAM-Benutzerhandbuch*.
## Löschen einer serviceverknüpften Rolle für Neptune
Wenn Sie ein Feature oder einen Dienst, die bzw. der eine serviceverknüpften Rolle erfordert, nicht mehr benötigen, sollten Sie diese Rolle löschen. Auf diese Weise haben Sie keine ungenutzte juristische Stelle, die nicht aktiv überwacht oder verwaltet wird. Sie müssen jedoch alle Ihre Instances und Cluster löschen, bevor Sie die verknüpfte serviceverknüpfte Rolle löschen können.
### Bereinigen einer serviceverknüpften Rolle vor dem Löschen
Bevor Sie mit IAM eine serviceverknüpfte Rolle löschen können, müssen Sie sich zunächst vergewissern, dass die Rolle über keine aktiven Sitzungen verfügt, und alle Ressourcen entfernen, die von der Rolle verwendet werden.
**So überprüfen Sie in der IAM-Konsole, ob die serviceverknüpfte Rolle über eine aktive Sitzung verfügt**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)
1. Wählen Sie im Navigationsbereich der IAM Console **Roles** (Rollen) aus. Wählen Sie dann den Namen (nicht das Kontrollkästchen) der Rolle `AWSServiceRoleForRDS` aus.
1. Wählen Sie auf der Seite **Summary** für die ausgewählte Rolle die Registerkarte **Access Advisor**.
1. Überprüfen Sie auf der Registerkarte **Access Advisor** die jüngsten Aktivitäten für die serviceverknüpfte Rolle.
**Anmerkung**
Wenn Sie sich nicht sicher sind, ob Neptune die Rolle `AWSServiceRoleForRDS` verwendet, können Sie versuchen, die Rolle zu löschen. Wenn der Service die Rolle verwendet, schlägt die Löschung fehl und Sie können die -Regionen anzeigen, in denen die Rolle verwendet wird. Wenn die Rolle verwendet wird, müssen Sie warten, bis die Sitzung beendet wird, bevor Sie die Rolle löschen können. Die Sitzung für eine serviceverknüpfte Rolle können Sie nicht widerrufen.
Wenn Sie die Rolle `AWSServiceRoleForRDS` entfernen möchten, müssen Sie zunächst *alle* Ihre Instances und Cluster löschen.
#### Löschen Ihrer kompletten Instances
Verwenden Sie eine dieser Verfahren, um Ihrer kompletten Instance zu löschen.
**So löschen Sie eine Instance (Konsole)**
1. Öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im Navigationsbereich **Instances** aus.
1. Wählen Sie in der Liste **Instances** die Instance aus, die Sie löschen möchten.
1. Wählen Sie **Instance-Aktionen** und dann **Löschen** aus.
1. Wenn Sie die Aufforderung **Create final Snapshot? (Finalen Snapshot erstellen)**, wählen Sie **Yes (Ja)** oder **No (Nein)** aus.
1. Wenn Sie im vorherigen Schritt **Yes (Ja)** gewählt haben, geben Sie unter **Final snapshot name (Endgültiger Snapshot-Name)** den Namen Ihres endgültigen DB-Snapshots ein.
1. Wählen Sie **Löschen** aus.
**So löschen Sie eine Instance (AWS CLI)**
Siehe `[delete-db-instance](https://docs.aws.amazon.com/cli/latest/reference/neptune/delete-db-instance.html)` in der *AWS CLI -Befehlsreferenz*.
**So löschen Sie eine Instance (API)**
Siehe `[DeleteDBInstance](&doc-domaiAPI_DeleteDBInstance.html)`.
#### Löschen Ihrer kompletten Cluster
Verwenden Sie eines der folgenden Verfahren, um einen einzelnen Cluster zu löschen. Wiederholen Sie anschließend das Verfahren für jeden Ihrer Cluster.
**So löschen Sie einen Cluster (Konsole)**
1. [Melden Sie sich bei der AWS Management Console an und öffnen Sie die Amazon Neptune Neptune-Konsole zu Hausehttps://console.aws.amazon.com/neptune/.](https://console.aws.amazon.com/neptune/home)
1. Wählen Sie in der Liste **Clusters** den Cluster aus, den Sie löschen möchten.
1. Wählen Sie **Cluster Actions** und dann **Delete** aus.
1. Wählen Sie **Löschen** aus.
**So löschen Sie einen Cluster (CLI)**
Siehe `[delete-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/neptune/delete-db-cluster.html)` in der *AWS CLI -Befehlsreferenz*.
**So löschen Sie einen Cluster (API)**
Siehe `[DeleteDBCluster](API_DeleteDBCluster.html)`
Sie können die IAM-Konsole, die IAM-CLI oder die IAM-API verwenden, um die serviceverknüpfte Rolle `AWSServiceRoleForRDS` zu löschen. Weitere Informationen finden Sie unter [Löschen einer serviceverknüpften Rolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#delete-service-linked-role) im *IAM-Leitfaden*.
# Temporäre Anmeldeinformationen verwenden, um eine Verbindung zu Amazon Neptune herzustellen
Amazon Neptune unterstützt die IAM-Authentifizierung mit temporären Anmeldeinformationen.
Sie können eine angenommene Rolle zur Authentifizierung mithilfe einer IAM-Authentifizierungsrichtlinie verwenden, etwa eine der Beispielrichtlinien in den vorherigen Abschnitten.
Wenn Sie temporäre Anmeldeinformationen verwenden, müssen Sie `AWS_SESSION_TOKEN` zusätzlich zu `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` und `SERVICE_REGION` angeben.
**Anmerkung**
Die temporären Anmeldeinformationen laufen nach einem angegebenen Intervall ab, *, einschließlich des Sitzungs-Tokens*.
Sie müssen Ihren Sitzungs-Token aktualisieren, wenn Sie neue Anmeldeinformationen anfragen. Weitere Informationen finden Sie unter [Verwenden temporärer Sicherheitsanmeldedaten](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html), um Zugriff auf Ressourcen anzufordern. AWS
In den folgenden Abschnitten wird beschrieben, wie Sie den Zugriff zulassen und temporäre Anmeldeinformationen abrufen.
**So führen Sie die Authentifizierung mithilfe temporärer Anmeldeinformationen durch**
1. Erstellen Sie eine IAM-Rolle mit Berechtigung für den Zugriff auf einen Neptune-Cluster. Weitere Informationen zum Erstellen dieser Rolle finden Sie unter [Verwenden verschiedener Arten von IAM-Richtlinien für die Steuerung des Zugriffs auf Neptune](security-iam-access-manage.md#iam-auth-policy).
1. Fügen Sie eine Vertrauensstellung der Rolle hinzu, die den Zugriff auf die Anmeldeinformationen ermöglicht.
Rufen Sie die temporären Anmeldeinformationen ab, einschließlich `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` und `AWS_SESSION_TOKEN`.
1. Stellen Sie eine Verbindung mit dem Neptune-Cluster her und signieren Sie die Anforderungen mithilfe der temporären Anmeldeinformationen. Für weitere Informationen zu Verbindungen und zum Signieren von Anfragen finden Sie unter [Mit Authentifizierung eine Verbindung zu Ihrer Amazon Neptune Neptune-Datenbank herstellen AWS Identity and Access Management](iam-auth-connecting.md).
Es gibt verschiedene Methoden zum Abrufen der temporären Anmeldeinformationen, die von der jeweiligen Umgebung abhängig sind.
**Topics**
+ [Abrufen temporärer Anmeldeinformationen mit dem AWS CLI](#iam-auth-temporary-credentials-cli)
+ [AWS Lambda für die Neptune-IAM-Authentifizierung einrichten](#iam-auth-temporary-credentials-lambda)
+ [Einrichten von Amazon EC2 für die Neptune-IAM-Authentifizierung](#iam-auth-temporary-credentials-ec2)
## Abrufen temporärer Anmeldeinformationen mit dem AWS CLI
Um Anmeldeinformationen mithilfe von AWS Command Line Interface (AWS CLI) abzurufen, müssen Sie zunächst eine Vertrauensstellung hinzufügen, die dem AWS Benutzer, der den AWS CLI Befehl ausführt, die Berechtigung erteilt, die Rolle zu übernehmen.
Fügen Sie der Neptune-IAM-Authentifizierungsrolle die folgende Vertrauensstellung hinzu. Wenn Sie keine Neptune-IAM-Authentifizierungsrolle haben, siehe [Verwenden verschiedener Arten von IAM-Richtlinien für die Steuerung des Zugriffs auf Neptune](security-iam-access-manage.md#iam-auth-policy).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::123456789012:user/test"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Informationen zum Hinzufügen der Vertrauensstellung zur Rolle finden Sie unter [Bearbeiten der Vertrauensstellung für eine vorhandene Rolle](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/edit_trust.html) im *AWS Directory Service Administrationshandbuch*.
Wenn die Neptune-Richtlinie noch nicht an eine Rolle angefügt ist, erstellen Sie eine neue Rolle. Fügen Sie die Neptune-IAM-Authentifizierungsrichtlinie an und dann die Vertrauensrichtlinie hinzu. Informationen zum Erstellen einer neuen Rolle finden Sie unter [Erstellen einer neuen Rolle](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/create_role.html).
**Anmerkung**
In den folgenden Abschnitten wird davon ausgegangen, dass Sie das AWS CLI installiert haben.
**Um das AWS CLI manuell auszuführen**
1. Geben Sie den folgenden Befehl ein, um die Anmeldeinformationen mithilfe der AWS CLI anzufordern. Ersetzen Sie den Rollen-ARN, den Namen der Sitzung und das Profil durch Ihre eigenen Werte.
```
aws sts assume-role --role-arn arn:aws:iam::123456789012:role/NeptuneIAMAuthRole --role-session-name test --profile testprofile
```
1. Das folgende Beispiel zeigt die Ausgabe des Befehls. Der Abschnitt `Credentials` enthält die Werte, die Sie benötigen.
**Anmerkung**
Notieren Sie den `Expiration`-Wert, da Sie ihn später zum Anfordern neuer Anmeldeinformationen benötigen.
```
{
"AssumedRoleUser": {
"AssumedRoleId": "AROA3XFRBF535PLBIFPI4:s3-access-example",
"Arn": "arn:aws:sts::123456789012:assumed-role/xaccounts3access/s3-access-example"
},
"Credentials": {
"SecretAccessKey": "9drTJvcXLB89EXAMPLELB8923FB892xMFI",
"SessionToken": "AQoXdzELDDY//////////wEaoAK1wvxJY12r2IrDFT2IvAzTCn3zHoZ7YNtpiQLF0MqZye/qwjzP2iEXAMPLEbw/m3hsj8VBTkPORGvr9jM5sgP+w9IZWZnU+LWhmg+a5fDi2oTGUYcdg9uexQ4mtCHIHfi4citgqZTgco40Yqr4lIlo4V2b2Dyauk0eYFNebHtYlFVgAUj+7Indz3LU0aTWk1WKIjHmmMCIoTkyYp/k7kUG7moeEYKSitwQIi6Gjn+nyzM+PtoA3685ixzv0R7i5rjQi0YE0lf1oeie3bDiNHncmzosRM6SFiPzSvp6h/32xQuZsjcypmwsPSDtTPYcs0+YN/8BRi2/IcrxSpnWEXAMPLEXSDFTAQAM6Dl9zR0tXoybnlrZIwMLlMi1Kcgo5OytwU=",
"Expiration": "2016-03-15T00:05:07Z",
"AccessKeyId": "ASIAJEXAMPLEXEG2JICEA"
}
}
```
1. Stellen Sie die Umgebungsvariablen anhand der zurückgegebenen Anmeldeinformationen ein.
```
export AWS_ACCESS_KEY_ID=ASIAJEXAMPLEXEG2JICEA
export AWS_SECRET_ACCESS_KEY=9drTJvcXLB89EXAMPLELB8923FB892xMFI
export AWS_SESSION_TOKEN=AQoXdzELDDY//////////wEaoAK1wvxJY12r2IrDFT2IvAzTCn3zHoZ7YNtpiQLF0MqZye/qwjzP2iEXAMPLEbw/m3hsj8VBTkPORGvr9jM5sgP+w9IZWZnU+LWhmg+a5fDi2oTGUYcdg9uexQ4mtCHIHfi4citgqZTgco40Yqr4lIlo4V2b2Dyauk0eYFNebHtYlFVgAUj+7Indz3LU0aTWk1WKIjHmmMCIoTkyYp/k7kUG7moeEYKSitwQIi6Gjn+nyzM+PtoA3685ixzv0R7i5rjQi0YE0lf1oeie3bDiNHncmzosRM6SFiPzSvp6h/32xQuZsjcypmwsPSDtTPYcs0+YN/8BRi2/IcrxSpnWEXAMPLEXSDFTAQAM6Dl9zR0tXoybnlrZIwMLlMi1Kcgo5OytwU=
export SERVICE_REGION=us-east-1 or us-east-2 or us-west-1 or us-west-2 or ca-central-1 or
ca-west-1 or sa-east-1 or eu-north-1 or eu-south-2 or eu-west-1 or eu-west-2 or eu-west-3 or
eu-central-1 or me-south-1 or me-central-1 or il-central-1 or af-south-1 or ap-east-1 or
ap-northeast-1 or ap-northeast-2 or ap-northeast-3 or ap-southeast-1 or ap-southeast-2 or
ap-southeast-3 or ap-southeast-4 or ap-southeast-5 or ap-south-1 or ap-south-2 or
cn-north-1 or cn-northwest-1 or
us-gov-east-1 or us-gov-west-1
```
1. Stellen Sie die Verbindung mit einem der folgenden Verfahren her.
+ [Herstellen einer Verbindung zu Amazon Neptune Neptune-Datenbanken mithilfe der IAM-Authentifizierung mit der Gremlin-Konsole](iam-auth-connecting-gremlin-console.md)
+ [Herstellen einer Verbindung zu Amazon Neptune Neptune-Datenbanken mithilfe von IAM mit Gremlin Java](iam-auth-connecting-gremlin-java.md)
+ [Herstellen einer Verbindung zu Amazon Neptune Neptune-Datenbanken mithilfe der IAM-Authentifizierung mit Java und SPARQL](iam-auth-connecting-sparql-java.md)
+ [Herstellen einer Verbindung zu Amazon Neptune Neptune-Datenbanken mithilfe der IAM-Authentifizierung mit Python](iam-auth-connecting-python.md)
**So verwenden Sie ein Skript zum Abrufen der Anmeldeinformationen**
1. Führen Sie den folgenden Befehl aus, um den **jq**-Befehl zu installieren. Das Skript verwendet diesen Befehl, um die Ausgabe des AWS CLI Befehls zu analysieren.
```
sudo yum -y install jq
```
1. Erstellen Sie in einem Texteditor eine Datei mit der Bezeichnung `credentials.sh`, und fügen Sie den folgenden Text hinzu. Ersetzen Sie die Service-Region, den Rollen-ARN, den Namen der Sitzung und das Profil durch Ihre eigenen Werte.
```
#!/bin/bash
creds_json=$(aws sts assume-role --role-arn arn:aws:iam::123456789012:role/NeptuneIAMAuthRole --role-session-name test --profile testprofile)
export AWS_ACCESS_KEY_ID=$(echo "$creds_json" | jq .Credentials.AccessKeyId |tr -d '"')
export AWS_SECRET_ACCESS_KEY=$(echo "$creds_json" | jq .Credentials.SecretAccessKey| tr -d '"')
export AWS_SESSION_TOKEN=$(echo "$creds_json" | jq .Credentials.SessionToken|tr -d '"')
export SERVICE_REGION=us-east-1 or us-east-2 or us-west-1 or us-west-2 or ca-central-1 or
ca-west-1 or sa-east-1 or eu-north-1 or eu-south-2 or eu-west-1 or eu-west-2 or eu-west-3 or
eu-central-1 or me-south-1 or me-central-1 or il-central-1 or af-south-1 or ap-east-1 or
ap-northeast-1 or ap-northeast-2 or ap-northeast-3 or ap-southeast-1 or ap-southeast-2 or
ap-southeast-3 or ap-southeast-4 or ap-southeast-5 or ap-south-1 or ap-south-2 or
cn-north-1 or cn-northwest-1 or
us-gov-east-1 or us-gov-west-1
```
1. Stellen Sie die Verbindung mit einem der folgenden Verfahren her.
+ [Herstellen einer Verbindung zu Amazon Neptune Neptune-Datenbanken mithilfe der IAM-Authentifizierung mit der Gremlin-Konsole](iam-auth-connecting-gremlin-console.md)
+ [Herstellen einer Verbindung zu Amazon Neptune Neptune-Datenbanken mithilfe von IAM mit Gremlin Java](iam-auth-connecting-gremlin-java.md)
+ [Herstellen einer Verbindung zu Amazon Neptune Neptune-Datenbanken mithilfe der IAM-Authentifizierung mit Java und SPARQL](iam-auth-connecting-sparql-java.md)
+ [Herstellen einer Verbindung zu Amazon Neptune Neptune-Datenbanken mithilfe der IAM-Authentifizierung mit Python](iam-auth-connecting-python.md)
## AWS Lambda für die Neptune-IAM-Authentifizierung einrichten
AWS Lambda schließt bei jeder Ausführung der Lambda-Funktion automatisch Anmeldeinformationen ein.
Zunächst müssen Sie eine Vertrauensstellung hinzufügen, die dem Lambda-Service die Berechtigung zur Übernahme der Rolle gewährt.
Fügen Sie der Neptune-IAM-Authentifizierungsrolle die folgende Vertrauensstellung hinzu. Wenn Sie keine Neptune-IAM-Authentifizierungsrolle haben, siehe [Verwenden verschiedener Arten von IAM-Richtlinien für die Steuerung des Zugriffs auf Neptune](security-iam-access-manage.md#iam-auth-policy).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Informationen zum Hinzufügen der Vertrauensstellung zur Rolle finden Sie unter [Bearbeiten der Vertrauensstellung für eine vorhandene Rolle](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/edit_trust.html) im *AWS Directory Service Administrationshandbuch*.
Wenn die Neptune-Richtlinie noch nicht an eine Rolle angefügt ist, erstellen Sie eine neue Rolle. Fügen Sie die Neptune-IAM-Authentifizierungsrichtlinie an und dann die Vertrauensrichtlinie hinzu. Informationen zum Erstellen einer neuen Rolle finden Sie unter [Erstellen einer neuen Rolle](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/create_role.html) im *AWS Directory Service Administrationshandbuch*.
**Zugriff auf Neptune über Lambda**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die AWS Lambda Konsole unter [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Erstellen Sie eine neue Lambda-Funktion für die Python-Version 3.6.
1. Weisen Sie die `AWSLambdaVPCAccessExecutionRole`-Rolle der Lambda-Funktion zu. Dies ist für den Zugriff auf Neptune-Ressourcen erforderlich, die nur in einer VPC existieren.
1. Weisen Sie der Lambda-Funktion die Neptune-Authentifizierungs-IAM-Rolle zu.
Weitere Informationen finden Sie unter [AWS -Lambda-Berechtigungen](https://docs.aws.amazon.com/lambda/latest/dg/intro-permission-model.html) im *AWS Lambda -Entwicklerhandbuch*.
1. Kopieren Sie das IAM-Authentifizierungs-Python-Beispiel in den Lambda-Funktionscode.
Weitere Informationen zum Beispiel und zum Beispielcode finden Sie unter [Herstellen einer Verbindung zu Amazon Neptune Neptune-Datenbanken mithilfe der IAM-Authentifizierung mit Python](iam-auth-connecting-python.md).
## Einrichten von Amazon EC2 für die Neptune-IAM-Authentifizierung
Mit Amazon EC2 können Sie Instance-Profile verwenden, um automatisch Anmeldeinformationen bereitzustellen. Weitere Informationen finden Sie unter [Verwenden von Instance-Profilen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2_instance-profiles.html) im *IAM-Benutzerhandbuch*.
Zunächst müssen Sie eine Vertrauensstellung hinzufügen, die dem Amazon-EC2-Service die Berechtigung zur Übernahme der Rolle gewährt.
Fügen Sie der Neptune-IAM-Authentifizierungsrolle die folgende Vertrauensstellung hinzu. Wenn Sie keine Neptune-IAM-Authentifizierungsrolle haben, siehe [Verwenden verschiedener Arten von IAM-Richtlinien für die Steuerung des Zugriffs auf Neptune](security-iam-access-manage.md#iam-auth-policy).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "ec2.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Informationen zum Hinzufügen der Vertrauensstellung zur Rolle finden Sie unter [Bearbeiten der Vertrauensstellung für eine vorhandene Rolle](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/edit_trust.html) im *AWS Directory Service Administrationshandbuch*.
Wenn die Neptune-Richtlinie noch nicht an eine Rolle angefügt ist, erstellen Sie eine neue Rolle. Fügen Sie die Neptune-IAM-Authentifizierungsrichtlinie an und dann die Vertrauensrichtlinie hinzu. Informationen zum Erstellen einer neuen Rolle finden Sie unter [Erstellen einer neuen Rolle](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/create_role.html) im *AWS Directory Service Administrationshandbuch*.
**So verwenden Sie ein Skript zum Abrufen der Anmeldeinformationen**
1. Führen Sie den folgenden Befehl aus, um den **jq**-Befehl zu installieren. Das Skript verwendet diesen Befehl zum Analysieren der Ausgabe des **curl**-Befehl.
```
sudo yum -y install jq
```
1. Erstellen Sie in einem Texteditor eine Datei mit der Bezeichnung `credentials.sh`, und fügen Sie den folgenden Text hinzu. Ersetzen Sie die Service-Region durch Ihren eigenen Wert.
```
TOKEN=$( curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600" )
role_name=$( curl -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/iam/security-credentials/ )
creds_json=$( curl -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/iam/security-credentials/${role_name} )
export AWS_ACCESS_KEY_ID=$(echo "$creds_json" | jq .AccessKeyId |tr -d '"')
export AWS_SECRET_ACCESS_KEY=$(echo "$creds_json" | jq .SecretAccessKey| tr -d '"')
export AWS_SESSION_TOKEN=$(echo "$creds_json" | jq .Token|tr -d '"')
export SERVICE_REGION=us-east-1 or us-east-2 or us-west-1 or us-west-2 or ca-central-1 or
ca-west-1 or sa-east-1 or eu-north-1 or eu-south-2 or eu-west-1 or eu-west-2 or eu-west-3 or
eu-central-1 or me-south-1 or me-central-1 or il-central-1 or af-south-1 or ap-east-1 or
ap-northeast-1 or ap-northeast-2 or ap-northeast-3 or ap-southeast-1 or ap-southeast-2 or
ap-southeast-3 or ap-southeast-4 or ap-southeast-5 or ap-south-1 or ap-south-2 or
cn-north-1 or cn-northwest-1 or
us-gov-east-1 or us-gov-west-1
```
1. Führen Sie das Skript in der `bash`-Shell mit dem `source`-Befehl aus:
```
source credentials.sh
```
Noch besser ist es, die Befehle in diesem Skript zur `.bashrc`-Datei auf Ihrer EC2-Instance hinzuzufügen, so dass sie automatisch aufgerufen werden, wenn Sie sich anmelden, um temporäre Anmeldeinformationen für die Gremlin-Konsole verfügbar zu machen.
1. Stellen Sie die Verbindung mit einem der folgenden Verfahren her.
+ [Herstellen einer Verbindung zu Amazon Neptune Neptune-Datenbanken mithilfe der IAM-Authentifizierung mit der Gremlin-Konsole](iam-auth-connecting-gremlin-console.md)
+ [Herstellen einer Verbindung zu Amazon Neptune Neptune-Datenbanken mithilfe von IAM mit Gremlin Java](iam-auth-connecting-gremlin-java.md)
+ [Herstellen einer Verbindung zu Amazon Neptune Neptune-Datenbanken mithilfe der IAM-Authentifizierung mit Java und SPARQL](iam-auth-connecting-sparql-java.md)
+ [Herstellen einer Verbindung zu Amazon Neptune Neptune-Datenbanken mithilfe der IAM-Authentifizierung mit Python](iam-auth-connecting-python.md)
# Protokollierung und Überwachung von Nutzung und Leistung in Amazon Neptune
Amazon Neptune unterstützt verschiedene Methoden für die Überwachung von Leistung und Nutzung:
+ **Cluster-Status** – Prüfen des Zustands der Graphdatenbank-Engine eines Neptune-Clusters. Weitere Informationen finden Sie unter [Prüfen des Zustands einer Neptune-Instance](access-graph-status.md).
+ **Amazon CloudWatch** — Neptune sendet automatisch Messwerte an Alarme CloudWatch und unterstützt CloudWatch diese auch. Weitere Informationen finden Sie unter [Überwachung von Neptune mit Amazon CloudWatch](cloudwatch.md).
+ **Audit-Protokolldateien** – Sie können Datenbankprotokolldateien über die Neptune-Konsole anzeigen, herunterladen oder beobachten. Weitere Informationen finden Sie unter [Verwenden von Prüfprotokollen mit Amazon-Neptune-Clustern](auditing.md).
+ **Protokolle in Amazon CloudWatch Logs** veröffentlichen — Sie können einen Neptune-DB-Cluster so konfigurieren, dass Audit-Protokolldaten in einer Protokollgruppe in Amazon CloudWatch Logs veröffentlicht werden. Mit CloudWatch Logs können Sie die Protokolldaten in Echtzeit analysieren, Alarme erstellen und Metriken anzeigen und CloudWatch Logs verwenden, um Ihre Protokolldatensätze auf einem äußerst dauerhaften Speicher zu speichern. CloudWatch Weitere Informationen finden Sie unter [Neptun-Logs CloudWatch ](cloudwatch-logs.md).
+ **AWS CloudTrail**— Neptune unterstützt die API-Protokollierung mithilfe von. CloudTrail Weitere Informationen finden Sie unter [Protokollieren Amazon Neptune Neptune-API-Aufrufen mit AWS CloudTrail](cloudtrail.md).
+ **Tagging** – Sie können Tags verwenden, um Ihren Neptune-Ressourcen Metadaten hinzuzufügen und die Nutzung mit Tags nachzuverfolgen. Weitere Informationen finden Sie unter [Taggen von Amazon Neptune Neptune-Ressourcen](tagging.md).
# Amazon Neptune- und Schnittstellen-VPC-Endpunkte ()AWS PrivateLink
Sie können [AWS PrivateLink](https://aws.amazon.com/privatelink/)es verwenden, um eine private Verbindung zwischen Ihrer VPC und den Amazon Neptune API-Endpunkten herzustellen. Sie können auf Amazon Neptune API-Operationen zugreifen, als ob sie sich in Ihrer VPC befinden würden, ohne ein Internet-Gateway, ein NAT-Gerät, eine VPN-Verbindung oder eine Verbindung verwenden zu müssen. Der Verkehr zwischen Ihrer VPC und Amazon Neptune verbleibt im Amazon-Netzwerk.
Amazon Neptune teilt die API-Infrastruktur mit Amazon Relational Database Service. *Um VPC-Schnittstellen-Endpunkte für Amazon Neptune einzurichten, folgen Sie den Anweisungen in [Amazon RDS-API und Schnittstellen-VPC-Endpunkten (AWS PrivateLink)](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/vpc-interface-endpoints.html) im Amazon Aurora Aurora-Benutzerhandbuch.*
# Überlegungen zur Einhaltung von Vorschriften für Amazon Neptune
Informationen darüber, ob ein in den Geltungsbereich bestimmter Compliance-Programme AWS-Service fällt, finden Sie unter AWS-Services Umfang nach Compliance-Programm unter [Umfang nach Compliance-Programm](https://aws.amazon.com/compliance/services-in-scope/)AWS-Services . Wählen Sie aus, an dem Sie interessiert sind. Allgemeine Informationen finden Sie unter [AWS Compliance-Programme AWS](https://aws.amazon.com/compliance/programs/) .
Sie können Prüfberichte von Drittanbietern unter herunterladen AWS Artifact. Weitere Informationen finden Sie unter [Berichte herunterladen unter ](https://docs.aws.amazon.com/artifact/latest/ug/downloading-documents.html).
Ihre Verantwortung für die Einhaltung der Vorschriften bei der Nutzung AWS-Services hängt von der Vertraulichkeit Ihrer Daten, den Compliance-Zielen Ihres Unternehmens und den geltenden Gesetzen und Vorschriften ab. Weitere Informationen zu Ihrer Verantwortung für die Einhaltung der Vorschriften bei der Nutzung AWS-Services finden Sie in der [AWS Sicherheitsdokumentation](https://docs.aws.amazon.com/security/).
# Aufbau robuster und katastrophentoleranter Amazon Neptune Neptune-Bereitstellungen
Die AWS globale Infrastruktur basiert auf Regionen und Availability Zones. AWS AWS Regionen bieten mehrere physisch getrennte und isolierte Availability Zones, die über Netzwerke mit niedriger Latenz, hohem Durchsatz und hoher Redundanz miteinander verbunden sind. Mithilfe von Availability Zones können Sie Anwendungen und Datenbanken erstellen und ausführen, die automatisch Failover zwischen Availability Zones ausführen, ohne dass es zu Unterbrechungen kommt. Availability Zones sind besser hoch verfügbar, fehlertoleranter und skalierbarer als herkömmliche Infrastrukturen mit einem oder mehreren Rechenzentren.
Ein Amazon–Neptune-DB-Cluster kann nur in einer Amazon VPC erstellt werden, die mindestens zwei Subnetze in mindestens zwei Availability Zones besitzt. Mit der Verteilung Ihrer Cluster-Instances über mindestens zwei Availability Zones trägt Neptune dazu bei, dass im DB-Cluster auch bei einem unwahrscheinlichen Availability-Zone-Ausfall Instances verfügbar sind. Das Cluster-Volume für den Neptune-DB-Cluster umfasst stets drei Availability Zones, um dauerhaften Speicherplatz mit einem geringeren Datenverlustrisiko bereitzustellen.
Weitere Informationen zu AWS Regionen und Availability Zones finden Sie unter [AWS Globale](https://aws.amazon.com/about-aws/global-infrastructure/) Infrastruktur.