SQL Server 2014:crittografia di backup nativa

Una nuova funzionalità di SQL Server 2014 di cui molti di voi non avevano sentito parlare fino all'annuncio di questa settimana al PASS Summit è la crittografia di backup nativa nelle edizioni Standard, Business Intelligence ed Enterprise (scusate, Web ed Express non sono supportati). Questo è qualcosa che i fornitori di terze parti offrono da molto tempo e finalmente si fa strada nel prodotto, supportando quattro algoritmi di crittografia:AES 128, AES 192, AES 256 e Triple DES (3DES).

Se stai attualmente utilizzando Transparent Data Encryption esclusivamente allo scopo di avere dati crittografati nei tuoi file di backup, questo potrebbe essere un modo per migrare da quella tecnica e avere backup crittografati senza il colpo che TDE inserisce nel tuo sistema live. Se stai attualmente utilizzando uno strumento di terze parti per i backup crittografati, dovresti confrontarlo con la funzionalità e le prestazioni dei backup crittografati nativi.

PS Puoi scaricare CTP2 in questo momento.

Non volevo confrontarmi con prodotti di terze parti:sono sicuro che fanno tutti un ottimo lavoro e probabilmente hanno funzionalità aggiuntive a cui non ho nemmeno pensato. Volevo solo testare che tipo di colpo avrebbero avuto i diversi algoritmi sui backup completi, da e verso i tradizionali dischi spinny (RAID 1) e le unità a stato solido, e con e senza compressione nativa.

