/ /

/ /

Spring Data MongoDB 사용하여 Java 에서 CSFLE 구현

개요

이 가이드 MongoDB 클라이언트 사이드 필드 레벨 암호화 (CSFLE)를 Spring Data MongoDB 와 통합하는 방법을 보여줍니다.

참고

이전에 CSFLE로 작업한 적이 없다면 MongoDB Server 매뉴얼의 CSFLE 튜토리얼 가이드를 참조하세요.

이전에 Spring Data MongoDB로 작업한 적이 없다면 Spring Data MongoDB 문서를 참조하세요.

GitHub 리포지토리

이 가이드 의 소스 코드 보려면 GitHub에서 mongodb-java-spring-boot-csfle 리포지토리 참조하세요.

다음 명령을 실행 하여 GitHub 리포지토리 에서 소스 코드 조회 할 수도 있습니다.

git clone git@github.com:mongodb-developer/mongodb-java-spring-boot-csfle.git

전제 조건

이 가이드 사용하기 전에 다음 단계를 수행하세요.

Java 17설치
MongoDB 자동 암호화 공유 라이브러리 v7.0.2 이상 버전을 설치합니다.
README.md 예시 코드를 실행 방법에 대한 자세한 내용은 README.md를 검토하세요.

또한 MongoDB v7.0.2 이상을 실행하는 MongoDB 클러스터 에 대한 액세스도 필요합니다.

기능 예시

이 예시 프로덕션 환경을 위한 템플릿 코드를 제공하며 다음과 같은 기능을 포함합니다.

여러 개의 암호화됨 컬렉션
자동화된 JSON Schema 생성
서버 측 JSON Schema
데이터 암호화 키(DEK) 및 암호화됨 컬렉션을 위한 분리된 클러스터
자동화된 DEK 생성 또는 조회
Spring Expression Language(SpEL) 평가 확장
자동 구현된 리포지토리
OpenAPI 3.0.1 문서화

이 템플릿은 SOLID 원칙을 따라 코드 가독성과 재사용성을 높입니다. SOLID에 대해 자세히 학습하려면 SOLID 를 참조하세요.

프로젝트 다이어그램

다음 다이어그램은 필드를 자동으로 암호화하고 해독할 수 있는 CSFLE 지원 MongoClient 를 만드는 데 필요한 구성 요소를 보여줍니다. 다이어그램의 화살표는 구성 요소 간의 종속성 및 관계를 보여줍니다.

다이어그램의 화살표는 구성 요소 간의 종속성 및 관계를 보여줍니다.

애플리케이션 MongoDB 와 연결을 설정한 후 다음 다이어그램과 같이 3계층 아키텍처를 사용하여 REST API 노출하고 MongoDB 데이터베이스 와의 통신을 관리 .

키 볼트 컬렉션 만들기

이 섹션에서는 키 볼트 컬렉션 과 해당 고유 인덱스 만드는 방법을 설명합니다.

새 MongoDB cluster 에서 시작하는 경우 먼저 keyAltNames 필드 에 키 볼트 컬렉션 과 해당 고유 인덱스 만들어야 합니다.

키 볼트 및 DEK 설정

KeyVaultAndDekSetup 클래스는 MongoDB 에 대한 표준 연결을 사용하여 키 볼트 컬렉션 과 해당 고유 인덱스 생성합니다. 그런 다음 암호화됨 각 컬렉션 의 문서를 암호화하는 데 필요한 DEK를 만듭니다.

다음 코드는 KeyVaultAndDekSetup 클래스를 보여줍니다.

