SQL Server Pencadangan ke URL

Artikel
10/18/2019

Topik ini memperkenalkan konsep, persyaratan, dan komponen yang diperlukan untuk menggunakan layanan penyimpanan Azure Blob sebagai tujuan pencadangan. Fungsionalitas pencadangan dan pemulihan sama atau mirip dengan saat menggunakan DISK atau TAPE, dengan beberapa perbedaan. Perbedaannya adalah dan pengecualian penting, dan beberapa contoh kode disertakan dalam topik ini.

Persyaratan, Komponen, dan Konsep

Di bagian ini:

Keamanan

Berikut ini adalah pertimbangan dan persyaratan keamanan saat mencadangkan atau memulihkan dari layanan penyimpanan Azure Blob.

Saat membuat kontainer untuk layanan penyimpanan Azure Blob, kami sarankan Anda mengatur akses ke privat. Mengatur akses ke privat membatasi akses ke pengguna atau akun yang dapat memberikan informasi yang diperlukan untuk mengautentikasi ke akun Azure.

Penting

SQL Server mengharuskan nama akun Azure dan autentikasi kunci akses disimpan dalam Kredensial SQL Server. Informasi ini digunakan untuk mengautentikasi ke akun Azure saat melakukan operasi pencadangan atau pemulihan.
Akun pengguna yang digunakan untuk mengeluarkan perintah BACKUP atau RESTORE harus berada dalam peran database operator db_backup dengan Mengubah izin kredensial apa pun .

Pengantar Komponen dan Konsep Utama

Dua bagian berikut memperkenalkan layanan penyimpanan Azure Blob, dan komponen SQL Server yang digunakan saat mencadangkan atau memulihkan dari layanan penyimpanan Azure Blob. Penting untuk memahami komponen dan interaksi di antara mereka untuk melakukan pencadangan ke atau memulihkan dari layanan penyimpanan Azure Blob.

Membuat akun Azure adalah langkah pertama untuk proses ini. SQL Server menggunakan nama akun penyimpanan Azure dan nilai kunci aksesnya untuk mengautentikasi dan menulis dan membaca blob ke layanan penyimpanan. Informasi masuk SQL Server akan menyimpan informasi autentikasi ini dan digunakan selama operasi pencadangan atau pemulihan. Untuk panduan lengkap membuat akun penyimpanan dan melakukan pemulihan sederhana, lihat Tutorial Menggunakan Azure Storage Service untuk pencadangan dan Pemulihan SQL Server.

memetakan akun penyimpanan ke akun penyimpanan pemetaan kredensial sql

Layanan Azure Blob Storage

Akun Penyimpanan: Akun penyimpanan adalah titik awal untuk semua layanan penyimpanan. Untuk mengakses layanan Azure Blob Storage, pertama-tama buat akun penyimpanan Azure. Nama akun penyimpanan dan properti kunci aksesnya diperlukan untuk mengautentikasi ke layanan Azure Blob Storage dan komponennya.

Wadah: Kontainer menyediakan pengelompokan satu set Blob, dan dapat menyimpan blob dalam jumlah tak terbatas. Untuk menulis cadangan SQL Server ke layanan Azure Blob, Anda harus memiliki setidaknya kontainer akar yang dibuat.

Gumpalan: File dengan jenis dan ukuran apa pun. Ada dua jenis blob yang dapat disimpan di layanan penyimpanan Azure Blob: blob blok dan halaman. pencadangan SQL Server menggunakan blob halaman sebagai jenis Blob. Blob dapat diatasi menggunakan format URL berikut: https://< storage account.blob.core.windows.net/>< container>/<blob>

Azure Blob Storage

Untuk informasi selengkapnya tentang layanan penyimpanan Azure Blob, lihat Cara menggunakan layanan Azure Blob Storage

Untuk informasi selengkapnya tentang halaman Blob, lihat Memahami Blok dan Halaman Blob

Komponen SQL Server

URL: URL menentukan Pengidentifikasi Sumber Daya Seragam (URI) ke file cadangan unik. URL digunakan untuk menyediakan lokasi dan nama file cadangan SQL Server. Dalam implementasi ini, satu-satunya URL yang valid adalah url yang menunjuk ke Blob halaman di akun penyimpanan Azure. URL harus menunjuk ke Blob yang sebenarnya, bukan hanya kontainer. Jika Blob tidak ada, blob akan dibuat. Jika Blob yang ada ditentukan, BACKUP gagal, kecuali opsi "WITH FORMAT" ditentukan.

Peringatan

Jika Anda memilih untuk menyalin dan mengunggah file cadangan ke layanan penyimpanan Azure Blob, gunakan blob halaman sebagai opsi penyimpanan Anda. Pemulihan dari Blok Blob tidak didukung. PEMULIHAN dari jenis blok blob gagal dengan kesalahan.

Berikut adalah contoh nilai URL: http[s]://ACCOUNTNAME.Blob.core.windows.net/< CONTAINER>/<FILENAME.bak>. HTTPS tidak diperlukan, tetapi disarankan.

Credential: Kredensial SQL Server adalah objek yang digunakan untuk menyimpan informasi autentikasi yang diperlukan untuk menyambungkan ke sumber daya di luar SQL Server. Di sini, SQL Server proses pencadangan dan pemulihan menggunakan kredensial untuk mengautentikasi ke layanan penyimpanan Azure Blob. Kredensial menyimpan nama akun penyimpanan dan nilai kunci akses akun penyimpanan. Setelah kredensial dibuat, kredensial harus ditentukan dalam opsi WITH CREDENTIAL saat mengeluarkan pernyataan BACKUP/RESTORE. Untuk informasi selengkapnya tentang cara menampilkan, menyalin, atau meregenerasi kunci akses akun penyimpanan, lihat Kunci Akses Akun Penyimpanan.

