Erste Schritte mit Oracle NoSQL Database Cloud Service

Oracle NoSQL Database Cloud Service ist ein vollständig verwalteter Datenbank-Cloudservice, der für Datenbankvorgänge konzipiert ist, die vorhersehbare Antworten mit eine Latenz im einstellbaren Millisekundenbereich auf einfache Abfragen erfordern.

Mit NoSQL Database Cloud Service können Entwickler sich ganz auf die Anwendungsentwicklung konzentrieren, anstatt Clusterserver einzurichten oder Systemüberwachung, -optimierung, -diagnose und -skalierung durchzuführen. NoSQL Database Cloud Service eignet sich für Anwendungen wie Internet der Dinge (Internet of Things), Personalisierung des Benutzererlebnisses, sofortige Betrugserkennung und Onlineanzeige der Werbung.

Nachdem Sie sich mit Ihrem Oracle Cloud-Account authentifiziert haben, können Sie eine NoSQL-Tabelle erstellen und Durchsatz- und Speicheranforderungen für die Tabelle angeben. Oracle reserviert und verwaltet die Ressourcen, um Ihre Anforderungen zu erfüllen, und stellt per Provisioning die erforderliche Kapazität für Sie bereit. Die Kapazität wird mit Lese- und Schreibeinheiten für den Durchsatz und GB für die Speichereinheiten angegeben.

Dieser Artikel enthält die folgenden Themen:

Quicklinks

Sie können mit Oracle NoSQL Database Service über einen der folgenden Quicklinks beginnen:

Tabelle - Quicklinks


Erste Schritte - Schnellstart: Erste Schritte - Wichtige Features - Cloud-Konzepte - Preise	Verbinden - Zugangsdaten anfordern - Authentifizierung für Verbindung mit NDCS - Anwendung mit NDCS verbinden - Datenregionen und zugehörige Serviceendpunkte	IDE and SDKs - Using IntelliJ Plugin for Development - Using Visual Studio Code Extension for Development - Oracle NoSQL Java SDK - Oracle NoSQL Python SDK - Oracle NoSQL GO SDK - Oracle NoSQL Node.js SDK - Oracle NoSQL Dotnet SDK - Oracle NoSQL Rust SDK
Tabellen erstellen - Tabelle entwerfen - Singleton-Tabellen mit der Konsole erstellen - Singleton-Tabellen mit APIs erstellen - Globale aktive Tabellen - Globale aktive Tabellen mit der Konsole erstellen - Globale aktive Tabellen mit APIs erstellen - Tabelle mit OCI cli erstellen	Daten einfügen und explorieren - Daten mit der Konsole hinzufügen - Daten mit APIs hinzufügen - Daten mit der Konsole abrufen - Daten mit der Get-API abrufen - Daten mit der Abfrage-API abrufen - Über-/untergeordnete Tabellen abfragen	Tabellen verwalten - Singleton-Tabellen mit APIs ändern - Globale aktive Tabellen mit APIs ändern - Tabellen und Indizes löschen - Tabellen und Indizes mit der Konsole verwalten
Sicherheit verwalten - Benutzergruppen und Policys einrichten - Anderen Benutzern die Berechtigung zum Verwalten von NoSQL-Tabellen erteilen - Policy-Referenz	Service überwachen - Serviceereignisse - Servicequotas - Metriken - Alarme erstellen und verwalten	Utilitys - Oracle NoSQL Database Cloud-Simulator herunterladen - Entwicklung im Oracle NoSQL Database Cloud-Simulator - Oracle NoSQL Database-Migrator verwenden - Oracle NoSQL Database Analytics Integrator verwenden
SQL-Referenz - Operatoren in SQL verwenden - Gruppierung sortieren und Daten einschränken - Primäre Ausdrücke in SQL verwenden - Timestamp-Funktionen in Abfragen verwenden - Zeichenfolgenfunktionen in Abfragen verwenden	Referenzhandbücher - Analytics Integrator-Referenz - Beispielanwendungsfälle für NDCS - Probleme mit GAT beheben

Service einrichten

Wenn Sie Oracle NoSQL Database Cloud Service zum ersten Mal einrichten, befolgen Sie diese Aufgaben als Richtlinie.

Aufgabe	Referenz	Zugehörige Informationen
Eine Bestellung für Oracle NoSQL Database Cloud Service aufgeben, oder sich für die kostenlose Oracle-Testversion registrieren.	Für Oracle Cloud Infrastructure registrieren in der Oracle Cloud Infrastructure-Dokumentation.	Informationen zur Schätzung der monatlichen Kosten für Ihr Oracle NoSQL Database Cloud Service-Abonnement finden Sie unter Monatliche Kosten schätzen. Informationen zum Upgrade Ihres kostenlosen Accounts oder zum Ändern Ihrer Zahlungsmethode finden Sie unter Zahlungsmethode ändern in der Oracle Cloud Infrastructure-Dokumentation.
Oracle Cloud-Account aktivieren und zum ersten Mal anmelden.	In der Konsole anmelden in derOracle Cloud Infrastructure-Dokumentation.	Informationen zur Oracle Cloud Infrastructure-Konsole finden Sie unter Konsole verwenden in der Oracle Cloud Infrastructure-Dokumentation.
(Empfohlen) Compartment für Ihren Service erstellen.	Compartment erstellen	Wenn Sie mit Compartments nicht vertraut sind, finden Sie weitere Informationen unter Compartments in der Oracle Cloud Infrastructure-Dokumentation.
Sicherheit für Ihren Service verwalten.	Oracle NoSQL Database Cloud Service-Sicherheitsmodell	Informationen zu NoSQL Database Cloud Service-Sicherheitsmodell finden Sie unter Informationen zum Oracle NoSQL Database Cloud Service-Sicherheitsmodell.

Zugriff auf den Service über die Infrastructure-Konsole

Erfahren Sie, wie Sie über die Infrastructure-Konsole auf Oracle NoSQL Database Cloud Service zugreifen können.

Suchen Sie die Service-URL in der Willkommens-E-Mail, und melden Sie sich dann bei Oracle NoSQL Database Cloud Service an.
Öffnen Sie das Navigationsmenü, klicken Sie auf Datenbanken und dann auf NoSQL-Datenbank.
Wählen Sie das Compartment aus, das vom Serviceadministrator für Ihre Tabellen erstellt wurde.

Um das Hilfesymbol für die aktuelle Seite anzuzeigen, klicken Sie oben im Register auf das Hilfesymbol Hilfe-Slide-in-Menüsymbol .

Compartment erstellen

Wenn Sie sich für Oracle Cloud Infrastructure registrieren, erstellt Oracle Ihren Mandanten mit einem Root-Compartment, das all Ihre Cloud-Ressourcen enthält. Danach erstellen Sie zusätzliche Compartments innerhalb des Mandanten (Root-Compartments) und entsprechende Policys, um den Zugriff auf die Ressourcen in jedem Compartment zu kontrollieren. Bevor Sie eine Oracle NoSQL Database Cloud Service-Tabelle erstellen, empfiehlt Oracle, dass Sie das Compartment einrichten, zu dem die Tabelle gehören soll.

Sie erstellen Compartments in Oracle Cloud Infrastructure Identity and Access Management (IAM). Siehe Mandanten einrichten und Compartments verwalten in der Oracle Cloud Infrastructure-Dokumentation.

Authentifizierung für die Verbindung zu Oracle NoSQL Database

Sie benötigen einen Oracle Cloud-Account, um Ihre Anwendung mit Oracle NoSQL Database Cloud Service zu verbinden.

Wenn Sie noch keinen Oracle Cloud-Account besitzen, können Sie mit Oracle Cloud beginnen. Sie müssen sich authentifizieren, wenn Sie eine Verbindung zu Oracle NoSQL Database herstellen. Sie können mit einer der folgenden Methoden authentifiziert werden:

Authentifizierungsmethode #1: Benutzer-Principals

