现已推出与 MongoDB 兼容的 Cloud Firestore 企业版！了解详情。

इस पेज का अनुवाद Cloud Translation API से किया गया है.

डेटाबेस से कनेक्ट करने और पुष्टि करने का तरीका

यह सिर्फ़ Cloud Firestore Enterprise वर्शन के लिए काम का है.

कनेक्शन से जुड़ी ज़रूरी शर्तें

MongoDB के साथ काम करने वाले क्लाइंट के लिए, Cloud Firestore का इस्तेमाल करने के लिए ये ज़रूरी हैं:

ड्राइवरों को load balanced मोड में कनेक्ट करना होगा. इससे ड्राइवर, उस सर्वर टोपोलॉजी को समझने की कोशिश नहीं करते जिससे वे कनेक्ट हो रहे हैं.
ड्राइवरों को एसएसएल की सुविधा चालू करके कनेक्ट करना होगा.
ड्राइवर को फिर से लिखने की सुविधा बंद करनी होगी. MongoDB के साथ काम करने वाला Cloud Firestore, फिर से लिखने की सुविधा के साथ काम नहीं करता. फिर से कोशिश करने की सुविधा के साथ डेटा पढ़ने की सुविधा को बंद करने की ज़रूरत नहीं है, क्योंकि यह सुविधा काम करती है.

कनेक्शन स्ट्रिंग वापस पाना

डेटाबेस कनेक्शन स्ट्रिंग, डेटाबेस के यूआईडी, डेटाबेस की जगह, और पुष्टि करने के तरीके पर निर्भर करती है. यहां दिए गए निर्देशों में बताया गया है कि कनेक्शन स्ट्रिंग कैसे बनाई जाती है.

कनेक्शन स्ट्रिंग, पुष्टि करने के तरीके पर निर्भर करती है. हालांकि, बुनियादी कनेक्शन स्ट्रिंग इस फ़ॉर्मैट का इस्तेमाल करती है:

mongodb://UID.LOCATION.firestore.goog:443/DATABASE_ID?loadBalanced=true&tls=true&retryWrites=false

इनमें से किसी एक तरीके से, बेस कनेक्शन स्ट्रिंग हासिल की जा सकती है:

Firebase कंसोल

Firebase कंसोल में, Firestore डेटाबेस पेज पर जाएं.

Firestore डेटाबेस पर जाएं
उस डेटाबेस पर क्लिक करें जिसकी पुष्टि करनी है.
एक्सप्लोरर पैनल में, ज़्यादा देखें पर क्लिक करें.
MongoDB टूल का इस्तेमाल करके कनेक्ट करें को चुनें.
कनेक्शन स्ट्रिंग कॉपी करें.

gcloud

यूआईडी और जगह की जानकारी वापस पाने के लिए, gcloud firestore database describe का इस्तेमाल करें:

gcloud firestore databases describe \
--database=DATABASE_ID \
--format='yaml(locationId, uid)'

DATABASE_ID को डेटाबेस आईडी से बदलें.

आउटपुट में, डेटाबेस की जगह और यूआईडी शामिल होता है. इस जानकारी का इस्तेमाल करके, बुनियादी कनेक्शन स्ट्रिंग बनाएं.

अपने डेटाबेस से कनेक्ट करने और पुष्टि करने के लिए, बेस कनेक्शन स्ट्रिंग और इनमें से किसी एक तरीके का इस्तेमाल करें:

उपयोगकर्ता नाम और पासवर्ड (SCRAM)
Compute Engine सेवा खाता
Cloud Run सेवा खाता
Google Auth Library

उपयोगकर्ता नाम और पासवर्ड (SCRAM) का इस्तेमाल करके कनेक्ट करना

अपने डेटाबेस के लिए उपयोगकर्ता क्रेडेंशियल बनाने और उसे कनेक्ट करने के लिए, यह तरीका अपनाएं.

शुरू करने से पहले

उपयोगकर्ता बनाने के लिए ज़रूरी अनुमतियां पाने के लिए, अपने एडमिन से कहें कि वह आपको आपके डेटाबेस पर userCredsAdmin (roles/datastore.userCredsAdmin) IAM भूमिका असाइन करे. भूमिकाएं असाइन करने के बारे में ज़्यादा जानने के लिए, प्रोजेक्ट, फ़ोल्डर, और संगठनों का ऐक्सेस मैनेज करना लेख पढ़ें.