Untuk instruksi langkah demi langkah tentang cara membuat kredensial SQL Server, lihat Membuat contoh Kredensial nanti dalam topik ini.

Untuk informasi umum tentang kredensial, lihat Kredensial

Untuk informasi, pada contoh lain di mana kredensial digunakan, lihat Membuat Proksi SQL Server Agent.

Batasan

Pencadangan ke penyimpanan premium tidak didukung.
Ukuran cadangan maksimum yang didukung adalah 1 TB.
Anda dapat mengeluarkan pernyataan pencadangan atau pemulihan dengan menggunakan cmdlet TSQL, SMO, atau PowerShell. Pencadangan ke atau pemulihan dari layanan penyimpanan Azure Blob dengan menggunakan wizard Pencadangan atau Pemulihan SQL Server Management Studio saat ini tidak diaktifkan.
Pembuatan nama perangkat logis tidak didukung. Jadi menambahkan URL sebagai perangkat cadangan menggunakan sp_dumpdevice atau melalui SQL Server Management Studio tidak didukung.
Penambahan ke blob cadangan yang ada tidak didukung. Cadangan ke Blob yang ada hanya dapat ditimpa dengan menggunakan opsi WITH FORMAT.

Pencadangan ke beberapa blob dalam satu operasi pencadangan tidak didukung. Misalnya, berikut mengembalikan kesalahan:

BACKUP DATABASE AdventureWorks2012
TO URL = 'https://mystorageaccount.blob.core.windows.net/mycontainer/AdventureWorks2012_1.bak'
   URL = 'https://mystorageaccount.blob.core.windows.net/mycontainer/AdventureWorks2012_2.bak'
      WITH CREDENTIAL = 'mycredential'
     ,STATS = 5;  
GO

Menentukan ukuran blok dengan BACKUP tidak didukung.
Menentukan MAXTRANSFERSIZE tidak didukung.
Menentukan opsi set cadangan - RETAINDAYS dan EXPIREDATE tidak didukung.
SQL Server memiliki batas maksimum 259 karakter untuk nama perangkat cadangan. BACKUP TO URL mengkonsumsi 36 karakter untuk elemen yang diperlukan yang digunakan untuk menentukan URL - 'https://.blob.core.windows.net//.bak', menyisakan 223 karakter total untuk nama akun, kontainer, dan blob.

Dukungan untuk Pernyataan Pencadangan/Pemulihan


Pernyataan Pencadangan/Pemulihan	Didukung	Pengecualian	Komentar
CADANGAN	✓	BLOCKSIZE, dan MAXTRANSFERSIZE tidak didukung.	Memerlukan WITH CREDENTIAL yang ditentukan
MEMULIHKAN	✓		Memerlukan WITH CREDENTIAL yang ditentukan
PULIHKAN FILELISTONLY	✓		Memerlukan WITH CREDENTIAL yang ditentukan
PULIHKAN HEADERONLY	✓		Memerlukan WITH CREDENTIAL yang ditentukan
PULIHKAN LABELONLY	✓		Memerlukan WITH CREDENTIAL yang ditentukan
PULIHKAN SECARA VERIFIKASI	✓		Memerlukan WITH CREDENTIAL yang ditentukan
PULIHKAN REWINDONLY	✓

Untuk sintaksis dan informasi umum tentang pernyataan cadangan, lihat BACKUP (Transact-SQL).

Untuk sintaksis dan informasi umum tentang pernyataan pemulihan, lihat RESTORE (Transact-SQL).

Dukungan untuk Argumen Pencadangan


Argumen	Didukung	Pengecualian	Komentar
DATABASE	✓
LOG	✓

KE (URL)	✓	Tidak seperti DISK dan TAPE, URL tidak mendukung penentuan atau pembuatan nama logis.	Argumen ini digunakan untuk menentukan jalur URL untuk file cadangan.
CERMIN KE	✓
DENGAN OPSI:
INFORMASI MASUK	✓		WITH CREDENTIAL hanya didukung saat menggunakan opsi BACKUP TO URL untuk mencadangkan ke layanan penyimpanan Azure Blob.
DIFERENSIAL	✓
COPY_ONLY	✓
PEMADATAN\|NO_COMPRESSION	✓
DESKRIPSI	✓
NAME	✓
KEDALUWARSA \| RETAINDAYS	✓
NOINIT \| INIT	✓		Opsi ini diabaikan jika digunakan. Menambahkan ke blob tidak dimungkinkan. Untuk menimpa cadangan, gunakan argumen FORMAT.
NOSKIP \| MELEWATKAN	✓
NOFORMAT \| FORMAT	✓		Opsi ini diabaikan jika digunakan. Cadangan yang diambil ke blob yang ada gagal kecuali WITH FORMAT ditentukan. Blob yang ada ditimpa ketika WITH FORMAT ditentukan.
MEDIADESCRIPTION	✓
MEDIANAME	✓
UKURAN BLOK	✓
BUFFERCOUNT	✓
MAXTRANSFERSIZE	✓
NO_CHECKSUM \| CHECKSUM	✓
STOP_ON_ERROR \| CONTINUE_AFTER_ERROR	✓
STATISTIK	✓
MUNDUR \| NOREWIND	✓
UNLOAD \| NOUNLOAD	✓
NORECOVERY \| SIAGA	✓
NO_TRUNCATE	✓

