での自動 の使用Queryable EncryptionAmazon Web Services

kmsProviderCredentials = {  aws: {    accessKeyId: process.env["AWS_ACCESS_KEY_ID"], // Your AWS access key ID    secretAccessKey: process.env["AWS_SECRET_ACCESS_KEY"], // Your AWS secret access key  },};

var kmsProviderCredentials = new Dictionary<string, IReadOnlyDictionary<string, object>>();var kmsOptions = new Dictionary<string, object>{    { "accessKeyId", _appSettings["Aws:AccessKeyId"] }, // Your AWS access key ID    { "secretAccessKey", _appSettings["Aws:SecretAccessKey"] } // Your AWS secret access key};kmsProviderCredentials.Add(kmsProvider, kmsOptions);

kmsProviderCredentials := map[string]map[string]interface{}{	"aws": {		"accessKeyId":     os.Getenv("AWS_ACCESS_KEY_ID"),     // AWS access key ID		"secretAccessKey": os.Getenv("AWS_SECRET_ACCESS_KEY"), // AWS secret access key	},}

Map<String, Object> kmsProviderDetails = new HashMap<>();kmsProviderDetails.put("accessKeyId", getEnv("AWS_ACCESS_KEY_ID")); // Your AWS access key IDkmsProviderDetails.put("secretAccessKey", getEnv("AWS_SECRET_ACCESS_KEY")); // Your AWS secret access key
Map<String, Map<String, Object>> kmsProviderCredentials = new HashMap<String, Map<String, Object>>();kmsProviderCredentials.put("aws", kmsProviderDetails);

kmsProviders = {  aws: {    accessKeyId: process.env.AWS_ACCESS_KEY_ID, // Your AWS access key ID    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY, // Your AWS secret access key  },};

kms_provider_credentials = {    "aws": {        "accessKeyId": os.environ['AWS_ACCESS_KEY_ID'], # Your AWS access key ID        "secretAccessKey": os.environ['AWS_SECRET_ACCESS_KEY'] # Your AWS secret access key    }}

customerMasterKeyCredentials = {  key: process.env["AWS_KEY_ARN"], // Your AWS Key ARN  region: process.env["AWS_KEY_REGION"], // Your AWS Key Region};

var customerMasterKeyCredentials = new BsonDocument{    { "key", _appSettings["Aws:KeyArn"] }, // Your AWS Key ARN    { "region", _appSettings["Aws:KeyRegion"] } // Your AWS Key Region};

customerMasterKeyCredentials := map[string]string{	"key":    os.Getenv("AWS_KEY_ARN"),    // Your AWS Key ARN	"region": os.Getenv("AWS_KEY_REGION"), // Your AWS Key Region}

BsonDocument customerMasterKeyCredentials = new BsonDocument();customerMasterKeyCredentials.put("provider", new BsonString(kmsProviderName));customerMasterKeyCredentials.put("key", new BsonString(getEnv("AWS_KEY_ARN"))); // Your AWS Key ARNcustomerMasterKeyCredentials.put("region", new BsonString(getEnv("AWS_KEY_REGION"))); // Your AWS Key Region

customerMasterKeyCredentials = {  key: process.env.AWS_KEY_ARN, // Your AWS Key ARN  region: process.env.AWS_KEY_REGION, // Your AWS Key Region};

customer_master_key_credentials = {    "key": os.environ['AWS_KEY_ARN'],  # Your AWS Key ARN    "region": os.environ['AWS_KEY_REGION'] # Your AWS Key Region}

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

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

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)

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();

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

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>)

const encryptedClient = Mongo(uri, autoEncryptionOptions);

MongoClientSettings.Extensions.AddAutoEncryption(); // .NET/C# Driver v3.0 or later onlyvar 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)

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",        }    ]}

const clientEncryption = encryptedClient.getClientEncryption()

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

clientEncryptionOpts := options.ClientEncryption().	SetKeyVaultNamespace(keyVaultNamespace).	SetKmsProviders(kmsProviderCredentials)
clientEncryption, err := mongo.NewClientEncryption(encryptedClient, clientEncryptionOpts)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))

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

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; }}

var patientDatabase = encryptedClient.GetDatabase(encryptedDatabaseName);patientDatabase.DropCollection(encryptedCollectionName); // Ensure the collection is dropped before creating a new onetry{    var createCollectionOptions = new CreateCollectionOptions<Patient>    {        EncryptedFields = encryptedFields    };
    clientEncryption.CreateEncryptedCollection(patientDatabase,        encryptedCollectionName,        createCollectionOptions,        kmsProviderName,        customerMasterKeyCredentials);}catch (Exception e){    throw new Exception("Unable to create encrypted collection due to the following error: " + e.Message);}

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"`}

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

CreateCollectionOptions createCollectionOptions = new CreateCollectionOptions().encryptedFields(encryptedFieldsMap);
CreateEncryptedCollectionParams encryptedCollectionParams = new CreateEncryptedCollectionParams(kmsProviderName);encryptedCollectionParams.masterKey(customerMasterKeyCredentials);
try {    clientEncryption.createEncryptedCollection(            encryptedClient.getDatabase(encryptedDatabaseName),            encryptedCollectionName,            createCollectionOptions,            encryptedCollectionParams);} catch (Exception e) {    throw new Exception("Unable to create encrypted collection due to the following error: " + e.getMessage());}

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

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