クイック スタート

アプリケーション変数を割り当てる

このチュートリアルのコード サンプルでは、次の変数を使用して Queryable Encryption ワークフローを実行します。

// KMS provider name should be one of the following: "aws", "gcp", "azure", "kmip" or "local"
const kmsProviderName = "<Your KMS Provider Name>";
const uri = process.env.MONGODB_URI; // Your connection URI
const keyVaultDatabaseName = "encryption";
const keyVaultCollectionName = "__keyVault";
const keyVaultNamespace = `${keyVaultDatabaseName}.${keyVaultCollectionName}`;
const encryptedDatabaseName = "medicalRecords";
const encryptedCollectionName = "patients";

// KMS provider name should be one of the following: "aws", "gcp", "azure", "kmip" or "local"
const string kmsProviderName = "<your KMS provider name>";
const string keyVaultDatabaseName = "encryption";
const string keyVaultCollectionName = "__keyVault";
var keyVaultNamespace =
    CollectionNamespace.FromFullName($"{keyVaultDatabaseName}.{keyVaultCollectionName}");
const string encryptedDatabaseName = "medicalRecords";
const string encryptedCollectionName = "patients";
var appSettings = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build();
var uri = appSettings["MongoDbUri"];

// KMS provider name should be one of the following: "aws", "gcp", "azure", "kmip" or "local"
kmsProviderName := "<KMS provider name>"
uri := os.Getenv("MONGODB_URI") // Your connection URI
keyVaultDatabaseName := "encryption"
keyVaultCollectionName := "__keyVault"
keyVaultNamespace := keyVaultDatabaseName + "." + keyVaultCollectionName
encryptedDatabaseName := "medicalRecords"
encryptedCollectionName := "patients"

// KMS provider name should be one of the following: "aws", "gcp", "azure", "kmip" or "local"
String kmsProviderName = "<KMS provider name>";
String uri = QueryableEncryptionHelpers.getEnv("MONGODB_URI"); // Your connection URI
String keyVaultDatabaseName = "encryption";
String keyVaultCollectionName = "__keyVault";
String keyVaultNamespace = keyVaultDatabaseName + "." + keyVaultCollectionName;
String encryptedDatabaseName = "medicalRecords";
String encryptedCollectionName = "patients";

// KMS provider name should be one of the following: "aws", "gcp", "azure", "kmip" or "local"
const kmsProviderName = "<Your KMS Provider Name>";
const uri = process.env.MONGODB_URI; // Your connection URI
const keyVaultDatabaseName = "encryption";
const keyVaultCollectionName = "__keyVault";
const keyVaultNamespace = `${keyVaultDatabaseName}.${keyVaultCollectionName}`;
const encryptedDatabaseName = "medicalRecords";
const encryptedCollectionName = "patients";

# KMS provider name should be one of the following: "aws", "gcp", "azure", "kmip" or "local"
kms_provider_name = "<KMS provider name>"
uri = os.environ['MONGODB_URI']  # Your connection URI
key_vault_database_name = "encryption"
key_vault_collection_name = "__keyVault"
key_vault_namespace = f"{key_vault_database_name}.{key_vault_collection_name}"
encrypted_database_name = "medicalRecords"
encrypted_collection_name = "patients"

暗号化されたコレクションの作成