Untuk informasi selengkapnya tentang argumen cadangan, lihat BACKUP (Transact-SQL).

Dukungan untuk Argumen Pemulihan


Argumen	Didukung	Pengecualian	Komentar
DATABASE	✓
LOG	✓
FROM (URL)	✓		Argumen FROM URL digunakan untuk menentukan jalur URL untuk file cadangan.
DENGAN Opsi:
INFORMASI MASUK	✓		WITH CREDENTIAL hanya didukung saat menggunakan opsi PULIHKAN DARI URL untuk memulihkan dari layanan Azure Blob Storage.
SEBAGIAN	✓
PEMULIHAN \| NORECOVERY \| SIAGA	✓
LOADHISTORY	✓
MOVE	✓
REPLACE	✓
RESTART	✓
RESTRICTED_USER	✓
FILE	✓
KATA SANDI	✓
MEDIANAME	✓
MEDIAPASSWORD	✓
UKURAN BLOK	✓
BUFFERCOUNT	✓
MAXTRANSFERSIZE	✓
CHECKSUM \| NO_CHECKSUM	✓
STOP_ON_ERROR \| CONTINUE_AFTER_ERROR	✓
FILESTREAM	✓
STATISTIK	✓
REWIND \| NOREWIND	✓
UNLOAD \| NOUNLOAD	✓
KEEP_REPLICATION	✓
KEEP_CDC	✓
ENABLE_BROKER \| ERROR_BROKER_CONVERSATIONS \| NEW_BROKER	✓
STOPAT \| STOPATMARK \| STOPBEFOREMARK	✓

Untuk informasi selengkapnya tentang Argumen pemulihan, lihat ARGUMEN RESTORE (Transact-SQL).

Menggunakan Tugas Pencadangan di SQL Server Management Studio

Tugas Pencadangan di SQL Server Management Studio telah ditingkatkan untuk menyertakan URL sebagai salah satu opsi tujuan, dan objek pendukung lainnya yang diperlukan untuk mencadangkan ke penyimpanan Azure seperti Kredensial SQL.

Langkah-langkah berikut ini menjelaskan perubahan yang dibuat pada tugas Mencadangkan Database untuk memungkinkan pencadangan ke penyimpanan Azure.:

Mulai SQL Server Management Studio dan sambungkan ke instans SQL Server. Pilih database yang ingin Anda cadangkan, dan klik kanan pada Tugas, dan pilih Cadangkan... Ini membuka kotak dialog Cadangkan Database.
Pada halaman umum, opsi URL digunakan untuk membuat cadangan ke penyimpanan Azure. Saat Anda memilih opsi ini, Anda akan melihat opsi lain yang diaktifkan di halaman ini:
1. Nama File: Nama file cadangan.
2. Kredensial SQL: Anda bisa menentukan kredensial SQL Server yang sudah ada, atau bisa membuat yang baru dengan mengklik buat di samping kotak Kredensial SQL.
  
  Penting
  
  Dialog yang terbuka saat Anda mengklik Buat memerlukan sertifikat manajemen atau profil penerbitan untuk langganan. SQL Server saat ini mendukung profil penerbitan versi 2.0. Untuk mengunduh versi profil penerbitan yang didukung, lihat Mengunduh Profil Penerbitan 2.0.
  
  Jika Anda tidak memiliki akses ke sertifikat manajemen atau profil penerbitan, Anda dapat membuat Kredensial SQL dengan menentukan nama akun penyimpanan dan mengakses informasi kunci menggunakan Transact-SQL atau SQL Server Management Studio. Lihat kode sampel di bagian Buat Kredensial untuk membuat kredensial menggunakan Transact-SQL. Atau, menggunakan SQL Server Management Studio, dari instans mesin database, klik kanan Keamanan, pilih Baru, dan pilih Kredensial. Tentukan nama akun penyimpanan untuk Identitas dan kunci akses di bidang Kata Sandi .
3. Kontainer penyimpanan Azure: Nama kontainer penyimpanan Azure untuk menyimpan file cadangan.
4. Awalan URL: Ini dibangun secara otomatis menggunakan informasi yang ditentukan dalam bidang yang dijelaskan dalam langkah-langkah sebelumnya. Jika Anda mengedit nilai ini secara manual, pastikan nilai tersebut cocok dengan informasi lain yang Anda berikan sebelumnya. Misalnya jika Anda mengubah URL penyimpanan, pastikan Info Masuk SQL diatur untuk mengautentikasi ke akun penyimpanan yang sama.

Saat Anda memilih URL sebagai tujuan, opsi tertentu di halaman Opsi Media dinonaktifkan. Topik berikut ini memiliki informasi selengkapnya tentang dialog Mencadangkan Database:

Mencadangkan Database (Halaman Umum)

Mencadangkan Database (Halaman Opsi Media)

Mencadangkan Database (Halaman Opsi Pencadangan)

Membuat Kredensial - Mengautentikasi ke Azure Storage

SQL Server Pencadangan ke URL Menggunakan Wizard Rencana Pemeliharaan