आपको कस्टम भूमिका या पहले से तय अन्य भूमिकाओं के ज़रिए भी ज़रूरी अनुमतियां मिल सकती हैं.

उपयोगकर्ता बनाना और उसे डेटाबेस से कनेक्ट करना

MongoDB के साथ काम करने वाले Cloud Firestore डेटाबेस के लिए उपयोगकर्ता बनाने के लिए, इनमें से किसी एक तरीके का इस्तेमाल करें:

Google Cloud कंसोल

Google Cloud Console में, डेटाबेस पेज पर जाएं.

डेटाबेस पर जाएं
डेटाबेस की सूची में से कोई डेटाबेस चुनें.
नेविगेशन मेन्यू में, Auth पर क्लिक करें.
उपयोगकर्ता जोड़ें पर क्लिक करें.
कोई उपयोगकर्ता नाम डालें.
नए उपयोगकर्ता के लिए कोई भूमिका चुनें.
जोड़ें पर क्लिक करें.
पुष्टि करने वाले डायलॉग बॉक्स में, नए उपयोगकर्ता का पासवर्ड दिखेगा.

ध्यान दें: पासवर्ड सिर्फ़ एक बार दिखता है और इसे फिर से नहीं देखा जा सकता. इस पासवर्ड को आने वाले समय में इस्तेमाल करने के लिए सेव करें.

gcloud CLI

SCRAM की मदद से पुष्टि करने के लिए, आपको सबसे पहले उपयोगकर्ता क्रेडेंशियल बनाना होगा. gcloud firestore user-creds कमांड का इस्तेमाल करें:
```
gcloud firestore user-creds create USERNAME --database=DATABASE_ID
```
इनकी जगह ये डालें:
- USERNAME: वह उपयोगकर्ता नाम जिसे बनाना है.
- DATABASE_ID: डेटाबेस आईडी.
इस कमांड के आउटपुट में उपयोगकर्ता का पासवर्ड शामिल होता है.

ध्यान दें: पासवर्ड सिर्फ़ एक बार दिखता है और इसे फिर से नहीं देखा जा सकता. इस पासवर्ड को आने वाले समय में इस्तेमाल करने के लिए सेव करें.

आउटपुट इस तरह का दिखेगा:
```
name: projects/PROJECT_NAME/databases/DATABASE_ID/userCreds/USERNAME
resourceIdentity:
  principal: principal://firestore.googleapis.com/projects/PROJECT_NUMBER/name/databases/DATABASE_ID/userCreds/USERNAME
securePassword: PASSWORD
```
डिफ़ॉल्ट रूप से, इस नए उपयोगकर्ता क्रेडेंशियल के पास कोई अनुमति नहीं होती. डेटाबेस को पढ़ने और उसमें बदलाव करने का ऐक्सेस पाने के लिए, इस डेटाबेस के लिए roles/datastore.user भूमिका जोड़ें:
```
gcloud projects add-iam-policy-binding PROJECT_NAME \
--member='principal://firestore.googleapis.com/projects/PROJECT_NUMBER/name/databases/DATABASE_ID/userCreds/USERNAME' \
--role=roles/datastore.user \
--condition='expression=resource.name == "projects/PROJECT_NAME/databases/DATABASE_ID",title="CONDITION_TITLE"'
```
इनकी जगह ये डालें:
- PROJECT_NAME: आपके प्रोजेक्ट का नाम.
- PROJECT_NUMBER: प्रोजेक्ट नंबर.
- DATABASE_ID: डेटाबेस आईडी.
- USERNAME: वह उपयोगकर्ता नाम जो आपने पहले बनाया था.
- CONDITION_TITLE: इस शर्त के लिए कोई टाइटल. इस शर्त के तहत, सिर्फ़ इस डेटाबेस को ऐक्सेस करने की अनुमति दी जाती है.

Java

इस सेक्शन में, उपयोगकर्ता क्रेडेंशियल बनाने और Java एडमिन क्लाइंट लाइब्रेरी का इस्तेमाल करके, IAM नीति को कॉन्फ़िगर करने का कोड उदाहरण दिया गया है. इस उदाहरण में, उपयोगकर्ता नाम और पासवर्ड बनाने के लिए Firestore Admin Client लाइब्रेरी का इस्तेमाल किया गया है. साथ ही, IAM को कॉन्फ़िगर करने के लिए Google Cloud Resource Manager लाइब्रेरी का इस्तेमाल किया गया है.