@Component
public class KeyVaultAndDekSetup {
    private static final Logger LOGGER = LoggerFactory.getLogger(KeyVaultAndDekSetup.class);
    private final KeyVaultService keyVaultService;
    private final DataEncryptionKeyService dataEncryptionKeyService;
    @Value("${spring.data.mongodb.vault.uri}")
    private String CONNECTION_STR;
    public KeyVaultAndDekSetup(KeyVaultService keyVaultService, DataEncryptionKeyService dataEncryptionKeyService) {
        this.keyVaultService = keyVaultService;
        this.dataEncryptionKeyService = dataEncryptionKeyService;
    }
    @PostConstruct
    public void postConstruct() {
        LOGGER.info("=> Start Encryption Setup.");
        LOGGER.debug("=> MongoDB Connection String: {}", CONNECTION_STR);
        MongoClientSettings mcs = MongoClientSettings.builder()
                                                     .applyConnectionString(new ConnectionString(CONNECTION_STR))
                                                     .build();
        try (MongoClient client = MongoClients.create(mcs)) {
            LOGGER.info("=> Created the MongoClient instance for the encryption setup.");
            LOGGER.info("=> Creating the encryption key vault collection.");
            keyVaultService.setupKeyVaultCollection(client);
            LOGGER.info("=> Creating the Data Encryption Keys.");
            EncryptedCollectionsConfiguration.encryptedEntities.forEach(dataEncryptionKeyService::createOrRetrieveDEK);
            LOGGER.info("=> Encryption Setup completed.");
        } catch (Exception e) {
            LOGGER.error("=> Encryption Setup failed: {}", e.getMessage(), e);
        }
    }
}

중요

프로덕션 환경에서는 keyAltNames 필드 에 키 볼트 컬렉션 과 해당 고유 인덱스 수동으로 만들 수 있습니다. 생성한 후에는 이 코드를 제거 할 수 있습니다.

이 코드는 try-with-리소스 차단 에서 표준(CSFLE 지원 아님) 및 임시 MongoClient 연결을 사용하여 MongoDB 클러스터 에 컬렉션 과 인덱스 생성합니다.

키 볼트 컬렉션 만들기

KeyVaultServiceImpl 클래스는 키 볼트 컬렉션 과 keyAltNames 고유 인덱스 생성합니다.

다음 코드는 KeyVaultServiceImpl 클래스를 보여줍니다.

@Service
public class KeyVaultServiceImpl implements KeyVaultService {
    private static final Logger LOGGER = LoggerFactory.getLogger(KeyVaultServiceImpl.class);
    private static final String INDEX_NAME = "uniqueKeyAltNames";
    @Value("${mongodb.key.vault.db}")
    private String KEY_VAULT_DB;
    @Value("${mongodb.key.vault.coll}")
    private String KEY_VAULT_COLL;
    public void setupKeyVaultCollection(MongoClient mongoClient) {
        LOGGER.info("=> Setup the key vault collection {}.{}", KEY_VAULT_DB, KEY_VAULT_COLL);
        MongoDatabase db = mongoClient.getDatabase(KEY_VAULT_DB);
        MongoCollection<Document> vault = db.getCollection(KEY_VAULT_COLL);
        boolean vaultExists = doesCollectionExist(db, KEY_VAULT_COLL);
        if (vaultExists) {
            LOGGER.info("=> Vault collection already exists.");
            if (!doesIndexExist(vault)) {
                LOGGER.info("=> Unique index created on the keyAltNames");
                createKeyVaultIndex(vault);
            }
        } else {
            LOGGER.info("=> Creating a new vault collection & index on keyAltNames.");
            createKeyVaultIndex(vault);
        }
    }
    private void createKeyVaultIndex(MongoCollection<Document> vault) {
        Bson keyAltNamesExists = exists("keyAltNames");
        IndexOptions indexOpts = new IndexOptions().name(INDEX_NAME)
                                                   .partialFilterExpression(keyAltNamesExists)
                                                   .unique(true);
        vault.createIndex(new BsonDocument("keyAltNames", new BsonInt32(1)), indexOpts);
    }
    private boolean doesCollectionExist(MongoDatabase db, String coll) {
        return db.listCollectionNames().into(new ArrayList<>()).stream().anyMatch(c -> c.equals(coll));
    }
    private boolean doesIndexExist(MongoCollection<Document> coll) {
        return coll.listIndexes()
                   .into(new ArrayList<>())
                   .stream()
                   .map(i -> i.get("name"))
                   .anyMatch(n -> n.equals(INDEX_NAME));
    }
}

키 볼트 컬렉션 및 인덱스 만든 후에는 표준 MongoDB 연결을 닫을 수 있습니다.

데이터 암호화 키 생성

