/ /

Crear y realizar una query

Docs Home

/ /

Tutorials

Crear y realizar una query

Crear y realizar una query

Crea una colección cifrada e inserta documentos

Las consultas de igualdad y rango de Queryable Encryption cuentan con soporte completo en producción. Las queries de prefijo, sufijo y subcadena sólo están disponibles en vista previa pública en MongoDB 8.2. No habilite estos tipos de query en producción. La funcionalidad GA de los tipos de consultas de prefijo, sufijo y subcadena será incompatible con la funcionalidad de vista previa. Para aprender más, consulta Tipos de query admitidos.

Overview

Esta guía te muestra cómo crear una colección compatible con cifrado consultable e insertar un documento con campos cifrados.

Después de completar los pasos en esta guía, deberías ser capaz de crear una colección cifrada e insertar un documento con campos que estén cifrados con tu llave maestra de cliente.

Antes de comenzar

Crea tu aplicación habilitada para cifrado consultable antes de crear una colección cifrada.

Si utilizas cifrado explícito, también debes crear con antelación una llave de cifrado de datos única para cada campo cifrado. Para obtener más información, consulta Llaves de cifrado y almacenes de claves.

Procedimiento

Especifica los campos a encriptar

Para cifrar un campo, agrégalos al esquema de cifrado. Para habilitar consultas en un campo, añade el queries propiedad. Se pueden habilitar campos para que sean consultables mediante los siguientes tipos de consultas:

Igualdad
Rango
Prefijo, sufijo o subcadena

Los siguientes pasos muestran cómo especificar los campos a cifrar con cada tipo de query.

Especificar campos para consultas de igualdad

Para habilitar query de igualdad en un campo, añade el campo al esquema de cifrado con un valor queryType de "equality". El siguiente ejemplo de código cifra tanto los campos ssn como billing, pero solo se puede consultar el campo ssn:

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

$encryptedFieldsMap = [
    'encryptedFields' => [
        'fields' => [
            [
                'path' => 'patientRecord.ssn',
                'bsonType' => 'string',
                'queries' => ['queryType' => 'equality'],
                'keyId' => null,
            ],
            [
                'path' => 'patientRecord.billing',
                'bsonType' => 'object',
                'keyId' => null,
            ],
        ],
    ],
];

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

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

let encrypted_fields_map = doc! {
    "fields": [
        {
            "path":     "patientRecord.ssn",
            "bsonType": "string",
            "keyId":    Bson::Null,
            "queries": { "queryType": "equality" },
        },
        {
            "path":     "patientRecord.billing",
            "bsonType": "object",
            "keyId":    Bson::Null,
        },
    ]
};

Especificar campos para consultas de rango

Para habilitar consultas de rango en un campo, añade el campo al esquema de cifrado con un queryType de "range". El siguiente ejemplo añade el campo billAmount al esquema de cifrado creado en el paso anterior y habilita queries de rango en él:

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

$encryptedFieldsMap = [
    'encryptedFields' => [
        'fields' => [
            [
                'path' => 'patientRecord.ssn',
                'bsonType' => 'string',
                'queries' => ['queryType' => 'equality'],
                'keyId' => null,
            ],
            [
                'path' => 'patientRecord.billing',
                'bsonType' => 'object',
                'keyId' => null,
            ],
            [
                'path' => 'patientRecord.billAmount',
                'bsonType' => 'int',
                'queries' => [
                    'queryType' => 'range',
                    'sparsity' => 1,
                    'trimFactor' => 4,
                    'min' => 100,
                    'max' => 2000,
                ],
                'keyId' => null,
            ],
        ],
    ],
];

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

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

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

Especifica los campos para consultas de prefijo, sufijo o subcadena

Nota

MongoDB Shell actualmente no es compatible con consultas de prefijo, sufijo o subcadena en campos cifrados.

Para habilitar consultas de prefijo, sufijo o subcadena en un campo, añade el campo al esquema de cifrado con un queryType de "prefixPreview", "suffixPreview" o "substringPreview" y las opciones asociadas. En el siguiente ejemplo, se habilitan las consultas de prefijo en el campo patientRecord.ssn:

var encryptedFields = new BsonDocument
{
    {
        "fields", new BsonArray
        {
            new BsonDocument
            {
                { "keyId", BsonNull.Value },
                { "path", "patientRecord.ssn" },
                { "bsonType", "string" },
                { "queries", new BsonDocument
                    {
                        { "queryType", "prefixPreview" },
                        { "strMinQueryLength", 3 },
                        { "strMaxQueryLength", 10 },
                        { "caseSensitive", true },
                        { "diacriticSensitive", true }
                    }
                }
            }
        }
    }
};

Tip

query de sufijo

Para activar consultas de sufijos en un campo, cambia la opción queryType a "suffixPreview" en el ejemplo de código anterior.

El siguiente ejemplo habilita las consultas de subcadenas en el campo patientRecord.ssn:

var encryptedFields = new BsonDocument
{
    {
        "fields", new BsonArray
        {
            new BsonDocument
            {
                { "keyId", BsonNull.Value },
                { "path", "patientRecord.ssn" },
                { "bsonType", "string" },
                { "queries", new BsonDocument
                    {
                        { "queryType", "substringPreview" },
                        { "strMaxLength", 12 },
                        { "strMinQueryLength", 3 },
                        { "strMaxQueryLength", 10 },
                        { "caseSensitive", true },
                        { "diacriticSensitive", true }
                    }
                }
            }
        }
    }
};

Nota

Actualmente, el controlador Go no admite consultas de prefijo, sufijo o subcadena en campos cifrados.

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("prefixPreview"))
                        .append("strMinQueryLength", new BsonInt32(3))
                        .append("strMaxQueryLength", new BsonInt32(10))
                        .append("caseSensitive", new BsonBoolean(true))
                        .append("diacriticSensitive", new BsonBoolean(true))))));

Tip

query de sufijo

Para activar consultas de sufijos en un campo, cambia la opción queryType a "suffixPreview" en el ejemplo de código anterior.

El siguiente ejemplo habilita las consultas de subcadenas en el campo patientRecord.ssn:

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("substringPreview"))
                        .append("strMaxLength", new BsonInt32(12))
                        .append("strMinQueryLength", new BsonInt32(3))
                        .append("strMaxQueryLength", new BsonInt32(10))
                        .append("caseSensitive", new BsonBoolean(true))
                        .append("diacriticSensitive", new BsonBoolean(true))))));

const encryptedFieldsMap = {
  encryptedFields: {
    fields: [
      {
        keyId: dek,
        path: "patientRecord.ssn",
        bsonType: "string",
        queries: { 
          queryType: "prefixPreview",
          strMinQueryLength: 3,
          strMaxQueryLength: 10,
          caseSensitive: true,
          diacriticSensitive: true,
        },
      },
    ],
  },
};

Tip

query de sufijo

Para activar consultas de sufijos en un campo, cambia la opción queryType a "suffix" en el ejemplo de código anterior.

El siguiente ejemplo habilita las consultas de subcadenas en el campo patientRecord.ssn:

const encryptedFieldsMap = {
  encryptedFields: {
    fields: [
      {
        keyId: dek,
        path: "patientRecord.ssn",
        bsonType: "string",
        queries: { 
          queryType: "substringPreview",
          strMaxLength: 12,
          strMinQueryLength: 3,
          strMaxQueryLength: 10,
          caseSensitive: true,
          diacriticSensitive: true,
        },
      },
    ],
  },
};

Nota

Actualmente, la librería PHP no admite queries de prefijo, sufijo o subcadena en campos cifrados.

encrypted_fields_map = {
    "fields": [
        {
            "path": "patientRecord.ssn",
            "bsonType": "string",
            "queries": [{
                "queryType": "prefixPreview",
                "strMinQueryLength": 3,
                "strMaxQueryLength": 10,
                "caseSensitive": True,
                "diacriticSensitive": True,
            }]
        },
    ]
}

Tip

query de sufijo

Para activar consultas de sufijos en un campo, cambia la opción queryType a "suffixPreview" en el ejemplo de código anterior.

El siguiente ejemplo habilita las consultas de subcadenas en el campo patientRecord.ssn:

encrypted_fields_map = {
    "fields": [
        {
            "path": "patientRecord.ssn",
            "bsonType": "string",
            "queries": [{
                "queryType": "substringPreview",
                "strMaxLength": 12,
                "strMinQueryLength": 3,
                "strMaxQueryLength": 10,
                "caseSensitive": True,
                "diacriticSensitive": True,
            }]
        },
    ]
}

Nota

Actualmente, el driver de Ruby no admite consultas de prefijo, sufijo ni subcadena en campos cifrados.

Nota

Actualmente, el controlador de Rust no admite consultas de prefijo, sufijo o subcadena en campos cifrados.

Para obtener versiones extendidas de estos pasos, consulte Crear un esquema de cifrado"..

Instancia un objeto de cifrado de cliente para acceder a la API de los métodos asistentes de cifrado

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

$clientEncryption = $encryptedClient->createClientEncryption($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)
)

client_encryption = Mongo::ClientEncryption.new(
  encrypted_client,
  key_vault_namespace: auto_encryption_options[:key_vault_namespace],
  kms_providers: auto_encryption_options[:kms_providers]
)

let encrypted_client = encrypted_client_builder
    .extra_options(Some(doc!{
        "cryptSharedLibPath": env::var("SHARED_LIB_PATH").expect("Set SHARED_LIB_PATH environment variable to path to crypt_shared library")
    }))
    .key_vault_client(Client::with_uri_str(uri).await.unwrap())
    .build()
    .await
    .unwrap();

Crear la colección

Importante

Cree explícitamente su colección, en lugar de crearla implícitamente con una operación de inserción. Cuando creas una colección usando createCollection(), MongoDB crea un índice en los campos cifrados. Sin este índice, las queries en campos cifrados pueden ejecutarse lentamente.

Crea tu colección cifrada utilizando el método de asistente para cifrar al que se accede a través de la clase ClientEncryption. Este método genera automáticamente claves de cifrado de datos para tus campos cifrados y crea la colección cifrada:

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

La versión en C# de este tutorial usa clases separadas como modelos de datos para representar la estructura del documento. Agrega las siguientes clases Patient, PatientRecord y PatientBilling a tu proyecto:

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

Después de agregar estas clases, crea tu colección cifrada utilizando el método asistente de cifrado al que se accede a través de la clase ClientEncryption. Este método genera automáticamente claves de cifrado de datos para tus campos cifrados y crea la colección cifrada:

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

Tip

Base de datos vs. Nombre de la base de datos

El método que crea la colección requiere una referencia a un objeto de base de datos en lugar del nombre de la base de datos.

La versión en Golang de este tutorial utiliza modelos de datos para representar la estructura del documento. Añade las siguientes estructuras a tu proyecto para representar los datos en tu colección:

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

Tip

Base de datos vs. Nombre de la base de datos

El método que crea la colección cifrada requiere una referencia a un objeto de la base de datos en lugar del nombre de la base de datos. Puedes obtener esta referencia utilizando un método en tu 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);
}

Tip

Base de datos vs. Nombre de la base de datos

Nota

Import ClientEncryption

Al utilizar el controlador de Node.js versión 6.0 y posteriores, se debe importar ClientEncryption desde mongodb.

Para versiones anteriores del controlador, importa ClientEncryption de mongodb-client-encryption.

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

Tip

Base de datos vs. Nombre de la base de datos

El método que crea la colección cifrada requiere una referencia a un objeto de base de datos en lugar de al nombre de la base de datos.

Crea tu colección encriptada llamando al método createEncryptedCollection() en tu base de datos. Este método genera automáticamente claves de cifrado de datos para tus campos cifrados y crea la colección cifrada:

$client->getDatabase($encryptedDatabase)->createEncryptedCollection(
    $encryptedCollectionName,
    $clientEncryption,
    $kmsProviderName,
    $customerMasterKeyCredentials,
    $encryptedFieldsMap,
);

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

Tip

Base de datos vs. Nombre de la base de datos

Cree su colección cifrada utilizando el método asistente de cifrado accesible a través de la clase ClientEncryption, como se muestra en el siguiente ejemplo:

client_encryption.create_encrypted_collection(
  encrypted_client.use(encrypted_database_name).database,
  encrypted_collection_name,
  encrypted_fields_map,
  kms_provider_name,
  customer_master_key_credentials
)

Este método genera automáticamente claves de cifrado de datos para tus campos cifrados y crea la colección cifrada.

Tip

Base de datos vs. Nombre de la base de datos

client_encryption.create_encrypted_collection(
    &encrypted_client.database(encrypted_database_name), 
    encrypted_collection_name,
    customer_master_key_credentials
)
.encrypted_fields(encrypted_fields_map)
.await
.1?;

Tip

Base de datos vs. Nombre de la base de datos

El método que crea la colección cifrada requiere una referencia a un objeto de base de datos en vez del nombre de la base de datos. Puedes obtener esta referencia utilizando el método database() en tu objeto cliente.

Para obtener información adicional, consulta Activar el cifrado con capacidad de consulta al crear una colección.

Inserte un documento con campos cifrados

Crea un documento de muestra que describa la información personal de un paciente. Utilice el cliente cifrado para insertarlo en la colección patients, como se muestra en el siguiente ejemplo:

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

Crea un documento de muestra que describa la información personal de un paciente. Utilice el cliente cifrado para insertarlo en la colección patients, como se muestra en el siguiente ejemplo:

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);
await encryptedCollection.InsertOneAsync(patient);

Crea un documento de muestra que describa la información personal de un paciente. Utilice el cliente cifrado para insertarlo en la colección patients, como se muestra en el siguiente ejemplo:

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 datos para representar la estructura del documento. Para configurar tu aplicación para que use POJOs, agrega el siguiente código:

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

Para aprender más sobre Java POJOs, consulta el artículo en Wikipedia sobre Plain Old Java Object (POJO).

Este tutorial utiliza los siguientes POJOs:

Patient
PatientRecord
PatientBilling

Puedes ver estas clases en el paquete de modelos de la aplicación Java completa.

Agrega estas clases POJO a tu aplicación. A continuación, crea una instancia de un Patient que describe la información personal de un paciente. Utiliza el cliente cifrado para insertarlo en la colección patients, como se muestra en el siguiente ejemplo:

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

Crea un documento de muestra que describa la información personal de un paciente. Utilice el cliente cifrado para insertarlo en la colección patients, como se muestra en el siguiente ejemplo:

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

Crea un documento de muestra que describa la información personal de un paciente. Utilice el cliente cifrado para insertarlo en la colección patients, como se muestra en el siguiente ejemplo:

$patientDocument = [
    'patientName' => 'Jon Doe',
    'patientId' => 12345678,
    'patientRecord' => [
        'ssn' => '987-65-4320',
        'billing' => [
            'type' => 'Visa',
            'number' => '4111111111111111',
        ],
        'billAmount' => 1500,
    ],
];
$encryptedCollection = $encryptedClient
    ->getDatabase($encryptedDatabaseName)
    ->getCollection($encryptedCollectionName);
$result = $encryptedCollection->insertOne($patientDocument);

Crea un documento de muestra que describa la información personal de un paciente. Utilice el cliente cifrado para insertarlo en la colección patients, como se muestra en el siguiente ejemplo:

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)

Crea un documento de muestra que describa la información personal de un paciente. Utilice el cliente cifrado para insertarlo en la colección patients, como se muestra en el siguiente ejemplo:

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

Crea un documento de muestra que describa la información personal de un paciente. Utilice el cliente cifrado para insertarlo en la colección patients, como se muestra en el siguiente ejemplo:

let patient_document = doc! {
    "patientName": "Jon Doe",
    "patientId": 12345678,
    "patientRecord": {
        "ssn": "987-65-4320",
        "billing": {
            "type": "Visa",
            "number": "4111111111111111",
        },
        "billAmount": 1500,
    }
};
let encrypted_coll: Collection<Document>  = encrypted_client
    .database(encrypted_database_name)
    .collection(encrypted_collection_name);
let insert_result = encrypted_coll.insert_one(patient_document).await?;

Próximos pasos

Después de crear una colección habilitada para Cifrado consultable, puedes query los campos cifrados.

Volver

Crear y realizar una query

Query