Remote Blob Store (RBS) (SQL Server)

Van toepassing op:SQL Server

SQL Server Remote BLOB Store (RBS) is een optioneel invoegtoepassingsonderdeel waarmee databasebeheerders binaire grote objecten kunnen opslaan in basisopslagoplossingen in plaats van rechtstreeks op de hoofddatabaseserver.

RBS is opgenomen op het SQL Server-installatiemedium, maar wordt niet geïnstalleerd door het installatieprogramma van SQL Server. Zoek RBS.msi op het installatiemedium om het installatiebestand te vinden.

Als u geen SQL Server-installatiemedia hebt, kunt u RBS downloaden op een van de volgende locaties:

Waarom RBS?

Geoptimaliseerde databaseopslag en -prestaties

Het opslaan van BLOBs in de database kan grote hoeveelheden bestandsruimte en dure serverbronnen verbruiken. RBS brengt de BLOBs over naar een toegewezen opslagoplossing die u kiest en slaat verwijzingen naar de BLOBs in de database op. Hiermee wordt serveropslag voor gestructureerde gegevens vrijgemaakt en worden serverresources voor databasebewerkingen vrijgemaakt.

Efficiënt BLOB-beheer

Verschillende RBS-functies bieden ondersteuning voor opgeslagen BLOBs-beheer:

• BLOBS worden beheerd met ACID-transacties (atomair, consistent, isoleerbaar, duurzaam).

• BLOBs worden ingedeeld in verzamelingen.

• Garbagecollection, consistentiecontrole en andere onderhoudsfuncties zijn opgenomen.

Gestandaardiseerde API

RBS definieert een set API's die een gestandaardiseerd programmeermodel bieden voor toepassingen voor toegang tot en wijziging van een BLOB-archief. Elk BLOB-archief kan een eigen providerbibliotheek opgeven die wordt aangesloten op de RBS-clientbibliotheek en specificeert hoe BLOBs worden opgeslagen en geopend.

Een aantal leveranciers van externe opslagoplossingen hebben RBS-providers ontwikkeld die voldoen aan deze standaard-API's en blobopslag ondersteunen op verschillende opslagplatforms.

Vereisten voor RBS

• Voor RBS is SQL Server Enterprise vereist voor de hoofddatabaseserver waarin de BLOB-metagegevens worden opgeslagen. Als u echter de opgegeven FILESTREAM-provider gebruikt, kunt u de BLOBs zelf opslaan op SQL Server Standard. Om verbinding te maken met SQL Server, vereist RBS ten minste ODBC-stuurprogrammaversie 11 voor SQL Server 2014 (12.x) en ODBC-stuurprogrammaversie 13 voor SQL Server 2016 (13.x). Stuurprogramma's zijn beschikbaar bij ODBC-stuurprogramma downloaden voor SQL Server.

RBS bevat een FILESTREAM-provider waarmee u RBS kunt gebruiken om BLOBs op te slaan op een exemplaar van SQL Server. Als u RBS wilt gebruiken om BLOBs op te slaan in een andere opslagoplossing, moet u een externe RBS-provider gebruiken die is ontwikkeld voor die opslagoplossing of een aangepaste RBS-provider ontwikkelen met behulp van de RBS-API.

RBS-beveiliging

Het sql Remote Blob Storage-teamblog is een goede bron van informatie over deze functie. Het RBS-beveiligingsmodel wordt beschreven in het bericht bij het RBS-beveiligingsmodel.

Aangepaste providers

Wanneer u een aangepaste provider gebruikt om BLOBs buiten SQL Server op te slaan, moet u ervoor zorgen dat u de opgeslagen BLOBs beveiligt met machtigingen en versleutelingsopties die geschikt zijn voor het opslagmedium dat door de aangepaste provider wordt gebruikt.

Symmetrische sleutel voor referentie-opslag

Als een provider de installatie en het gebruik van een geheim vereist dat is opgeslagen in de credentials opslag, gebruikt RBS een symmetrische sleutel om de provider geheimen te versleutelen die een client kan gebruiken om toegang te verkrijgen tot de blob-opslag van de provider.

• RBS 2016 maakt gebruik van een AES_128 symmetrische sleutel. Sql Server 2016 (13.x) staat het maken van nieuwe TRIPLE_DES sleutels niet toe, met uitzondering van achterwaartse compatibiliteitsredenen. Zie CREATE SYMMETRIC KEY (Transact-SQL)voor meer informatie.

• RBS 2014 en eerdere versies gebruiken een referentiearchief dat geheimen bevat die zijn versleuteld met behulp van het TRIPLE_DES symmetrisch sleutelalgoritmen die verouderd zijn. Als u momenteel TRIPLE_DES gebruikt, raadt Microsoft u aan uw beveiliging te verbeteren door de stappen in dit onderwerp te volgen om uw sleutel te roteren naar een sterkere versleutelingsmethode.