이 섹션에서는 ClientEncryption 연결을 사용하여 DEK를 만드는 방법을 보여 줍니다.

키 볼트 클라이언트 구성

MongoDBKeyVaultClientConfiguration 클래스는 DataEncryptionKeyService 가 DEK를 생성하는 데 사용하는 ClientEncryption 빈을 생성합니다.

다음 코드는 MongoDBKeyVaultClientConfiguration 클래스를 보여줍니다.

@Configuration
public class MongoDBKeyVaultClientConfiguration {
    private static final Logger LOGGER = LoggerFactory.getLogger(MongoDBKeyVaultClientConfiguration.class);
    private final KmsService kmsService;
    @Value("${spring.data.mongodb.vault.uri}")
    private String CONNECTION_STR;
    @Value("${mongodb.key.vault.db}")
    private String KEY_VAULT_DB;
    @Value("${mongodb.key.vault.coll}")
    private String KEY_VAULT_COLL;
    private MongoNamespace KEY_VAULT_NS;
    public MongoDBKeyVaultClientConfiguration(KmsService kmsService) {
        this.kmsService = kmsService;
    }
    @PostConstruct
    public void postConstructor() {
        this.KEY_VAULT_NS = new MongoNamespace(KEY_VAULT_DB, KEY_VAULT_COLL);
    }
    /**
     * MongoDB Encryption Client that can manage Data Encryption Keys (DEKs).
     *
     * @return ClientEncryption MongoDB connection that can create or delete DEKs.
     */
    @Bean
    public ClientEncryption clientEncryption() {
        LOGGER.info("=> Creating the MongoDB Key Vault Client.");
        MongoClientSettings mcs = MongoClientSettings.builder()
                                                     .applyConnectionString(new ConnectionString(CONNECTION_STR))
                                                     .build();
        ClientEncryptionSettings ces = ClientEncryptionSettings.builder()
                                                               .keyVaultMongoClientSettings(mcs)
                                                               .keyVaultNamespace(KEY_VAULT_NS.getFullName())
                                                               .kmsProviders(kmsService.getKmsProviders())
                                                               .build();
        return ClientEncryptions.create(ces);
    }
}

키 관리 시스템(KMS) 을 사용하여 ClientEncryption Bean을 만들고 이를 사용하여 DEK를 생성할 수 있습니다. 암호화됨 각 컬렉션 에 대해 하나의 DEK가 필요합니다.

데이터 암호화 키 서비스 구현

DataEncryptionKeyServiceImpl 클래스는 DEK를 만들고 저장합니다. 엔터티의 SpEL 표현식을 평가하여 JSON Schema를 생성하는 경우 DEK를 조회 해야 합니다.

다음 코드는 DataEncryptionKeyServiceImpl 클래스를 보여줍니다.

@Service
public class DataEncryptionKeyServiceImpl implements DataEncryptionKeyService {
    private static final Logger LOGGER = LoggerFactory.getLogger(DataEncryptionKeyServiceImpl.class);
    private final ClientEncryption clientEncryption;
    private final Map<String, String> dataEncryptionKeysB64 = new HashMap<>();
    @Value("${mongodb.kms.provider}")
    private String KMS_PROVIDER;
    public DataEncryptionKeyServiceImpl(ClientEncryption clientEncryption) {
        this.clientEncryption = clientEncryption;
    }
    public Map<String, String> getDataEncryptionKeysB64() {
        LOGGER.info("=> Getting Data Encryption Keys Base64 Map.");
        LOGGER.info("=> Keys in DEK Map: {}", dataEncryptionKeysB64.entrySet());
        return dataEncryptionKeysB64;
    }
    public String createOrRetrieveDEK(EncryptedEntity encryptedEntity) {
        Base64.Encoder b64Encoder = Base64.getEncoder();
        String dekName = encryptedEntity.getDekName();
        BsonDocument dek = clientEncryption.getKeyByAltName(dekName);
        BsonBinary dataKeyId;
        if (dek == null) {
            LOGGER.info("=> Creating Data Encryption Key: {}", dekName);
            DataKeyOptions dko = new DataKeyOptions().keyAltNames(of(dekName));
            dataKeyId = clientEncryption.createDataKey(KMS_PROVIDER, dko);
            LOGGER.debug("=> DEK ID: {}", dataKeyId);
        } else {
            LOGGER.info("=> Existing Data Encryption Key: {}", dekName);
            dataKeyId = dek.get("_id").asBinary();
            LOGGER.debug("=> DEK ID: {}", dataKeyId);
        }
        String dek64 = b64Encoder.encodeToString(dataKeyId.getData());
        LOGGER.debug("=> Base64 DEK ID: {}", dek64);
        LOGGER.info("=> Adding Data Encryption Key to the Map with key: {}",
                    encryptedEntity.getEntityClass().getSimpleName());
        dataEncryptionKeysB64.put(encryptedEntity.getEntityClass().getSimpleName(), dek64);
        return dek64;
    }
}