Maven बिल्ड के लिए, इन कोऑर्डिनेट का इस्तेमाल किया जा सकता है:

com.google.cloud:google-cloud-firestore-admin:3.33.1
com.google.cloud:google-cloud-resourcemanager:1.76.0

उपयोगकर्ता क्रेडेंशियल और IAM नीति उपलब्ध कराएं:

import com.google.cloud.firestore.v1.FirestoreAdminClient;
import com.google.cloud.resourcemanager.v3.ProjectName;
import com.google.cloud.resourcemanager.v3.ProjectsClient;
import com.google.firestore.admin.v1.CreateUserCredsRequest;
import com.google.firestore.admin.v1.GetUserCredsRequest;
import com.google.firestore.admin.v1.UserCreds;
import com.google.iam.v1.Binding;
import com.google.iam.v1.GetIamPolicyRequest;
import com.google.iam.v1.GetPolicyOptions;
import com.google.iam.v1.Policy;
import com.google.iam.v1.SetIamPolicyRequest;
import com.google.protobuf.FieldMask;
import com.google.type.Expr;

public class FirestoreUserCredsExample {
  /**
   * Provision user credentials and configure an IAM policy to allow SCRAM authentication into the
   * specified Firestore with Mongo Compatibility database.
   */
  private static void provisionFirestoreUserCredsAndIAM(
      String projectId, String databaseId, String userName) throws Exception {
    UserCreds userCreds = createUserCreds(projectId, databaseId, userName);

    // Note the password returned in the UserCreds proto - it cannot be retrieved again
    // after the initial call to the createUserCreds API.
    System.out.printf(
        "Created credentials for username: %s:\nIAM principal: %s\nPassword: [%s]\n",
        userName, userCreds.getResourceIdentity().getPrincipal(), userCreds.getSecurePassword());

    // Provision an IAM binding for the principal associated with these user credentials.
    updateIamPolicyForUserCreds(projectId, databaseId, userName, userCreds);

    // Emit the password again.
    System.out.printf(
        "Successfully configured IAM policy for database: %s, username: %s\n",
        databaseId, userName);
    System.out.printf("Please make a note of the password: [%s]\n", userCreds.getSecurePassword());
  }

  /** Provision new user credentials using the FirestoreAdminClient. */
  private static UserCreds createUserCreds(String projectId, String databaseId, String userName)
      throws Exception {
    FirestoreAdminClient firestoreAdminClient = FirestoreAdminClient.create();
    return firestoreAdminClient.createUserCreds(
        CreateUserCredsRequest.newBuilder()
            .setParent(String.format("projects/%s/databases/%s", projectId, databaseId))
            .setUserCredsId(userName)
            .build());
  }

  /** Update the IAM policy using the Resource Manager ProjectsClient. */
  private static void updateIamPolicyForUserCreds(
      String projectId, String databaseId, String userName, UserCreds userCreds) throws Exception {
    try (ProjectsClient projectsClient = ProjectsClient.create()) {
      ProjectName projectName = ProjectName.of(projectId);

      // Get the current IAM policy.
      Policy currentPolicy =
          projectsClient.getIamPolicy(
              GetIamPolicyRequest.newBuilder()
                  .setResource(projectName.toString())
                  .setOptions(GetPolicyOptions.newBuilder().setRequestedPolicyVersion(3).build())
                  .build());

      String role = "roles/datastore.user";
      String title = String.format("Conditional IAM binding for %s", userName);
      String expression =
          String.format("resource.name == \"projects/%s/databases/%s\"", projectId, databaseId);

      // Construct an updated IAM policy with an additional binding for the user credentials.
      Policy.Builder policyBuilder = currentPolicy.toBuilder();
      Binding newBinding =
          Binding.newBuilder()
              .setRole(role)
              .setCondition(Expr.newBuilder().setTitle(title).setExpression(expression).build())
              .addMembers(userCreds.getResourceIdentity().getPrincipal())
              .build();
      policyBuilder.addBindings(newBinding);

      // Update the policy
      SetIamPolicyRequest request =
          SetIamPolicyRequest.newBuilder()
              .setResource(projectName.toString())
              .setPolicy(policyBuilder.build())
              .setUpdateMask(FieldMask.newBuilder().addPaths("bindings").addPaths("etag").build())
              .build();
      System.out.println(request);

      Policy updatedPolicy = projectsClient.setIamPolicy(request);
      System.out.println("Policy updated successfully: " + updatedPolicy);
    }
  }
}

