Crie uma collection criptografada e insira documento

Nesta página

Visão geral

Antes de começar
Procedimento
Próximos passos

Visão geral

Este guia mostra como criar uma coleção habilitada para Queryable Encryption e inserir um documento com campos criptografados.

Depois de concluir as etapas deste guia, você deverá ser capaz de criar uma collection criptografada e inserir um documento com campos criptografados com sua chave mestra do cliente.

Antes de começar

Crie seu aplicação habilitado para Queryable Encryption antes de criar uma collection criptografada.

Se estiver usando criptografia explícita, você também deverá criar uma chave de criptografia de dados exclusiva para cada campo criptografado com antecedência. Para obter mais informações, consulte Chaves de criptografia e cofres de chaves.

Procedimento

Especifique campos para criptografia

Para criptografar um campo, adicione-o ao esquema de criptografia. Para habilitar queries em um campo, adicione a propriedade queries . Você pode habilitar campos para serem consultados por queries de igualdade ou queries de intervalo. As etapas a seguir demonstram como especificar campos para criptografar com cada tipo de query.

Especifique campos para queries de igualdade

Para habilitar queries de igualdade em um campo, adicione o campo ao esquema de criptografia com um queryType de "equality". A seguinte amostra de código criptografa os campos ssn e billing , mas somente o campo ssn pode ser consultado:

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", "patientRecord.ssn" },
                { "bsonType", "string" },
                { "queries", new BsonDocument("queryType", "equality") }
            },
            new BsonDocument
            {
                { "keyId", BsonNull.Value },
                { "path", "patientRecord.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",
        }
    ]
}

Especifique campos para queries de intervalo

Para habilitar queries de intervalo em um campo, adicione o campo ao esquema de criptografia com um queryType de "range". O exemplo seguinte adiciona o campo billAmount ao esquema de criptografia criado na etapa anterior e habilita consultas de faixa nele:

const encryptedFieldsMap = {
  encryptedFields: {
    fields: [
      {
        path: "patientRecord.ssn",
        bsonType: "string",
        queries: { queryType: "equality" },
      },
      {
        path: "patientRecord.billing",
        bsonType: "object",
      },
      {
        path: "patientRecord.billAmount",
        bsonType: "int",
        queries: {
          queryType: "range",
          sparsity: 1,
          trimFactor: 4,
          min: 100,
          max: 2000,
        },
      },
    ],
  },
};

var encryptedFields = new BsonDocument
{
    {
        "fields", new BsonArray
        {
            new BsonDocument
            {
                { "keyId", BsonNull.Value },
                { "path", "patientRecord.ssn" },
                { "bsonType", "string" },
                { "queries", new BsonDocument("queryType", "equality") }
            },
            new BsonDocument
            {
                { "keyId", BsonNull.Value },
                { "path", "patientRecord.billing" },
                { "bsonType", "object" }
            },
            new BsonDocument
            {
                { "keyId", BsonNull.Value },
                { "path", "patientRecord.billAmount" },
                { "bsonType", "int" },
                { "queries", new BsonDocument
                    {
                        { "queryType", "range" },
                        { "sparsity", 1 },
                        { "min", 100 },
                        { "max", 2000 },
                        { "trimFactor", 4 }
                    }
                },
            }
        }
    }
};

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",
		},
		bson.M{
			"keyId":    nil,
			"path":     "patientRecord.billAmount",
			"bsonType": "int",
			"queries": []bson.M{
				{
					"queryType":  "range",
					"sparsity":   1,
					"min":        100,
					"max":        2000,
					"trimFactor": 4,
				},
			},
		},
	},
}

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")),
        new BsonDocument()
                .append("keyId", new BsonNull())
                .append("path", new BsonString("patientRecord.billAmount"))
                .append("bsonType", new BsonString("int"))
                .append("queries", new BsonDocument()
                        .append("queryType", new BsonString("range"))
                        .append("sparsity", new BsonInt32(1))
                        .append("trimFactor", new BsonInt32(4))
                        .append("min", new BsonInt32(100))
                        .append("max", new BsonInt32(2000))
                ))));

const encryptedFieldsMap = {
  encryptedFields: {
    fields: [
      {
        path: "patientRecord.ssn",
        bsonType: "string",
        queries: { queryType: "equality" },
      },
      {
        path: "patientRecord.billing",
        bsonType: "object",
      },
      {
        path: "patientRecord.billAmount",
        bsonType: "int",
        queries: {
          queryType: "range",
          sparsity: 1,
          trimFactor: 4,
          min: 100,
          max: 2000,
        },
      },
    ],
  },
};

encrypted_fields_map = {
    "fields": [
        {
            "path": "patientRecord.ssn",
            "bsonType": "string",
            "queries": [{"queryType": "equality"}]
        },
        {
            "path": "patientRecord.billing",
            "bsonType": "object",
        },
        {
          "path": "patientRecord.billAmount",
          "bsonType": "int",
          "queries": [{ "queryType": "range",
                        "sparsity": 1,
                        "min": 100,
                        "max": 2000, 
                        "trimFactor": 4 }],
        },
    ]
}

Para versões estendidas dessas etapas, consulte Criar um esquema de criptografia.