Mirip dengan tugas pencadangan yang dijelaskan sebelumnya, Wizard Rencana Pemeliharaan di SQL Server Management Studio telah ditingkatkan untuk menyertakan URL sebagai salah satu opsi tujuan, dan objek pendukung lainnya yang diperlukan untuk mencadangkan ke penyimpanan Azure seperti Kredensial SQL. Untuk informasi selengkapnya, lihat bagian Tentukan Tugas Pencadangan di Menggunakan Wizard Rencana Pemeliharaan.

Memulihkan dari penyimpanan Azure Menggunakan SQL Server Management Studio

Jika Anda memulihkan database, URL disertakan sebagai perangkat untuk dipulihkan. Langkah-langkah berikut menjelaskan perubahan dalam tugas Pulihkan untuk memungkinkan pemulihan dari penyimpanan Azure:

Saat Anda memilih Perangkat di halaman Umum tugas Pulihkan di SQL Server Management Studio, ini akan membawa Anda ke kotak dialog Pilih perangkat cadangan yang menyertakan URL sebagai jenis media cadangan.
Saat Anda memilih URL dan klik Tambahkan, ini akan membuka dialog Sambungkan ke penyimpanan Azure . Tentukan informasi Kredensial SQL untuk mengautentikasi ke penyimpanan Azure.
SQL Server kemudian tersambung ke penyimpanan Azure menggunakan informasi Kredensial SQL yang Anda berikan dan membuka dialog Temukan File Cadangan di Azure. File cadangan yang berada di penyimpanan ditampilkan di halaman ini. Pilih file yang ingin Anda gunakan untuk memulihkan dan klik OK. Ini akan membawa Anda kembali ke dialog Pilih Perangkat Cadangan , dan Mengklik OK pada dialog ini akan membawa Anda kembali ke dialog Pemulihan utama tempat Anda akan dapat menyelesaikan pemulihan. Untuk informasi selengkapnya lihat, topik berikut ini:

Pulihkan Database (Halaman Umum)

Pulihkan Database (Halaman File)

Pulihkan Database (Halaman Opsi)

Contoh Kode

Bagian ini berisi contoh berikut.

Membuat Kredensial
Mencadangkan database lengkap
Mencadangkan database dan log
Membuat cadangan file lengkap grup file utama
Membuat cadangan file diferensial dari grup file utama
Memulihkan database dan memindahkan file
Memulihkan ke titik waktu menggunakan STOPAT

Membuat Kredensial

Contoh berikut membuat kredensial yang menyimpan informasi autentikasi Azure Storage.

IF NOT EXISTS  
(SELECT * FROM sys.credentials   
WHERE credential_identity = 'mycredential')  
CREATE CREDENTIAL mycredential WITH IDENTITY = 'mystorageaccount'  
,SECRET = '<storage access key>' ;

// Connect to default sql server instance on local machine  
Server server = new Server(".");  
string identity = "mystorageaccount";  
string secret = "<storage access key>";  

// Create a Credential  
string credentialName = "mycredential";  
Credential credential = new Credential(server, credentialName);  
credential.Create(identity, secret);

# create variables  
$storageAccount = "mystorageaccount"  
$storageKey = "<storage access key>"  
$secureString = ConvertTo-SecureString $storageKey  -asplaintext -force  
$credentialName = "mycredential"  

$srvPath = "SQLSERVER:\SQL\COMPUTERNAME\INSTANCENAME"  
# for default instance, the $srvpath variable would be "SQLSERVER:\SQL\COMPUTERNAME\DEFAULT"  

# Create a credential  
New-SqlCredential -Name $credentialName -Path $srvpath -Identity $storageAccount -Secret $secureString

Mencadangkan database lengkap

Contoh berikut mencadangkan database AdventureWorks2012 ke layanan penyimpanan Azure Blob.

BACKUP DATABASE AdventureWorks2012   
TO URL = 'https://mystorageaccount.blob.core.windows.net/mycontainer/AdventureWorks2012.bak'   
      WITH CREDENTIAL = 'mycredential'   
      ,COMPRESSION  
      ,STATS = 5;  
GO

// Connect to default sql server instance on local machine  
Server server = new Server(".");  
string identity = "mystorageaccount";  

string credentialName = "mycredential";  
string dbName = "AdventureWorks2012";  
string blobContainerName = "mycontainer";  

// Generate Unique Url  
string url = String.Format(@"https://{0}.blob.core.windows.net/{1}/{2}-{3}.bak",  
         identity,  
         blobContainerName,  
         dbName,  
         DateTime.Now.ToString("s").Replace(":", "-"));  

// Backup to Url  
Backup backup = new Backup();  
backup.CredentialName = credentialName;  
backup.Database = dbName;  
backup.CompressionOption = BackupCompressionOptions.On;  
backup.Devices.AddDevice(url, DeviceType.Url);  
backup.SqlBackup(server);

# create variables  
$backupUrlContainer = "https://mystorageaccount.blob.core.windows.net/mycontainer/"  
$credentialName = "mycredential"  
$srvPath = "SQLSERVER:\SQL\COMPUTERNAME\INSTANCENAME"   
# for default instance, the $srvpath varilable would be "SQLSERVER:\SQL\COMPUTERNAME\DEFAULT"  

# navigate to SQL Server Instance  
CD $srvPath   
$backupFile = $backupUrlContainer + "AdventureWorks2012" +  ".bak"  
Backup-SqlDatabase -Database AdventureWorks2012 -backupFile $backupFile  -SqlCredential $credentialName -CompressionOption On