참고

DEK는 맵에 저장되므로 나중에 JSON 스키마에 대해 다시 조회 필요가 없습니다.

엔터티 정의

Spring Data MongoDB POJO 중심 모델을 사용하여 리포지토리를 구현 하고 문서를 MongoDB 컬렉션에 매핑합니다.

사람 엔터티 만들기

다음 코드는 PersonEntity 클래스를 보여줍니다.

@Document("persons")
@Encrypted(keyId = "#{mongocrypt.keyId(#target)}")
public class PersonEntity {
    @Id
    private ObjectId id;
    private String firstName;
    private String lastName;
    @Encrypted(algorithm = "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic")
    private String ssn;
    @Encrypted(algorithm = "AEAD_AES_256_CBC_HMAC_SHA_512-Random")
    private String bloodType;
    public PersonEntity() {
    }
    public PersonEntity(ObjectId id, String firstName, String lastName, String ssn, String bloodType) {
        this.id = id;
        this.firstName = firstName;
        this.lastName = lastName;
        this.ssn = ssn;
        this.bloodType = bloodType;
    }
    @Override
    public String toString() {
        return "PersonEntity{" + "id=" + id + ", firstName='" + firstName + '\'' + ", lastName='" + lastName + '\'' + ", ssn='" + ssn + '\'' + ", bloodType='" + bloodType + '\'' + '}';
    }
    public ObjectId getId() {
        return id;
    }
    public void setId(ObjectId id) {
        this.id = id;
    }
    public String getFirstName() {
        return firstName;
    }
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }
    public String getLastName() {
        return lastName;
    }
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
    public String getSsn() {
        return ssn;
    }
    public void setSsn(String ssn) {
        this.ssn = ssn;
    }
    public String getBloodType() {
        return bloodType;
    }
    public void setBloodType(String bloodType) {
        this.bloodType = bloodType;
    }
}

앞의 클래스에는 CSFLE를 자동화하는 데 필요한 모든 정보가 포함되어 있습니다. 이 클래스는 다음과 같은 방식으로 @Encrypted 주석을 사용합니다.

@Encrypted 클래스 주석에는 SpEL 표현식 #{mongocrypt.keyId(#target)}이(가) 포함되어 있습니다. 이 표현식 이전 단계에서 생성하거나 조회한 DEK의 keyId 를 지정합니다. CSFLE는 암호화 에 이 DEK를 사용합니다.
ssn 필드 의 @Encrypted 주석은 결정론적 알고리즘 필요함을 지정합니다.
bloodType 필드 의 @Encrypted 주석은 임의의 알고리즘 필요함을 지정합니다.

이 엔터티에 대해 Spring Data MongoDB 에서 생성한 JSON Schema는 다음과 같습니다.

{
  "encryptMetadata": {
    "keyId": [
      {
        "$binary": {
          "base64": "WyHXZ+53SSqCC/6WdCvp0w==",
          "subType": "04"
        }
      }
    ]
  },
  "type": "object",
  "properties": {
    "ssn": {
      "encrypt": {
        "bsonType": "string",
        "algorithm": "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic"
      }
    },
    "bloodType": {
      "encrypt": {
        "bsonType": "string",
        "algorithm": "AEAD_AES_256_CBC_HMAC_SHA_512-Random"
      }
    }
  }
}