Python

इस सेक्शन में, Python एडमिन क्लाइंट लाइब्रेरी का इस्तेमाल करके, उपयोगकर्ता क्रेडेंशियल बनाने और IAM नीति को कॉन्फ़िगर करने का कोड उदाहरण दिया गया है. इस सैंपल में, उपयोगकर्ता नाम और पासवर्ड बनाने के लिए Google Cloud Firestore API क्लाइंट लाइब्रेरी का इस्तेमाल किया गया है. साथ ही, IAM को कॉन्फ़िगर करने के लिए Google Cloud IAM API क्लाइंट लाइब्रेरी और Google Cloud Resource Manager API क्लाइंट लाइब्रेरी का इस्तेमाल किया गया है.

pip टूल की मदद से, ज़रूरी Python लाइब्रेरी इंस्टॉल की जा सकती हैं:

pip install google-cloud-iam
pip install google-cloud-firestore
pip install google-cloud-resource-manager

उपयोगकर्ता क्रेडेंशियल और IAM नीति उपलब्ध कराएं:

from google.cloud import resourcemanager_v3
from google.cloud.firestore_admin_v1 import FirestoreAdminClient
from google.cloud.firestore_admin_v1 import types
from google.iam.v1 import iam_policy_pb2
from google.iam.v1 import policy_pb2
from google.type import expr_pb2


def create_user_creds(project_id: str, database_id: str, user_name: str):
  """Provision new user credentials using the FirestoreAdminClient."""
  client = FirestoreAdminClient()
  request = types.CreateUserCredsRequest(
      parent=f'projects/{project_id}/databases/{database_id}',
      user_creds_id=user_name,
  )
  response = client.create_user_creds(request)
  return response


def update_iam_policy_for_user_creds(
    project_id: str, database_id: str, user_name: str, user_creds
):
  """Update the IAM policy using the Resource Manager ProjectsClient."""
  client = resourcemanager_v3.ProjectsClient()
  request = iam_policy_pb2.GetIamPolicyRequest()
  request.resource = f'projects/{project_id}'
  request.options.requested_policy_version = 3

  # Get the current IAM policy
  current_policy = client.get_iam_policy(request)

  # Construct an updated IAM policy with an additional binding
  # for the user credentials.
  updated_policy = policy_pb2.Policy()
  binding = policy_pb2.Binding()
  iam_condition = expr_pb2.Expr()

  iam_condition.title = f'Conditional IAM binding for {user_name}'
  iam_condition.expression = (
      f'resource.name == "projects/{project_id}/databases/{database_id}"'
  )

  binding.role = 'roles/datastore.user'
  binding.condition.CopyFrom(iam_condition)
  binding.members.append(user_creds.resource_identity.principal)
  updated_policy.bindings.append(binding)

  # Update the policy
  updated_policy.MergeFrom(current_policy)
  set_policy_request = iam_policy_pb2.SetIamPolicyRequest()
  set_policy_request.resource = f'projects/{project_id}'
  set_policy_request.policy.CopyFrom(updated_policy)

  final_policy = client.set_iam_policy(set_policy_request)
  print(f'Policy updated successfully {final_policy}')


def provision_firestore_user_creds_and_iam(
    project_id: str, database_id: str, user_name: str
):
  """Provision user credentials and configure an IAM policy."""
  user_creds = create_user_creds(project_id, database_id, user_name)

  # Note the password returned in the UserCreds proto - it cannot be
  # retrieved again after the initial call to the create_user_creds API.
  print(f'Created credentials for username: {user_name}')
  print(f'IAM principal: {user_creds.resource_identity.principal}')
  print(f'Password: [{user_creds.secure_password}]')

  # Provision an IAM binding for the principal associated with
  # these user credentials.
  update_iam_policy_for_user_creds(
      project_id, database_id, user_name, user_creds
  )

  # Emit the password again
  print(
      f'Successfully configured IAM policy for database: {database_id},'
      f' username: {user_name}'
  )
  print(f'Please make a note of the password: [{user_creds.secure_password}]')

SCRAM का इस्तेमाल करके अपने डेटाबेस से कनेक्ट करने के लिए, इस कनेक्शन स्ट्रिंग का इस्तेमाल करें:

mongodb://USERNAME:PASSWORD@UID.LOCATION.firestore.goog:443/DATABASE_ID?loadBalanced=true&authMechanism=SCRAM-SHA-256&tls=true&retryWrites=false

