_sseMigration(config) {
        if (config.sseMigration) {
            /**
             * For data that was encrypted internally by default and a new external provider is setup.
             * This config helps detect the existing encryption key to decrypt with the good provider.
             * The key format will be migrated automatically on GET/HEADs to include provider details.
             */
            this.sseMigration = {};
            const { previousKeyType, previousKeyProtocol, previousKeyProvider } = config.sseMigration;
            if (!previousKeyType) {
                assert.fail(
                    'NotImplemented: No dynamic KMS key migration. Set sseMigration.previousKeyType');
            }

            // If previousKeyType is provided it's used as static value to migrate the format of the key
            // without additional dynamic evaluation if the key provider is unknown.
            assert(isValidType(previousKeyType),
                'ssenMigration.previousKeyType must be "internal" or "external"');
            this.sseMigration.previousKeyType = previousKeyType;

            let expectedProtocol;
            if (previousKeyType === KmsType.internal) {
                // For internal key type default protocol is file and provider is scality
                this.sseMigration.previousKeyProtocol = previousKeyProtocol || KmsProtocol.file;
                this.sseMigration.previousKeyProvider = previousKeyProvider || 'scality';
                expectedProtocol = [KmsProtocol.scality, KmsProtocol.mem, KmsProtocol.file];
            } else if (previousKeyType === KmsType.external) {
                // No defaults allowed for external provider
                assert(previousKeyProtocol,
                    'sseMigration.previousKeyProtocol must be defined for external provider');
                this.sseMigration.previousKeyProtocol = previousKeyProtocol;
                assert(previousKeyProvider,
                    'sseMigration.previousKeyProvider must be defined for external provider');
                this.sseMigration.previousKeyProvider = previousKeyProvider;
                expectedProtocol = [KmsProtocol.kmip, KmsProtocol.aws_kms];
            }

            assert(isValidProtocol(previousKeyType, this.sseMigration.previousKeyProtocol),
                `sseMigration.previousKeyProtocol must be one of ${expectedProtocol}`);
            assert(isValidProvider(previousKeyProvider),
                'sseMigration.previousKeyProvider must be lowercase alphanumeric only');

            if (this.sseMigration.previousKeyType === KmsType.external) {
                if ([KmsProtocol.file, KmsProtocol.mem].includes(this.backends.kms)) {
                    assert.fail(
                        `sseMigration.previousKeyType "external" can't migrate to "internal" KMS provider ${
                            this.backends.kms}`
                    );
                }
                // We'd have to compare protocol & providerName
                assert.fail('sseMigration.previousKeyType "external" is not yet available');
            }
        }
    }
Configure the backends for Authentication, Data and Metadata.