SpEL 평가 구성

EntitySpelEvaluationExtension 클래스를 사용하면 SpEL 표현식 을 평가할 수 있습니다. 다음 코드는 이 클래스를 보여줍니다.

@Component
public class EntitySpelEvaluationExtension implements EvaluationContextExtension {
    private static final Logger LOGGER = LoggerFactory.getLogger(EntitySpelEvaluationExtension.class);
    private final DataEncryptionKeyService dataEncryptionKeyService;
    public EntitySpelEvaluationExtension(DataEncryptionKeyService dataEncryptionKeyService) {
        this.dataEncryptionKeyService = dataEncryptionKeyService;
    }
    @Override
    @NonNull
    public String getExtensionId() {
        return "mongocrypt";
    }
    @Override
    @NonNull
    public Map<String, Function> getFunctions() {
        try {
            return Collections.singletonMap("keyId", new Function(
                    EntitySpelEvaluationExtension.class.getMethod("computeKeyId", String.class), this));
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        }
    }
    public String computeKeyId(String target) {
        String dek = dataEncryptionKeyService.getDataEncryptionKeysB64().get(target);
        LOGGER.info("=> Computing dek for target {} => {}", target, dek);
        return dek;
    }
}

참고

이 클래스는 DEK를 조회하여 target와(과) 일치시킵니다. 이 예시 에서 target 은 PersonEntity입니다.

JSON Schema 생성 및 MongoClient 구성

다음 섹션에서는 Spring Data MongoDB 프로젝트 에서 JSON 스키마를 생성하는 방법을 보여줍니다.

스키마 생성 프로세스 이해

JSON 스키마를 생성하려면 Spring Data의 자동 구성을 통해 생성된 MappingContext 엔터티가 필요합니다. 자동 구성은 MongoClient 연결과 MongoTemplate를 생성합니다.

그러나 자동 암호화 활성화된 상태에서 MongoClient 를 생성하려면 JSON 스키마가 필요합니다.

해결책은 MongoClientSettingsBuilderCustomizer 빈을 인스턴스화하여 자동 구성 프로세스 에 JSON Schema 생성을 삽입하는 것입니다.

보안 MongoDB 클라이언트 구성

다음 코드는 MongoDBSecureClientConfiguration 클래스를 보여줍니다.

@Configuration
@DependsOn("keyVaultAndDekSetup")
public class MongoDBSecureClientConfiguration {
    private static final Logger LOGGER = LoggerFactory.getLogger(MongoDBSecureClientConfiguration.class);
    private final KmsService kmsService;
    private final SchemaService schemaService;
    @Value("${crypt.shared.lib.path}")
    private String CRYPT_SHARED_LIB_PATH;
    @Value("${spring.data.mongodb.storage.uri}")
    private String CONNECTION_STR_DATA;
    @Value("${spring.data.mongodb.vault.uri}")
    private String CONNECTION_STR_VAULT;
    @Value("${mongodb.key.vault.db}")
    private String KEY_VAULT_DB;
    @Value("${mongodb.key.vault.coll}")
    private String KEY_VAULT_COLL;
    private MongoNamespace KEY_VAULT_NS;
    public MongoDBSecureClientConfiguration(KmsService kmsService, SchemaService schemaService) {
        this.kmsService = kmsService;
        this.schemaService = schemaService;
    }
    @PostConstruct
    public void postConstruct() {
        this.KEY_VAULT_NS = new MongoNamespace(KEY_VAULT_DB, KEY_VAULT_COLL);
    }
    @Bean
    public MongoClientSettings mongoClientSettings() {
        LOGGER.info("=> Creating the MongoClientSettings for the encrypted collections.");
        return MongoClientSettings.builder().applyConnectionString(new ConnectionString(CONNECTION_STR_DATA)).build();
    }
    @Bean
    public MongoClientSettingsBuilderCustomizer customizer(MappingContext mappingContext) {
        LOGGER.info("=> Creating the MongoClientSettingsBuilderCustomizer.");
        return builder -> {
            MongoJsonSchemaCreator schemaCreator = MongoJsonSchemaCreator.create(mappingContext);
            Map<String, BsonDocument> schemaMap = schemaService.generateSchemasMap(schemaCreator)
                                                               .entrySet()
                                                               .stream()
                                                               .collect(toMap(e -> e.getKey().getFullName(),
                                                                              Map.Entry::getValue));
            Map<String, Object> extraOptions = Map.of("cryptSharedLibPath", CRYPT_SHARED_LIB_PATH,
                                                      "cryptSharedLibRequired", true);
            MongoClientSettings mcs = MongoClientSettings.builder()
                                                         .applyConnectionString(
                                                                 new ConnectionString(CONNECTION_STR_VAULT))
                                                         .build();
            AutoEncryptionSettings oes = AutoEncryptionSettings.builder()
                                                               .keyVaultMongoClientSettings(mcs)
                                                               .keyVaultNamespace(KEY_VAULT_NS.getFullName())
                                                               .kmsProviders(kmsService.getKmsProviders())
                                                               .schemaMap(schemaMap)
                                                               .extraOptions(extraOptions)
                                                               .build();
            builder.autoEncryptionSettings(oes);
        };
    }
}