Quindi, ho scaricato il file di dati AdventureWorks2012, ne ho fatto due copie, le ho chiamate awSSD.mdf e awHDD.mdf e posizionarne uno sull'unità RAID 1 (D:\) e uno sull'unità SSD (E:\). Poi ho allegato entrambi con FOR ATTACH_REBUILD_LOG , impostali su FULL ripristino, modificato le impostazioni di crescita automatica predefinite e impostato il percorso predefinito per i file di registro intermedi (poiché questo è l'unico modo che conosco per specificare il percorso del file di registro ricostruito):

USE [master];
GO
 
EXEC xp_instance_regwrite N'HKEY_LOCAL_MACHINE', 
  N'Software\Microsoft\MSSQLServer\MSSQLServer', 
  N'DefaultLog', REG_SZ, N'D:\CTP2_Data';
GO
 
CREATE DATABASE awHDD ON (filename='D:\CTP2_Data\awHDD.mdf') FOR ATTACH_REBUILD_LOG; 
ALTER DATABASE awHDD SET RECOVERY FULL;
ALTER DATABASE awHDD MODIFY FILE (NAME = N'AdventureWorks2012_Data', FILEGROWTH = 512000KB);
ALTER DATABASE awHDD MODIFY FILE (NAME = N'AdventureWorks2012_Log',  FILEGROWTH = 512000KB);
GO
 
EXEC xp_instance_regwrite N'HKEY_LOCAL_MACHINE', 
  N'Software\Microsoft\MSSQLServer\MSSQLServer', 
  N'DefaultLog', REG_SZ, N'E:\CTP2_Data';
GO
 
CREATE DATABASE awSSD ON (filename='E:\CTP2_Data\awSSD.mdf') FOR ATTACH_REBUILD_LOG; 
ALTER DATABASE awSSD SET RECOVERY FULL;
ALTER DATABASE awSSD MODIFY FILE (NAME = N'AdventureWorks2012_Data', FILEGROWTH = 512000KB);
ALTER DATABASE awSSD MODIFY FILE (NAME = N'AdventureWorks2012_Log',  FILEGROWTH = 512000KB);

Successivamente, li ho ingranditi utilizzando questo script di Jonathan Kehayias (in modo che sia il database che il registro fossero abbastanza grandi da essere significativi). Ci sono voluti circa 4 minuti per database sia su HDD che su SSD.

A quel punto, EXEC sp_helpfile; ha prodotto quanto segue per ogni database:

name                       fileid   filename   size                
-----------------------    ------   --------   ----------
AdventureWorks2012_Data	   1        <db>.mdf   1553408 KB
AdventureWorks2012_Log	   2        <db>.ldf   5605504 KB

Ora, un paio di cose su questa funzione prima di poter effettivamente iniziare a eseguire backup crittografati. È necessario disporre di un certificato (o chiave asimmetrica) per utilizzare la crittografia e questo a sua volta richiederà una chiave principale. Ho scelto un certificato e li ho creati come segue:

USE master;
GO
CREATE MASTER KEY ENCRYPTION BY PASSWORD = 'p@ssw0rd';
GO
OPEN MASTER KEY DECRYPTION BY PASSWORD = 'p@ssw0rd';
GO
CREATE CERTIFICATE TestCert WITH SUBJECT = 'EncryptionTesting';
GO

Viene visualizzato un avviso anche se si tenta di creare un backup crittografato utilizzando un certificato di cui non è stato eseguito il backup di per sé:

Nel mio caso potrei semplicemente eseguire il backup del certificato e della chiave principale, in questo modo:

BACKUP CERTIFICATE TestCert 
  TO FILE = 'C:\temp\TestCert.cert' 
  WITH PRIVATE KEY 
  (
    FILE = 'C:\temp\TestCert.key', 
    ENCRYPTION BY PASSWORD = 'p@ssw0rd'
  );
 
BACKUP MASTER KEY TO FILE = 'C:\temp\MasterKey.key' 
  ENCRYPTION BY PASSWORD = 'p@ssw0rd';

A rigor di termini, il backup della chiave principale non è necessario per eseguire un backup crittografato (o anche per evitare l'avviso), ma dovresti comunque eseguirne il backup. E probabilmente vorrai usare una password più forte di p@ssw0rd , salvalo in un posto diverso dall'unità C:sulla stessa macchina, ecc. Infine, dovresti prestare attenzione che se crittografi i tuoi backup e non prendi tutte le dovute precauzioni, potrebbero essere inutili in caso di disastro . Questa non è una funzione che dovresti semplicemente attivare senza una buona dose di diligenza e test.

Con tutto questo fuori mano, potrei andare avanti con i test. Questo sistema ha un solo disco basato su piatto e un singolo SSD, quindi non ho potuto testare SSD -> SSD o HDD diversi -> HDD diversi; solo il backup dall'uno all'altro o sulla stessa unità. La sintassi di base per il backup con crittografia è:

BACKUP DATABASE ... WITH ENCRYPTION 
  (ALGORITHM = <algorithm>, SERVER CERTIFICATE = <certificate>);

E i quattro valori possibili per <algorithm> sono AES_128 , AES_192 , AES_256 e TRIPLE_DES_3KEY .

Quindi, successivamente, ho generato lo script per eseguire i backup per confrontare le prestazioni e le dimensioni di varie combinazioni:i quattro diversi algoritmi di crittografia (e nessuna crittografia), con e senza compressione, da dove provengono i dati (HDD o SSD) e da dove viene eseguito il backup dei dati su (HDD o SSD). Sono 40 backup diversi e lo script che ho usato per generarlo è simile al seguente:

DECLARE @sql NVARCHAR(MAX) = N'';
 
;WITH s(s) AS (SELECT 1 UNION ALL SELECT 2),
m AS (SELECT m FROM (VALUES('AES_128'),('AES_192'),('AES_256'),('TRIPLE_DES_3KEY'),(NULL)) AS m(m)),
c AS (SELECT c FROM (VALUES('NO_COMPRESSION'),('COMPRESSION')) AS c(c)),
d AS (SELECT d,t FROM (VALUES('D','HDD'),('E','SSD')) AS d(d,t))
SELECT @sql += N'
BACKUP DATABASE aw' + CASE s WHEN 1 THEN 'HDD' ELSE 'SSD' END 
 + ' TO DISK = 
 ''' + d + ':\backup\' + n + '.bak''
 WITH INIT, ' + c + ',' + COALESCE('
 ENCRYPTION (ALGORITHM = ' + m + ', SERVER CERTIFICATE = TestCert),', '') + '
 NAME = ''' + n + ''';' FROM 
 (
  SELECT *, n = 'test' + CONVERT(VARCHAR(8000), RIGHT('0' + RTRIM(r),2)) + '-' +    
   COALESCE(m,'NO_ENCRYPTION') + '-' + CASE WHEN r < 11 THEN 'HDD' ELSE 'SSD' END 
   + '-to-' + t + '-' + c FROM 
   (
     SELECT *, r = ROW_NUMBER() OVER (PARTITION BY d.d ORDER BY s.s,m.m,c.c) 
      FROM s CROSS JOIN m CROSS JOIN c CROSS JOIN d
   ) AS x
) AS y ORDER BY r;
 
--EXEC sp_executesql @sql;
--GO 10
 
SELECT CONVERT(XML, @sql);

Sembra davvero complicato, ma in realtà sta solo generando 40 BACKUP DATABASE stringhe. Seleziono come XML in modo che, quando fai clic sui risultati nella griglia, puoi visualizzare l'intero output, invece di ciò che PRINT o selezionando l'output in griglia/testo ti limiterai a. L'output in questo caso è di seguito (fai clic per mostrare/nascondere):

BACKUP DATABASE awHDD TO DISK = 'D:\backup\test01-NO_ENCRYPTION-HDD-to-HDD-COMPRESSION.bak'
 WITH INIT, COMPRESSION, NAME = 'test01-NO_ENCRYPTION-HDD-to-HDD-COMPRESSION';
BACKUP DATABASE awHDD TO DISK = 'E:\backup\test01-NO_ENCRYPTION-HDD-to-SSD-COMPRESSION.bak'
 WITH INIT, COMPRESSION, NAME = 'test01-NO_ENCRYPTION-HDD-to-SSD-COMPRESSION';
BACKUP DATABASE awHDD TO DISK = 'E:\backup\test02-NO_ENCRYPTION-HDD-to-SSD-NO_COMPRESSION.bak'
 WITH INIT, NO_COMPRESSION, NAME = 'test02-NO_ENCRYPTION-HDD-to-SSD-NO_COMPRESSION';
BACKUP DATABASE awHDD TO DISK = 'D:\backup\test02-NO_ENCRYPTION-HDD-to-HDD-NO_COMPRESSION.bak'
 WITH INIT, NO_COMPRESSION, NAME = 'test02-NO_ENCRYPTION-HDD-to-HDD-NO_COMPRESSION';
BACKUP DATABASE awHDD TO DISK = 'D:\backup\test03-AES_128-HDD-to-HDD-COMPRESSION.bak'
 WITH INIT, COMPRESSION, ENCRYPTION (ALGORITHM = AES_128, SERVER CERTIFICATE = TestCert),
 NAME = 'test03-AES_128-HDD-to-HDD-COMPRESSION';
BACKUP DATABASE awHDD TO DISK = 'E:\backup\test03-AES_128-HDD-to-SSD-COMPRESSION.bak'
 WITH INIT, COMPRESSION, ENCRYPTION (ALGORITHM = AES_128, SERVER CERTIFICATE = TestCert),
 NAME = 'test03-AES_128-HDD-to-SSD-COMPRESSION';
BACKUP DATABASE awHDD TO DISK = 'E:\backup\test04-AES_128-HDD-to-SSD-NO_COMPRESSION.bak'
 WITH INIT, NO_COMPRESSION, ENCRYPTION (ALGORITHM = AES_128, SERVER CERTIFICATE = TestCert),
 NAME = 'test04-AES_128-HDD-to-SSD-NO_COMPRESSION';
BACKUP DATABASE awHDD TO DISK = 'D:\backup\test04-AES_128-HDD-to-HDD-NO_COMPRESSION.bak'
 WITH INIT, NO_COMPRESSION, ENCRYPTION (ALGORITHM = AES_128, SERVER CERTIFICATE = TestCert),
 NAME = 'test04-AES_128-HDD-to-HDD-NO_COMPRESSION';
BACKUP DATABASE awHDD TO DISK = 'D:\backup\test05-AES_192-HDD-to-HDD-COMPRESSION.bak'
 WITH INIT, COMPRESSION, ENCRYPTION (ALGORITHM = AES_192, SERVER CERTIFICATE = TestCert),
 NAME = 'test05-AES_192-HDD-to-HDD-COMPRESSION';
BACKUP DATABASE awHDD TO DISK = 'E:\backup\test05-AES_192-HDD-to-SSD-COMPRESSION.bak'
 WITH INIT, COMPRESSION, ENCRYPTION (ALGORITHM = AES_192, SERVER CERTIFICATE = TestCert),
 NAME = 'test05-AES_192-HDD-to-SSD-COMPRESSION';
BACKUP DATABASE awHDD TO DISK = 'E:\backup\test06-AES_192-HDD-to-SSD-NO_COMPRESSION.bak'
 WITH INIT, NO_COMPRESSION, ENCRYPTION (ALGORITHM = AES_192, SERVER CERTIFICATE = TestCert),
 NAME = 'test06-AES_192-HDD-to-SSD-NO_COMPRESSION';
BACKUP DATABASE awHDD TO DISK = 'D:\backup\test06-AES_192-HDD-to-HDD-NO_COMPRESSION.bak'
 WITH INIT, NO_COMPRESSION, ENCRYPTION (ALGORITHM = AES_192, SERVER CERTIFICATE = TestCert),
 NAME = 'test06-AES_192-HDD-to-HDD-NO_COMPRESSION';
BACKUP DATABASE awHDD TO DISK = 'D:\backup\test07-AES_256-HDD-to-HDD-COMPRESSION.bak'
 WITH INIT, COMPRESSION, ENCRYPTION (ALGORITHM = AES_256, SERVER CERTIFICATE = TestCert),
 NAME = 'test07-AES_256-HDD-to-HDD-COMPRESSION';
BACKUP DATABASE awHDD TO DISK = 'E:\backup\test07-AES_256-HDD-to-SSD-COMPRESSION.bak'
 WITH INIT, COMPRESSION, ENCRYPTION (ALGORITHM = AES_256, SERVER CERTIFICATE = TestCert),
 NAME = 'test07-AES_256-HDD-to-SSD-COMPRESSION';
BACKUP DATABASE awHDD TO DISK = 'E:\backup\test08-AES_256-HDD-to-SSD-NO_COMPRESSION.bak'
 WITH INIT, NO_COMPRESSION, ENCRYPTION (ALGORITHM = AES_256, SERVER CERTIFICATE = TestCert),
 NAME = 'test08-AES_256-HDD-to-SSD-NO_COMPRESSION';
BACKUP DATABASE awHDD TO DISK = 'D:\backup\test08-AES_256-HDD-to-HDD-NO_COMPRESSION.bak'
 WITH INIT, NO_COMPRESSION, ENCRYPTION (ALGORITHM = AES_256, SERVER CERTIFICATE = TestCert),
 NAME = 'test08-AES_256-HDD-to-HDD-NO_COMPRESSION';
BACKUP DATABASE awHDD TO DISK = 'D:\backup\test09-TRIPLE_DES_3KEY-HDD-to-HDD-COMPRESSION.bak'
 WITH INIT, COMPRESSION, ENCRYPTION (ALGORITHM = TRIPLE_DES_3KEY, SERVER CERTIFICATE = TestCert),
 NAME = 'test09-TRIPLE_DES_3KEY-HDD-to-HDD-COMPRESSION';
BACKUP DATABASE awHDD TO DISK = 'E:\backup\test09-TRIPLE_DES_3KEY-HDD-to-SSD-COMPRESSION.bak'
 WITH INIT, COMPRESSION, ENCRYPTION (ALGORITHM = TRIPLE_DES_3KEY, SERVER CERTIFICATE = TestCert),
 NAME = 'test09-TRIPLE_DES_3KEY-HDD-to-SSD-COMPRESSION';
BACKUP DATABASE awHDD TO DISK = 'E:\backup\test10-TRIPLE_DES_3KEY-HDD-to-SSD-NO_COMPRESSION.bak'
 WITH INIT, NO_COMPRESSION, ENCRYPTION (ALGORITHM = TRIPLE_DES_3KEY, SERVER CERTIFICATE = TestCert),
 NAME = 'test10-TRIPLE_DES_3KEY-HDD-to-SSD-NO_COMPRESSION';
BACKUP DATABASE awHDD TO DISK = 'D:\backup\test10-TRIPLE_DES_3KEY-HDD-to-HDD-NO_COMPRESSION.bak'
 WITH INIT, NO_COMPRESSION, ENCRYPTION (ALGORITHM = TRIPLE_DES_3KEY, SERVER CERTIFICATE = TestCert),
 NAME = 'test10-TRIPLE_DES_3KEY-HDD-to-HDD-NO_COMPRESSION';
BACKUP DATABASE awSSD TO DISK = 'D:\backup\test11-NO_ENCRYPTION-SSD-to-HDD-COMPRESSION.bak'
 WITH INIT, COMPRESSION, NAME = 'test11-NO_ENCRYPTION-SSD-to-HDD-COMPRESSION';
BACKUP DATABASE awSSD TO DISK = 'E:\backup\test11-NO_ENCRYPTION-SSD-to-SSD-COMPRESSION.bak'
 WITH INIT, COMPRESSION, NAME = 'test11-NO_ENCRYPTION-SSD-to-SSD-COMPRESSION';
BACKUP DATABASE awSSD TO DISK = 'E:\backup\test12-NO_ENCRYPTION-SSD-to-SSD-NO_COMPRESSION.bak'
 WITH INIT, NO_COMPRESSION, NAME = 'test12-NO_ENCRYPTION-SSD-to-SSD-NO_COMPRESSION';
BACKUP DATABASE awSSD TO DISK = 'D:\backup\test12-NO_ENCRYPTION-SSD-to-HDD-NO_COMPRESSION.bak'
 WITH INIT, NO_COMPRESSION, NAME = 'test12-NO_ENCRYPTION-SSD-to-HDD-NO_COMPRESSION';
BACKUP DATABASE awSSD TO DISK = 'D:\backup\test13-AES_128-SSD-to-HDD-COMPRESSION.bak'
 WITH INIT, COMPRESSION, ENCRYPTION (ALGORITHM = AES_128, SERVER CERTIFICATE = TestCert),
 NAME = 'test13-AES_128-SSD-to-HDD-COMPRESSION';
BACKUP DATABASE awSSD TO DISK = 'E:\backup\test13-AES_128-SSD-to-SSD-COMPRESSION.bak'
 WITH INIT, COMPRESSION, ENCRYPTION (ALGORITHM = AES_128, SERVER CERTIFICATE = TestCert),
 NAME = 'test13-AES_128-SSD-to-SSD-COMPRESSION';
BACKUP DATABASE awSSD TO DISK = 'E:\backup\test14-AES_128-SSD-to-SSD-NO_COMPRESSION.bak'
 WITH INIT, NO_COMPRESSION, ENCRYPTION (ALGORITHM = AES_128, SERVER CERTIFICATE = TestCert),
 NAME = 'test14-AES_128-SSD-to-SSD-NO_COMPRESSION';
BACKUP DATABASE awSSD TO DISK = 'D:\backup\test14-AES_128-SSD-to-HDD-NO_COMPRESSION.bak'
 WITH INIT, NO_COMPRESSION, ENCRYPTION (ALGORITHM = AES_128, SERVER CERTIFICATE = TestCert),
 NAME = 'test14-AES_128-SSD-to-HDD-NO_COMPRESSION';
BACKUP DATABASE awSSD TO DISK = 'D:\backup\test15-AES_192-SSD-to-HDD-COMPRESSION.bak'
 WITH INIT, COMPRESSION, ENCRYPTION (ALGORITHM = AES_192, SERVER CERTIFICATE = TestCert),
 NAME = 'test15-AES_192-SSD-to-HDD-COMPRESSION';
BACKUP DATABASE awSSD TO DISK = 'E:\backup\test15-AES_192-SSD-to-SSD-COMPRESSION.bak'
 WITH INIT, COMPRESSION, ENCRYPTION (ALGORITHM = AES_192, SERVER CERTIFICATE = TestCert),
 NAME = 'test15-AES_192-SSD-to-SSD-COMPRESSION';
BACKUP DATABASE awSSD TO DISK = 'E:\backup\test16-AES_192-SSD-to-SSD-NO_COMPRESSION.bak'
 WITH INIT, NO_COMPRESSION, ENCRYPTION (ALGORITHM = AES_192, SERVER CERTIFICATE = TestCert),
 NAME = 'test16-AES_192-SSD-to-SSD-NO_COMPRESSION';
BACKUP DATABASE awSSD TO DISK = 'D:\backup\test16-AES_192-SSD-to-HDD-NO_COMPRESSION.bak'
 WITH INIT, NO_COMPRESSION, ENCRYPTION (ALGORITHM = AES_192, SERVER CERTIFICATE = TestCert),
 NAME = 'test16-AES_192-SSD-to-HDD-NO_COMPRESSION';
BACKUP DATABASE awSSD TO DISK = 'D:\backup\test17-AES_256-SSD-to-HDD-COMPRESSION.bak'
 WITH INIT, COMPRESSION, ENCRYPTION (ALGORITHM = AES_256, SERVER CERTIFICATE = TestCert),
 NAME = 'test17-AES_256-SSD-to-HDD-COMPRESSION';
BACKUP DATABASE awSSD TO DISK = 'E:\backup\test17-AES_256-SSD-to-SSD-COMPRESSION.bak'
 WITH INIT, COMPRESSION, ENCRYPTION (ALGORITHM = AES_256, SERVER CERTIFICATE = TestCert),
 NAME = 'test17-AES_256-SSD-to-SSD-COMPRESSION';
BACKUP DATABASE awSSD TO DISK = 'E:\backup\test18-AES_256-SSD-to-SSD-NO_COMPRESSION.bak'
 WITH INIT, NO_COMPRESSION, ENCRYPTION (ALGORITHM = AES_256, SERVER CERTIFICATE = TestCert),
 NAME = 'test18-AES_256-SSD-to-SSD-NO_COMPRESSION';
BACKUP DATABASE awSSD TO DISK = 'D:\backup\test18-AES_256-SSD-to-HDD-NO_COMPRESSION.bak'
 WITH INIT, NO_COMPRESSION, ENCRYPTION (ALGORITHM = AES_256, SERVER CERTIFICATE = TestCert),
 NAME = 'test18-AES_256-SSD-to-HDD-NO_COMPRESSION';
BACKUP DATABASE awSSD TO DISK = 'D:\backup\test19-TRIPLE_DES_3KEY-SSD-to-HDD-COMPRESSION.bak'
 WITH INIT, COMPRESSION, ENCRYPTION (ALGORITHM = TRIPLE_DES_3KEY, SERVER CERTIFICATE = TestCert),
 NAME = 'test19-TRIPLE_DES_3KEY-SSD-to-HDD-COMPRESSION';
BACKUP DATABASE awSSD TO DISK = 'E:\backup\test19-TRIPLE_DES_3KEY-SSD-to-SSD-COMPRESSION.bak'
 WITH INIT, COMPRESSION, ENCRYPTION (ALGORITHM = TRIPLE_DES_3KEY, SERVER CERTIFICATE = TestCert),
 NAME = 'test19-TRIPLE_DES_3KEY-SSD-to-SSD-COMPRESSION';
BACKUP DATABASE awSSD TO DISK = 'E:\backup\test20-TRIPLE_DES_3KEY-SSD-to-SSD-NO_COMPRESSION.bak'
 WITH INIT, NO_COMPRESSION, ENCRYPTION (ALGORITHM = TRIPLE_DES_3KEY, SERVER CERTIFICATE = TestCert),
 NAME = 'test20-TRIPLE_DES_3KEY-SSD-to-SSD-NO_COMPRESSION';
BACKUP DATABASE awSSD TO DISK = 'D:\backup\test20-TRIPLE_DES_3KEY-SSD-to-HDD-NO_COMPRESSION.bak'
 WITH INIT, NO_COMPRESSION, ENCRYPTION (ALGORITHM = TRIPLE_DES_3KEY, SERVER CERTIFICATE = TestCert),
 NAME = 'test20-TRIPLE_DES_3KEY-SSD-to-HDD-NO_COMPRESSION';

Non avevo bisogno di fare nulla di speciale per cronometrarli, perché potevo estrarre tutte le statistiche rilevanti dal database msdb dopo che erano state completate (l'unico aspetto negativo è che la durata è misurata solo con la granularità dei secondi, a meno che non lo volessi per analizzare l'output manualmente). Quindi ho decommentato il EXEC sp_executesql e GO linee (volevo eseguire ogni backup 10 volte per ottenere medie, escludere anomalie, ecc.), premere F5 e sono andato a lavorare su una delle mie sessioni per il PASS Summit.

Quando sono tornato, ho controllato le tabelle msdb per ottenere le dimensioni / durate per ogni backup. Questa domanda è abbastanza semplice:

;WITH x AS
(
  SELECT 
    name, 
    natural_size    = backup_size/1024/1024.0, 
    compressed_size = compressed_backup_size/1024/1024.0,
    duration        = 1.0*DATEDIFF(SECOND, backup_start_date, backup_finish_date)
  FROM msdb.dbo.backupset 
  WHERE name LIKE 'test%'
)
SELECT 
  name, 
  [natural_size]    = MAX(natural_size), 
  [compressed_size] = MAX(compressed_size), 
  [min_duration]    = MIN(duration),
  [max_duration]    = MAX(duration), 
  [avg_duration]    = AVG(duration)
FROM x 
GROUP BY name
ORDER BY name;

Questo mi darebbe i dati di cui avevo bisogno per creare dei graziosi grafici.

Impatto sulle dimensioni

A seconda della tua esperienza con la crittografia in generale, potrebbe sorprenderti o meno che la crittografia di un backup del database abbia un impatto minimo sulle sue dimensioni complessive. Come funziona va oltre lo scopo di questo post, di certo; una semplice spiegazione sarebbe che, almeno con la crittografia AES, la compressione non è molto efficace sulla maggior parte dell'output perché è fondamentalmente incomprensibile casuale.

Il risultato finale è che questo grafico non è molto eccitante. Le dimensioni compresse e non compresse dei backup nativi rispetto ai quattro diversi metodi di crittografia:

Dimensioni, in MB, dei backup con e senza crittografia

Come puoi vedere, l'impatto sulle dimensioni del database è stato quasi nullo:circa lo 0,03% in più per un backup non compresso e un ulteriore 0,04% per un backup compresso.

Impatto sulle prestazioni

Sebbene la crittografia abbia avuto un impatto trascurabile sulle dimensioni, ha fatto influenzare la velocità del backup. Ma in alcuni casi, non nel modo in cui penseresti. Ecco la misura complessiva dei tempi di esecuzione medi per ciascun approccio:

Durata media, in secondi, di vari backup

Mi aspettavo davvero che la crittografia causasse sempre un calo delle prestazioni e dovresti testare nel tuo ambiente per vedere se i tuoi risultati sono diversi dai miei. Tornerò e aggiornerò questo con un nuovo grafico che mostra casi particolari che sono stati sorprendenti per me e rimuoverò alcuni valori anomali per assicurarmi che i risultati siano veramente rappresentativi.

Un avvertimento

Una nota importante:non è possibile aggiungere backup crittografati. Se generi un file di backup crittografato utilizzando WITH INIT , quindi prova ad aggiungere un altro backup crittografato allo stesso file, riceverai questo errore:

Puoi, in modo confuso, aggiungere un non -backup crittografato quando il file iniziale è stato crittografato. Questa non è l'intenzione, ed è un bug che ho segnalato su Connect (#805220, ma è attualmente contrassegnato come privato); si spera che affrontino questo problema prima di RTM.

Nel frattempo, devi stare attento qui perché non è stato cambiato nulla su RESTORE HEADERONLY output per indicare se uno qualsiasi dei backup inclusi è stato crittografato. Per scoprirlo, dovrai controllare il BackupSetGUID valore in quell'output in Position = 1 e trova il backup_set_uuid corrispondente valore in msdb.dbo.backupset . Questa tabella ha nuove colonne per supportare la crittografia, da cui puoi ottenere queste informazioni:key_algorithm , encryptor_thumbprint e encryptor_type . Questo è problematico nei casi in cui non hai il backupset dati:forse è stato cancellato durante le attività di manutenzione, o forse non puoi accedervi perché ti stai davvero riprendendo da un disastro o hai solo il file .bak (o hai solo il file .bak per altri motivi). In questo caso spero che ci sia un altro modo per dire dal file di backup che è stato crittografato (e come), ma al momento in cui scrivo non conosco un modo. Ho presentato un suggerimento (#805292, anche privato) che l'output di RESTORE HEADERONLY essere aumentata con le informazioni di crittografia nello stesso modo in cui è stata aumentata con le informazioni di compressione quando tale funzionalità è stata aggiunta in SQL Server 2008.

Quando risolveranno questi problemi (e sono fiducioso che lo faranno), rimuoverò tutto questo rumore, ma è importante esserne consapevoli nel frattempo, se hai intenzione di eseguire dei test con i CTP attuali.

Prossimo...

Cosa significa questo tipo di backup per il ripristino, tornerò in un altro post, quando testerò le velocità di ripristino e rivelerò eventuali aree problematiche lì. Voglio anche rivisitare questi test per indagare sui backup dei registri crittografati.