इनकी जगह ये डालें:

USERNAME: उपयोगकर्ता नाम.
PASSWORD: यह वह पासवर्ड है जिसे आपने इस उपयोगकर्ता के लिए जनरेट किया है.
UID: डेटाबेस का यूआईडी.
LOCATION: डेटाबेस की जगह.
DATABASE_ID: डेटाबेस आईडी.

Google Auth Library से कनेक्ट करना

नीचे दिए गए कोड के उदाहरण में, OIDC कॉलबैक हैंडलर को रजिस्टर करने का तरीका बताया गया है. इसमें Google Cloud स्टैंडर्ड OAuth लाइब्रेरी का इस्तेमाल किया गया है.

इस लाइब्रेरी की मदद से, कई तरह की पुष्टि करने की सुविधा का इस्तेमाल किया जा सकता है. जैसे, ऐप्लिकेशन के डिफ़ॉल्ट क्रेडेंशियल और वर्कलोड आइडेंटिटी फ़ेडरेशन.

इसके लिए, auth लाइब्रेरी को डिपेंडेंसी के तौर पर जोड़ना ज़रूरी है:

// Maven
<dependency>
  <groupId>com.google.auth</groupId>
  <artifactId>google-auth-library-oauth2-http</artifactId>
  <version>1.19.0</version>
</dependency>

// Gradle
implementation 'com.google.auth:google-auth-library-oauth2-http:1.19.0'

यहां दिए गए कोड सैंपल में, कनेक्ट करने का तरीका बताया गया है:

val db = MongoClients.create(
    clientSettings(
      "DATABASE_UID",
      "LOCATION"
    ).build()
  ).getDatabase("DATABASE_ID")


/**
 * Creates a connection to a Firestore with MongoDB Compatibility database.
 * @param databaseUid The uid of the database to connect to as a string. For example: f116f93a-519c-208a-9a72-3ef6c9a1f081
 * @param locationId The location of the database to connect to, for example: nam5, us-central1, us-east4 etc...
 * @param environment Determines whether to try and fetch an authentication credential from the
 * Compute Engine VM metadata service or whether to call gcloud.
 */
private static MongoClientSettings.Builder clientSettings(
  String databaseUid: String
  String locationId:String
): MongoClientSettings.Builder {
  MongoCredential credential =
    MongoCredential.createOidcCredential(null)
      .withMechanismProperty(
        MongoCredential.OIDC_CALLBACK_KEY,
        new MongoCredential.OidcCallback() {
          @Override
          MongoCredential.OidcCallbackResult onRequest(
MongoCredential.OidcCallbackContext context) {
     // Customize this credential builder for additional credential types.
     GoogleCredentials credentials = GoogleCredentials.getApplicationDefault();
            return new MongoCredential.OidcCallbackResult(
         credentials.getAccessToken().getTokenValue(),
         Duration.between(Instant.now(),
credentials.getAccessToken().getExpirationTime().toInstant()));
          }
        },
      );
  return MongoClientSettings.builder()
    .hosts(listOf(ServerAddress(
        "$databaseUid.$locationId.firestore.goog", 443)))
    .credential(credential)
    .applyToClusterSettings(builder ->
         builder.mode(ClusterConnectionMode.LOAD_BALANCED))
    ).applyToSslSettings(ssl -> ssl.enabled(true)).retryWrites(false);
}

इनकी जगह ये डालें:

DATABASE_UID: आपके प्रोजेक्ट का नाम.
LOCATION: आपके डेटाबेस की जगह.
DATABASE_ID डेटाबेस आईडी.

Google Cloud कंप्यूट एनवायरमेंट से कनेक्ट करना

इस सेक्शन में, Google Cloud कंप्यूट एनवायरमेंट से MongoDB के साथ काम करने वाले Cloud Firestore से कनेक्ट करने के बारे में बताया गया है. जैसे, Compute Engine या Cloud Run सेवा या नौकरी.

Compute Engine वीएम से कनेक्ट करना

Compute Engine सेवा खाते का इस्तेमाल करके, अपने डेटाबेस से कनेक्ट किया जा सकता है और उसकी पुष्टि की जा सकती है. इसके लिए, Google Cloud प्रोजेक्ट के लिए IAM नीति बनाएं. इस प्रोजेक्ट में आपका डेटाबेस मौजूद है.

शुरू करने से पहले