Hier verwenden Sie einen OCI-Benutzer und einen API-Schlüssel zur Authentifizierung. Die Zugangsdaten, die für die Verbindung Ihrer Anwendung verwendet werden, sind mit einem bestimmten Benutzer verknüpft. Wenn Sie einen Benutzer für Ihre Anwendung erstellen möchten, lesen Sie Benutzer, Gruppen und Policys mit Identity and Access Management einrichten.

Sie können Ihre Zugangsdaten für diese Authentifizierungsmethode mit einer der folgenden Methoden angeben:

Wenn Sie eine Datei auf einem lokalen Datenträger verwenden, enthält die Datei Details wie Benutzer-OCID, Mandanten-OCID, Region, Private-Key-Pfad und Fingerprint. Sie können dies verwenden, wenn Sie über ein sicheres Netzwerk arbeiten und private Schlüssel und Konfigurationen lokal in Übereinstimmung mit Ihren Sicherheitsrichtlinien speichern.
Angabe der Zugangsdaten über eine API.
Die Zugangsdaten werden irgendwo in einem Vault gespeichert.

In den Zugangsdaten enthaltene Informationen:

Tabelle - Zugangsdaten

Was ist es?	Wo finde ich es?
Mandanten-ID und Benutzer-ID (beide sind OCID)	Siehe OCID und Benutzer-OCID des Mandanten abrufen in der Oracle Cloud Infrastructure-Dokumentation.
API-Signaturschlüssel	Für den Anwendungsbenutzer muss ein API-Signaturschlüssel generiert und hochgeladen werden. Wenn dieser Schritt bereits ausgeführt wurde, können Sie ihn überspringen. Weitere Informationen finden Sie in den folgenden Ressourcen in der Oracle Cloud Infrastructure-Dokumentation: So generieren Sie einen API-Signaturschlüssel, um den Signaturschlüssel mit einer optionalen Passphrase zu generieren. Public Key hochladen: So laden Sie den API-Signaturschlüssel in den Benutzeraccount hoch.
Fingerprint für den Signaturschlüssel und (optional) Passphrase für den Signaturschlüssel	Der Fingerprint und die Passphrase des Signaturschlüssels werden beim Generieren und Hochladen des API-Signaturschlüssels erstellt. Siehe So rufen Sie den Fingerprint des Schlüssels ab in der Oracle Cloud Infrastructure-Dokumentation.

Was ist es?

Wo finde ich es?

Mandanten-ID und Benutzer-ID (beide sind OCID)

Siehe OCID und Benutzer-OCID des Mandanten abrufen in der Oracle Cloud Infrastructure-Dokumentation.

API-Signaturschlüssel

Für den Anwendungsbenutzer muss ein API-Signaturschlüssel generiert und hochgeladen werden. Wenn dieser Schritt bereits ausgeführt wurde, können Sie ihn überspringen.

Weitere Informationen finden Sie in den folgenden Ressourcen in der Oracle Cloud Infrastructure-Dokumentation:

So generieren Sie einen API-Signaturschlüssel, um den Signaturschlüssel mit einer optionalen Passphrase zu generieren.
Public Key hochladen: So laden Sie den API-Signaturschlüssel in den Benutzeraccount hoch.

Fingerprint für den Signaturschlüssel und (optional) Passphrase für den Signaturschlüssel

Der Fingerprint und die Passphrase des Signaturschlüssels werden beim Generieren und Hochladen des API-Signaturschlüssels erstellt. Siehe So rufen Sie den Fingerprint des Schlüssels ab in der Oracle Cloud Infrastructure-Dokumentation.

Hinweis: Notieren Sie sich den Speicherort Ihres Private Keys, der optionalen Passphrase und des Fingerprints des Public Keys beim Generieren und Hochladen des API-Signaturschlüssels.

Nachdem Sie die oben beschriebenen Aufgaben ausgeführt haben, erfassen Sie die Zugangsdaten, und geben Sie sie für Ihre Anwendung an.

Zugangsdaten für Ihre Anwendung angeben:

Mit den Oracle NoSQL Database-SDKs können Sie die Zugangsdaten für eine Anwendung auf mehrere Arten angeben. Die SDKs unterstützen eine Konfigurationsdatei sowie eine oder mehrere Schnittstellen, die eine direkte Spezifikation der Informationen ermöglichen. In der Dokumentation für den verwendeten Programmiersprachentreiber finden Sie Informationen zu den spezifischen Zugangsdatenschnittstellen.

Wenn Sie eine Konfigurationsdatei verwenden, lautet der Standardspeicherort ~/.oci/config. Mit den SDKs kann die Datei an alternativen Speicherorten gespeichert werden. Der Inhalt sieht wie folgt aus:

[DEFAULT]
user=ocid1.user.oc1..aaaaaaaas...7ap
fingerprint=d1:b2:32:53:d3:5f:cf:68:2d:6f:8b:5f:77:8f:07:13
key_file=~/.oci/oci_api_key_private.pem
tenancy=ocid1.tenancy.oc1..aaaaaaaap...keq
pass_phrase=mysecretphrase

Die Zeile [DEFAULT] gibt an, dass die nachfolgenden Zeilen das Profil DEFAULT spezifizieren. Eine Konfigurationsdatei kann mehrere Profile mit dem Präfix [PROFILE_NAME] enthalten. Beispiel:

[DEFAULT]
user=ocid1.user.oc1..aaaaaaaas...7us
fingerprint=d1:b2:32:53:d3:5f:cf:68:2d:6f:8b:5f:77:8f:07:15
key_file=~/.oci/oci_api_key_private.pem
tenancy=ocid1.tenancy.oc1..aaaaabbap...keq
pass_phrase=mysecretphrase

[MYPROFILE]
user=ocid1.user.oc1..aaaaaaaas...7ap
fingerprint=d1:b2:32:53:d3:5f:cf:68:2d:6f:8b:5f:77:8f:07:13
key_file=~/.oci/oci_api_key_private.pem
tenancy=ocid1.tenancy.oc1..aaaaaaaap...keq
pass_phrase=mysecretphrase

Authentifizierungsmethode #2: Instanz-Principals

Instanz-Principals ist eine Funktion in Oracle Cloud Infrastructure Identity and Access Management (IAM), mit der Sie Serviceaufrufe von einer Instanz ausführen können. Bei Instanz-Principals müssen Sie keine Benutzerzugangsdaten für die auf Ihren Compute-Instanzen ausgeführten Services konfigurieren oder die Zugangsdaten rotieren. Instanzen selbst sind jetzt ein Principal-Typ in IAM. Jede Compute-Instanz hat eine eigene Identität und authentifiziert sie mit Zertifikaten, die der Instanz hinzugefügt werden. Diese Zertifikate werden automatisch erstellt, Instanzen zugewiesen und rotiert.

Mit der Instanz-Principals-Authentifizierung können Sie eine Instanz dazu autorisieren, API-Aufrufe bei Oracle Cloud Infrastructure-Services auszuführen. Wenn die erforderlichen Ressourcen und Policys eingerichtet wurden, kann eine auf einer Instanz ausgeführte Anwendung öffentliche Oracle Cloud Infrastructure-Services aufrufen. Sie müssen hierzu keine Benutzerzugangsdaten oder Konfigurationsdateien konfigurieren. Die Instanz-Principal-Authentifizierung kann von einer Instanz aus verwendet werden, in welcher Sie keine Konfigurationsdatei speichern möchten.

Authentifizierungsmethode #3: Resource Principals

Mit einem Resource Principal können Sie Oracle Cloud Infrastructure-Ressourcen authentifizieren und darauf zugreifen. Der Resource Principal besteht aus einem temporären Sessiontoken und sicheren Zugangsdaten, mit denen sich andere Oracle Cloud-Services bei Oracle NoSQL Database authentifizieren können. Die Resource-Principal-Authentifizierung ähnelt der Instanz-Principal-Authentifizierung, ist jedoch für Ressourcen bestimmt, die keine Instanzen sind, wie serverlose Funktionen.