Mencadangkan database dan log

Contoh berikut mencadangkan database sampel AdventureWorks2012, yang menggunakan model pemulihan sederhana secara default. Untuk mendukung pencadangan log, database AdventureWorks2012 dimodifikasi untuk menggunakan model pemulihan penuh. Contohnya kemudian membuat cadangan database lengkap ke Azure Blob, dan setelah periode aktivitas pembaruan, cadangkan log. Contoh ini membuat nama file cadangan dengan stempel tanggalwaktu.

-- To permit log backups, before the full database backup, modify the database   
-- to use the full recovery model.  
USE master;  
GO  
ALTER DATABASE AdventureWorks2012  
   SET RECOVERY FULL;  
GO  

-- Back up the full AdventureWorks2012 database.  
       -- First create a file name for the backup file with DateTime stamp  

DECLARE @Full_Filename AS VARCHAR (300);  
SET @Full_Filename = 'https://mystorageaccount.blob.core.windows.net/mycontainer/AdventureWorks2012_Full_'+   
REPLACE (REPLACE (REPLACE (CONVERT (VARCHAR (40), GETDATE (), 120), '-','_'),':', '_'),' ', '_') + '.bak';   
--Back up Adventureworks2012 database  

BACKUP DATABASE AdventureWorks2012  
TO URL =  @Full_Filename  
WITH CREDENTIAL = 'mycredential';  
,COMPRESSION  
GO  
-- Back up the AdventureWorks2012 log.  
DECLARE @Log_Filename AS VARCHAR (300);  
SET @Log_Filename = 'https://mystorageaccount.blob.core.windows.net/mycontainer/AdventureWorks2012_Log_'+   
REPLACE (REPLACE (REPLACE (CONVERT (VARCHAR (40), GETDATE (), 120), '-','_'),':', '_'),' ', '_') + '.trn';  
BACKUP LOG AdventureWorks2012  
 TO URL = @Log_Filename  
 WITH CREDENTIAL = 'mycredential'  
 ,COMPRESSION;  
GO

// Connect to default sql server instance on local machine  
Server server = new Server(".");  
string identity = "mystorageaccount";  

string credentialName = "mycredential";  
string dbName = "AdventureWorks2012";  
string blobContainerName = "mycontainer";  

// Generate Unique Url for data backup  
string urlDataBackup = String.Format(@"https://{0}.blob.core.windows.net/{1}/{2}_Data-{3}.bak",  
         identity,  
         blobContainerName,  
         dbName,  
         DateTime.Now.ToString("s").Replace(":", "-"));  

// Backup Database to Url  
Backup backupData = new Backup();  
backupData.CredentialName = credentialName;  
backupData.Database = dbName;  
backup.CompressionOption = BackupCompressionOptions.On;  
backupData.Devices.AddDevice(urlDataBackup, DeviceType.Url);  
backupData.SqlBackup(server);  

// Generate Unique Url for data backup  
string urlLogBackup = String.Format(@"https://{0}.blob.core.windows.net/{1}/{2}_Log-{3}.bak",  
         identity,  
         blobContainerName,  
         dbName,  
         DateTime.Now.ToString("s").Replace(":", "-"));  

// Backup Database Log to Url  
Backup backupLog = new Backup();  
backupLog.CredentialName = credentialName;  
backupLog.Database = dbName;  
backup.CompressionOption = BackupCompressionOptions.On;  
backupLog.Devices.AddDevice(urlLogBackup, DeviceType.Url);  
backupLog.Action = BackupActionType.Log;  
backupLog.SqlBackup(server);

#create variables  
$backupUrlContainer = "https://mystorageaccount.blob.core.windows.net/mycontainer/"  
$credentialName = "mycredential"  
$srvPath = "SQLSERVER:\SQL\COMPUTERNAME\INSTANCENAME"  
# for default instance, the $srvpath variable would be "SQLSERVER:\SQL\COMPUTERNAME\DEFAULT"  

# navigate to theSQL Server Instance
CD $srvPath   
#Create a unique file name for the full database backup  
$backupFile = $backupUrlContainer + "AdventureWorks2012_" + (Get-Date).ToString("s").Replace("-","_").Replace(":", "_").Replace(" ","_").Replace("/", "_") +  ".bak"  

#Backup Database to URL
Backup-SqlDatabase -Database AdventureWorks2012 -backupFile $backupFile  -SqlCredential $credentialName -CompressionOption On -BackupAction Database    

#Create a unique file name for log backup  

$backupFile = $backupUrlContainer + "AdventureWorks2012_" + (Get-Date).ToString("s").Replace("-","_").Replace(":", "_").Replace(" ","_").Replace("/", "_") +  ".trn"  

#Backup Log to URL
Backup-SqlDatabase -Database AdventureWorks2012 -backupFile $backupFile  -SqlCredential $credentialName -CompressionOption On -BackupAction Log

Membuat cadangan file lengkap grup file utama

Contoh berikut membuat cadangan file lengkap dari grup file utama.

--Back up the files in Primary:  
BACKUP DATABASE AdventureWorks2012  
    FILEGROUP = 'Primary'  
    TO URL = 'https://mystorageaccount.blob.core.windows.net/mycontainer/AdventureWorks2012files.bck'  
    WITH CREDENTIAL = 'mycredential'  
    ,COMPRESSION;  
GO

// Connect to default sql server instance on local machine  
Server server = new Server(".");  
string identity = "mystorageaccount";  