1. CMK の作成

   Queryable Encryption を実行するには、カスタマー マスター キー（ CMK ）を作成する必要があります。

   96バイトのカスタマー マスター キーを作成し、それをファイルcustomer-master-key.txtとしてファイルシステムに保存します。

   MongoDB Shell

   C#

   Go

   Java (Sync)

   Node.js

   Python

   customerMasterKeyPath = "customer-master-key.txt";
   if (!fs.existsSync(customerMasterKeyPath)) {
     fs.writeFileSync(customerMasterKeyPath, crypto.randomBytes(96));
   }

   using var randomNumberGenerator = RandomNumberGenerator.Create();
   try
   {
       var bytes = new byte[96];
       randomNumberGenerator.GetBytes(bytes);
       var localCustomerMasterKeyBase64 = Convert.ToBase64String(bytes);
       File.WriteAllText("customer-master-key.txt", localCustomerMasterKeyBase64);
   }
   catch (Exception e)
   {
       throw new Exception("Unable to write Customer Master Key file due to the following error: " + e.Message);
   }

   key := make([]byte, 96)
   if _, err := rand.Read(key); err != nil {
   	panic(fmt.Sprintf("Unable to create a random 96 byte data key: %v\n", err))
   }
   if err := os.WriteFile("customer-master-key.txt", key, 0644); err != nil {
   	panic(fmt.Sprintf("Unable to write key to file: %v\n", err))
   }

   byte[] localCustomerMasterKey = new byte[96];
   new SecureRandom().nextBytes(localCustomerMasterKey);
   try (FileOutputStream stream = new FileOutputStream("customer-master-key.txt")) {
       stream.write(localCustomerMasterKey);
       // ...

   if (!existsSync("./customer-master-key.txt")) {
     try {
       writeFileSync("customer-master-key.txt", randomBytes(96));
     } catch (err) {
       throw new Error(
         `Unable to write Customer Master Key to file due to the following error: ${err}`
       );
     }
   }

   path = "customer-master-key.txt"
   file_bytes = os.urandom(96)
   with open(path, "wb") as f:
       f.write(file_bytes)

   警告

   本番環境ではローカルキー ファイルを使用しない

   ファイルシステム内のローカルキー ファイルは安全でなく、本番環境には推奨されません。 代わりに、CMK をリモート キー管理システム に保存する必要があります （ KMS ）。

   Queryable Encryption の実装でリモートKMSを使用する方法については、チュートリアルのガイドを参照してください。

   Tip

   コマンドラインから CMK を生成

   次のコマンドを使用して、Unix shell または PowerShell からCMKを生成します。

   • Unix shell:

     echo $(head -c 96 /dev/urandom | base64 | tr -d '\n')

   • PowerShell:

     $r=[byte[]]::new(64);$g=[System.Security.Cryptography.RandomNumberGenerator]::Create();$g.GetBytes($r);[Convert]::ToBase64String($r)

   上記のコマンドの出力をcustomer-master-key.txtという名前のファイルに保存します。

2. CMK の取得と KMS プロバイダー設定の指定

   このガイドの「 カスタマー マスター キーの作成」ステップで生成したカスタマー マスター キー ファイルの内容を取得します。

   CMK値を KMS プロバイダー設定に渡します。 クライアントはこれらの設定を使用してCMKを検出します。 プロバイダー名をlocalに設定して、ローカルキー プロバイダーを使用しているドライバーに通知します。

   MongoDB Shell

   C#

   Go

   Java (Sync)

   Node.js

   Python

   // WARNING: Do not use a local key file in a production application
   const localMasterKey = fs.readFileSync("./customer-master-key.txt");
   kmsProviderCredentials = {
     local: {
       key: localMasterKey,
     },
   };

   // WARNING: Do not use a local key file in a production application
   var kmsProviderCredentials = new Dictionary<string, IReadOnlyDictionary<string, object>>();
   try
   {
       var localCustomerMasterKeyBase64 = File.ReadAllText("customer-master-key.txt");
       var localCustomerMasterKeyBytes = Convert.FromBase64String(localCustomerMasterKeyBase64);
       var localOptions = new Dictionary<string, object>
       {
           { "key", localCustomerMasterKeyBytes }
       };
       kmsProviderCredentials.Add(kmsProvider, localOptions);
   }

   key, err := os.ReadFile("customer-master-key.txt")
   if err != nil {
   	panic(fmt.Sprintf("Could not read the Customer Master Key: %v", err))
   }
   kmsProviderCredentials := map[string]map[string]interface{}{"local": {"key": key}}

   byte[] localCustomerMasterKey = new byte[96];
   try (FileInputStream fis = new FileInputStream("customer-master-key.txt")) {
       if (fis.read(localCustomerMasterKey) < 96)
           throw new Exception("Expected to read 96 bytes from the customer master key file");
   } catch (Exception e) {
       throw new Exception("Unable to read the Customer Master Key due to the following error: " + e.getMessage());
   }
   Map<String, Object> keyMap = new HashMap<String, Object>();
   keyMap.put("key", localCustomerMasterKey);
   Map<String, Map<String, Object>> kmsProviderCredentials = new HashMap<String, Map<String, Object>>();
   kmsProviderCredentials.put("local", keyMap);

   // WARNING: Do not use a local key file in a production application
   const localMasterKey = readFileSync("./customer-master-key.txt");
   kmsProviders = {
     local: {
       key: localMasterKey,
     },
   };

   path = "./customer-master-key.txt"
   with open(path, "rb") as f:
       local_master_key = f.read()
       kms_provider_credentials = {
           "local": {
               "key": local_master_key
           },
       }

3. 自動暗号化オプションを設定する

   MongoDB Shell

   C#

   Go

   Java (Sync)

   Node.js

   Python

   次のオプションを含むautoEncryptionOptionsオブジェクトを作成します。

   • キーヴォールト コレクションの名前空間

   • 前のステップで定義されたkmsProviderCredentialsオブジェクト

   const autoEncryptionOptions = {
     keyVaultNamespace: keyVaultNamespace,
     kmsProviders: kmsProviderCredentials,
   };

   次のオプションを含むAutoEncryptionOptionsオブジェクトを作成します。

   • キーヴォールト コレクションの名前空間

   • 前のステップで定義されたkmsProviderCredentialsオブジェクト

   • へのパスを含む extraOptionsオブジェクト

     自動暗号化共有ライブラリ

     var extraOptions = new Dictionary<string, object>
     {
         { "cryptSharedLibPath", _appSettings["CryptSharedLibPath"] } // Path to your Automatic Encryption Shared Library
     };
     var autoEncryptionOptions = new AutoEncryptionOptions(
         keyVaultNamespace,
         kmsProviderCredentials,
         extraOptions: extraOptions);

   次のオプションを含むAutoEncryptionオブジェクトを作成します。

   • キーヴォールト コレクションの名前空間

   • 前のステップで定義されたkmsProviderCredentialsオブジェクト

   • へのパスを含む cryptSharedLibraryPathオブジェクト

     自動暗号化共有ライブラリ

   cryptSharedLibraryPath := map[string]interface{}{
   	"cryptSharedLibPath": os.Getenv("SHARED_LIB_PATH"), // Path to your Automatic Encryption Shared Library
   }
   autoEncryptionOptions := options.AutoEncryption().
   	SetKeyVaultNamespace(keyVaultNamespace).
   	SetKmsProviders(kmsProviderCredentials).
   	SetExtraOptions(cryptSharedLibraryPath)

   次のオプションを含むAutoEncryptionSettingsオブジェクトを作成します。

   • キーヴォールト コレクションの名前空間

   • 前のステップで定義されたkmsProviderCredentialsオブジェクト

   • へのパスを含む extraOptionsオブジェクト

     自動暗号化共有ライブラリ

   Map<String, Object> extraOptions = new HashMap<String, Object>();
   extraOptions.put("cryptSharedLibPath", getEnv("SHARED_LIB_PATH")); // Path to your Automatic Encryption Shared Library
   AutoEncryptionSettings autoEncryptionSettings = AutoEncryptionSettings.builder()
           .keyVaultNamespace(keyVaultNamespace)
           .kmsProviders(kmsProviderCredentials)
           .extraOptions(extraOptions)
           .build();

   次のオプションを含むautoEncryptionOptionsオブジェクトを作成します。

   • キーヴォールト コレクションの名前空間

   • 前のステップで定義されたkmsProvidersオブジェクト

   • へのパスを含む sharedLibraryPathOptionsオブジェクト

     自動暗号化共有ライブラリ

   const extraOptions = {
     cryptSharedLibPath: process.env.SHARED_LIB_PATH, // Path to your Automatic Encryption Shared Library
   };
   const autoEncryptionOptions = {
     keyVaultNamespace,
     kmsProviders,
     extraOptions,
   };

   次のオプションを含むAutoEncryptionOptsオブジェクトを作成します。

   • 前のステップで定義されたkms_provider_credentialsオブジェクト

   • キーヴォールト コレクションの名前空間

   • 自動暗号化共有ライブラリへのパス

   auto_encryption_options = AutoEncryptionOpts(
       kms_provider_credentials,
       key_vault_namespace,
       crypt_shared_lib_path=os.environ['SHARED_LIB_PATH'] # Path to your Automatic Encryption Shared Library>
   )

   注意

   自動暗号化オプション

   自動暗号化オプションは、暗号化共有ライブラリに構成情報を提供し、暗号化されたフィールドにアクセスするときにアプリケーションの動作を変更します。

   自動暗号化共有ライブラリの詳細については、「 Queryable Encryption のための自動暗号化共有ライブラリ」ページを参照してください。

4. 暗号化されたコレクションを設定するためのクライアントの作成

   コレクション内のデータの暗号化と復号化に使用されるクライアントを作成するには、接続 URI と 自動暗号化オプションを使用して新しいMongoClientをインスタンス化します。

   MongoDB Shell

   C#

   Go

   Java (Sync)

   Node.js

   Python

   const encryptedClient = Mongo(uri, autoEncryptionOptions);

   重要: .NET/ C#ドライバー バージョン3.0 以降を使用している場合は、新しい をインスタンス化する前に、次のコードをアプリケーションに追加する必要があります。MongoClient

   var clientSettings = MongoClientSettings.FromConnectionString(uri);
   clientSettings.AutoEncryptionOptions = qeHelpers.GetAutoEncryptionOptions(
       keyVaultNamespace,
       kmsProviderCredentials);
   var encryptedClient = new MongoClient(clientSettings);

   encryptedClient, err := mongo.Connect(
   	context.TODO(),
   	options.Client().ApplyURI(uri).SetAutoEncryptionOptions(autoEncryptionOptions),
   )
   if err != nil {
   	panic(fmt.Sprintf("Unable to connect to MongoDB: %v\n", err))
   }
   defer func() {
   	_ = encryptedClient.Disconnect(context.TODO())
   }()

   MongoClientSettings clientSettings = MongoClientSettings.builder()
           .applyConnectionString(new ConnectionString(uri))
           .autoEncryptionSettings(autoEncryptionSettings)
           .build();
   try (MongoClient encryptedClient = MongoClients.create(clientSettings)) {

   const encryptedClient = new MongoClient(uri, {
     autoEncryption: autoEncryptionOptions,
   });

   encrypted_client = MongoClient(
       uri, auto_encryption_opts=auto_encryption_options)

5. 暗号化するフィールドの指定

   フィールドを暗号化するには、暗号化スキーマに追加します。 フィールドでクエリを有効にするには、「クエリ」プロパティを追加します。 暗号化スキーマは、次のように作成します。

   MongoDB Shell

   C#

   Go

   Java (Sync)

   Node.js

   Python

   const encryptedFieldsMap = {
     encryptedFields: {
       fields: [
         {
           path: "patientRecord.ssn",
           bsonType: "string",
           queries: { queryType: "equality" },
         },
         {
           path: "patientRecord.billing",
           bsonType: "object",
         },
       ],
     },
   };

   var encryptedFields = new BsonDocument
   {
       {
           "fields", new BsonArray
           {
               new BsonDocument
               {
                   { "keyId", BsonNull.Value },
                   { "path", "record.ssn" },
                   { "bsonType", "string" },
                   { "queries", new BsonDocument("queryType", "equality") }
               },
               new BsonDocument
               {
                   { "keyId", BsonNull.Value },
                   { "path", "record.billing" },
                   { "bsonType", "object" }
               }
           }
       }
   };

   encryptedFieldsMap := bson.M{
   	"fields": []bson.M{
   		bson.M{
   			"keyId":    nil,
   			"path":     "patientRecord.ssn",
   			"bsonType": "string",
   			"queries": []bson.M{
   				{
   					"queryType": "equality",
   				},
   			},
   		},
   		bson.M{
   			"keyId":    nil,
   			"path":     "patientRecord.billing",
   			"bsonType": "object",
   		},
   	},
   }

   BsonDocument encryptedFieldsMap = new BsonDocument().append("fields",
           new BsonArray(Arrays.asList(
                   new BsonDocument()
                           .append("keyId", new BsonNull())
                           .append("path", new BsonString("patientRecord.ssn"))
                           .append("bsonType", new BsonString("string"))
                           .append("queries", new BsonDocument()
                                   .append("queryType", new BsonString("equality"))),
                   new BsonDocument()
                           .append("keyId", new BsonNull())
                           .append("path", new BsonString("patientRecord.billing"))
                           .append("bsonType", new BsonString("object")))));

   const encryptedFieldsMap = {
     encryptedFields: {
       fields: [
         {
           path: "patientRecord.ssn",
           bsonType: "string",
           queries: { queryType: "equality" },
         },
         {
           path: "patientRecord.billing",
           bsonType: "object",
         },
       ],
     },
   };

   encrypted_fields_map = {
       "fields": [
           {
               "path": "patientRecord.ssn",
               "bsonType": "string",
               "queries": [{"queryType": "equality"}]
           },
           {
               "path": "patientRecord.billing",
               "bsonType": "object",
           }
       ]
   }

   注意

   前のコード例では、「ssn」フィールドと「 Billing 」フィールドの両方が暗号化されていますが、クエリは「ssn」フィールドのみです。

6. コレクションの作成

   暗号化ヘルパー メソッドの API にアクセスするには、 ClientEncryptionをインスタンス化します。

   MongoDB Shell

   C#

   Go

   Java (Sync)

   Node.js

   Python

   const clientEncryption = encryptedClient.getClientEncryption()

   var clientEncryptionOptions = new ClientEncryptionOptions(
       keyVaultClient: keyVaultClient,
       keyVaultNamespace: keyVaultNamespace,
       kmsProviders: kmsProviderCredentials
   );
   var clientEncryption = new ClientEncryption(clientEncryptionOptions);

   opts := options.ClientEncryption().
   	SetKeyVaultNamespace(keyVaultNamespace).
   	SetKmsProviders(kmsProviderCredentials)
   clientEncryption, err := mongo.NewClientEncryption(encryptedClient, opts)
   if err != nil {
   	panic(fmt.Sprintf("Unable to create a ClientEncryption instance due to the following error: %s\n", err))
   }

   ClientEncryptionSettings clientEncryptionSettings = ClientEncryptionSettings.builder()
           .keyVaultMongoClientSettings(MongoClientSettings.builder()
                   .applyConnectionString(new ConnectionString(uri))
                   .build())
           .keyVaultNamespace(keyVaultNamespace)
           .kmsProviders(kmsProviderCredentials)
           .build();
   ClientEncryption clientEncryption = ClientEncryptions.create(clientEncryptionSettings);

   const clientEncryption = new ClientEncryption(encryptedClient, autoEncryptionOptions);

   client_encryption = ClientEncryption(
       kms_providers=kms_provider_credentials,
       key_vault_namespace=key_vault_namespace,
       key_vault_client=encrypted_client,
       codec_options=CodecOptions(uuid_representation=STANDARD)
   )

   Because you are using a local Customer Master Key, you don't need to provide Customer Master Key credentials. 暗号化されたコレクションを作成するときに、認証情報の代わりに使用する空のオブジェクトを含む変数を作成します。

   MongoDB Shell

   C#

   Go

   Java (Sync)

   Node.js

   Python

   customerMasterKeyCredentials = {};

   var customerMasterKeyCredentials = new BsonDocument();

   cmkCredentials := map[string]string{}

   BsonDocument customerMasterKeyCredentials = new BsonDocument();

   customerMasterKeyCredentials = {};

   customer_master_key_credentials = {}
   MongoDB Shell

   C#

   Go

   Java (Sync)

   Node.js

   Python

   ClientEncryptionクラスからアクセスされる暗号化ヘルパー メソッドを使用して、暗号化されたコレクションを作成します。 このメソッドは、暗号化されたフィールドのデータ暗号化キーを自動的に生成し、暗号化されたコレクションを作成します。

   await clientEncryption.createEncryptedCollection(
     encryptedDatabaseName,
     encryptedCollectionName,
     {
       provider: kmsProviderName,
       createCollectionOptions: encryptedFieldsMap,
       masterKey: customerMasterKeyCredentials,
     }
   );

   このチュートリアルの C# バージョンでは、ドキュメント構造を表すためのデータモデルとして個別の クラスを使用します。 次のPatient 、 PatientRecord 、 PatientBillingクラスをプロジェクトに追加します。

   using MongoDB.Bson;
   using MongoDB.Bson.Serialization.Attributes;
   [BsonIgnoreExtraElements]
   public class Patient
   {
       public ObjectId Id { get; set; }
       public string Name { get; set; }
       public PatientRecord Record { get; set; }
   }

   public class PatientRecord
   {
       public string Ssn { get; set; }
       public PatientBilling Billing { get; set; }
   }

   public class PatientBilling
   {
       public string CardType { get; set; }
       public long CardNumber { get; set; }
   }

   これらのクラスを追加したら、 ClientEncryptionクラスからアクセスされる暗号化ヘルパー メソッドを使用して暗号化されたコレクションを作成します。 このメソッドは、暗号化されたフィールドのデータ暗号化キーを自動的に生成し、暗号化されたコレクションを作成します。

   var createCollectionOptions = new CreateCollectionOptions<Patient>
   {
       EncryptedFields = encryptedFields
   };
   clientEncryption.CreateEncryptedCollection(patientDatabase,
       encryptedCollectionName,
       createCollectionOptions,
       kmsProviderName,
       customerMasterKeyCredentials);

   暗号化されたコレクションを作成するメソッドには、データベース名ではなく 、データベースオブジェクトへの参照が必要です。 この参照は、クライアント オブジェクトで メソッドを使用して取得できます。

   このチュートリアルのGoバージョンでは、データモデルを使用してドキュメント構造を表します。 コレクション内のデータを表すには、次の構造体をプロジェクトに追加します。

   type PatientDocument struct {
   	PatientName   string        `bson:"patientName"`
   	PatientID     int32         `bson:"patientId"`
   	PatientRecord PatientRecord `bson:"patientRecord"`
   }

   type PatientRecord struct {
   	SSN     string      `bson:"ssn"`
   	Billing PaymentInfo `bson:"billing"`
   }

   type PaymentInfo struct {
   	Type   string `bson:"type"`
   	Number string `bson:"number"`
   }

   これらのクラスを追加したら、 ClientEncryptionクラスからアクセスされる暗号化ヘルパー メソッドを使用して暗号化されたコレクションを作成します。 このメソッドは、暗号化されたフィールドのデータ暗号化キーを自動的に生成し、暗号化されたコレクションを作成します。

   createCollectionOptions := options.CreateCollection().SetEncryptedFields(encryptedFieldsMap)
   _, _, err =
   	clientEncryption.CreateEncryptedCollection(
   		context.TODO(),
   		encryptedClient.Database(encryptedDatabaseName),
   		encryptedCollectionName,
   		createCollectionOptions,
   		kmsProviderName,
   		customerMasterKey,
   	)

   暗号化されたコレクションを作成するメソッドには、データベース名ではなく 、データベースオブジェクトへの参照が必要です。 この参照は、クライアント オブジェクトで メソッドを使用して取得できます。

   ClientEncryptionクラスからアクセスされる暗号化ヘルパー メソッドを使用して、暗号化されたコレクションを作成します。 このメソッドは、暗号化されたフィールドのデータ暗号化キーを自動的に生成し、暗号化されたコレクションを作成します。

   CreateCollectionOptions createCollectionOptions = new CreateCollectionOptions().encryptedFields(encryptedFieldsMap);
   CreateEncryptedCollectionParams encryptedCollectionParams = new CreateEncryptedCollectionParams(kmsProviderName);
   encryptedCollectionParams.masterKey(customerMasterKeyCredentials);
   try {
       clientEncryption.createEncryptedCollection(
               encryptedClient.getDatabase(encryptedDatabaseName),
               encryptedCollectionName,
               createCollectionOptions,
               encryptedCollectionParams);
   } 

   暗号化されたコレクションを作成するメソッドには、データベース名ではなく 、データベースオブジェクトへの参照が必要です。 この参照は、クライアント オブジェクトで メソッドを使用して取得できます。

   ClientEncryptionクラスからアクセスされる暗号化ヘルパー メソッドを使用して、暗号化されたコレクションを作成します。 このメソッドは、暗号化されたフィールドのデータ暗号化キーを自動的に生成し、暗号化されたコレクションを作成します。

   注意

   ClientEncryption のインポート

   Node.js ドライバー v6.0 以降を使用する場合は、 mongodb ClientEncryptionをインポートする必要があります。

   以前のドライバー バージョンの場合は、 mongodb-client-encryption ClientEncryptionをインポートします。

   await clientEncryption.createEncryptedCollection(
     encryptedDatabase,
     encryptedCollectionName,
     {
       provider: kmsProviderName,
       createCollectionOptions: encryptedFieldsMap,
       masterKey: customerMasterKeyCredentials,
     }
   );

   暗号化されたコレクションを作成するメソッドには、データベース名ではなく 、データベースオブジェクトへの参照が必要です。 この参照は、クライアント オブジェクトで メソッドを使用して取得できます。

   ClientEncryptionクラスからアクセスされる暗号化ヘルパー メソッドを使用して、暗号化されたコレクションを作成します。 このメソッドは、暗号化されたフィールドのデータ暗号化キーを自動的に生成し、暗号化されたコレクションを作成します。

   client_encryption.create_encrypted_collection(
       encrypted_client[encrypted_database_name],
       encrypted_collection_name,
       encrypted_fields_map,
       kms_provider_name,
       customer_master_key_credentials,
   )

   暗号化されたコレクションを作成するメソッドには、データベース名ではなく 、データベースオブジェクトへの参照が必要です。 この参照は、クライアント オブジェクトで メソッドを使用して取得できます。

暗号化されたフィールドを含むドキュメントの挿入

const patientDocument = {
  patientName: "Jon Doe",
  patientId: 12345678,
  patientRecord: {
    ssn: "987-65-4320",
    billing: {
      type: "Visa",
      number: "4111111111111111",
    },
  },
};
const encryptedCollection = encryptedClient.getDB(encryptedDatabaseName).getCollection(encryptedCollectionName);
const insertResult = await encryptedCollection.insertOne(patientDocument);

var patient = new Patient
{
    Name = "Jon Doe",
    Id = new ObjectId(),
    Record = new PatientRecord
    {
        Ssn = "987-65-4320",
        Billing = new PatientBilling
        {
            CardType = "Visa",
            CardNumber = 4111111111111111
        }
    }
};
var encryptedCollection = encryptedClient.GetDatabase(encryptedDatabaseName).
    GetCollection<Patient>(encryptedCollectionName);
encryptedCollection.InsertOne(patient);

patientDocument := &PatientDocument{
	PatientName: "John Doe",
	PatientID:   12345678,
	PatientRecord: PatientRecord{
		SSN: "987-65-4320",
		Billing: PaymentInfo{
			Type:   "Visa",
			Number: "4111111111111111",
		},
	},
}
coll := encryptedClient.Database(encryptedDatabaseName).Collection(encryptedCollectionName)
_, err = coll.InsertOne(context.TODO(), patientDocument)
if err != nil {
	panic(fmt.Sprintf("Unable to insert the patientDocument: %s", err))
}

CodecProvider pojoCodecProvider = PojoCodecProvider.builder().automatic(true).build();
CodecRegistry pojoCodecRegistry = fromRegistries(getDefaultCodecRegistry(), fromProviders(pojoCodecProvider));

MongoDatabase encryptedDb = encryptedClient.getDatabase(encryptedDatabaseName).withCodecRegistry(pojoCodecRegistry);
MongoCollection<Patient> collection = encryptedDb.getCollection(encryptedCollectionName, Patient.class);
PatientBilling patientBilling = new PatientBilling("Visa", "4111111111111111");
PatientRecord patientRecord = new PatientRecord("987-65-4320", patientBilling);
Patient patientDocument = new Patient("Jon Doe", patientRecord);
InsertOneResult result = collection.insertOne(patientDocument);

const patientDocument = {
  patientName: "Jon Doe",
  patientId: 12345678,
  patientRecord: {
    ssn: "987-65-4320",
    billing: {
      type: "Visa",
      number: "4111111111111111",
    },
  },
};
const encryptedCollection = encryptedClient
  .db(encryptedDatabaseName)
  .collection(encryptedCollectionName);
const result = await encryptedCollection.insertOne(patientDocument);

patient_document = {
    "patientName": "Jon Doe",
    "patientId": 12345678,
    "patientRecord": {
        "ssn": "987-65-4320",
        "billing": {
            "type": "Visa",
            "number": "4111111111111111",
        },
    },
}
encrypted_collection = encrypted_client[encrypted_database_name][encrypted_collection_name]
result = encrypted_collection.insert_one(patient_document)

暗号化されたフィールドに対するクエリ

次のコード サンプルでは、暗号化されたフィールドに対して検索クエリを実行し、復号化されたデータを出力します。

const findResult = await encryptedCollection.findOne({
  "patientRecord.ssn": "987-65-4320",
});
console.log(findResult);

var ssnFilter = Builders<Patient>.Filter.Eq("record.ssn", patient.Record.Ssn);
var findResult = await encryptedCollection.Find(ssnFilter).ToCursorAsync();
Console.WriteLine(findResult.FirstOrDefault().ToJson());

var findResult PatientDocument
err = coll.FindOne(
	context.TODO(),
	bson.M{"patientRecord.ssn": "987-65-4320"},
).Decode(&findResult)

Patient findResult = collection.find(
    new BsonDocument()
            .append("patientRecord.ssn", new BsonString("987-65-4320")))
            .first();
 
System.out.println(findResult);

const findResult = await encryptedCollection.findOne({
  "patientRecord.ssn": "987-65-4320",
});
console.log(findResult);

find_result = encrypted_collection.find_one({
    "patientRecord.ssn": "987-65-4320"
})
print(find_result)

上記のコード サンプルの出力は、次のようになります。

{
  "_id": {
    "$oid": "648b384a722cb9b8392df76a"
  },
  "name": "Jon Doe",
  "record": {
    "ssn": "987-65-4320",
    "billing": {
      "type": "Visa",
      "number": "4111111111111111"
    }
  },
  "__safeContent__": [
    {
      "$binary": {
        "base64": "L1NsYItk0Sg+oL66DBj6IYHbX7tveANQyrU2cvMzD9Y=",
        "subType": "00"
      }
    }
  ]
}