Mit einem Resource Principal können Ressourcen autorisiert werden, Aktionen in Oracle Cloud Infrastructure-Services auszuführen. Jede Ressource hat ihre eigene Identität und authentifiziert die Zertifikate, die ihr hinzugefügt werden. Diese Zertifikate werden automatisch erstellt, Ressourcen zugewiesen und rotiert, sodass Sie keine eigenen Zugangsdaten für den Zugriff auf die Ressource erstellen und verwalten müssen. Wenn Sie sich mit einem Resource Principal authentifizieren, müssen Sie keine Zugangsdaten erstellen und verwalten, um auf Oracle Cloud Infrastructure-Ressourcen zuzugreifen.

Nach der Authentifizierung müssen Sie für den Zugriff auf die Oracle Cloud Infrastructure-Ressourcen autorisiert sein. Weitere Informationen finden Sie unter Benutzer, Gruppen und Policys mit Identity and Access Management einrichten.

Authentifizierungsmethode #4: Tokenbasierte Authentifizierung

Mit der tokenbasierten Authentifizierung können Sie ein temporäres Sessiontoken erstellen und verwenden, um Oracle Cloud Infrastructure-Ressourcen zu authentifizieren und darauf zuzugreifen. Mit der tokenbasierten Authentifizierung erstellen Sie eine lokale Konfigurationsdatei, die Informationen wie Benutzer-OCID, Mandanten-OCID, Region, Private-Key-Pfad und einen temporären Sessiontokendateipfad enthält. Diese Methode verwendet diese Informationen zusammen mit dem temporären Sessiontoken, das (standardmäßig) nach einer Stunde abläuft. Die auf Sessiontoken basierende Authentifizierung kann verwendet werden, wenn Sie eine schnelle, temporäre Authentifizierung benötigen.

Sessiontoken erstellen: Sie können ein Sessiontoken mit oder ohne Webbrowser generieren.

Mit einem Browser:

So verwenden Sie die tokenbasierte Authentifizierung für die CLI auf einem Rechner mit einem Webbrowser:

Führen sie im Terminal den folgenden Befehl aus:
```
oci session authenticate
```
Region auswählen.
Geben Sie Ihre Benutzerzugangsdaten im Browser ein.
Schließen Sie nach erfolgreicher Authentifizierung den Browser, und folgen Sie der interaktiven Eingabeaufforderung auf dem Terminal. Sie müssen den Namen des Profils angeben, das Sie in der Konfigurationsdatei erstellen möchten. Die neue Profilkonfiguration wird in die Datei ~/.oci/config geschrieben. Im Folgenden finden Sie ein Beispiel für die Konfigurationsdatei, in der das neue Profil (z.B. TEST) aktualisiert wird.
```
[TEST]
user=<ocid1.user.oc1.........>
fingerprint=<XX:XX:...........>
key_file=<C:\Users\XXXXXX\.oci\oci_api_key_private.pem>
tenancy=<ocid1.tenancy.oc1.....>
region=us-ashburn-1
security_token_file=<C:\Users\XXXXXX\.oci\sessions\TEST\token>
```

Ohne Browser:

Um die tokenbasierte Authentifizierung für die CLI ohne Webbrowser zu verwenden, müssen Sie sich zunächst mit der API-schlüsselbasierten Authentifizierung authentifizieren.

oci setup config

Mit diesem Befehl werden Sie zur Eingabe der Informationen aufgefordert, die zum Erstellen der Konfigurationsdatei und der öffentlichen und privaten API-Schlüssel erforderlich sind. Im Setupdialogfeld werden diese Informationen verwendet, um ein API-Schlüsselpaar zu generieren und die Konfigurationsdatei zu erstellen. Um die tokenbasierte Authentifizierung für die CLI ohne Webbrowser zu verwenden, führen Sie den folgenden Befehl aus:

oci session authenticate --no-browser

Sie müssen den Namen des Profils angeben, das Sie in der Konfigurationsdatei erstellen möchten. Die neue Profilkonfiguration wird in die Datei ~/.oci/config geschrieben. Im Folgenden finden Sie ein Beispiel für die Konfigurationsdatei, in der das neue Profil (z.B. TEST) aktualisiert wird.

[TEST]
user=<ocid1.user.oc1.........>
fingerprint=<XX:XX:...........>
key_file=<full_directory_path_oci_api_key_private.pem>
tenancy=<ocid1.tenancy.oc1.....>
region=us-ashburn-1
security_token_file=<full_directory_path_token>

Authentifizierungsmethode Nr. 5: Identitätsbasierte Authentifizierung für OKE-Workload

Die Oracle Container Engine for Kubernetes (OKE) Workload Identity bietet eine feingranulierte Identitäts- und Zugriffsmanagementkontrolle. Eine Workload ist eine Anwendung, die auf Kubernetes ausgeführt wird. Es kann aus einer einzelnen Komponente oder mehreren Komponenten bestehen, die in einem Satz von Pods zusammenarbeiten. Eine Workload-Ressource wird durch die eindeutige Kombination aus Cluster, Namespace und Serviceaccount identifiziert. Diese eindeutige Kombination wird als Workload-Identität bezeichnet. Mit der OKE-Workload-Identität können Sie K8s-Pods Policy-gesteuerten Zugriff auf Oracle Cloud Infrastructure-(OCI-)Ressourcen mit OCI Identity and Access Management (IAM) erteilen.

Mit Workload Identity müssen Sie Zugangsdaten nicht mehr als Geheimnisse in Ihrem Kubernetes-Cluster speichern oder sich auf dynamische OCI-Gruppen verlassen, um Policy-gesteuerten Zugriff auf OCI-Ressourcen für Worker-Knoten und insbesondere den Zugriff auf Ihre NoSQL-Tabellen zu ermöglichen. Wenn Anwendungen Zugriff auf OCI-Ressourcen benötigen, können Sie mit Workload Identity OCI-IAM-Policys für den Kubernetes-Serviceaccount schreiben, der mit Anwendungspods verknüpft ist. Mit diesem Feature können die in diesen Pods ausgeführten Anwendungen basierend auf den Berechtigungen, die von den Policys bereitgestellt werden, direkt auf die OCI-API zugreifen.

So erteilen Sie allen Pods in einer Workload Zugriff auf eine beliebige OCI-Ressource:

Erstellen Sie einen Namespace für einen Serviceaccount.
Erstellen Sie einen Serviceaccount für die zu verwendende Anwendung.
Definieren Sie eine IAM-Policy, um der Workload-Ressource Zugriff auf andere OCI-Ressourcen zu erteilen.
Laden Sie das entsprechende SDK für die Sprache herunter, in der die Anwendung geschrieben wird, und konfigurieren Sie es.
Bearbeiten Sie die Anwendung, um Folgendes anzugeben:
- dass Workload-Anforderungen mit dem Identitätsprovider der Kubernetes Engine authentifiziert werden müssen
- die OCI-Ressourcen, auf die zugegriffen werden soll
Aktualisieren Sie die Deployment-Spezifikation der Anwendung, um anzugeben, dass jeder Pod in der Workload den Serviceaccount verwenden soll.

Autorisierung, damit die Workload auf die erforderlichen OCI-Ressourcen zugreifen kann:

Klicken Sie in der OCI-Konsole auf Identität & Sicherheit, und öffnen Sie das Navigationsmenü. Klicken Sie unter "Identität" auf Policys.
Klicken Sie auf Policy erstellen, und geben Sie der Policy einen Namen.

Geben Sie eine Policy-Anweisung ein, damit die Workload auf die erforderlichen OCI-Ressourcen zugreifen kann. Verwenden Sie dazu das folgende Format:

Allow any-user to <verb> <resource> in <location> where all
{
request.principal.type = 'workload',
request.principal.namespace = '<namespace-name>',
request.principal.service_account = '<service-account-name>',
request.principal.cluster_id = '<cluster-ocid>'
}

Hierbei gilt:

<namespace-name> ist der Name des Namespace, den Sie zuvor erstellt haben.
<service-account-name> ist der Name des Serviceaccounts, den Sie zuvor erstellt haben.
<cluster-OCID> ist die OCID des Clusters, die Sie zuvor erhalten haben.

Klicken Sie auf Erstellen, um die neue Policy zu erstellen.

Anwendung mit NDCS verbinden

Erfahren Sie, wie Sie Ihre Anwendung mit dem Oracle NoSQL Database Cloud Service verbinden.

Ihre Anwendung stellt eine Verbindung zu Oracle NoSQL Database Cloud Service her, nachdem sie mit einer der vielen verfügbaren Methoden authentifiziert wurde.

Sie können sich mit einer der folgenden Methoden authentifizieren:

API-Signaturschlüssel
- Von jedem SDK-Programm (Java, Python, C#, GO, Node.js, Rust) direkt hartcodiert
- Eine Konfigurationsdatei mit einem Standardprofil
- Eine Konfigurationsdatei mit einem nicht standardmäßigen Profil
Instanz-Principals mit Authentifizierungstoken
Ressourcen-Principals
Session-Token
OKE Workload-Identität

Weitere Informationen zu den Authentifizierungsoptionen finden Sie unter Authentifizierung für die Verbindung zu Oracle NoSQL Database.

Sie können mit einer der folgenden Methoden eine Verbindung zu NDCS herstellen:

Direkte Angabe von Anmeldeinformationen im Code:

/* Use the SignatureProvider to supply your credentials to NoSQL Database.
 * By default, the SignatureProvider will read your OCI configuration file
 * from the default location, ~/.oci/config. See SignatureProvider for
 * additional options for reading configurations in other ways.
 */

SignatureProvider sp = new SignatureProvider(
 tenantId,     // a string, OCID
 userId,       // a string, OCID
 fingerprint , // a string
 privateKey,   // a string, content of private key
 passPhrase    // optional, char[]
);
//Create an handle to access the cloud service in your service region.
NoSQLHandleConfig config = new NoSQLHandleConfig(Region.<your-service-region>);
config.setAuthorizationProvider(sp);
NoSQLHandle handle = NoSQLHandleFactory.createNoSQLHandle(config);

//At this point, your handle is set up to perform data operations.

Verbindung mit der Standardkonfigurationsdatei mit einem Standardprofil herstellen:

/* Use the SignatureProvider to supply your credentials to NoSQL Database.
 * By default, the SignatureProvider will read your OCI configuration file
 * from the default location, ~/.oci/config. See SignatureProvider for
 * additional options for reading configurations in other ways.
 */

SignatureProvider sp = new SignatureProvider();

Verbindung mit der Standardkonfigurationsdatei mit einem nicht standardmäßigen Profil wird hergestellt:

/* Use the SignatureProvider to supply your credentials to NoSQL Database.
 * Specify the name of the non-default profile in the constructor for SignatureProvider. */

 final String profile_name = "<name_of_the_profile>";
 SignatureProvider sp = new  SignatureProvider(profile_name);

Verbindung mit der angegebenen Konfigurationsdatei und dem angegebenen Profil herstellen:

/* Use the SignatureProvider to supply your credentials to NoSQL Database.
 * You specify the full path of the non-default config file and also the name
 * of the profile
 */

final String config_filepath = "<full_path_of_config_file>";
final String profile_name = "<name_of_the_profile>";
SignatureProvider sp = new SignatureProvider(config_filepath, profile_name);

Verbindung mit einem Instance Principal herstellen:

Instanz-Principal ist ein IAM-Servicefeature, mit dem Instanzen als autorisierte Akteure (oder Principals) Aktionen an Serviceressource ausführen können. Jede Compute-Instanz hat eine eigene Identität und authentifiziert die Zertifikate, die ihr hinzugefügt werden.
```
SignatureProvider authProvider = SignatureProvider.createWithInstancePrincipal();
```
Verbindung mit einem Resource Principal herstellen:

Resource Principal ist ein IAM-Servicefeature, mit dem die Ressourcen als autorisierte Akteure (oder Principals) Aktionen für Serviceressourcen ausführen können.
```
SignatureProvider authProvider = SignatureProvider.createWithResourcePrincipal();
```
Verbindung mit Session-Token wird hergestellt:

Mit der Methode createWithSessionToken() können Sie einen SignatureProvider mit einem temporären Sessiontoken erstellen, das aus einer Tokendatei gelesen wird. Der Pfad der Tokendatei wird aus dem Standardprofil in der Konfigurationsdatei am Standardspeicherort gelesen. Die verwendete Konfigurationsdatei ist ~/.oci/config.
```
SignatureProvider authProvider =
SignatureProvider.createWithSessionToken();
```
Sie können den Pfad der Tokendatei auch im nicht standardmäßigen Profil in der Konfigurationsdatei angeben, wie unten gezeigt. Der Pfad der Tokendatei wird aus dem angegebenen Profil in der Konfigurationsdatei am Standardspeicherort gelesen.
```
SignatureProvider authProvider =
SignatureProvider.createWithSessionToken(<profile_name>);
```
Verbindung mit OKE Workload Identity herstellen:

Sie können einen SignatureProvider mit der Workload-Identität von Container Engine for Kubernetes (OKE) mit dem Kubernetes-Serviceaccounttoken im Standardpfad /var/run/secrets/kubernetes.io/serviceaccount/token erstellen. Dieser Provider kann nur in Kubernetes-Pods verwendet werden.
```
SignatureProvider authProvider =
SignatureProvider.createWithOkeWorkloadIdentity();
```
Sie können auch das spezifische Kubernetes-Serviceaccounttoken angeben, das wie unten dargestellt verwendet werden soll.
```
SignatureProvider authProvider =
SignatureProvider.createWithOkeWorkloadIdentity(<serviceAccountToken>);
```
Alternativ können Sie auch den Speicherort des spezifischen Kubernetes-Serviceaccounttokens angeben, das wie unten dargestellt verwendet werden soll.
```
SignatureProvider authProvider =
SignatureProvider.createWithOkeWorkloadIdentity(<serviceAccountToken_location>);
```

Weitere Informationen zu den verwendeten Java-Klassen finden Sie unter SignatureProvider.

Sie können mit einer der folgenden Methoden eine Verbindung zu NDCS herstellen:

Direkte Angabe von Anmeldeinformationen im Code:

from borneo.iam import SignatureProvider
#
# Use SignatureProvider directly via API. Note that the
# private_key argument can either point to a key file or be the
# string content of the private key itself.
#
at_provider = SignatureProvider(tenant_id='ocid1.tenancy.oc1..tenancy',
                                user_id='ocid1.user.oc1..user',
                                private_key=key_file_or_key,
                                fingerprint='fingerprint',
                                pass_phrase='mypassphrase')

Verbindung mit der Standardkonfigurationsdatei mit einem Standardprofil herstellen:

from borneo.iam import SignatureProvider
#
# Use SignatureProvider with a default credentials file and
# profile in $HOME/.oci/config
#
at_provider = SignatureProvider()

Verbindung mit der angegebenen Konfigurationsdatei mit einem nicht standardmäßigen Profil wird hergestellt:

from borneo.iam import SignatureProvider
#
# Use SignatureProvider with a non-default credentials file and profile
#
at_provider = SignatureProvider(config_file='myconfigfile',
                                profile_name='myprofile')

Mit einem Instanz-Principal anmelden:

Instanz-Principal ist ein IAM-Servicefeature, mit dem Instanzen als autorisierte Akteure (oder Principals) Aktionen an Serviceressource ausführen können. Jede Compute-Instanz hat eine eigene Identität und authentifiziert die Zertifikate, die ihr hinzugefügt werden.
```
at_provider =
SignatureProvider.create_with_instance_principal(region=my_region)
```
Verbindung mit einem Resource Principal herstellen:

Resource Principal ist ein IAM-Servicefeature, mit dem die Ressourcen als autorisierte Akteure (oder Principals) Aktionen für Serviceressourcen ausführen können.
```
at_provider = SignatureProvider.create_with_resource_principal()
```

Verbindung mit Session-Token wird hergestellt:

Borneo verwendet das OCI-SDK zur Authentifizierung mit Sessiontoken. Der OCI-Unterzeichner wird wie unten dargestellt als Parameter an den SignatureProvider-Konstruktor übergeben.

from borneo.iam import SignatureProvider
# Use SignatureProvider with a provider argument which is an instance of
# oci.auth.signers.SecurityTokenSigner
at_provider = SignatureProvider(<instance of oci.auth.signers.SecurityTokenSigner>)

Verbindung mit OKE Workload Identity herstellen:

Der OKE-Workload-Authentifizierungssignierer ist ein Signaturgeber, der einer gesamten Workload (einer Anwendung, die auf Kubernetes-Clustern ausgeführt wird) mit der OKE-Workload-Identität Zugriff auf NoSQL-Tabellen gewährt. Sie können sie über oci.auth.signers.get_oke_workload_identity_resource_principal_signer abrufen. Der abgerufene Signaturgeber kann dann bei der Initialisierung eines Clients verwendet werden.
```
from borneo.iam import SignatureProvider
oke_workload_signer = oci.auth.signers.get_oke_workload_identity_resource_principal_signer()
```
Wenn sich der Tokenpfad für einen Kubernetes-Serviceaccount vom Standardpfad unterscheidet, können Sie den Pfad wie unten dargestellt angeben:
```
token_path = "path_to_your_token_file"
oke_workload_signer  = oci.auth.signers.get_oke_workload_identity_resource_principal_signer(service_account_token_path=token_path)
at_provider = SignatureProvider(oke_workload_signer)
```
Sie können das Kubernetes-Serviceaccounttoken auch direkt übergeben, wie unten dargestellt:
```
#token_string = "your_token_string"
#oke_workload_signer = oci.auth.signers.get_oke_workload_identity_resource_principal_signer(service_account_token=token_string)
at_provider = SignatureProvider(oke_workload_signer)
```

Sie können Ihre Anwendung mit einer der folgenden Methoden mit NDCS verbinden:

Direkte Angabe von Anmeldeinformationen im Code:

privateKeyFile := "/path/to/privateKeyFile"
passphrase := "examplepassphrase"
sp, err := iam.NewRawSignatureProvider("ocid1.tenancy.oc1..tenancy",
                                       "ocid1.user.oc1..user",
                                       "<your-service-region>",
                                       "fingerprint",
                                       "compartmentID",
                                       privateKeyFile ,
                                       &passphrase )
if err != nil {
    return
}
cfg := nosqldb.Config{
    AuthorizationProvider: sp,
    // This is only required if the "region" property is not
    //specified in the config file.
    Region: "<your-service-region>",
}

Verbindung mit der Standardkonfigurationsdatei mit einem Standardprofil herstellen:

cfg := nosqldb.Config{
// This is only required if the "region" property is not
//specified in ~/.oci/config.
// This takes precedence over the "region" property when both are specified.
    Region: "<your-service-region>",
}
client, err := nosqldb.NewClient(cfg)

Verbindung mit der angegebenen Konfigurationsdatei mit einem nicht standardmäßigen Profil wird hergestellt:

sp, err := iam.NewSignatureProviderFromFile("your_config_file_path",
           "your_profile_name", "", "compartment_id")
if err != nil {
    return
}
cfg := nosqldb.Config{
    AuthorizationProvider: sp,
    // This is only required if the "region" property is not specified in the config file.
    Region: "us-ashburn-1",
}
client, err := nosqldb.NewClient(cfg)

Mit einem Instanz-Principal anmelden:

Instanz-Principal ist ein IAM-Servicefeature, mit dem Instanzen als autorisierte Akteure (oder Principals) Aktionen an Serviceressource ausführen können. Jede Compute-Instanz hat eine eigene Identität und authentifiziert die Zertifikate, die ihr hinzugefügt werden.
```
sp, err := iam.NewSignatureProviderWithInstancePrincipal("compartment_id")
if err != nil {
    return
}
cfg := nosqldb.Config{
    AuthorizationProvider: sp,
    Region: "<your-service-region>",
}
client, err := nosqldb.NewClient(cfg)
```

Verbindung mit einem Resource Principal herstellen:

Resource Principal ist ein IAM-Servicefeature, mit dem die Ressourcen als autorisierte Akteure (oder Principals) Aktionen für Serviceressourcen ausführen können.

sp, err := iam.NewSignatureProviderWithResourcePrincipal("compartment_id")
if err != nil {
    return
}
cfg := nosqldb.Config{
    AuthorizationProvider: sp,
    Region: "<your-service-region>",
}
client, err := nosqldb.NewClient(cfg)

Verbindung mit Session-Token wird hergestellt:

Die Funktion NewSessionTokenSignatureProvider erstellt eine SignatureProvider mit einem temporären Sessiontoken, das aus einer Tokendatei gelesen wird.
```
func NewSessionTokenSignatureProvider() (*SignatureProvider, error)
```
Die verwendete Konfigurationsdatei ist ~/.oci/config. Das Profil DEFAULT wird verwendet. Der Pfad der Tokendatei wird mit dem Wert des Feldes security_token_file aus der Konfiguration gelesen. Wenn Sie diesen Konstruktor verwenden, verfügt der Benutzer über ein Standard-Compartment für alle Tabellen. Es handelt sich um das Root Compartment des Mandanten des Benutzers.

Um eine nicht standardmäßige Konfigurationsdatei (mit Ausnahme von ~/.oci/config) zu verwenden, können Sie die Funktion NewSessionTokenSignatureProviderFromFile verwenden.
```
func NewSessionTokenSignatureProviderFromFile(configFilePath,
ociProfile, privateKeyPassphrase string) (*SignatureProvider, error)
```
Diese Funktion erstellt eine SignatureProvider mit einem temporären Sessiontoken, das aus einer Tokendatei gelesen wird. Verwenden Sie dazu die ociProfile, die in der OCI-Konfigurationsdatei configFilePath angegeben ist. Der Pfad der Tokendatei wird mit dem Wert des Feldes security_token_file aus der Konfiguration gelesen. Das Feld privateKeyPassphrase ist nur erforderlich, wenn der Private Key eine Passphrase verwendet und nicht im Feld pass_phrase in der OCI-Konfigurationsdatei angegeben ist. Wenn Sie diesen Konstruktor verwenden, verfügt der Benutzer über ein Standard-Compartment für alle Tabellen. Es handelt sich um das Root Compartment des Mandanten des Benutzers.

Verbindung mit OKE Workload Identity herstellen:

Das Oracle NoSQL-Go-SDK unterstützt die Ausführung von Programmen innerhalb von OKE-Workload-Containern in OCI. Fügen Sie in Ihrem Code, der einen SignatureProvider zur Verwendung mit NoSQL erstellt, den folgenden Code hinzu, um die OKE-Workload-Identität zu verwenden:

conf, err := ociauth.OkeWorkloadIdentityConfigurationProvider()
if err != nil {
   return nil, fmt.Errorf("cannot create an Oke Provider: %v", err)
}
myconf := &myConfigProvider{conf}
sp, err := iam.NewSignatureProviderWithConfiguration(myconf, compartmentID)
if err != nil {
  return nil, fmt.Errorf("cannot create a Signature Provider: %v", err)
}

Sie können mit einer der folgenden Methoden eine Verbindung zu NDCS herstellen:

Direkte Angabe von Anmeldeinformationen im Code:

Sie können Zugangsdaten direkt als Teil der Eigenschaft auth.iam in der anfänglichen Konfiguration angeben. Erstellen Sie die NoSQLClient-Instanz wie folgt:

import { NoSQLClient, Region } from 'oracle-nosqldb';
let client = new NoSQLClient({
    region: <your-service-region>
    auth: {
        iam: {
            tenantId: myTenancyOCID,
            userId: myUserOCID,
            fingerprint: myPublicKeyFingerprint,
            privateKeyFile: myPrivateKeyFile,
            passphrase: myPrivateKeyPassphrase
        }
    }
});

Verbindung mit der Standardkonfigurationsdatei mit einem Standardprofil herstellen:

Sie können die Zugangsdaten in einer Oracle Cloud Infrastructure-Konfigurationsdatei speichern. Der Standardpfad für die Konfigurationsdatei ist ~/.oci/config, wobei ~ für das Home-Verzeichnis des Benutzers steht. Unter Windows ist ~ ein Wert der Umgebungsvariablen USERPROFILE. Die Datei kann mehrere Profile enthalten. Standardmäßig verwendet das SDK das Profil DEFAULT, um die Zugangsdaten zu speichern.

Um diese Standardwerte zu verwenden, erstellen Sie eine Datei namens config im Verzeichnis ~/.oci mit dem folgenden Inhalt:
```
[DEFAULT]
tenancy=<your-tenancy-ocid>
user=<your-user-ocid>
fingerprint=<fingerprint-of-your-public-key>
key_file=<path-to-your-private-key-file>
pass_phrase=<your-private-key-passphrase>
region=<your-region-identifier>
```
Beachten Sie, dass Sie auch Ihre Regions-ID zusammen mit Zugangsdaten in der OCI-Konfigurationsdatei angeben können. Der Treiber prüft standardmäßig den Speicherort oben. Wenn eine Region zusammen mit Zugangsdaten bereitgestellt wird, müssen Sie keine Erstkonfiguration angeben und können den Konstruktor ohne Argumente verwenden:
```
import { NoSQLClient, Region } from 'oracle-nosqldb';
let client = new NoSQLClient();
```
Alternativ können Sie die Region in der Konfiguration angeben:
```
import { NoSQLClient, Region } from 'oracle-nosqldb';
let client = new NoSQLClient({ region: Region.<your-service-region> });
```
Verbindung mit der angegebenen Konfigurationsdatei mit einem nicht standardmäßigen Profil wird hergestellt:

Sie können einen anderen Pfad für die OCI-Konfigurationsdatei sowie ein anderes Profil in der Konfigurationsdatei verwenden. Geben Sie diese in diesem Fall innerhalb der Eigenschaft auth.iam der Erstkonfiguration an. Beispiel: Wenn Ihr OCI-Konfigurationsdateipfad ~/myapp/.oci/config lautet und Sie Ihre Zugangsdaten unter Profil Jane speichern:

Erstellen Sie dann die NoSQLClient-Instanz wie folgt:
```
import { NoSQLClient, Region } from 'oracle-nosqldb';
let client = new NoSQLClient({
    region: Region.<your-service-region>,
    auth: {
        iam: {
            configFile: '<your_config_file>',
            profileName: '<name_of_your_profile>'
        }
    }
});
```
Mit einem Instanz-Principal anmelden:

Instanz-Principal ist ein IAM-Servicefeature, mit dem Instanzen als autorisierte Akteure (oder Principals) Aktionen an Serviceressource ausführen können. Jede Compute-Instanz hat eine eigene Identität und authentifiziert die Zertifikate, die ihr hinzugefügt werden.

Erstellen Sie nach der Einrichtung die NoSQLClient-Instanz wie folgt:
```
import { NoSQLClient, Region } from 'oracle-nosqldb';
const client = new NoSQLClient({
    region: Region.<your-service-region>,
    compartment: 'ocid1.compartment.oc1..............'
    auth: {
        iam: {
            useInstancePrincipal: true
        }
    }
});
```
Sie können auch die JSON-Konfigurationsdatei mit derselben Konfiguration wie oben beschrieben verwenden. Beachten Sie, dass Sie bei Verwendung des Instanz-Principals die Compartment-ID (OCID) als Compartment-Eigenschaft angeben müssen. Dies ist auch erforderlich, wenn Sie das Standard-Compartment verwenden möchten. Beachten Sie, dass Sie die Compartment-ID und keinen Compartment-Namen oder -Pfad verwenden müssen. Wenn Sie Instance Principal verwenden, dürfen Sie dem Tabellennamen beim Aufrufen von NoSQLClient-APIs keinen Compartment-Namen oder -Pfad voranstellen.
Verbindung mit einem Resource Principal herstellen:

Resource Principal ist ein IAM-Servicefeature, mit dem die Ressourcen als autorisierte Akteure (oder Principals) Aktionen für Serviceressourcen ausführen können.

Erstellen Sie nach der Einrichtung die NoSQLClient-Instanz wie folgt:
```
import { NoSQLClient, Region } from 'oracle-nosqldb';
const client = new NoSQLClient({
    region: Region.<your-service-region>,
    compartment: 'ocid1.compartment.oc1...........................'
    auth: {
        iam: {
            useResourcePrincipal: true
        }
    }
});
```
Sie können auch die JSON-Konfigurationsdatei mit derselben Konfiguration wie oben beschrieben verwenden. Beachten Sie, dass Sie bei Verwendung des Resource Principals die Compartment-ID (OCID) als Compartment-Eigenschaft angeben müssen. Dies ist auch erforderlich, wenn Sie das Standard-Compartment verwenden möchten. Beachten Sie, dass Sie die Compartment-ID und keinen Compartment-Namen oder -Pfad verwenden müssen. Wenn Sie Resource Principal verwenden, dürfen Sie dem Tabellennamen beim Aufrufen von NoSQLClient-APIs keinen Compartment-Namen oder -Pfad voranstellen.
Verbindung mit Session-Token wird hergestellt:

Mit der auf Sessiontoken basierenden Authentifizierung erstellen Sie eine lokale Konfigurationsdatei, die Informationen wie Benutzer-OCID, Mandanten-OCID, Region, Private-Key-Pfad und einen temporären Sessiontokendateipfad enthält.
```
import { NoSQLClient, Region } from 'oracle-nosqldb';
const client = new NoSQLClient({
    region: Region.<your-service-region>,
    compartment: 'ocid1.compartment.oc1..............
   ' auth: {
       iam: { useSessionToken: true }
  }
});
```
Diese Methode verwendet ein temporäres Sessiontoken, das aus einer Tokendatei gelesen wird. Der Pfad der Tokendatei wird aus dem Standardprofil in der OCI-Konfigurationsdatei als Wert des Feldes security_token_file gelesen.

Um eine nicht standardmäßige Konfigurationsdatei (mit Ausnahme von ~/.oci/config) zu verwenden, können Sie den Pfad der Konfigurationsdatei und den Namen des Profils wie unten dargestellt angeben.
```
import { NoSQLClient, Region } from 'oracle-nosqldb';
const client = new NoSQLClient({
  region: Region.<your-service-region>,
  compartment: 'ocid1.compartment.oc1..............
  ' auth: {
    iam: {  useSessionToken: true,
      "configFile": "<path_to_config_file>",
      "profileName": "<profile_name>"
    }
  }
});
```
Verbindung mit OKE Workload Identity herstellen:

Das Oracle NoSQL Node.js-SDK unterstützt die Ausführung von Programmen innerhalb von OKE-Workload-Containern in OCI.
```
import { NoSQLClient, Region } from 'oracle-nosqldb';
const client = new NoSQLClient({
    region: Region.<your-service-region>,
    compartment: 'ocid1.compartment.oc1...........................'
    ' auth: {
        iam: { useOKEWorkloadIdentity: true }
    }'
  }
);
```
Dieses Autorisierungsschema kann nur in Kubernetes-Pods verwendet werden. Für die Verwendung der OKE-Workload-Identität ist ein Serviceaccounttoken erforderlich. Standardmäßig lädt der Provider das Serviceaccounttoken aus dem Standarddateipfad /var/run/secrets/kubernetes.io/serviceaccount/token. Sie können dies überschreiben und Ihr Serviceaccounttoken angeben, indem Sie eine der 3 Eigenschaften angeben:
- serviceAccountToken zur Angabe einer Serviceaccount-Tokenzeichenfolge.
- serviceAccountTokenFile, um einen Pfad zur Tokendatei des Serviceaccounts anzugeben.
- serviceAccountTokenProvider, um einen benutzerdefinierten Provider zum Laden von Serviceaccounttoken bereitzustellen.

Einzelheiten zum Inhalt und Format der Datei finden Sie unter SDK-Konfigurationsdatei.

Sie können mit einer der folgenden Methoden eine Verbindung zu NDCS herstellen:

Direkte Angabe von Anmeldeinformationen im Code:

Beim Erstellen von IAMAuthorizationProvider können Sie Zugangsdaten direkt als IAMCredentials angeben. Erstellen Sie NoSQLClient wie folgt:

var client = new NoSQLClient(
    new NoSQLConfig
    {
        Region=<your-service-region>,
        AuthorizationProvider = new IAMAuthorizationProvider(
            new IAMCredentials
            {
                TenantId=myTenancyOCID,
                UserId=myUserOCID,
                Fingerprint=myPublicKeyFingerprint,
                PrivateKeyFile=myPrivateKeyFile
            })
    });

Verbindung mit der Standardkonfigurationsdatei mit einem Standardprofil herstellen:

Sie können die Zugangsdaten in einer Oracle Cloud Infrastructure-Konfigurationsdatei speichern. Der Standardpfad für die Konfigurationsdatei ist ~/.oci/config, wobei ~ für das Home-Verzeichnis des Benutzers steht. Unter Windows ist ~ ein Wert der Umgebungsvariablen USERPROFILE. Die Datei kann mehrere Profile enthalten. Standardmäßig verwendet das SDK das Profil DEFAULT zum Speichern der Zugangsdaten

Um diese Standardwerte zu verwenden, erstellen Sie eine Datei namens config im Verzeichnis ~/.oci mit dem folgenden Inhalt:
```
[DEFAULT]
tenancy=<your-tenancy-ocid>
user=<your-user-ocid>
fingerprint=<fingerprint-of-your-public-key>
key_file=<path-to-your-private-key-file>
pass_phrase=<your-private-key-passphrase>
region=<your-region-identifier>
```
Beachten Sie, dass Sie auch Ihre Regions-ID zusammen mit Zugangsdaten in der OCI-Konfigurationsdatei angeben können. Standardmäßig sucht der Treiber nach Zugangsdaten und einer Region in der OCI-Konfigurationsdatei im Standardpfad und im Standardprofil. Wenn Sie also die Region zusammen mit den oben gezeigten Zugangsdaten angeben, können Sie eine NoSQLClient-Instanz erstellen, ohne eine Konfiguration zu übergeben:
```
var client = new NoSQLClient();
```
Alternativ können Sie die Region (sowie andere Eigenschaften) in NoSQLConfig angeben:
```
var client = new NoSQLClient(
    new NoSQLConfig(
    {
        Region = Region.<your-service-region>,
        Timeout = TimeSpan.FromSeconds(10),
    }));
```
Verbindung mit der angegebenen Konfigurationsdatei mit einem nicht standardmäßigen Profil wird hergestellt:

Sie können einen anderen Pfad für die OCI-Konfigurationsdatei sowie ein anderes Profil in der Konfigurationsdatei verwenden. In diesem Fall geben Sie diese in der Eigenschaft auth.iam der Erstkonfiguration an. Beispiel: Wenn Ihr OCI-Konfigurationsdateipfad ~/myapp/.oci/config lautet und Sie Ihre Zugangsdaten unter Profil Jane speichern:

Erstellen Sie dann die NoSQLClient-Instanz wie folgt:
```
var client = new NoSQLClient(
    new NoSQLConfig
    {
        Region = Region.<your-service-region>,
        AuthorizationProvider = new IAMAuthorizationProvider(
            "<your_config_file>", "<your_profile_name>")
    });
```
Mit einem Instanz-Principal anmelden:

Instanz-Principal ist ein IAM-Servicefeature, mit dem Instanzen als autorisierte Akteure (oder Principals) Aktionen an Serviceressource ausführen können. Jede Compute-Instanz hat eine eigene Identität und authentifiziert die Zertifikate, die ihr hinzugefügt werden. Erstellen Sie nach der Einrichtung die NoSQLClient-Instanz wie folgt:
```
var client = new NoSQLClient(
    new NoSQLConfig
    {
        Region=<your-service-region>,
        Compartment="ocid1.compartment.oc1.............................",
        AuthorizationProvider=IAMAuthorizationProvider.CreateWithInstancePrincipal()
    });
```
Sie können dieselbe Konfiguration auch wie folgt in JSON darstellen:
```
{
    "Region": "<your-service-region>",
    "AuthorizationProvider":
    {
        "AuthorizationType": "IAM",
        "UseInstancePrincipal": true
    },
    "Compartment": "ocid1.compartment.oc1.............................",
}
```
Beachten Sie, dass Sie bei Verwendung des Instanz-Principals die Compartment-ID (OCID) als compartment-Eigenschaft angeben müssen. Dies ist auch erforderlich, wenn Sie das Standard-Compartment verwenden möchten. Beachten Sie, dass Sie die Compartment-ID und keinen Compartment-Namen oder -Pfad verwenden müssen. Wenn Sie Instance Principal verwenden, dürfen Sie dem Tabellennamen beim Aufrufen von NoSQLClient-APIs keinen Compartment-Namen oder -Pfad voranstellen.
Verbindung mit einem Resource Principal herstellen:

Resource Principal ist ein IAM-Servicefeature, mit dem die Ressourcen als autorisierte Akteure (oder Principals) Aktionen für Serviceressourcen ausführen können. Erstellen Sie nach der Einrichtung die NoSQLClient-Instanz wie folgt:
```
var client = new NoSQLClient(
    new NoSQLConfig
    {
        Region = <your-service-region>,
        Compartment =
            "ocid1.compartment.oc1.............................",
        AuthorizationProvider =
            IAMAuthorizationProvider.CreateWithResourcePrincipal()
    });
```
Sie können dieselbe Konfiguration auch wie folgt in JSON darstellen:
```
{
    "Region": "<your-service-region>",
    "AuthorizationProvider":
    {
        "AuthorizationType": "IAM",
        "UseResourcePrincipal": true
    },
    "Compartment": "ocid1.compartment.oc1.............................",
}
```
Beachten Sie, dass Sie bei der Verwendung des Resource Principals die Compartment-ID (OCID) als Eigenschaft compartment angeben müssen. Dies ist auch erforderlich, wenn Sie das Standard-Compartment verwenden möchten. Beachten Sie, dass Sie die Compartment-ID und keinen Compartment-Namen oder -Pfad verwenden müssen. Wenn Sie Resource Principal verwenden, dürfen Sie dem Tabellennamen beim Aufrufen von NoSQLClient-APIs keinen Compartment-Namen oder -Pfad voranstellen.
Verbindung mit Session-Token wird hergestellt:

Mit der auf Sessiontoken basierenden Authentifizierung erstellen Sie eine lokale Konfigurationsdatei, die Informationen wie Benutzer-OCID, Mandanten-OCID, Region, Private-Key-Pfad und einen temporären Sessiontokendateipfad enthält.

Sie können die Session-Token-basierte Authentifizierung mit einer der drei folgenden Methoden verwenden:

Option 1: Damit wird eine neue Instanz von IAMAuthorizationProvider mit Sessiontoken-basierter Authentifizierung mit der OCI-Standardkonfigurationsdatei und dem Standardprofilnamen erstellt.
```
var client = new NoSQLClient(
new NoSQLConfig {
   Region = <your-service-region>,
   Compartment = "ocid1.compartment.oc1.............................",
   AuthorizationProvider = IAMAuthorizationProvider.CreateWithSessionToken()
});
```
Option 2: Damit wird eine neue Instanz von IAMAuthorizationProvider mit Sessiontoken-basierter Authentifizierung mit der OCI-Standardkonfigurationsdatei und dem angegebenen Profilnamen erstellt.
```
var client = new NoSQLClient(
new NoSQLConfig {
   Region = <your-service-region>,
   Compartment = "ocid1.compartment.oc1.............................",
   AuthorizationProvider = IAMAuthorizationProvider.CreateWithSessionToken(<profileName>)
});
```
Option 3: Damit wird eine neue Instanz von IAMAuthorizationProvider mit Sessiontoken-basierter Authentifizierung mit der angegebenen OCI-Konfigurationsdatei und dem angegebenen Profilnamen erstellt.
```
var client = new NoSQLClient(
new NoSQLConfig {
   Region = <your-service-region>,
   Compartment = "ocid1.compartment.oc1.............................",
   AuthorizationProvider = IAMAuthorizationProvider.CreateWithSessionToken(<configFile>,<profileName>)
});
```
Sie können dieselbe Konfiguration auch wie folgt in JSON darstellen:
```
{
  "Region": "<your-service-region>",
  "AuthorizationProvider": {
    "AuthorizationType": "IAM",
    "UseSessionToken": true
  },
  "Compartment": "ocid1.compartment.oc1............................."
}
```
Verbindung mit OKE Workload Identity herstellen:

Das Oracle NoSQL Dotnet SDK unterstützt die Ausführung von Programmen innerhalb von OKE-Workload-Containern in OCI.

Im folgenden Beispiel wird eine neue Instanz von IAMAuthorizationProvider mit der OKE-Workload-Identität erstellt. Mit dieser Methode können Sie eine optionale Tokenzeichenfolge für das Servicekonto angeben. Wenn keine Angabe gemacht wird, wird das Serviceaccounttoken aus dem Standarddateipfad /var/run/secrets/kubernetes.io/serviceaccount/token gelesen.
```
var client = new NoSQLClient(
new NoSQLConfig {
   Region = <your-service-region>,
   Compartment = "ocid1.compartment.oc1.............................",
   AuthorizationProvider = IAMAuthorizationProvider.CreateWithOKEWorkloadIdentity()
});
```
Sie können auch eine neue Instanz von IAMAuthorizationProvider mit der OKE-Workload-Identität und der angegebenen Serviceaccounttokendatei erstellen, wie unten dargestellt.
```
var client = new NoSQLClient(
new NoSQLConfig {
   Region = <your-service-region>,
   Compartment = "ocid1.compartment.oc1.............................",
   AuthorizationProvider =
    IAMAuthorizationProvider.CreateWithOKEWorkloadIdentityAndTokenFile(<serviceAccountTokenFile>)
});
```
Sie können dieselbe Konfiguration auch wie folgt in JSON darstellen:
```
{ "Region": "<your-service-region>",
 "AuthorizationProvider":  {
   "AuthorizationType": "IAM",
   "UseOKEWorkLoadIdentity": true
 },
 "Compartment": "ocid1.compartment.oc1.............................",
}
```

Sie können mit einer der folgenden Methoden eine Verbindung zu NDCS herstellen:

Verbindung mit der Standardkonfigurationsdatei mit einem Standardprofil herstellen:

Sie können die Zugangsdaten in einer Oracle Cloud Infrastructure-Konfigurationsdatei speichern. Der Standardpfad für die Konfigurationsdatei ist ~/.oci/config, wobei ~ für das Home-Verzeichnis des Benutzers steht. Unter Windows ist ~ ein Wert der Umgebungsvariablen USERPROFILE. Die Datei kann mehrere Profile enthalten. Standardmäßig verwendet das SDK das Profil DEFAULT zum Speichern der Zugangsdaten

Um diese Standardwerte zu verwenden, erstellen Sie eine Datei namens config im Verzeichnis ~/.oci mit dem folgenden Inhalt:
```
[DEFAULT]
tenancy=<your-tenancy-ocid>
user=<your-user-ocid>
fingerprint=<fingerprint-of-your-public-key>
key_file=<path-to-your-private-key-file>
pass_phrase=<your-private-key-passphrase>
region=<your-region-identifier>
```
Beachten Sie, dass Sie auch Ihre Regions-ID zusammen mit Zugangsdaten in der OCI-Konfigurationsdatei angeben können. Standardmäßig sucht der Treiber nach Zugangsdaten und einer Region in der OCI-Konfigurationsdatei im Standardpfad und im Standardprofil. Die Region ist nur erforderlich, wenn HandleBuilder::cloud_region() nicht verwendet wird. Die pass_phrase ist nur erforderlich, wenn eine RSA-Schlüsseldatei erforderlich ist.

Der erste Schritt in einer Oracle NoSQL Database Cloud Service Rust-Anwendung besteht darin, ein Handle zu erstellen, mit dem Anforderungen basierend auf der Konfiguration in einer HandleBuilder-Struktur an den Service gesendet werden. Instanzen des Handle sind für die gleichzeitige Verwendung sicher und sollen in einer Multi-Thread- oder asynchronen Anwendung gemeinsam verwendet werden. Das folgende Codebeispiel zeigt, wie Sie mit einer Benutzerkonfigurationsdatei eine Verbindung zum Cloud-Service herstellen:
```
let handle = Handle::builder()
.cloud_auth_from_file("~/.oci/config")?
.build().await?;
```
Mit einem Instanz-Principal anmelden

Instanz-Principal ist ein IAM-Servicefeature, mit dem Instanzen als autorisierte Akteure (oder Principals) Aktionen an Serviceressource ausführen können. Jede Compute-Instanz hat eine eigene Identität und authentifiziert die Zertifikate, die ihr hinzugefügt werden. Um NoSQL in diesem Modus zu konfigurieren, verwenden Sie den folgenden Code:
```
let handle = Handle::builder()
.cloud_auth_from_instance()?
.compartment_id ("ocid1.compartment.oc1.............................")?
.build().await?;
```

Typischer Workflow

Typische Aufgabensequenz für das Arbeiten mit Oracle NoSQL Database Cloud Service.

Wenn Sie zum ersten Mal Anwendungen mit Oracle NoSQL Database Cloud Service entwickeln, befolgen Sie diese Aufgaben als Richtlinie.

Aufgabe	Beschreibung	Weitere Informationen
Ihre Anwendung verbinden	Stellen Sie die Verbindung Ihrer Anwendung mit Oracle NoSQL Database Cloud Service-Tabellen her.	Anwendung mit NDCS verbinden
Ihre Anwendung entwickeln	Entwickeln Sie Ihre Anwendung, nachdem eine Verbindung zu Oracle NoSQL Database Cloud Service-Tabellen hergestellt wurde.	Entwicklung in Oracle Cloud Entwicklung im Oracle NoSQL Database Cloud-Simulator</p>

Wenn Sie Oracle NoSQL Database Cloud Service zum ersten Mal einrichten, finden Sie Weitere Informationen unter Service einrichten.

Schnellstart-Tutorials

Rufen Sie die Schnellstart-Tutorials auf, und steigen Sie in die Arbeit mit dem Service ein.

Erhalten Sie Zugriff auf den Service.

Registrieren Sie sich für eine Cloud-Promotion, oder kaufen Sie ein Oracle Cloud-Abonnement. Aktivieren Sie Ihre Bestellung, erstellen Sie Benutzer (optional). Siehe Service einrichten.
Fordern Sie Zugangsdaten für die Verbindung mit Ihrer Anwendung an. Siehe Authentifizierung für die Verbindung zu Oracle NoSQL Database.
Erstellt eine Tabelle in Oracle NoSQL Database Cloud Service. Erste Schritte finden Sie unter Erste Schritte mit Tabellen in Oracle NoSQL Database Cloud Service.

Erste Schritte mit Oracle NoSQL Database Cloud Service

Quicklinks

Service einrichten

Zugriff auf den Service über die Infrastructure-Konsole

Compartment erstellen

Authentifizierung für die Verbindung zu Oracle NoSQL Database

Anwendung mit NDCS verbinden

Typischer Workflow

Schnellstart-Tutorials

Verwandte Themen