string credentialName = "mycredential";  
string dbName = "AdventureWorks2012";  
string blobContainerName = "mycontainer";  

// Generate Unique Url  
string url = String.Format(@"https://{0}.blob.core.windows.net/{1}/{2}-{3}.bck",  
         identity,  
         blobContainerName,  
         dbName,  
         DateTime.Now.ToString("s").Replace(":", "-"));  

// Backup to Url  
Backup backup = new Backup();  
backup.CredentialName = credentialName;  
backup.Database = dbName;  
backup.Action = BackupActionType.Files;  
backup.DatabaseFileGroups.Add("PRIMARY");  
backup.CompressionOption = BackupCompressionOptions.On;  
backup.Devices.AddDevice(url, DeviceType.Url);  
backup.SqlBackup(server);

#create variables  
$backupUrlContainer = "https://mystorageaccount.blob.core.windows.net/mycontainer/"  
$credentialName = "mycredential"  
$srvPath = "SQLSERVER:\SQL\COMPUTERNAME\INSTANCENAME"  
# for default instance, the $srvpath variable would be "SQLSERVER:\SQL\COMPUTERNAME\DEFAULT"  

# navigate to the SQL Server Instance  

CD $srvPath   
#Create a unique file name for the file backup  
$backupFile = $backupUrlContainer + "AdventureWorks2012_" + (Get-Date).ToString("s").Replace("-","_").Replace(":", "_").Replace(" ","_").Replace("/", "_") +  ".bck"  

#Backup Primary File Group to URL  

Backup-SqlDatabase -Database AdventureWorks2012 -backupFile $backupFile  -SqlCredential $credentialName -CompressionOption On -BackupAction Files -DatabaseFileGroup Primary

Membuat cadangan file diferensial dari grup file utama

Contoh berikut membuat cadangan file diferensial dari grup file utama.

--Back up the files in Primary:  
BACKUP DATABASE AdventureWorks2012  
    FILEGROUP = 'Primary'  
    TO URL = 'https://mystorageaccount.blob.core.windows.net/mycontainer/AdventureWorks2012filesdiff.bck'  
    WITH   
       CREDENTIAL = 'mycredential'  
       ,COMPRESSION  
   ,DIFFERENTIAL;  
GO

// Connect to default sql server instance on local machine  
Server server = new Server(".");  
string identity = "mystorageaccount";  

string credentialName = "mycredential";  
string dbName = "AdventureWorks2012";  
string blobContainerName = "mycontainer";  

// Generate Unique Url  
string url = String.Format(@"https://{0}.blob.core.windows.net/{1}/{2}-{3}.bak",  
         identity,  
         blobContainerName,  
         dbName,  
         DateTime.Now.ToString("s").Replace(":", "-"));  

// Backup to Url  
Backup backup = new Backup();  
backup.CredentialName = credentialName;  
backup.Database = dbName;  
backup.Action = BackupActionType.Files;  
backup.DatabaseFileGroups.Add("PRIMARY");  
backup.Incremental = true;  
backup.CompressionOption = BackupCompressionOptions.On;  
backup.Devices.AddDevice(url, DeviceType.Url);  
backup.SqlBackup(server);

#create variables  
$backupUrlContainer = "https://mystorageaccount.blob.core.windows.net/mycontainer/"  
$credentialName = "mycredential"  
$srvPath = "SQLSERVER:\SQL\COMUTERNAME\INSTANCENAME"  
# for default instance, the $srvpath variable would be "SQLSERVER:\SQL\COMPUTERNAME\DEFAULT"  

# navigate to SQL Server Instance
CD $srvPath   

#create a unique file name for the full backup  
$backupdbFile = $backupUrlContainer + "AdventureWorks2012_" + (Get-Date).ToString("s").Replace("-","_").Replace(":", "_").Replace(" ","_").Replace("/", "_") +  ".bak"  

#Create a differential backup of the primary filegroup
Backup-SqlDatabase -Database AdventureWorks2012 -backupFile $backupFile  -SqlCredential $credentialName -CompressionOption On -BackupAction Files -DatabaseFileGroup Primary -Incremental

Memulihkan database dan memindahkan file

Untuk memulihkan cadangan database lengkap dan memindahkan database yang dipulihkan ke C:\Program Files\Microsoft SQL Server\MSSQL12. Direktori MSSQLSERVER\MSSQL\Data, gunakan langkah-langkah berikut.

-- Backup the tail of the log first
DECLARE @Log_Filename AS VARCHAR (300);  
SET @Log_Filename = 'https://mystorageaccount.blob.core.windows.net/mycontainer/AdventureWorks2012_Log_'+   
REPLACE (REPLACE (REPLACE (CONVERT (VARCHAR (40), GETDATE (), 120), '-','_'),':', '_'),' ', '_') + '.trn';  
BACKUP LOG AdventureWorks2012  
 TO URL = @Log_Filename  
 WITH CREDENTIAL = 'mycredential'  
 ,NORECOVERY;  
GO  

RESTORE DATABASE AdventureWorks2012 FROM URL = 'https://mystorageaccount.blob.core.windows.net/mycontainer/AdventureWorks2012.bak'  
WITH CREDENTIAL = 'mycredential'  
 ,MOVE 'AdventureWorks2012_data' to 'C:\Program Files\Microsoft SQL Server\myinstance\MSSQL\DATA\AdventureWorks2012.mdf'  
 ,MOVE 'AdventureWorks2012_log' to 'C:\Program Files\Microsoft SQL Server\myinstance\MSSQL\DATA\AdventureWorks2012.ldf'  
 ,STATS = 5