U kunt de symmetrische sleuteleigenschappen van het RBS-referentiearchief bepalen door de volgende Transact-SQL instructie uit te voeren in de RBS-database:
SELECT * FROM sys.symmetric_keys WHERE name = 'mssqlrbs_encryption_skey'; Als in de uitvoer van die instructie wordt aangegeven dat TRIPLE_DES nog steeds wordt gebruikt, moet u deze sleutel draaien.

De symmetrische sleutel draaien

Wanneer u RBS gebruikt, moet u de symmetrische sleutel van het referentiearchief periodiek roteren. Dit is een algemene best practice voor beveiliging om te voldoen aan het beveiligingsbeleid van de organisatie. Een manier om de symmetrische sleutel van het RBS-referentiearchief te roteren, is door het onderstaande script in de RBS-database te gebruiken. U kunt dit script ook gebruiken om te migreren naar sterkere eigenschappen van versleutelingssterkte, zoals algoritme of sleutellengte. Maak een back-up van uw database vóór sleutelrotatie. Bij de conclusie van het script heeft het enkele verificatiestappen.
Als voor uw beveiligingsbeleid verschillende sleuteleigenschappen (bijvoorbeeld algoritme of sleutellengte) zijn vereist van de opgegeven sleuteleigenschappen, kan het script worden gebruikt als sjabloon. Wijzig de sleuteleigenschappen op twee plaatsen: 1) het maken van de tijdelijke sleutel 2) het maken van de permanente sleutel.

RBS-middelen

RBS-blog
De RBS-blog biedt aanvullende informatie om u te helpen RBS te begrijpen, implementeren en onderhouden.

Script voor sleutelrotatie

In dit voorbeeld wordt een opgeslagen procedure gemaakt met de naam sp_rotate_rbs_symmetric_credential_key om de momenteel gebruikte symmetrische sleutel voor het RBS-referentiearchief te vervangen
met een van uw keuzen. U wilt dit misschien doen als er een beveiligingsbeleid van kracht is.
periodieke sleutelrotatie of als er specifieke algoritmevereisten zijn.
In deze opgeslagen procedure vervangt een symmetrische sleutel met AES_256 de huidige. Als gevolg van de symmetrische sleutelvervanging moeten geheimen opnieuw worden versleuteld met de nieuwe sleutel. Met deze opgeslagen procedure worden de geheimen ook opnieuw versleuteld. Er moet een back-up van de database worden gemaakt voordat sleutelrotatie wordt uitgevoerd.

CREATE PROC sp_rotate_rbs_symmetric_credential_key  
AS  
BEGIN  
BEGIN TRANSACTION;  
BEGIN TRY  
CLOSE ALL SYMMETRIC KEYS;  
  
/* Prove that all secrets can be re-encrypted, by creating a   
temporary key (#mssqlrbs_encryption_skey) and create a   
temp table (#myTable) to hold the re-encrypted secrets.    
Check to see if all re-encryption worked before moving on.*/  
  
CREATE TABLE #myTable(sql_user_sid VARBINARY(85) NOT NULL,  
    blob_store_id SMALLINT NOT NULL,  
    credential_name NVARCHAR(256) COLLATE Latin1_General_BIN2 NOT NULL,  
    old_secret VARBINARY(MAX), -- holds secrets while existing symmetric key is deleted  
    credential_secret VARBINARY(MAX)); -- holds secrets with the new permanent symmetric key  
  
/* Create a new temporary symmetric key with which the credential store secrets   
can be re-encrypted. These will be used once the existing symmetric key is deleted.*/  
CREATE SYMMETRIC KEY #mssqlrbs_encryption_skey    
    WITH ALGORITHM = AES_256 ENCRYPTION BY   
    CERTIFICATE [cert_mssqlrbs_encryption];  
  
OPEN SYMMETRIC KEY #mssqlrbs_encryption_skey    
    DECRYPTION BY CERTIFICATE [cert_mssqlrbs_encryption];  
  
INSERT INTO #myTable   
    SELECT cred_store.sql_user_sid, cred_store.blob_store_id, cred_store.credential_name,   
    encryptbykey(  
        key_guid('#mssqlrbs_encryption_skey'),   
        decryptbykeyautocert(cert_id('cert_mssqlrbs_encryption'),   
            NULL, cred_store.credential_secret)  
        ),   
    NULL  
    FROM [mssqlrbs_resources].[rbs_internal_blob_store_credentials] AS cred_store;  
  