अपनी वीएम के लिए, उपयोगकर्ता के मैनेज किए गए सेवा खाते को कॉन्फ़िगर करें:

VM बनाते समय सेवा खाता कॉन्फ़िगर करने के लिए, उपयोगकर्ता के मैनेज किए गए सेवा खाते का इस्तेमाल करने वाली VM बनाना लेख पढ़ें.
किसी मौजूदा वीएम पर सेवा खाता कॉन्फ़िगर करने के लिए, अटैच किए गए सेवा खाते में बदलाव करना लेख पढ़ें.

अपने Compute Engine सेवा खाते के लिए IAM नीति कॉन्फ़िगरेशन पूरा करने के लिए, क्रेडेंशियल कॉन्फ़िगर करें सेक्शन में दिए गए निर्देश देखें.

Cloud Run से कनेक्ट करें

Cloud Run सेवा खाते का इस्तेमाल करके, अपने डेटाबेस से कनेक्ट किया जा सकता है और उसकी पुष्टि की जा सकती है. इसके लिए, Google Cloud प्रोजेक्ट के लिए IAM नीति बनाएं. इस प्रोजेक्ट में आपका डेटाबेस मौजूद है.

शुरू करने से पहले

Cloud Run के लिए सेवा खाता कॉन्फ़िगर करने के लिए, सेवा आइडेंटिटी कॉन्फ़िगर करना लेख पढ़ें
Cloud Run सेवा से पहले से जुड़े सेवा खाते का पता लगाने के लिए, gcloud run services describe देखें

अपने Cloud Run सेवा खाते के लिए IAM नीति कॉन्फ़िगरेशन पूरा करने के लिए, क्रेडेंशियल कॉन्फ़िगर करें सेक्शन में दिए गए निर्देश देखें.

क्रेडेंशियल कॉन्फ़िगर करना

सेवा खाते को roles/datastore.user के लिए पढ़ने और लिखने की roles/datastore.user भूमिका देने के लिए, यह कमांड चलाएं:Cloud Firestore

gcloud projects add-iam-policy-binding PROJECT_NAME --member="SERVICE_ACCOUNT_EMAIL" --role=roles/datastore.user

इनकी जगह ये डालें:

PROJECT_NAME: आपके प्रोजेक्ट का नाम.
SERVICE_ACCOUNT_EMAIL: यह उस सेवा खाते का ईमेल पता है जिसे आपने बनाया है.

कनेक्शन स्ट्रिंग बनाना

कनेक्शन स्ट्रिंग बनाने के लिए, इस फ़ॉर्मैट का इस्तेमाल करें:

mongodb://DATABASE_UID.LOCATION.firestore.goog:443/DATABASE_ID?loadBalanced=true&tls=true&retryWrites=false&authMechanism=MONGODB-OIDC&authMechanismProperties=ENVIRONMENT:gcp,TOKEN_RESOURCE:FIRESTORE

इनकी जगह ये डालें:

DATABASE_UID: आपके प्रोजेक्ट का नाम.
LOCATION: आपके डेटाबेस की जगह.
DATABASE_ID डेटाबेस आईडी.

यूआईडी और जगह की जानकारी वापस पाने के बारे में ज़्यादा जानने के लिए, कनेक्शन स्ट्रिंग वापस पाना लेख पढ़ें.

कुछ समय के लिए दिए गए ऐक्सेस टोकन से कनेक्ट करना

डाइग्नोस्टिक टूल चलाने के लिए, कुछ समय के लिए Google Cloud ऐक्सेस टोकन का इस्तेमाल किया जा सकता है. जैसे, mongosh. कम समय के लिए ऐक्सेस टोकन की पुष्टि करने के लिए, gcloud auth print-access-token का इस्तेमाल किया जा सकता है. यह टोकन एक घंटे के लिए मान्य है.

उदाहरण के लिए, mongosh का इस्तेमाल करके अपने डेटाबेस से कनेक्ट करने के लिए, यह कमांड इस्तेमाल करें:

mongosh --tls \
      --username access_token --password $(gcloud auth print-access-token) \
      'mongodb://UID.LOCATION.firestore.goog:443/DATABASE_ID?loadBalanced=true&authMechanism=PLAIN&authSource=$external&retryWrites=false'

इनकी जगह ये डालें:

DATABASE_UID: डेटाबेस का यूआईडी
LOCATION: डेटाबेस की जगह
DATABASE_ID: डेटाबेस आईडी