팁

클러스터마다 다른 백업 보존 정책을 사용하려는 경우 각 클러스터 에 하나의 DEK를 저장 수 있습니다. 이를 통해 클러스터 및 모든 백업에서 법적 컴플라이언스 에 필요할 수 있는 DEK를 완전히 지울 수 있습니다.

자세한 내용은 Java 드라이버 사용한 CSFLE를 참조하세요.

스키마 서비스 구현

다음 코드는 생성된 JSON 스키마를 지도에 저장하는 SchemaServiceImpl 클래스를 보여줍니다.

@Service
public class SchemaServiceImpl implements SchemaService {
    private static final Logger LOGGER = LoggerFactory.getLogger(SchemaServiceImpl.class);
    private Map<MongoNamespace, BsonDocument> schemasMap;
    @Override
    public Map<MongoNamespace, BsonDocument> generateSchemasMap(MongoJsonSchemaCreator schemaCreator) {
        LOGGER.info("=> Generating schema map.");
        List<EncryptedEntity> encryptedEntities = EncryptedCollectionsConfiguration.encryptedEntities;
        return schemasMap = encryptedEntities.stream()
                                             .collect(toMap(EncryptedEntity::getNamespace,
                                                            e -> generateSchema(schemaCreator, e.getEntityClass())));
    }
    @Override
    public Map<MongoNamespace, BsonDocument> getSchemasMap() {
        return schemasMap;
    }
    private BsonDocument generateSchema(MongoJsonSchemaCreator schemaCreator, Class<?> entityClass) {
        BsonDocument schema = schemaCreator.filter(MongoJsonSchemaCreator.encryptedOnly())
                                           .createSchemaFor(entityClass)
                                           .schemaDocument()
                                           .toBsonDocument();
        LOGGER.info("=> JSON Schema for {}:\n{}", entityClass.getSimpleName(),
                    schema.toJson(JsonWriterSettings.builder().indent(true).build()));
        return schema;
    }
}

이 템플릿은 서버 측 JSON Schemas도 구현하기 때문에 애플리케이션 이 JSON Schemas를 저장합니다. 이는 CSFLE의 권장사항입니다.

암호화된 컬렉션 생성 또는 업데이트

서버 측 JSON 스키마 이해

자동 암호화 공유 라이브러리에는 클라이언트 사이드 JSON 스키마만 필요합니다. 그러나 서버 측 JSON Schemas가 없으면 잘못 구성된 다른 클라이언트 또는 클러스터 에 직접 연결된 관리자가 필드를 암호화하지 않고 문서를 삽입하거나 업데이트 수 있습니다.

이를 방지하려면 서버 측 JSON Schema를 사용하여 문서 에 필드 유형을 시행하다 할 수 있습니다.

JSON Schema는 애플리케이션 버전에 따라 변경되므로 애플리케이션 다시 시작할 때마다 JSON Schema를 업데이트해야 합니다.

암호화된 컬렉션 설정 구현

다음 코드는 EncryptedCollectionsSetup 클래스를 보여줍니다.