IF( EXISTS(SELECT * FROM #myTable WHERE old_secret IS NULL))  
BEGIN  
    PRINT 'Abort. Failed to read some values';  
    SELECT * FROM #myTable;  
    ROLLBACK;  
END;  
ELSE  
BEGIN  
/* Re-encryption worked, so drop the existing RBS credential store   
 symmetric key and replace it with a new symmetric key.*/  
DROP SYMMETRIC KEY [mssqlrbs_encryption_skey];  
  
CREATE SYMMETRIC KEY [mssqlrbs_encryption_skey]   
WITH ALGORITHM = AES_256   
ENCRYPTION BY CERTIFICATE [cert_mssqlrbs_encryption];  
  
OPEN SYMMETRIC KEY [mssqlrbs_encryption_skey]   
DECRYPTION BY CERTIFICATE [cert_mssqlrbs_encryption];  
  
/*Re-encrypt using the new permanent symmetric key.    
Verify if encryption provided a result*/  
UPDATE #myTable   
SET [credential_secret] =   
    encryptbykey(key_guid('mssqlrbs_encryption_skey'), decryptbykey(old_secret))  
  
IF( EXISTS(SELECT * FROM #myTable WHERE credential_secret IS NULL))  
BEGIN  
    PRINT 'Aborted. Failed to re-encrypt some values'  
    SELECT * FROM #myTable  
    ROLLBACK  
END  
ELSE  
BEGIN  
  
/* Replace the actual RBS credential store secrets with the newly   
encrypted secrets stored in the temp table #myTable.*/                
SET NOCOUNT ON;  
DECLARE @sql_user_sid varbinary(85);  
DECLARE @blob_store_id smallint;  
DECLARE @credential_name varchar(256);  
DECLARE @credential_secret varbinary(256);  
DECLARE curSecretValue CURSOR   
    FOR SELECT sql_user_sid, blob_store_id, credential_name, credential_secret   
FROM #myTable ORDER BY sql_user_sid, blob_store_id, credential_name;  
  
OPEN curSecretValue;  
FETCH NEXT FROM curSecretValue   
    INTO @sql_user_sid, @blob_store_id, @credential_name, @credential_secret  
WHILE @@FETCH_STATUS = 0  
BEGIN  
    UPDATE [mssqlrbs_resources].[rbs_internal_blob_store_credentials]   
        SET [credential_secret] = @credential_secret   
        FROM [mssqlrbs_resources].[rbs_internal_blob_store_credentials]   
        WHERE sql_user_sid = @sql_user_sid AND blob_store_id = @blob_store_id AND   
            credential_name = @credential_name  
FETCH NEXT FROM curSecretValue   
    INTO @sql_user_sid, @blob_store_id, @credential_name, @credential_secret  
END  
CLOSE curSecretValue  
DEALLOCATE curSecretValue  
  
DROP TABLE #myTable;  
CLOSE ALL SYMMETRIC KEYS;  
DROP SYMMETRIC KEY #mssqlrbs_encryption_skey;  
  
/* Verify that you can decrypt all encrypted credential store entries using the certificate.*/  
IF( EXISTS(SELECT * FROM [mssqlrbs_resources].[rbs_internal_blob_store_credentials]   
WHERE decryptbykeyautocert(cert_id('cert_mssqlrbs_encryption'),   
    NULL, credential_secret) IS NULL))  
BEGIN  
    print 'Aborted. Failed to verify key rotation'  
    ROLLBACK;  
END;  
ELSE  
    COMMIT;  
END;  
END;  
END TRY  
BEGIN CATCH  
     PRINT 'Exception caught: ' + cast(ERROR_NUMBER() as nvarchar) + ' ' + ERROR_MESSAGE();  
     ROLLBACK  
END CATCH  
END;  
GO  

U kunt nu de sp_rotate_rbs_symmetric_credential_key opgeslagen procedure gebruiken om de symmetrische sleutel van het RBS-referentiearchief te roteren en de geheimen blijven hetzelfde voor en na de sleutelrotatie.

SELECT *, decryptbykeyautocert(cert_id('cert_mssqlrbs_encryption'), NULL, credential_secret)   
FROM [mssqlrbs_resources].[rbs_internal_blob_store_credentials];  
  
EXEC sp_rotate_rbs_symmetric_credential_key;  
  
SELECT *, decryptbykeyautocert(cert_id('cert_mssqlrbs_encryption'), NULL, credential_secret)   
FROM [mssqlrbs_resources].[rbs_internal_blob_store_credentials];  
  
/* See that the RBS credential store symmetric key properties reflect the new changes*/  
SELECT * FROM sys.symmetric_keys WHERE name = 'mssqlrbs_encryption_skey';  

Zie ook

Externe Blob Store en AlwaysOn-beschikbaarheidsgroepen (SQL Server)
SYMMETRISCHE SLEUTEL (Transact-SQL) maken