Instancie `ClientEncryption` para acessar a API para os métodos assistente de criptografia

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

Criar a coleção

Importante

Crie sua coleção explicitamente, ao invés de criá-la implicitamente com uma operação de inserção. Quando você cria uma coleção utilizando createCollection(), MongoDB cria um índice nos campos codificados. Sem esse índice, queries em campos criptografados podem ser executadas lentamente.

Crie sua coleção criptografada usando o método assistente de criptografia acessado por meio da classe ClientEncryption . Este método gera automaticamente chaves de criptografia de dados para seus campos criptografados e cria a coleção criptografada:

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

A versão C# deste tutorial usa classes separadas como Modelo de dados Realm para representar a estrutura do documento. Adicione as seguintes classes Patient, PatientRecord e PatientBilling ao seu projeto:

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

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

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

Após adicionar essas classes, crie sua collection criptografada usando o método auxiliar de encryption acessado por meio da classe ClientEncryption . Esse método gera automaticamente diretório de dados para seu campo criptografados e cria a collection criptografada:

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

Dica

Banco de dados vs. nome do banco de dados

O método que cria a coleção requer uma referência a um objeto de banco de dados de dados em vez do nome do banco de dados de dados.

A versão Go deste tutorial usa modelos de dados para representar a estrutura do documento. Adicione as seguintes estruturas ao seu projeto para representar os dados em sua collection:

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"`
	BillAmount int         `bson:"billAmount"`
}

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

Dica

Banco de dados vs. nome do banco de dados

O método que cria a coleção criptografada requer uma referência a um objeto de banco de dados em vez do nome do banco de dados. Você pode obter essa referência usando um método em seu objeto cliente.

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

Dica

Banco de dados vs. nome do banco de dados

Observação

Importar ClientEncryption

Ao usar o driver Node.js v6.0 e posterior, você deve importar ClientEncryption de mongodb.

Para versões anteriores do driver, importe ClientEncryption de mongodb-client-encryption.

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

Dica

Banco de dados vs. nome do banco de dados

O método que cria a coleção criptografada requer uma referência a um objeto de banco de dados em vez do nome do banco de dados.

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

Dica

Banco de dados vs. nome do banco de dados

Para obter mais informações, consulte Habilitar Queryable Encryption ao criar uma collection.

Inserir um documento com campos criptografados

Crie um documento de amostra que descreva as informações pessoais de um paciente. Use o cliente criptografado para inseri-lo na coleção patients, conforme mostrado no exemplo a seguir:

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

Crie um documento de amostra que descreva as informações pessoais de um paciente. Use o cliente criptografado para inseri-lo na coleção patients, conforme mostrado no exemplo a seguir:

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

Crie um documento de amostra que descreva as informações pessoais de um paciente. Use o cliente criptografado para inseri-lo na coleção patients, conforme mostrado no exemplo a seguir:

patientDocument := &PatientDocument{
	PatientName: "Jon Doe",
	PatientID:   12345678,
	PatientRecord: PatientRecord{
		SSN: "987-65-4320",
		Billing: PaymentInfo{
			Type:   "Visa",
			Number: "4111111111111111",
		},
		BillAmount: 1500,
	},
}
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))
}

Este tutorial utiliza POJOs como modelos de dados para representar a estrutura do documento . Para configurar seu aplicação para usar POJOs, adicione o seguinte código:

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

Para saber mais sobre POJOs Java , consulte o artigo da Java Objeto Java antigo simples.

Este tutorial usa os seguintes POJOs:

Patient
PatientRecord
PatientBilling

Você pode visualizar essas classes no pacote de modelos do aplicação Java completo .

Adicione estas classes POJO ao seu aplicação. Em seguida, crie uma instância de um Patient que descreva as informações pessoais de um pai. Use o cliente criptografado para inseri-lo na collection patients , conforme mostrado no exemplo a seguir:

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, 1500);
Patient patientDocument = new Patient("Jon Doe", patientRecord);
InsertOneResult result = collection.insertOne(patientDocument);

Crie um documento de amostra que descreva as informações pessoais de um paciente. Use o cliente criptografado para inseri-lo na coleção patients, conforme mostrado no exemplo a seguir:

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

Crie um documento de amostra que descreva as informações pessoais de um paciente. Use o cliente criptografado para inseri-lo na coleção patients, conforme mostrado no exemplo a seguir:

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

Próximos passos

Depois de criar uma coleção habilitada para Queryable Encryption, você pode consultar os campos criptografados.

Voltar

Criar e e fazer query

Query

Visão geral

Antes de começar

Procedimento

Especifique campos para criptografia

Instancie ClientEncryption para acessar a API para os métodos assistente de criptografia

Criar a coleção

Importante

Dica

Banco de dados vs. nome do banco de dados

Dica

Banco de dados vs. nome do banco de dados

Dica

Banco de dados vs. nome do banco de dados

Observação

Importar ClientEncryption

Dica

Banco de dados vs. nome do banco de dados

Dica

Banco de dados vs. nome do banco de dados

Inserir um documento com campos criptografados

Próximos passos

Instancie `ClientEncryption` para acessar a API para os métodos assistente de criptografia