// Connect to default sql server instance on local machine  
Server server = new Server(".");  
string identity = "mystorageaccount";  

string credentialName = "mycredential";  
string dbName = "AdventureWorks2012";  
string blobContainerName = "mycontainer";  

// Generate Unique Url  
string urlBackupData = String.Format(@"https://{0}.blob.core.windows.net/{1}/{2}-Data{3}.bak",  
         identity,  
         blobContainerName,  
         dbName,  
         DateTime.Now.ToString("s").Replace(":", "-"));  

// Backup to Url  
Backup backup = new Backup();  
backup.CredentialName = credentialName;  
backup.Database = dbName;  
backup.Devices.AddDevice(urlBackupData, DeviceType.Url);  
backup.SqlBackup(server);  

// Generate Unique Url for tail log backup  
string urlTailLogBackup = String.Format(@"https://{0}.blob.core.windows.net/{1}/{2}-TailLog{3}.bak",  
         identity,  
         blobContainerName,  
         dbName,  
         DateTime.Now.ToString("s").Replace(":", "-"));  

// Backup Tail Log to Url  
Backup backupTailLog = new Backup();  
backupTailLog.CredentialName = credentialName;  
backupTailLog.Database = dbName;  
backupTailLog.Action = BackupActionType.Log;  
backupTailLog.NoRecovery = true;  
backupTailLog.Devices.AddDevice(urlTailLogBackup, DeviceType.Url);  
backupTailLog.SqlBackup(server);  

// Restore a database and move files  
string newDataFilePath = server.MasterDBLogPath  + @"\" + dbName + DateTime.Now.ToString("s").Replace(":", "-") + ".mdf";  
string newLogFilePath = server.MasterDBLogPath  + @"\" + dbName + DateTime.Now.ToString("s").Replace(":", "-") + ".ldf";  

Restore restore = new Restore();  
restore.CredentialName = credentialName;  
restore.Database = dbName;  
restore.ReplaceDatabase = true;  
restore.Devices.AddDevice(urlBackupData, DeviceType.Url);  
restore.RelocateFiles.Add(new RelocateFile(dbName, newDataFilePath));  
restore.RelocateFiles.Add(new RelocateFile(dbName+ "_Log", newLogFilePath));  
restore.SqlRestore(server);

#create variables  
$backupUrlContainer = "https://mystorageaccount.blob.core.windows.net/mycontainer/"  
$credentialName = "mycredential"  
$srvPath = "SQLSERVER:\SQL\COMPUTERNAME\INSTNACENAME"  
# for default instance, the $srvpath variable would be "SQLSERVER:\SQL\COMPUTERNAME\DEFAULT"  

# navigate to SQL Server Instance
CD $srvPath   

#create a unique file name for the full backup  
$backupdbFile = $backupUrlContainer + "AdventureWorks2012_" + (Get-Date).ToString("s").Replace("-","_").Replace(":", "_").Replace(" ","_").Replace("/", "_") +  ".bak"  

# Full database backup to URL  
Backup-SqlDatabase -Database AdventureWorks2012 -backupFile $backupdbFile  -SqlCredential $credentialName -CompressionOption On      

#Create a unique file name for the tail log backup  
$backuplogFile = $backupUrlContainer + "AdventureWorks2012_" + (Get-Date).ToString("s").Replace("-","_").Replace(":", "_").Replace(" ","_").Replace("/", "_") +  ".trn"  

#Backup tail log to URL
Backup-SqlDatabase -Database AdventureWorks2012 -backupFile $backupFile  -SqlCredential $credentialName  -BackupAction Log -NoRecovery    

# Restore Database and move files
$newDataFilePath = New-Object Microsoft.SqlServer.Management.Smo.RelocateFile ("AdventureWorks_Data","C:\Program Files\Microsoft SQL Server\myinstance\MSSQL\DATA\AdventureWorks2012.mdf")  
$newLogFilePath = New-Object Microsoft.SqlServer.Management.Smo.RelocateFile("AdventureWorks_Log","C:\Program Files\Microsoft SQL Server\myinstance\MSSQL\DATA\AdventureWorks2012.ldf")  

Restore-SqlDatabase -Database AdventureWorks2012 -SqlCredential $credentialName -BackupFile $backupdbFile -RelocateFile @($newDataFilePath,$newLogFilePath)

Memulihkan ke titik waktu menggunakan STOPAT

Contoh berikut memulihkan database ke statusnya ke titik waktu tertentu, dan memperlihatkan operasi pemulihan.

RESTORE DATABASE AdventureWorks FROM URL = 'https://mystorageaccount.blob.core.windows.net/mycontainer/AdventureWorks2012.bak'   
WITH   
  CREDENTIAL = 'mycredential'  
 ,MOVE 'AdventureWorks2012_data' to 'C:\Program Files\Microsoft SQL Server\myinstance\MSSQL\DATA\AdventureWorks2012.mdf'  
 ,Move 'AdventureWorks2012_log' to 'C:\Program Files\Microsoft SQL Server\myinstance\MSSQL\DATA\AdventureWorks2012.ldf'  
 ,NORECOVERY  
 --,REPLACE  
 ,STATS = 5;  
GO   