@Component
public class EncryptedCollectionsSetup {
    private static final Logger LOGGER = LoggerFactory.getLogger(EncryptedCollectionsSetup.class);
    private final MongoClient mongoClient;
    private final SchemaService schemaService;
    public EncryptedCollectionsSetup(MongoClient mongoClient, SchemaService schemaService) {
        this.mongoClient = mongoClient;
        this.schemaService = schemaService;
    }
    @PostConstruct
    public void postConstruct() {
        LOGGER.info("=> Setup the encrypted collections.");
        schemaService.getSchemasMap()
                     .forEach((namespace, schema) -> createOrUpdateCollection(mongoClient, namespace, schema));
    }
    private void createOrUpdateCollection(MongoClient mongoClient, MongoNamespace ns, BsonDocument schema) {
        MongoDatabase db = mongoClient.getDatabase(ns.getDatabaseName());
        String collStr = ns.getCollectionName();
        if (doesCollectionExist(db, ns)) {
            LOGGER.info("=> Updating {} collection's server side JSON Schema.", ns.getFullName());
            db.runCommand(new Document("collMod", collStr).append("validator", jsonSchemaWrapper(schema)));
        } else {
            LOGGER.info("=> Creating encrypted collection {} with server side JSON Schema.", ns.getFullName());
            db.createCollection(collStr, new CreateCollectionOptions().validationOptions(
                    new ValidationOptions().validator(jsonSchemaWrapper(schema))));
        }
    }
    public BsonDocument jsonSchemaWrapper(BsonDocument schema) {
        return new BsonDocument("$jsonSchema", schema);
    }
    private boolean doesCollectionExist(MongoDatabase db, MongoNamespace ns) {
        return db.listCollectionNames()
                 .into(new ArrayList<>())
                 .stream()
                 .anyMatch(c -> c.equals(ns.getCollectionName()));
    }
}

여러 엔터티 지원

이 가이드 의 템플릿은 엔터티 수에 관계없이 지원 수 있습니다.

다른 유형의 엔터티를 추가하려면 이전 단계에서 설명한 대로 3계층 아키텍처의 구성 요소를 만듭니다. 그런 다음 다음 예시 와 같이 엔티티를 EncryptedCollectionsConfiguration 클래스에 추가합니다.

public class EncryptedCollectionsConfiguration {
    public static final List<EncryptedEntity> encryptedEntities = List.of(
            new EncryptedEntity("mydb", "persons", PersonEntity.class, "personDEK"),
            new EncryptedEntity("mydb", "companies", CompanyEntity.class, "companyDEK"));
}

엔터티 클래스의 필드에 @Encrypted(algorithm = "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic") 주석을 추가했기 때문에 프레임워크 서버 측 JSON Schema를 사용하여 DEK를 자동으로 생성하고 암호화됨 컬렉션 만듭니다.

암호화된 필드별 쿼리

이 템플릿은 findFirstBySsn(ssn) 메서드를 구현합니다. 이 방법을 사용하면 이 필드 암호화됨 경우에도 사회 보장 번호로 개인의 문서 찾을 수 있습니다.

참고

이 방법은 결정론적 암호화 알고리즘 사용하기 때문에 가능합니다.

사람 리포지토리 구현

다음 코드는 PersonRepository 인터페이스를 보여줍니다.

@Repository
public interface PersonRepository extends MongoRepository<PersonEntity, String> {
    PersonEntity findFirstBySsn(String ssn);
}

추가 리소스

If you have questions, open an issue in the mongodb-java-spring-boot-csfle 리포지토리에서 문제를 제기하거나 MongoDB Community 포럼에서 질문하세요.

CSFLE에 대해 자세히 학습 다음 리소스를 참조하세요.

Spring Data MongoDB 에 대해 자세히 학습 다음 리소스를 참조하세요.

이 가이드 의 버전은 MongoDB YouTube 채널에서 동영상 형식으로 볼 수 있습니다.

돌아가기

Spring 데이터를 사용한 Spring Boot의 샤딩

MongoDB 와 Spring을 사용하여 마이크로서비스 앱 빌드하기