RESTORE LOG AdventureWorks FROM URL = 'https://mystorageaccount.blob.core.windows.net/mycontainer/AdventureWorks2012.trn'   
WITH CREDENTIAL = 'mycredential'  
 ,RECOVERY   
 ,STOPAT = 'Oct 23, 2012 5:00 PM'   
GO

// Connect to default sql server instance on local machine  
Server server = new Server(".");  
string identity = "mystorageaccount";  

string credentialName = "mycredential";  
string dbName = "AdventureWorks2012";  
string blobContainerName = "mycontainer";  

// Generate Unique Url  
string urlBackupData = String.Format(@"https://{0}.blob.core.windows.net/{1}/{2}-Data{3}.bak",  
         identity,  
         blobContainerName,  
         dbName,  
         DateTime.Now.ToString("s").Replace(":", "-"));  

// Backup to Url  
Backup backup = new Backup();  
backup.CredentialName = credentialName;  
backup.Database = dbName;  
backup.Devices.AddDevice(urlBackupData, DeviceType.Url);  
backup.SqlBackup(server);  

// Generate Unique Url for Tail Log backup  
string urlTailLogBackup = String.Format(@"https://{0}.blob.core.windows.net/{1}/{2}-TailLog{3}.bak",  
         identity,  
         blobContainerName,  
         dbName,  
         DateTime.Now.ToString("s").Replace(":", "-"));  

// Backup Tail Log to Url  
Backup backupTailLog = new Backup();  
backupTailLog.CredentialName = credentialName;  
backupTailLog.Database = dbName;  
backupTailLog.Action = BackupActionType.Log;  
backupTailLog.NoRecovery = true;  
backupTailLog.Devices.AddDevice(urlTailLogBackup, DeviceType.Url);  
backupTailLog.SqlBackup(server);  

// Restore a database and move files  
string newDataFilePath = server.MasterDBLogPath + @"\" + dbName + DateTime.Now.ToString("s").Replace(":", "-") + ".mdf";  
string newLogFilePath = server.MasterDBLogPath + @"\" + dbName + DateTime.Now.ToString("s").Replace(":", "-") + ".ldf";  

Restore restore = new Restore();  
restore.CredentialName = credentialName;  
restore.Database = dbName;  
restore.ReplaceDatabase = true;  
restore.NoRecovery = true;  
restore.Devices.AddDevice(urlBackupData, DeviceType.Url);  
restore.RelocateFiles.Add(new RelocateFile(dbName, newDataFilePath));  
restore.RelocateFiles.Add(new RelocateFile(dbName + "_Log", newLogFilePath));  
restore.SqlRestore(server);  
   
// Restore transaction Log with stop at   
Restore restoreLog = new Restore();  
restoreLog.CredentialName = credentialName;  
restoreLog.Database = dbName;  
restoreLog.Action = RestoreActionType.Log;  
restoreLog.Devices.AddDevice(urlBackupData, DeviceType.Url);  
restoreLog.ToPointInTime = DateTime.Now.ToString();   
restoreLog.SqlRestore(server);

#create variables  
$backupUrlContainer = "https://mystorageaccount.blob.core.windows.net/mycontainer/"  
$credentialName = "mycredential"  
$srvPath = "SQLSERVER:\SQL\COMPUTERNAME\INSTANCENAME"  
# for default instance, the $srvpath variable would be "SQLSERVER:\SQL\COMPUTERNAME\DEFAULT"  

# Navigate to SQL Server Instance Directory
CD $srvPath   

#create a unique file name for the full backup  
$backupdbFile = $backupUrlContainer + "AdventureWorks2012_" + (Get-Date).ToString("s").Replace("-","_").Replace(":", "_").Replace(" ","_").Replace("/", "_") +  ".bak"  

# Full database backup to URL  
Backup-SqlDatabase -Database AdventureWorks2012 -backupFile $backupdbFile  -SqlCredential $credentialName -CompressionOption On     

#Create a unique file name for the tail log backup  
$backuplogFile = $backupUrlContainer + "AdventureWorks2012_" + (Get-Date).ToString("s").Replace("-","_").Replace(":", "_").Replace(" ","_").Replace("/", "_") +  ".trn"  

#Backup tail log to URL
Backup-SqlDatabase -Database AdventureWorks2012 -backupFile $backupFile  -SqlCredential $credentialName  -BackupAction Log -NoRecovery     

# Restore Database and move files
$newDataFilePath = New-Object Microsoft.SqlServer.Management.Smo.RelocateFile ("AdventureWorks_Data","C:\Program Files\Microsoft SQL Server\myinstance\MSSQL\DATA\AdventureWorks2012.mdf")  
$newLogFilePath = New-Object Microsoft.SqlServer.Management.Smo.RelocateFile("AdventureWorks_Log","C:\Program Files\Microsoft SQL Server\myinstance\MSSQL\DATA\AdventureWorks2012.ldf")  

Restore-SqlDatabase -Database AdventureWorks2012 -SqlCredential $credentialName -BackupFile $backupdbFile -RelocateFile @($newDataFilePath,$newLogFilePath) -NoRecovery    

# Restore Transaction log with Stop At:  
Restore-SqlDatabase -Database AdventureWorks2012 -SqlCredential $credentialName -BackupFile $backuplogFile  -ToPointInTime (Get-Date).ToString()

Lihat juga

SQL Server Pencadangan ke Praktik Terbaik url dan Pemecahan Masalah
Pencadangan dan Pemulihan Database Sistem (SQL Server)

Share via