Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Importazione ed esportazione di database SQL Server mediante backup e ripristino nativi
Amazon RDS supporta il backup nativo e il ripristino dei database Microsoft SQL Server tramite file di backup completi (file .bak). Quanto utilizzi RDS, puoi accedere ai file archiviati in Amazon S3 invece di utilizzare il file system locale sul server del database.
Ad esempio, puoi creare un backup completo dal server locale, archiviarlo in S3 e quindi ripristinarlo in un'istanza database Amazon RDS esistente. Puoi anche eseguire i backup da RDS, archiviarli in S3 e quindi ripristinarli quando lo desideri.
Il backup e il ripristino nativi sono disponibili in tutte le AWS regioni per le istanze DB Single-AZ e Multi-AZ, incluse le istanze DB Multi-AZ con repliche di lettura. Backup e ripristino nativi sono disponibili per tutte le edizioni di Microsoft SQL Server supportate su Amazon RDS.
Il seguente schema mostra gli scenari supportati.
![\[Architettura di backup e ripristino nativi\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/SQL-bak-file.png)
L'utilizzo di file .bak nativi per effettuare il backup e il ripristino di database è in genere il modo più veloce per compiere queste operazioni. Vi sono molteplici vantaggi aggiuntivi con l'utilizzo di backup e ripristino nativi. Ad esempio, puoi eseguire le operazioni seguenti:
+ Migrare i database a o da Amazon RDS.
+ Spostare i database tra le istanze database RDS for SQL Server.
+ Migrare dati, schemi, procedure archiviate, trigger e altri codici di database in file .bak.
+ Eseguire backup e ripristino di singoli database invece che di intere istanze database.
+ Creare copie di database per sviluppo, attività di test, formazione e dimostrazioni.
+ Archiviare e trasferire i file di backup con Amazon S3, per un ulteriore livello di protezione per il disaster recovery.
+ Creare backup nativi di database con Transparent Data Encryption (TDE) attivato e ripristinare tali backup nei database on-premise. Per ulteriori informazioni, consulta [Supporto per Transparent Data Encryption in SQL Server](Appendix.SQLServer.Options.TDE.md).
+ Ripristinare i backup nativi dei database on-premise con TDE attivato in istanze database di RDS per SQL Server. Per ulteriori informazioni, consulta [Supporto per Transparent Data Encryption in SQL Server](Appendix.SQLServer.Options.TDE.md).
**Contents**
+ [Limitazioni e consigli](#SQLServer.Procedural.Importing.Native.Limitations)
+ [Configurazione di backup e ripristino nativi](SQLServer.Procedural.Importing.Native.Enabling.md)
+ [Creazione manuale di un ruolo IAM per backup e ripristino nativi](SQLServer.Procedural.Importing.Native.Enabling.md#SQLServer.Procedural.Importing.Native.Enabling.IAM)
+ [Uso di backup e ripristino nativi](SQLServer.Procedural.Importing.Native.Using.md)
+ [Backup di un database](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Backup)
+ [Utilizzo](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Backup.Syntax)
+ [Esempi](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Backup.Examples)
+ [Ripristino di un database](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Restore)
+ [Utilizzo](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Restore.Syntax)
+ [Esempi](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Restore.Examples)
+ [Ripristino di un log](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Restore.Log)
+ [Utilizzo](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Restore.Log.Syntax)
+ [Esempi](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Restore.Log.Examples)
+ [Completamento di un ripristino del database](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Finish.Restore)
+ [Utilizzo](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Finish.Restore.Syntax)
+ [Utilizzo di database parzialmente ripristinati](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Partially.Restored)
+ [Rimozione di un database parzialmente ripristinato](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Drop.Partially.Restored)
+ [Comportamento di ripristino e point-in-time ripristino delle istantanee per database parzialmente ripristinati](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Snapshot.Restore)
+ [Annullamento di un'attività](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Cancel)
+ [Utilizzo](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Cancel.Syntax)
+ [Monitoraggio dello stato delle attività](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Tracking)
+ [Utilizzo](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Tracking.Syntax)
+ [Esempi](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Tracking.Examples)
+ [Risposta](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Tracking.Response)
+ [Compressione dei file di backup](SQLServer.Procedural.Importing.Native.Compression.md)
+ [Risoluzione dei problemi](SQLServer.Procedural.Importing.Native.Troubleshooting.md)
+ [Importazione ed esportazione di dati SQL Server mediante altri metodi](SQLServer.Procedural.Importing.Snapshots.md)
+ [Importazione di dati in Amazon RDS per SQL Server utilizzando uno snapshot](SQLServer.Procedural.Importing.Snapshots.md#SQLServer.Procedural.Importing.Procedure)
+ [Importazione dei dati](SQLServer.Procedural.Importing.Snapshots.md#ImportData.SQLServer.Import)
+ [Procedura guidata Genera e pubblica script](SQLServer.Procedural.Importing.Snapshots.md#ImportData.SQLServer.MgmtStudio.ScriptWizard)
+ [Importazione/Esportazione guidata](SQLServer.Procedural.Importing.Snapshots.md#ImportData.SQLServer.MgmtStudio.ImportExportWizard)
+ [Copia bulk](SQLServer.Procedural.Importing.Snapshots.md#ImportData.SQLServer.MgmtStudio.BulkCopy)
+ [Esportazione di dati da Amazon RDS per SQL Server](SQLServer.Procedural.Importing.Snapshots.md#SQLServer.Procedural.Exporting)
+ [Importazione/Esportazione guidata di SQL Server](SQLServer.Procedural.Importing.Snapshots.md#SQLServer.Procedural.Exporting.SSIEW)
+ [Procedura guidata Genera e pubblica script e utilità bcp di SQL Server](SQLServer.Procedural.Importing.Snapshots.md#SQLServer.Procedural.Exporting.SSGPSW)
+ [Utilizzo dell’utilità BCP di Linux per importare ed esportare dati](SQLServer.Procedural.Importing.BCP.Linux.md)
+ [Prerequisiti](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Prerequisites)
+ [Installazione degli strumenti a riga di comando di SQL Server su Linux](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Installing)
+ [Esportazione di dati da Amazon RDS per SQL Server](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Exporting)
+ [Sintassi di base per l’esportazione](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Exporting.Basic)
+ [Esempio di esportazione](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Exporting.Example)
+ [Importazione di dati in RDS per SQL Server](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Importing)
+ [Sintassi di base per l’importazione](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Importing.Basic)
+ [Esempio di importazione](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Importing.Example)
+ [Opzioni di BCP comuni](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Options)
+ [Best practice e considerazioni](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.BestPractices)
+ [Risoluzione dei problemi comuni](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Troubleshooting)
## Limitazioni e consigli
Le limitazioni all'utilizzo di backup e ripristino nativi sono le seguenti:
+ Non puoi eseguire il backup o il ripristino da un bucket Amazon S3 in una AWS regione diversa dalla tua istanza database Amazon RDS.
+ Non è possibile ripristinare un database se esiste già un database con lo stesso nome. I nomi dei database sono univoci.
+ Consigliamo vivamente di non ripristinare backup da un fuso orario in un fuso orario diverso. Se ripristini backup da un fuso orario in un fuso orario diverso, devi controllare le query e le applicazioni per verificare gli effetti del cambiamento di fuso orario.
+ RDS per Microsoft SQL Server ha un limite di dimensione di 5 TB per file. Per i backup nativi di database di grandi dimensioni, è possibile utilizzare il backup con più file.
+ La dimensione massima del database di cui è possibile eseguire il backup su S3 dipende dalla memoria, dalla CPU, dall'I/O e dalle risorse di rete disponibili nell'istanza del DB. Più grande è il database, maggiore è la quantità di memoria utilizzata dall'agente di backup.
+ Non puoi eseguire il backup o il ripristino da più di 10 file di backup alla volta.
+ Il backup differenziale si basa sull'ultimo backup completo. Per completare i backup differenziali non puoi effettuare una snapshot tra l'ultimo backup completo e il backup differenziale. Se si desidera effettuare un backup differenziale, ma esiste uno snapshot, effettua un altro backup completo prima di procedere con il backup differenziale.
+ I ripristini differenziali e di log non sono supportati per i database con file in cui il relativo file\$1guid (identificatore univoco) è impostato su `NULL`.
+ Puoi eseguire fino a due attività di backup o ripristino contemporaneamente.
+ Non è possibile eseguire backup dei log nativi da SQL Server Amazon RDS.
+ RDS supporta ripristini nativi di database fino a 64 TiB. I ripristini nativi di database su SQL Server Express Edition sono limitati a 10 GB.
+ Non puoi effettuare un backup nativo durante la finestra di manutenzione o quando Amazon RDS è impegnato ad acquisire uno snapshot del database. Se un'attività di backup nativa si sovrappone alla finestra di backup giornaliero di Servizi RDS, l'attività di backup nativa viene annullata.
+ Nelle istanze database Multi-AZ è possibile ripristinare in modo nativo solo i database con backup nel modello di ripristino "Full" (Completo).
+ Non è supportata la chiamata delle procedure RDS per backup e ripristino nativi in una transazione.
+ Utilizza una crittografia AWS KMS key simmetrica per crittografare i backup. Amazon RDS non supporta le chiavi KMS asimmetriche. Per ulteriori informazioni, consulta [Creazione di chiavi KMS di crittografia simmetrica](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) nella *Guida per gli sviluppatori di AWS Key Management Service *.
+ I file di backup nativi sono crittografati con la chiave KMS specifica utilizzando la modalità di crittografia "Solo crittografia". Quando vengono ripristinati i file di backup crittografati, tieni presente che sono crittografati con modalità di crittografia "Solo crittografia".
+ Non è possibile ripristinare un database che contiene un gruppo di file FILESTREAM.
+ La crittografia lato server di Amazon S3 con AWS KMS (SSE-KMS) è supportata tramite la configurazione di crittografia predefinita del bucket S3 quando si passa alla procedura di backup storage. `@enable_bucket_default_encryption=1` Per impostazione predefinita, il ripristino supporta la crittografia lato server dell'oggetto S3.
Quando fornisci una chiave KMS a una procedura archiviata, tutti i backup e i ripristini nativi vengono crittografati e decrittografati sul lato client con la chiave KMS. AWS archivia i backup nel bucket S3 con SSE-S3 quando o con la chiave di crittografia predefinita configurata del bucket S3 quando. `@enable_bucket_default_encryption=0` `@enable_bucket_default_encryption=1`
+ Quando si utilizzano punti di accesso S3, il punto di accesso non può essere configurato per utilizzare un VPC interno RDS.
+ Per le massime prestazioni, consigliamo di utilizzare bucket di directory o punti di accesso per i bucket di directory, se disponibili nella propria regione.
Ti consigliamo di utilizzare backup e ripristino nativi per migrare il tuo database in RDS se il database può essere offline quando il file di backup viene creato, copiato e ripristinato. Se il database locale non può essere offline, ti consigliamo di utilizzare il AWS Database Migration Service per migrare il database su Amazon RDS. [Per ulteriori informazioni, consulta Cos'è? AWS Database Migration Service](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html)
Backup e ripristino nativi non hanno lo scopo di sostituire le funzionalità di ripristino dei dati della funzione di copia di snapshot tra regioni. Ti consigliamo di utilizzare la copia istantanea per copiare lo snapshot del database in un'altra AWS regione per il disaster recovery tra regioni in Amazon RDS. Per ulteriori informazioni, consulta [Copia di uno snapshot del database per Amazon RDS](USER_CopySnapshot.md).
# Configurazione di backup e ripristino nativi
Per configurare backup e ripristino nativi, sono necessari tre componenti:
1. Un bucket Amazon S3 per archiviare i file di backup.
Devi disporre di un bucket S3 per utilizzare i file di backup e quindi caricare i backup che desideri migrare su RDS. Se disponi già di un bucket Amazon S3, puoi utilizzarlo. Se non hai già un bucket, puoi [ crearne uno nuovo](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingaBucket.html). In alternativa, puoi scegliere che venga creato automaticamente un nuovo bucket quando aggiungi l'opzione `SQLSERVER_BACKUP_RESTORE` usando la Console di gestione AWS.
Per ulteriori informazioni, consulta la [Guida per l'utente di Amazon Simple Storage Service](https://docs.aws.amazon.com/AmazonS3/latest/userguide/).
1. Un ruolo AWS Identity and Access Management (IAM) per accedere al bucket.
Se disponi già di un ruolo IAM, puoi utilizzarlo. In alternativa, puoi scegliere che venga creato automaticamente un nuovo ruolo IAM quando aggiungi l'opzione `SQLSERVER_BACKUP_RESTORE` usando la Console di gestione AWS. In alternativa, è possibile crearne uno nuovo manualmente.
Se vuoi creare un nuovo ruolo IAM manualmente, segui l'approccio illustrato nella sezione successiva. Eseguire la stessa operazione se si desidera associare le relazioni di trust e i criteri di autorizzazione a un ruolo IAM esistente.
1. L'opzione `SQLSERVER_BACKUP_RESTORE` aggiunta a un gruppo di opzioni nella tua istanza database.
Per abilitare backup e ripristino nativi sulla tua istanza database, devi aggiungere l'opzione `SQLSERVER_BACKUP_RESTORE` a un gruppo di opzioni sulla tua istanza database. Per ulteriori informazioni e istruzioni, consulta [Supporto per backup nativo e ripristino in SQL Server](Appendix.SQLServer.Options.BackupRestore.md).
## Creazione manuale di un ruolo IAM per backup e ripristino nativi
Se lo desideri, puoi creare manualmente un nuovo ruolo IAM da utilizzare con il backup e il ripristino nativi. In tal caso, crea un ruolo da cui delegare le autorizzazioni del servizio Amazon RDS al bucket Amazon S3. Quando si crea un ruolo IAM, si allegano una relazione di trust e un criterio di autorizzazioni. La policy di attendibilità consente a Servizi RDS di assumere questo ruolo. La policy di autorizzazione definisce le operazioni che questo ruolo può eseguire. Per ulteriori informazioni sulla creazione del ruolo, consulta la pagina [Creazione di un ruolo per delegare le autorizzazioni a un servizio AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html).
Per la funzione di backup e ripristino nativi, utilizza le policy di attendibilità e autorizzazione simili agli esempi presenti in questa sezione. Nell'esempio che segue utilizziamo il nome del servizio `rds.amazonaws.com` come alias per tutti gli account di servizio. Negli altri esempi specifichiamo un Amazon Resource Name (ARN) per identificare un altro account, un altro utente o un altro ruolo al quale concediamo l'accesso nella policy di attendibilità.
Si consiglia di utilizzare le chiavi di contesto delle condizioni globali [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn) e [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount) nelle relazioni di trust basate sulle risorse per limitare le autorizzazioni del servizio relative a una risorsa specifica. Questo è il modo più efficace per proteggersi dal [problema di deputy confused](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html).
Puoi usare le chiavi di contesto delle condizioni globali e avere il valore `aws:SourceArn` che contiene l'ID dell'account. In questo caso, il valore `aws:SourceAccount` e l'account nel valore `aws:SourceArn` deve utilizzare lo stesso ID account quando viene utilizzato nella stessa istruzione.
+ Utilizzare `aws:SourceArn` se si desidera un accesso cross-service per una singola risorsa.
+ Utilizzare `aws:SourceAccount` se si desidera consentire l'associazione di qualsiasi risorsa in tale account all'uso cross-service.
Nella relazione di attendibilità, assicurati di utilizzare la chiave di contesto della condizione globale `aws:SourceArn` con l'ARN completo delle risorse che accedono al ruolo. Per il backup e il ripristino nativi, assicurati di includere sia il gruppo di opzioni database che le istanze database, come illustrato nell'esempio seguente.
**Example di relazione di attendibilità con chiave di contesto delle condizioni globali per backup e ripristino nativi**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceArn": [
"arn:aws:rds:Region:0123456789:db:db_instance_identifier",
"arn:aws:rds:Region:0123456789:og:option_group_name"
],
"aws:SourceAccount": "0123456789"
}
}
}
]
}
```
Nell'esempio che segue viene utilizzato un ARN per specificare la risorsa. Per ulteriori informazioni sull'utilizzoARNs, consulta [Amazon resource names (ARNs)](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html).
**Example di policy di autorizzazione per backup e ripristino nativi senza supporto della crittografia**
****
```
{
"Version":"2012-10-17",
"Statement":
[
{
"Effect": "Allow",
"Action":
[
"s3:ListBucket",
"s3:GetBucketLocation"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket"
},
{
"Effect": "Allow",
"Action":
[
"s3:GetObjectAttributes",
"s3:GetObject",
"s3:PutObject",
"s3:ListMultipartUploadParts",
"s3:AbortMultipartUpload"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
}
]
}
```
**Example Policy di autorizzazione per backup e ripristino nativi con supporto della crittografia**
Se desideri crittografare i tuoi file di backup, includi una chiave di crittografia nella policy di autorizzazione. Per ulteriori informazioni sulle chiavi di crittografia, consulta [Nozioni di base](https://docs.aws.amazon.com/kms/latest/developerguide/getting-started.html) nella *Guida per gli sviluppatori di AWS Key Management Service *.
Per crittografare i backup è necessario utilizzare una chiave KMS di crittografia simmetrica. Amazon RDS non supporta le chiavi KMS asimmetriche. Per ulteriori informazioni, consulta [Creazione di chiavi KMS di crittografia simmetrica](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) nella *Guida per gli sviluppatori di AWS Key Management Service *.
Il ruolo IAM deve inoltre essere un utente chiave e un amministratore chiave per la chiave KMS, ovvero deve essere specificato nel criterio chiave. Per ulteriori informazioni, consulta [Creazione di chiavi KMS di crittografia simmetrica](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) nella *Guida per gli sviluppatori di AWS Key Management Service *.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowAccessToKey",
"Effect": "Allow",
"Action": [
"kms:DescribeKey",
"kms:GenerateDataKey",
"kms:Encrypt",
"kms:Decrypt"
],
"Resource": "arn:aws:kms:us-east-1:123456789012:key/key-id"
},
{
"Sid": "AllowAccessToS3",
"Effect": "Allow",
"Action": [
"s3:ListBucket",
"s3:GetBucketLocation"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket"
},
{
"Sid": "GetS3Info",
"Effect": "Allow",
"Action": [
"s3:GetObjectAttributes",
"s3:GetObject",
"s3:PutObject",
"s3:ListMultipartUploadParts",
"s3:AbortMultipartUpload"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
}
]
}
```
**Example politica di autorizzazioni per il backup e il ripristino nativi utilizzando punti di accesso senza supporto per la crittografia**
Le azioni richieste per utilizzare i punti di accesso S3 sono le stesse dei bucket S3. Il percorso della risorsa viene aggiornato in modo che corrisponda al pattern ARN del punto di accesso S3.
I punti di accesso devono essere configurati per utilizzare **Network origin: Internet** as RDS does not public private. VPCs Il traffico S3 proveniente dalle istanze RDS non passa attraverso la rete Internet pubblica poiché passa attraverso la rete privata. VPCs
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:ListBucket",
"s3:GetBucketLocation"
],
"Resource": [
"arn:aws:s3:us-east-1:111122223333:accesspoint/amzn-s3-demo-ap",
"arn:aws:s3:::underlying-bucket"
]
},
{
"Effect": "Allow",
"Action": [
"s3:GetObjectAttributes",
"s3:GetObject",
"s3:PutObject",
"s3:ListMultipartUploadParts",
"s3:AbortMultipartUpload"
],
"Resource": [
"arn:aws:s3:us-east-1:111122223333:accesspoint/amzn-s3-demo-ap/*",
"arn:aws:s3:::underlying-bucket/*"
]
}
]
}
```
**Example politica di autorizzazioni per il backup e il ripristino nativi utilizzando punti di accesso per i bucket di directory senza supporto per la crittografia**
I bucket di directory utilizzano un [meccanismo di autorizzazione diverso, basato sulla sessione](https://docs.aws.amazon.com//AmazonS3/latest/userguide/s3-express-authenticating-authorizing.html), rispetto ai bucket generici, pertanto l'unica autorizzazione richiesta per il ripristino del backup nativo è l'autorizzazione «s3express:» a livello di bucket. CreateSession [Per configurare l'accesso a livello di oggetto, è necessario utilizzare i punti di accesso per i bucket di directory.](https://docs.aws.amazon.com//AmazonS3/latest/userguide/access-points-directory-buckets-policies.html)
I punti di accesso devono essere configurati per utilizzare **Network Origin: Internet** as RDS does not publishing private. VPCs Il traffico S3 proveniente dalle istanze RDS non passa attraverso la rete Internet pubblica poiché passa attraverso la rete privata. VPCs
****
```
{
"Version":"2012-10-17",
"Statement":
[
{
"Effect": "Allow",
"Action": "s3express:CreateSession",
"Resource":
[
"arn:aws:s3express:us-east-1:111122223333:accesspoint/amzn-s3-demo-accesspoint--use1-az6--xa-s3",
"arn:aws:s3express:us-east-1:111122223333:bucket/amzn-s3-demo-bucket--use1-az6--x-s3"
]
}
]
}
```
# Uso di backup e ripristino nativi
Dopo aver abilitato e configurato backup e ripristino nativi, puoi iniziare a utilizzarli. Per farlo, devi innanzitutto connetterti al database Microsoft SQL Server e poi chiamare una stored procedure Amazon RDS per eseguire il lavoro. Per istruzioni sulla connessione al tuo database, consulta [Connessione all’istanza database Microsoft SQL Server](USER_ConnectToMicrosoftSQLServerInstance.md).
Alcune delle stored procedure richiedono di fornire un Amazon Resource Name (ARN) al tuo file e bucket Amazon S3. Il formato per l'ARN è `arn:aws:s3:::bucket_name/file_name.extension`. Amazon S3 non richiede un numero di account o una AWS regione in. ARNs
Se fornisci anche una chiave KMS opzionale, il formato per l'ARN della chiave è `arn:aws:kms:region:account-id:key/key-id`. Per ulteriori informazioni, consulta [Amazon resource names (ARNs) e AWS service namespaces](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html). Per crittografare i backup è necessario utilizzare una chiave KMS di crittografia simmetrica. Amazon RDS non supporta le chiavi KMS asimmetriche. Per ulteriori informazioni, consulta [Creazione di chiavi KMS di crittografia simmetrica](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) nella *Guida per gli sviluppatori di AWS Key Management Service *.
**Nota**
Indipendentemente dal fatto che utilizzi o meno una chiave KMS, le attività di backup e ripristino native abilitano la crittografia Advanced Encryption Standard (AES) a 256 bit sul lato server tramite SSE-S3 per impostazione predefinita per i file caricati su S3. Il passaggio `@enable_bucket_default_encryption=1` alla procedura di backup storage utilizza la chiave di crittografia predefinita configurata del bucket S3.
Per istruzioni su come chiamare ciascuna stored procedure, consulta i seguenti argomenti:
+ [Backup di un database](#SQLServer.Procedural.Importing.Native.Using.Backup)
+ [Ripristino di un database](#SQLServer.Procedural.Importing.Native.Using.Restore)
+ [Ripristino di un log](#SQLServer.Procedural.Importing.Native.Restore.Log)
+ [Completamento di un ripristino del database](#SQLServer.Procedural.Importing.Native.Finish.Restore)
+ [Utilizzo di database parzialmente ripristinati](#SQLServer.Procedural.Importing.Native.Partially.Restored)
+ [Annullamento di un'attività](#SQLServer.Procedural.Importing.Native.Using.Cancel)
+ [Monitoraggio dello stato delle attività](#SQLServer.Procedural.Importing.Native.Tracking)
## Backup di un database
Per eseguire il backup del tuo database, utilizza la stored procedure `rds_backup_database`.
**Nota**
Non puoi effettuare il backup di un database durante la finestra di manutenzione o quando Amazon RDS è impegnato ad acquisire uno snapshot.
### Utilizzo
```
exec msdb.dbo.rds_backup_database
@source_db_name='database_name',
@s3_arn_to_backup_to='arn:aws:s3:::bucket_name/file_name.extension',
[@kms_master_key_arn='arn:aws:kms:region:account-id:key/key-id'],
[@overwrite_s3_backup_file=0|1],
[@block_size=512|1024|2048|4096|8192|16384|32768|65536],
[@max_transfer_size=n],
[@buffer_count=n],
[@type='DIFFERENTIAL|FULL'],
[@number_of_files=n],
[@enable_bucket_default_encryption=0|1];
```
I parametri seguenti sono obbligatori:
+ `@source_db_name` – Nome del database di cui eseguire il backup.
+ `@s3_arn_to_backup_to`— L'ARN che indica il bucket Amazon S3, il punto di accesso, il bucket di directory o il punto di accesso per il bucket di directory da utilizzare per il backup, più il nome del file di backup.
Il file può avere qualsiasi estensione, ma di norma è `.bak`. Tieni presente che il punto di accesso ARNs deve essere del formato indicato. `arn:aws:s3:us-east-1:111122223333:access-point-name/object/key`
I parametri seguenti sono facoltativi:
+ `@kms_master_key_arn`: l'ARN per la chiave KMS di crittografia simmetrica da utilizzare per crittografare l'elemento.
+ Non è possibile utilizzare la chiave di crittografia predefinita. Se si utilizza la chiave predefinita, non verrà eseguito il backup del database.
+ Se non si specifica un identificatore della chiave KMS, il file di backup non verrà crittografato. Per ulteriori informazioni, consulta [Crittografia delle risorse Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Overview.Encryption.html).
+ Quando si specifica una chiave KMS, viene utilizzata la crittografia lato client.
+ Amazon RDS non supporta le chiavi KMS asimmetriche. Per ulteriori informazioni, consulta [Creazione di chiavi KMS di crittografia simmetrica](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) nella *Guida per gli sviluppatori di AWS Key Management Service *.
+ `@overwrite_s3_backup_file` – Un valore che indica se sovrascrivere un file di backup esistente.
+ `0` – Il file esistente non viene sovrascritto. Questo è il valore predefinito.
L'impostazione di `@overwrite_s3_backup_file` su 0 restituisce un errore se il file esiste già.
+ `1` – Il file esistente con il nome specificato viene sovrascritto, anche se non è un file di backup.
+ `@type` – Tipo di backup.
+ `DIFFERENTIAL` – Viene eseguito un backup differenziale.
+ `FULL` – Viene eseguito un backup completo. Questo è il valore predefinito.
Il backup differenziale si basa sull'ultimo backup completo. Per completare i backup differenziali non puoi effettuare una snapshot tra l'ultimo backup completo e il backup differenziale. Per effettuare un backup differenziale ed esiste uno snapshot, effettua un altro backup completo prima di procedere con il backup differenziale.
Puoi cercare l'ultimo backup completo o snapshot utilizzando la seguente query SQL di esempio.
```
select top 1
database_name
, backup_start_date
, backup_finish_date
from msdb.dbo.backupset
where database_name='mydatabase'
and type = 'D'
order by backup_start_date desc;
```
+ `@number_of_files` – Numero di file in cui verrà diviso il backup (blocchi). Il numero massimo è 10.
+ Il backup a più file è supportato per backup completi e differenziali.
+ Se immetti un valore pari a 1 o ometti il parametro, viene creato un singolo file di backup.
Fornisci il prefisso in comune dei file, quindi il suffisso con un asterisco (`*`). L'asterisco può trovarsi in qualsiasi punto dell'*file\$1name*ARN S3. L'asterisco viene sostituito da una serie di stringhe alfanumeriche nei file generati, a partire da `1-of-number_of_files`.
Ad esempio, se i nomi dei file nell'ARN S3 sono `backup*.bak` e imposti `@number_of_files=4`, i file di backup generati sono `backup1-of-4.bak`, `backup2-of-4.bak`, `backup3-of-4.bak` e `backup4-of-4.bak`.
+ Se uno dei nomi di file esiste già e `@overwrite_s3_backup_file` è 0, viene restituito un errore.
+ I backup con più file possono avere un solo asterisco nella *file\$1name* parte dell'ARN S3.
+ I backup a file singolo possono avere un numero qualsiasi di asterischi nella *file\$1name* parte dell'ARN S3. Gli asterischi non vengono rimossi dal nome file generato.
+ `@block_size`: la dimensione del blocco (in byte) che specifica la dimensione fisica del blocco per le operazioni di backup. I valori validi sono 512, 1.024, 2.048, 4.096, 8.192, 16.384, 32.768, e 65.536.
+ `@max_transfer_size`— La dimensione massima di trasferimento indica il limite superiore del volume di dati (in byte) trasmesso per operazione durante il processo di backup. I/O I valori validi sono multipli di 65.536 byte (64 KB) fino a 4.194.304 byte (4 MB).
+ `@buffer_count`— Numero totale di I/O buffer da utilizzare per il processo di backup.
+ `@enable_bucket_default_encryption`— Un valore che indica se utilizzare la configurazione di crittografia predefinita del bucket S3 per la crittografia lato server in S3. I bucket di directory utilizzano sempre la configurazione di crittografia predefinita del bucket indipendentemente da questa impostazione.
+ `0`— La crittografia lato server utilizza la crittografia Advanced Encryption Standard (AES) a 256 bit tramite SSE-S3.
+ `1`[— La crittografia lato server utilizza la crittografia predefinita configurata del bucket S3.](https://docs.aws.amazon.com//AmazonS3/latest/userguide/bucket-encryption.html)
### Esempi
**Example di backup differenziale**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup1.bak',
@overwrite_s3_backup_file=1,
@type='DIFFERENTIAL';
```
**Example di backup completo con crittografia lato client**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup1.bak',
@kms_master_key_arn='arn:aws:kms:us-east-1:123456789012:key/AKIAIOSFODNN7EXAMPLE',
@overwrite_s3_backup_file=1,
@type='FULL';
```
**Example di backup di più file**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@number_of_files=4;
```
**Example di backup differenziale di più file**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@type='DIFFERENTIAL',
@number_of_files=4;
```
**Example di backup di più file con crittografia**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@kms_master_key_arn='arn:aws:kms:us-east-1:123456789012:key/AKIAIOSFODNN7EXAMPLE',
@number_of_files=4;
```
**Example di backup di più file con sovrascrittura S3**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@overwrite_s3_backup_file=1,
@number_of_files=4;
```
**Example di backup con dimensione del blocco**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@block_size=512;
```
**Example di backup di più file con `@max_transfer_size` e `@buffer_count`**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@number_of_files=4,
@max_transfer_size=4194304,
@buffer_count=10;
```
**Example di backup di file singolo con il parametro @number\$1of\$1files**
Questo esempio genera un file di backup denominato `backup*.bak`.
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@number_of_files=1;
```
**Example di backup completo con crittografia lato server**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@overwrite_s3_backup_file=1,
@type='FULL',
@enable_bucket_default_encryption=1;
```
**Example di backup completo utilizzando un punto di accesso**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:us-east-1:111122223333:accesspoint/my-access-point/object/backup1.bak',
@overwrite_s3_backup_file=1,
@type='FULL';
```
**Example del backup completo utilizzando un punto di accesso per un bucket di directory**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3express:us-east-1:123456789012:accesspoint/my-access-point--use1-az6--xa-s3/object/backup1.bak',
@overwrite_s3_backup_file=1,
@type='FULL';
```
## Ripristino di un database
Per eseguire il ripristino del tuo database devi chiamare la stored procedure `rds_restore_database`. Amazon RDS crea uno snapshot iniziale del database dopo che l'attività di ripristino è stata completata e il database è aperto.
### Utilizzo
```
exec msdb.dbo.rds_restore_database
@restore_db_name='database_name',
@s3_arn_to_restore_from='arn:aws:s3:::bucket_name/file_name.extension',
@with_norecovery=0|1,
[@keep_cdc=0|1],
[@data_file_volume='D:|H:|I:|J:'],
[@log_file_volume='D:|H:|I:|J:'],
[@kms_master_key_arn='arn:aws:kms:region:account-id:key/key-id'],
[@block_size=512|1024|2048|4096|8192|16384|32768|65536],
[@max_transfer_size=n],
[@buffer_count=n],
[@type='DIFFERENTIAL|FULL'];
```
I parametri seguenti sono obbligatori:
+ `@restore_db_name` – Il nome del database da ripristinare. I nomi dei database sono univoci. Non è possibile ripristinare un database se esiste già un database con lo stesso nome.
+ `@s3_arn_to_restore_from` – L'ARN che indica il prefisso e i nomi Amazon S3 dei file di backup utilizzati per ripristinare il database.
+ Per il backup di un file singolo, fornisci l'intero nome file.
+ Per eseguire un backup a più file, fornisci il prefisso in comune dei file, quindi il suffisso con un asterisco (`*`).
+ Se si utilizza un bucket di directory, l'ARN deve terminare `/*` con [a causa delle differenze tra i bucket di](https://docs.aws.amazon.com//AmazonS3/latest/userguide/s3-express-differences.html) directory.
+ Se `@s3_arn_to_restore_from` è vuoto, viene restituito il seguente errore: S3 ARN prefix cannot be empty (Il prefisso ARN di S3 non può essere vuoto).
Il seguente parametro è obbligatorio per i ripristini differenziali, ma facoltativo per i ripristini completi:
+ `@with_norecovery` – La clausola di ripristino da utilizzare per l'operazione di ripristino.
+ Impostala su `0` per ripristinare con RECOVERY. In questo caso, il database è online dopo il ripristino.
+ Impostala su `1` per ripristinare con NORECOVERY. In questo caso, il database rimane nello stato RESTORING dopo il completamento dell'attività di ripristino. Con questo approccio puoi eseguire ripristini differenziali successivi.
+ Per i ripristini DIFFERENTIAL, specifica `0` o `1`.
+ Per i ripristini `FULL`, per impostazione predefinita questo valore è `0`.
I parametri seguenti sono facoltativi:
+ `@keep_cdc`— Indica se mantenere la configurazione Change Data Capture (CDC) sul database ripristinato. Impostato su per `1` abilitare KEEP\$1CDC, per disabilitare. `0` Il valore predefinito è `0`.
+ `@data_file_volume`— specifica la lettera di unità per i file di dati del database. Il valore predefinito è `D:`.
+ `@log_file_volume`— Speciifica la lettera di unità per i file di registro del database. Il valore predefinito è. `D:`
+ `@kms_master_key_arn`: la chiave KMS da usare per decrittografare il file di backup, se è stato crittografato.
Quando si specifica una chiave KMS, viene utilizzata la crittografia lato client.
+ `@type` – Tipo di ripristino. I tipi validi sono `DIFFERENTIAL` e `FULL`. Il valore predefinito è `FULL`.
+ `@block_size`: la dimensione del blocco (in byte) che specifica la dimensione fisica del blocco per le operazioni di backup. I valori validi sono 512, 1.024, 2.048, 4.096, 8.192, 16.384, 32.768, e 65.536.
+ `@max_transfer_size`— La dimensione massima di trasferimento indica il limite superiore del volume di dati (in byte) trasmesso per I/O operazione durante il processo di backup. I valori validi sono multipli di 65.536 byte (64 KB) fino a 4.194.304 byte (4 MB).
+ `@buffer_count`— Numero totale di I/O buffer da utilizzare per il processo di backup.
**Nota**
Per i ripristini differenziali, il database deve trovarsi nello stato RESTORING oppure deve già esistere un'attività che ripristina con NORECOVERY.
Non è possibile ripristinare i backup differenziali successivi mentre il database è online.
Non è possibile inviare un'attività di ripristino per un database che ha già un'attività di ripristino in sospeso con RECOVERY.
I ripristini completi con NORECOVERY e KEEP\$1CDC non sono supportati.
Tutti i ripristini nativi non sono supportati sulle istanze con repliche di lettura tra regioni.
Per le configurazioni supportate, il ripristino di un database in un’istanza Multi-AZ con repliche di lettura è simile al ripristino di un database in un’istanza Multi-AZ. Non è necessario eseguire ulteriori azioni per ripristinare un database in una replica.
### Esempi
**Example di ripristino di un singolo file**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak';
```
**Example di ripristino di più file**
Per evitare errori durante il ripristino di più file, assicurati che tutti i file di backup abbiano lo stesso prefisso e che nessun altro file utilizzi tale prefisso.
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup*';
```
**Example di ripristino completo del database con RECOVERY**
I seguenti tre esempi eseguono la stessa attività di ripristino completo con RECOVERY.
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak';
```
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
[@type='DIFFERENTIAL|FULL'];
```
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@type='FULL',
@with_norecovery=0;
```
**Example di ripristino completo del database con crittografia**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@kms_master_key_arn='arn:aws:kms:us-east-1:123456789012:key/AKIAIOSFODNN7EXAMPLE';
```
**Example di ripristino con dimensione del blocco**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@block_size=512;
```
**Example di ripristino di più file con @max\$1transfer\$1size e @buffer\$1count**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup*',
@max_transfer_size=4194304,
@buffer_count=10;
```
**Example di ripristino completo del database con NORECOVERY**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@type='FULL',
@with_norecovery=1;
```
**Example di ripristino differenziale con NORECOVERY**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@type='DIFFERENTIAL',
@with_norecovery=1;
```
**Example di ripristino differenziale con RECOVERY**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@type='DIFFERENTIAL',
@with_norecovery=0;
```
**Example del ripristino completo del database con RECOVERY utilizzando un punto di accesso**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:us-east-1:111122223333:accesspoint/my-access-point/object/backup1.bak',
@with_norecovery=0;
```
**Example del ripristino completo del database con KEEP\$1CDC**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@keep_cdc=1;
```
## Ripristino di un log
Per ripristinare il log chiama la stored procedure `rds_restore_log`.
### Utilizzo
```
exec msdb.dbo.rds_restore_log
@restore_db_name='database_name',
@s3_arn_to_restore_from='arn:aws:s3:::bucket_name/log_file_name.extension',
[@kms_master_key_arn='arn:aws:kms:region:account-id:key/key-id'],
[@with_norecovery=0|1],
[@keep_cdc=0|1],
[@stopat='datetime'],
[@block_size=512|1024|2048|4096|8192|16384|32768|65536],
[@max_transfer_size=n],
[@buffer_count=n];
```
I parametri seguenti sono obbligatori:
+ `@restore_db_name` – Il nome del database di cui vuoi ripristinare il log.
+ `@s3_arn_to_restore_from` – L'ARN che indica il prefisso e i nomi Amazon S3 dei file di log utilizzati per ripristinare il log. Il file può avere qualsiasi estensione, ma di norma è `.trn`.
Se `@s3_arn_to_restore_from` è vuoto, viene restituito il seguente errore: S3 ARN prefix cannot be empty (Il prefisso ARN di S3 non può essere vuoto).
I parametri seguenti sono facoltativi:
+ `@keep_cdc`— Indica se mantenere la configurazione Change Data Capture (CDC) sul database ripristinato. Impostato su 1 per abilitare KEEP\$1CDC, 0 per disabilitare. Il valore predefinito è 0.
+ `@kms_master_key_arn`: la chiave KMS da usare per decrittografare il registro, se è stato crittografato.
+ `@with_norecovery` – La clausola di ripristino da utilizzare per l'operazione di ripristino. Il valore predefinito è `1`.
+ Impostala su `0` per ripristinare con RECOVERY. In questo caso, il database è online dopo il ripristino. Non è possibile ripristinare i backup di log successivi mentre il database è online.
+ Impostala su `1` per ripristinare con NORECOVERY. In questo caso, il database rimane nello stato RESTORING dopo il completamento dell'attività di ripristino. Con questo approccio puoi eseguire ripristini di log successivi.
+ `@stopat` – Un valore che specifica che lo stato del database viene ripristinato alla data e all'ora specificate (nel formato datetime). Solo i record del log delle transazioni scritti prima della data e dell'ora specificate vengono applicati al database.
Se questo parametro non viene specificato (è NULL), viene ripristinato il log completo.
+ `@block_size`: la dimensione del blocco (in byte) che specifica la dimensione fisica del blocco per le operazioni di backup. I valori validi sono 512, 1.024, 2.048, 4.096, 8.192, 16.384, 32.768, e 65.536.
+ `@max_transfer_size`— La dimensione massima di trasferimento indica il limite superiore del volume di dati (in byte) trasmesso per I/O operazione durante il processo di backup. I valori validi sono multipli di 65.536 byte (64 KB) fino a 4.194.304 byte (4 MB).
+ `@buffer_count`— Numero totale di I/O buffer da utilizzare per il processo di backup.
**Nota**
Per i ripristini di log, il database deve trovarsi nello stato RESTORING oppure deve già esistere un'attività che ripristina con NORECOVERY.
Non è possibile ripristinare i backup di log mentre il database è online.
Non è possibile inviare un'attività di ripristino di log per un database che ha già un'attività di ripristino in sospeso con RECOVERY.
### Esempi
**Example di ripristino di log**
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn';
```
**Example di ripristino di log con crittografia**
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn',
@kms_master_key_arn='arn:aws:kms:us-east-1:123456789012:key/AKIAIOSFODNN7EXAMPLE';
```
**Example di ripristino di log con NORECOVERY**
I seguenti due esempi eseguono la stessa attività di ripristino di log con NORECOVERY.
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn',
@with_norecovery=1;
```
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn';
```
**Example di ripristino con dimensione del blocco**
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn',
@block_size=512;
```
**Example di ripristino di log con RECOVERY**
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn',
@with_norecovery=0;
```
**Example di ripristino di log con la clausola STOPAT**
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn',
@with_norecovery=0,
@stopat='2019-12-01 03:57:09';
```
**Example del ripristino dei log con KEEP\$1CDC**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@keep_cdc=1;
```
## Completamento di un ripristino del database
Se l'ultima attività di ripristino sul database è stata eseguita utilizzando `@with_norecovery=1`, il database è ora nello stato RESTORING. Apri il database per il normale funzionamento utilizzando la stored procedure `rds_finish_restore`.
### Utilizzo
```
exec msdb.dbo.rds_finish_restore @db_name='database_name';
```
**Nota**
Per utilizzare questo approccio, il database deve trovarsi nello stato RESTORING senza attività di ripristino in sospeso.
Per completare il ripristino del database, utilizza l'accesso master. In alternativa, utilizza l'accesso utente che ha ripristinato più di recente il database o il log con NORECOVERY.
## Utilizzo di database parzialmente ripristinati
### Rimozione di un database parzialmente ripristinato
Per rimuovere un database parzialmente ripristinato (lasciato nello stato RESTORING), utilizza la stored procedure `rds_drop_database`.
```
exec msdb.dbo.rds_drop_database @db_name='database_name';
```
**Nota**
Non è possibile inviare una richiesta DROP per un database che ha già un'attività di ripristino in sospeso o in completamento.
Per rimuovere il database, utilizza l'accesso master. In alternativa, utilizza l'accesso utente che ha ripristinato più di recente il database o il log con NORECOVERY.
### Comportamento di ripristino e point-in-time ripristino delle istantanee per database parzialmente ripristinati
I database parzialmente ripristinati nell'istanza di origine (lasciati nello stato RESTORING) vengono eliminati dall'istanza di destinazione durante il ripristino e il ripristino delle istantanee. point-in-time
## Annullamento di un'attività
Per annullare un'attività di backup o ripristino, chiama la stored procedure `rds_cancel_task`.
**Nota**
Non puoi annullare un'attività FINISH\$1RESTORE.
### Utilizzo
```
exec msdb.dbo.rds_cancel_task @task_id=ID_number;
```
Il parametro seguente è obbligatorio:
+ `@task_id` – L'ID dell'attività da annullare. L'ID attività si ottiene chiamando `rds_task_status`.
## Monitoraggio dello stato delle attività
Per monitorare lo stato delle tue attività di backup e ripristino, chiama la stored procedure `rds_task_status`. Se non fornisci alcun parametro, la stored procedure restituisce lo stato di tutte le attività. Lo stato delle attività viene aggiornato all'incirca ogni due minuti. La cronologia delle operazioni viene conservata per 36 giorni.
### Utilizzo
```
exec msdb.dbo.rds_task_status
[@db_name='database_name'],
[@task_id=ID_number];
```
I parametri seguenti sono facoltativi:
+ `@db_name` – Il nome del database per il quale visualizzare lo stato dell'attività.
+ `@task_id` – L'ID dell'attività per la quale visualizzare lo stato.
### Esempi
**Example di elenco dello stato per un'attività specifica**
```
exec msdb.dbo.rds_task_status @task_id=5;
```
**Example di elenco dello stato per un'attività e un database specifici**
```
exec msdb.dbo.rds_task_status
@db_name='my_database',
@task_id=5;
```
**Example di elenco di tutte le attività e relativi stati per un database specifico**
```
exec msdb.dbo.rds_task_status @db_name='my_database';
```
**Example di elenco di tutte le attività e relativi stati per l'istanza corrente**
```
exec msdb.dbo.rds_task_status;
```
### Risposta
La stored procedure `rds_task_status` restituisce le seguenti colonne.
****
| Colonna | Descrizione |
| --- | --- |
| `task_id` | L'ID dell'attività. |
| `task_type` | Tipo di attività in base ai parametri di input, come segue: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/SQLServer.Procedural.Importing.Native.Using.html) Amazon RDS crea uno snapshot iniziale del database dopo che è stato aperto al completamento delle seguenti attività di ripristino: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/SQLServer.Procedural.Importing.Native.Using.html) |
| `database_name` | Il nome del database al quale l'attività è associata. |
| `% complete` | L'avanzamento dell'attività espresso in percentuale. |
| `duration (mins)` | La quantità di tempo dedicato all'attività, in minuti. |
| `lifecycle` | Lo stato dell'attività. I possibili stati sono i seguenti: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/SQLServer.Procedural.Importing.Native.Using.html) |
| `task_info` | Ulteriori informazioni sull'attività. Se si verifica un errore durante il backup o il ripristino di un database, questa colonna contiene informazioni sull'errore. Per l'elenco dei possibili errori e le strategie di mitigazione, consulta [Risoluzione dei problemi](SQLServer.Procedural.Importing.Native.Troubleshooting.md). |
| `last_updated` | La data e l'ora dell'ultimo aggiornamento dello stato dell'attività. Lo stato viene aggiornato dopo ogni 5% di avanzamento. |
| `created_at` | La data e l'ora di creazione dell'attività. |
| S3\$1object\$1arn | L'ARN che indica il prefisso e il nome Amazon S3 del file di cui viene eseguito il backup o il ripristino. |
| `overwrite_s3_backup_file` | Il valore del parametro `@overwrite_s3_backup_file` specificato quando chiami un'attività di backup. Per ulteriori informazioni, consulta [Backup di un database](#SQLServer.Procedural.Importing.Native.Using.Backup). |
| KMS\$1master\$1key\$1arn | L'ARN per la chiave KMS utilizzata per la crittografia (per il backup) e la decrittografia (per il ripristino). |
| filepath | Non applicabile ad attività di backup e ripristino nativi. |
| overwrite\$1file | Non applicabile ad attività di backup e ripristino nativi. |
# Compressione dei file di backup
Per risparmiare spazio nel tuo bucket Amazon S3 puoi comprimere i tuoi file di backup. Per ulteriori informazioni sulla compressione dei file di backup, consulta [Compressione backup](https://msdn.microsoft.com/en-us/library/bb964719.aspx) nella documentazione di Microsoft.
La compressione dei file di backup è supportata per le seguenti edizioni dei database:
+ Microsoft SQL Server Enterprise Edition
+ Microsoft SQL Server Standard Edition
Per verificare l’opzione di compressione per i file di backup è necessario eseguire il seguente codice:
```
1. exec rdsadmin.dbo.rds_show_configuration 'S3 backup compression';
```
Per attivare la compressione per i file di backup è necessario eseguire il seguente codice:
```
1. exec rdsadmin.dbo.rds_set_configuration 'S3 backup compression', 'true';
```
Per disattivare la compressione per i file di backup è necessario eseguire il seguente codice:
```
1. exec rdsadmin.dbo.rds_set_configuration 'S3 backup compression', 'false';
```
# Risoluzione dei problemi
Di seguito sono elencati i problemi che si potrebbero riscontrare quando si utilizzano backup e ripristino nativi.
****
| Problema | Suggerimenti sulla risoluzione dei problemi |
| --- | --- |
| L'opzione di backup/ripristino del database non è ancora abilitata o è in fase di abilitazione. Please try again later. (Per favore, riprova più tardi) | Accertarsi di aver aggiunto l’opzione `SQLSERVER_BACKUP_RESTORE` al gruppo di opzioni DB associato all'istanza database. Per ulteriori informazioni, consulta [Aggiunta dell'opzione Native Backup and Restore (Backup nativo e ripristino)](Appendix.SQLServer.Options.BackupRestore.md#Appendix.SQLServer.Options.BackupRestore.Add). |
| Autorizzazione EXECUTE negata per l’oggetto ‘*rds\$1backup\$1database*’ del database ‘msdb’ con schema ‘dbo’. | Durante l’esecuzione della stored procedure, accertarti di utilizzare l’utente principale. Se questo errore si verifica anche dopo aver effettuato l’accesso come utente principale, potrebbe essere dovuto al disallineamento delle autorizzazioni dell’utente amministratore. Per reimpostare l’utente principale, utilizza la Console di gestione AWS. Consultare [Reimpostazione dell’appartenenza al ruolo db\$1owner per l’utente master per Amazon RDS per SQL Server](Appendix.SQLServer.CommonDBATasks.ResetPassword.md). |
| Autorizzazione EXECUTE negata per l’oggetto ‘*rds\$1restore\$1database*’, del database ‘msdb’ con schema ‘dbo’. | Durante l’esecuzione della stored procedure, accertarti di utilizzare l’utente principale. Se questo errore si verifica anche dopo aver effettuato l’accesso come utente principale, potrebbe essere dovuto al disallineamento delle autorizzazioni dell’utente amministratore. Per reimpostare l’utente principale, utilizza la Console di gestione AWS. Consultare [Reimpostazione dell’appartenenza al ruolo db\$1owner per l’utente master per Amazon RDS per SQL Server](Appendix.SQLServer.CommonDBATasks.ResetPassword.md). |
| Accesso negato | Il processo di backup o ripristino non può accedere al file di backup. Ciò è in genere dovuto a problemi di questo tipo: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/SQLServer.Procedural.Importing.Native.Troubleshooting.html) |
| BACKUP DATABASE WITH COMPRESSION (BACKUP di DATABASE CON COMPRESSIONE) non è supportato nell'edizione | La compressione dei file di backup è supportata solo per Microsoft SQL Server Enterprise Edition e Standard Edition. Per ulteriori informazioni, consulta [Compressione dei file di backup](SQLServer.Procedural.Importing.Native.Compression.md). |
| La chiave non esiste | Hai tentato di ripristinare un backup crittografato ma non hai fornito una chiave di crittografia valida. Controlla la chiave di crittografia e riprova. Per ulteriori informazioni, consulta [Ripristino di un database](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Restore). |
| Riemetti l'attività con il tipo corretto e la proprietà di sovrascrivere | Se tenti di effettuare il backup del tuo database e indichi il nome di un file che già esiste, ma imposti la proprietà di sovrascrittura su falso, l'operazione di salvataggio non viene completata. Pre risolvere l'errore, indica il nome di un file che non esiste oppure imposta la proprietà di sovrascrittura su vero. Per ulteriori informazioni, consulta [Backup di un database](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Backup). È anche possibile che, nonostante volessi ripristinare il tuo database, hai chiamato la stored procedure `rds_backup_database` per errore. In questo caso, chiama piuttosto la stored procedure `rds_restore_database`. Per ulteriori informazioni, consulta [Ripristino di un database](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Restore). Se avevi l'intenzione di ripristinare il tuo database e hai chiamato la stored procedure `rds_restore_database`, verifica di aver indicato il nome di un file di backup valido. Per ulteriori informazioni, consulta [Uso di backup e ripristino nativi](SQLServer.Procedural.Importing.Native.Using.md). |
| Specifica un bucket che si trova nella stessa regione dell'istanza di RDS | Non puoi eseguire il backup o il ripristino in o da un bucket Amazon S3 in una regione AWS diversa da quella dell'istanza database di Amazon RDS. Puoi utilizzare la replica Amazon S3 per copiare il file di backup nella regione AWS corretta. Per ulteriori informazioni, consulta la sezione [Replica tra regioni](https://docs.aws.amazon.com/AmazonS3/latest/userguide/crr.html) nella documentazione di Amazon S3. |
| Il bucket specificato non esiste. | Verifica di aver indicato l'ARN corretto per il bucket e il file, nel formato corretto. Per ulteriori informazioni, consulta [Uso di backup e ripristino nativi](SQLServer.Procedural.Importing.Native.Using.md). |
| L'utente non è autorizzato ad eseguire sulla risorsa | Hai richiesto un'operazione crittografata ma non hai fornito le autorizzazioni AWS KMS corrette. Verifica di disporre delle autorizzazioni corrette o aggiungile. Per ulteriori informazioni, consulta [Configurazione di backup e ripristino nativi](SQLServer.Procedural.Importing.Native.Enabling.md). |
| L'attività di ripristino non è in grado di eseguire il ripristino da più di 10 file di backup). Ridurre il numero di file corrispondenti e riprovare. | Ridurre il numero di file di cui stai provando a effettuare il ripristino. Se necessario, puoi rendere ogni singolo file più grande. |
| Il database '*nome\$1database*' esiste già. Non sono consentiti due database che differiscono solo per maiuscole e minuscole o accento. Scegli un nome di database diverso. | Non è possibile ripristinare un database se esiste già un database con lo stesso nome. I nomi dei database sono univoci. |
# Importazione ed esportazione di dati SQL Server mediante altri metodi
Di seguito, è possibile trovare informazioni relative all'utilizzo di snapshot per importare i dati Microsoft SQL Server in Amazon RDS. È anche possibile trovare informazioni relative all'utilizzo di snapshot per esportare i dati da un'istanza database RDS che esegue SQL Server.
Se lo scenario lo consente, è più semplice spostare i dati da e in Amazon RDS utilizzando la funzionalità di backup e di ripristino nativa. Per ulteriori informazioni, consulta [Importazione ed esportazione di database SQL Server mediante backup e ripristino nativi](SQLServer.Procedural.Importing.md).
**Nota**
Amazon RDS per Microsoft SQL Server non supporta l'importazione di dati nel database `msdb`.
## Importazione di dati in Amazon RDS per SQL Server utilizzando uno snapshot
**Per importare dati in un'istanza database SQL Server utilizzando uno snapshot**
1. Creare un'Istanza database. Per ulteriori informazioni, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md).
1. Negare alle applicazioni l'accesso all'istanza database di destinazione.
Se si impedisce l'accesso all'istanza database durante l'importazione di dati, il trasferimento di dati sarà più veloce. Inoltre, non ci si dovrà preoccupare di eventuali conflitti durante il caricamento dei dati se altre applicazioni non possono scrivere sull'istanza database nello stesso momento. Se si verificano dei problemi ed è necessario eseguire il rollback a uno snapshot di database precedente, le sole modifiche che si perderanno sono i dati importati. Sarà possibile importare nuovamente tali dati dopo la risoluzione del problema.
Per informazioni sul controllo accessi all'istanza database, consulta [Controllo dell'accesso con i gruppi di sicurezza](Overview.RDSSecurityGroups.md).
1. Creare uno snapshot del database di destinazione.
Se il database di destinazione è già popolato con dati, è consigliabile creare uno snapshot del database prima di importare i dati. Se si verificano dei problemi nell'importazione dei dati o si desidera eliminare le modifiche, è possibile ripristinare lo stato precedente del database utilizzando lo snapshot. Per informazioni sugli snapshot di database, consulta [Creazione di uno snapshot del database per un’istanza database Single-AZ per Amazon RDS](USER_CreateSnapshot.md).
**Nota**
Quando si crea uno snapshot di database, le operazioni I/O per il database vengono sospese per un momento (millisecondi) durante l'esecuzione del backup.
1. Disabilitare i backup automatici sul database di destinazione.
La disabilitazione dei backup automatici sull'istanza database di destinazione migliora le prestazioni durante l'importazione dei dati in quanto Amazon RDS non registra le transazioni se i backup automatici sono disabilitati. È tuttavia necessario considerare vari aspetti. I backup automatici sono necessari per eseguire un ripristino point-in-time. Pertanto, non è possibile ripristinare il database a uno specifico point-in-time durante l'importazione dei dati. Inoltre, qualsiasi backup automatico creato sull'istanza database viene eliminato, a meno che non si scelga di conservarlo.
La scelta di conservare i backup automatici può contribuire a proteggere dall'eliminazione accidentale dei dati. Amazon RDS insieme a ciascun backup automatico salva anche le proprietà dell'istanza database per facilitarne il recupero. L’utilizzo di questa opzione consente di ripristinare un’istanza database eliminata in un momento specifico del periodo di conservazione dei backup anche dopo averla eliminata. I backup automatici vengono automaticamente eliminati alla fine della finestra di backup specificata, così come accade per un'istanza database attiva.
È possibile anche utilizzare snapshot precedenti per ripristinare il database e tutti gli snapshot creati restano disponibili. Per informazioni sui backup automatici, consulta [Introduzione ai backup](USER_WorkingWithAutomatedBackups.md).
1. Disabilitare i vincoli di chiave esterna, se applicabile.
Se è necessario disabilitare tali vincoli, è possibile farlo con lo script seguente.
```
--Disable foreign keys on all tables
DECLARE @table_name SYSNAME;
DECLARE @cmd NVARCHAR(MAX);
DECLARE table_cursor CURSOR FOR SELECT name FROM sys.tables;
OPEN table_cursor;
FETCH NEXT FROM table_cursor INTO @table_name;
WHILE @@FETCH_STATUS = 0 BEGIN
SELECT @cmd = 'ALTER TABLE '+QUOTENAME(@table_name)+' NOCHECK CONSTRAINT ALL';
EXEC (@cmd);
FETCH NEXT FROM table_cursor INTO @table_name;
END
CLOSE table_cursor;
DEALLOCATE table_cursor;
GO
```
1. Eliminare gli indici, se applicabile.
1. Disabilitare i trigger, se applicabile.
Se è necessario disabilitare i trigger, è possibile farlo con lo script seguente.
```
--Disable triggers on all tables
DECLARE @enable BIT = 0;
DECLARE @trigger SYSNAME;
DECLARE @table SYSNAME;
DECLARE @cmd NVARCHAR(MAX);
DECLARE trigger_cursor CURSOR FOR SELECT trigger_object.name trigger_name,
table_object.name table_name
FROM sysobjects trigger_object
JOIN sysobjects table_object ON trigger_object.parent_obj = table_object.id
WHERE trigger_object.type = 'TR';
OPEN trigger_cursor;
FETCH NEXT FROM trigger_cursor INTO @trigger, @table;
WHILE @@FETCH_STATUS = 0 BEGIN
IF @enable = 1
SET @cmd = 'ENABLE ';
ELSE
SET @cmd = 'DISABLE ';
SET @cmd = @cmd + ' TRIGGER dbo.'+QUOTENAME(@trigger)+' ON dbo.'+QUOTENAME(@table)+' ';
EXEC (@cmd);
FETCH NEXT FROM trigger_cursor INTO @trigger, @table;
END
CLOSE trigger_cursor;
DEALLOCATE trigger_cursor;
GO
```
1. Eseguire una query sull'istanza SQL Server di origine per tutti gli account di accesso che si intende importare nell'istanza database di destinazione.
SQL Server archivia account di accesso e password nel database `master`. Poiché Amazon RDS non concede l'accesso al database `master`, non è possibile importare direttamente account di accesso e password nell'istanza database di destinazione. È necessario invece eseguire una query sul database `master` sull'istanza SQL Server di origine per generare un file DDL (Data Definition Language). Il file deve includere tutti gli accessi e le password che si desidera aggiungere all'istanza database di destinazione. Il file deve includere anche le appartenenze ai ruoli e le autorizzazioni che si desidera trasferire.
Per informazioni sull’esecuzione di query sul database `master`, consulta [Trasferire account di accesso e password tra istanze di SQL Server](https://learn.microsoft.com/en-us/troubleshoot/sql/database-engine/security/transfer-logins-passwords-between-instances) nella Knowledge Base di Microsoft.
L'output dello script è un altro script che è possibile eseguire sull'istanza database di destinazione. Il codice dello script nell'articolo della Knowledge Base è il seguente:
```
p.type IN
```
Sostituire ogni occorrenza di `p.type` con il codice seguente:
```
p.type = 'S'
```
1. Importare i dati utilizzando il metodo in [Importazione dei dati](#ImportData.SQLServer.Import).
1. Concedere alle applicazioni l'accesso all'istanza database di destinazione.
Al termine dell'importazione dei dati, è possibile concedere l'accesso all'istanza database alle applicazioni bloccate durante l'importazione. Per informazioni sul controllo accessi all'istanza database, consulta [Controllo dell'accesso con i gruppi di sicurezza](Overview.RDSSecurityGroups.md).
1. Abilitare i backup automatici sull'istanza database di destinazione.
Per informazioni sui backup automatici, consulta [Introduzione ai backup](USER_WorkingWithAutomatedBackups.md).
1. Abilitare i vincoli di chiave esterna.
Se i vincoli di chiave esterna sono stati disabilitati in precedenza, è possibile abilitarli con lo script seguente.
```
--Enable foreign keys on all tables
DECLARE @table_name SYSNAME;
DECLARE @cmd NVARCHAR(MAX);
DECLARE table_cursor CURSOR FOR SELECT name FROM sys.tables;
OPEN table_cursor;
FETCH NEXT FROM table_cursor INTO @table_name;
WHILE @@FETCH_STATUS = 0 BEGIN
SELECT @cmd = 'ALTER TABLE '+QUOTENAME(@table_name)+' CHECK CONSTRAINT ALL';
EXEC (@cmd);
FETCH NEXT FROM table_cursor INTO @table_name;
END
CLOSE table_cursor;
DEALLOCATE table_cursor;
```
1. Abilitare gli indici, se applicabile.
1. Abilitare i trigger, se applicabile.
Se i trigger sono stati disabilitati in precedenza, è possibile abilitarli con lo script seguente.
```
--Enable triggers on all tables
DECLARE @enable BIT = 1;
DECLARE @trigger SYSNAME;
DECLARE @table SYSNAME;
DECLARE @cmd NVARCHAR(MAX);
DECLARE trigger_cursor CURSOR FOR SELECT trigger_object.name trigger_name,
table_object.name table_name
FROM sysobjects trigger_object
JOIN sysobjects table_object ON trigger_object.parent_obj = table_object.id
WHERE trigger_object.type = 'TR';
OPEN trigger_cursor;
FETCH NEXT FROM trigger_cursor INTO @trigger, @table;
WHILE @@FETCH_STATUS = 0 BEGIN
IF @enable = 1
SET @cmd = 'ENABLE ';
ELSE
SET @cmd = 'DISABLE ';
SET @cmd = @cmd + ' TRIGGER dbo.'+QUOTENAME(@trigger)+' ON dbo.'+QUOTENAME(@table)+' ';
EXEC (@cmd);
FETCH NEXT FROM trigger_cursor INTO @trigger, @table;
END
CLOSE trigger_cursor;
DEALLOCATE trigger_cursor;
```
### Importazione dei dati
Microsoft SQL Server Management Studio è un client SQL Server grafico incluso in tutte le edizioni di Microsoft SQL Server ad eccezione di Express Edition. SQL Server Management Studio Express è fornito da Microsoft come download gratuito. Per trovare questo download, consulta [il sito Web di Microsoft](https://www.microsoft.com/en-us/download).
**Nota**
SQL Server Management Studio è disponibile solo come applicazione basata su Windows.
SQL Server Management Studio include i seguenti strumenti, utili nell'importazione di dati in un'istanza database SQL Server:
+ Procedura guidata Genera e pubblica script
+ Importazione/Esportazione guidata
+ Copia bulk
#### Procedura guidata Genera e pubblica script
La procedura guidata Genera e pubblica script crea uno script che contiene lo schema di un database, i dati o entrambi. È possibile generare uno script per un database nella distribuzione SQL Server locale. È quindi possibile eseguire lo script per trasferire le informazioni in esso contenute in un'istanza database Amazon RDS.
**Nota**
Per database di dimensioni di 1 GiB o superiori, è più efficace eseguire lo script del solo schema di database. Si utilizza quindi l'Importazione/Esportazione guidata della caratteristica copia bulk di SQL Server per il trasferimento dei dati.
Per informazioni dettagliate sulla procedura guidata Genera e pubblica script, consulta la [documentazione di Microsoft SQL Server](http://msdn.microsoft.com/en-us/library/ms178078%28v=sql.105%29.aspx).
Nella procedura guidata, presta particolare attenzione alle opzioni avanzate nella pagina **Opzioni di creazione script** per assicurarti che tutti gli elementi da includere nello script siano selezionati. Ad esempio, per impostazione predefinita, i trigger di database non sono inclusi nello script.
Quando lo script viene generato e salvato, puoi utilizzare SQL Server Management Studio per la connessione all'istanza database e quindi eseguire lo script.
#### Importazione/Esportazione guidata
Importazione/Esportazione guidata crea un pacchetto Integration Services speciale, che puoi utilizzare per copiare i dati dal database SQL Server locale nell'istanza database di destinazione. La procedura guidata può filtrare le tabelle e persino le tuple in una tabella da copiare nell'istanza database di destinazione.
**Nota**
Importazione/Esportazione guidata è una soluzione appropriata per i set di dati di grandi dimensioni, ma forse non la più rapida per esportare dati a distanza dalla distribuzione locale. Una soluzione più rapida è la funzionalità di copia bulk di SQL Server.
Per ulteriori informazioni su Importazione/Esportazione guidata, consulta la [documentazione di Microsoft SQL Server](http://msdn.microsoft.com/en-us/library/ms140052%28v=sql.105%29.aspx).
Nella pagina **Choose a Destination (Seleziona destinazione)** della procedura guidata, procedere come segue:
+ In **Nome server**, digitare il nome dell'endpoint per l'istanza database.
+ Per la modalità di autenticazione del server, scegliere **Usa autenticazione di SQL Server**.
+ Per **Nome utente** e **Password**, digitare le credenziali per l'utente master creato per l'istanza database.
#### Copia bulk
La funzionalità di copia bulk di SQL Server è una soluzione efficace per copiare dati da un database di origine all'istanza database. La copia bulk scrive i dati specificati in un file di dati, ad esempio un file ASCII. In seguito, puoi eseguire la copia bulk per scrivere il contenuto del file sull'istanza database di destinazione.
Questa sezione utilizza l'utilità **bcp** inclusa in tutte le edizioni di SQL Server. Per informazioni dettagliate sulle operazioni di importazione ed esportazione bulk, consulta la [documentazione di Microsoft SQL Server](http://msdn.microsoft.com/en-us/library/ms187042%28v=sql.105%29.aspx).
**Nota**
Prima di utilizzare la funzionalità di copia bulk, devi dapprima importare lo schema del database nell'istanza database di destinazione. La procedura guidata Genera e pubblica script, descritta precedentemente in questo argomento, è uno strumento eccellente per questo scopo.
Il comando seguente esegue la connessione all'istanza SQL Server locale. Genera un file delimitato da tabulazioni di una tabella specificata nella directory principale C:\$1 della distribuzione SQL Server esistente. La tabella è specificata dal relativo nome completo e il file di testo ha lo stesso nome della tabella che viene copiata.
```
bcp dbname.schema_name.table_name out C:\table_name.txt -n -S localhost -U username -P password -b 10000
```
Il codice precedente include le seguenti opzioni:
+ `-n` specifica che la copia bulk utilizza i tipi di dati nativi dei dati da copiare.
+ `-S` specifica l'istanza SQL Server a si collega l'utilità *bcp*.
+ `-U` specifica il nome utente dell'account utilizzato per il login all'istanza SQL Server.
+ `-P` specifica la password per l'utente specificato da `-U`.
+ `-b` specifica il numero di righe per batch di dati importati.
**Nota**
Potrebbero esserci altri parametri importanti per la tua operazione di importazione. Ad esempio, potresti avere bisogno del parametro `-E` relativo ai valori di identità. Per ulteriori informazioni, consulta la descrizione completa della sintassi della riga di comando per l'utilità **bcp** nella [documentazione di Microsoft SQL Server](http://msdn.microsoft.com/en-us/library/ms162802%28v=sql.105%29.aspx).
Ad esempio, supponiamo che un database denominato `store` che utilizza lo schema predefinito `dbo` contenga una tabella denominata `customers`. L'account utente `admin`, con la password `insecure`, copia 10.000 righe della tabella `customers` in un file denominato `customers.txt`.
```
bcp store.dbo.customers out C:\customers.txt -n -S localhost -U admin -P insecure -b 10000
```
Dopo aver generato il file di dati, è possibile caricare i dati nell'istanza database utilizzando un comando simile. Prima di procedere, crea il database e lo schema nell'istanza database di destinazione. Utilizza quindi l'argomento `in` per specificare un file di input anziché `out` per specificare un file di output. Invece di utilizzare localhost per specificare l'istanza SQL Server locale, specifica l'endpoint dell'istanza database. Se utilizzi una porta differente dalla porta 1433, specifica anche quella. Il nome utente e la password sono la password e l'utente master dell'istanza database. La sintassi è esposta di seguito.
```
bcp dbname.schema_name.table_name
in C:\table_name.txt -n -S endpoint,port -U master_user_name -P master_user_password -b 10000
```
Per continuare l'esempio precedente, supponiamo che il nome utente master sia `admin` e che la password sia `insecure`. L'endpoint per l'istanza database è `rds.ckz2kqd4qsn1.us-east-1.rds.amazonaws.com` e si utilizza la porta 4080. Il comando è il seguente.
```
bcp store.dbo.customers in C:\customers.txt -n -S rds.ckz2kqd4qsn1.us-east-1.rds.amazonaws.com,4080 -U admin -P insecure -b 10000
```
**Nota**
Specifica una password diversa dal prompt mostrato qui come best practice per la sicurezza.
## Esportazione di dati da Amazon RDS per SQL Server
Puoi scegliere una delle seguenti opzioni per esportare dati da un'istanza database RDS for SQL Server:
+ **Backup di database nativo con file di backup completo (.bak)** – L'utilizzo di file .bak per il backup di database è estremamente ottimizzato ed è in genere il modo più rapido per esportare dati. Per ulteriori informazioni, consulta [Importazione ed esportazione di database SQL Server mediante backup e ripristino nativi](SQLServer.Procedural.Importing.md).
+ **Procedura guidata di importazione ed esportazione di SQL Server** – Per ulteriori informazioni, consulta [Importazione/Esportazione guidata di SQL Server](#SQLServer.Procedural.Exporting.SSIEW).
+ **Procedura guidata di generazione e pubblicazione di script di SQL Server e utilità bcp** – Per ulteriori informazioni, consulta [Procedura guidata Genera e pubblica script e utilità bcp di SQL Server](#SQLServer.Procedural.Exporting.SSGPSW).
### Importazione/Esportazione guidata di SQL Server
Puoi utilizzare Importazione/Esportazione guidata di SQL Server per copiare una o più tabelle, viste o query dall'istanza database RDS for SQL Server in un altro datastore. Questa scelta è la migliore se il datastore di destinazione non è SQL Server. Per ulteriori informazioni, consulta [Importazione ed esportazione guidata di SQL Server](http://msdn.microsoft.com/en-us/library/ms141209%28v=sql.110%29.aspx) nella documentazione di SQL Server.
L'Importazione/Esportazione guidata di SQL Server è disponibile come parte di Microsoft SQL Server Management Studio. Il client SQL Server grafico è incluso in tutte le edizioni di Microsoft SQL Server ad eccezione di Express Edition. SQL Server Management Studio è disponibile solo come applicazione basata su Windows. SQL Server Management Studio Express è fornito da Microsoft come download gratuito. Per trovare questo download, consulta [il sito Web di Microsoft](http://www.microsoft.com/en-us/search/Results.aspx?q=sql%20server%20management%20studio).
**Per esportare dati con Importazione/Esportazione guidata di SQL Server**
1. In SQL Server Management Studio, connettersi all'istanza database RDS for SQL Server. Per informazioni dettagliate su come eseguire questa operazione, consulta [Connessione all’istanza database Microsoft SQL Server](USER_ConnectToMicrosoftSQLServerInstance.md).
1. In **Esplora oggetti**, espandere **Database**, aprire il menu contestuale (fare clic con il pulsante destro del mouse) del database di origine, scegliere **Attività**, quindi scegliere **Esporta dati**. Viene visualizzata la procedura guidata.
1. Nella pagina **Seleziona origine dati**, procedere come segue:
1. Per **Origine dati** scegliere **SQL Server Native Client 11.0**.
1. Verifica che la casella **Nome server** riporti l'endpoint dell'istanza database RDS for SQL Server.
1. Selezionare **Usa autenticazione di SQL Server**. In **Nome utente** e **Password** specifica il nome utente master e la password dell'istanza database.
1. Verificare che nella casella **Database** sia visualizzato il database da cui esportare i dati.
1. Scegli **Next (Successivo)**.
1. Nella pagina **Seleziona destinazione**, procedere come segue:
1. Per **Destinazione** scegliere **SQL Server Native Client 11.0**.
**Nota**
Sono disponibili altre origini dati di destinazione. Queste includono i provider di dati .NET Framework, i provider OLE DB, SQL Server Native Client e ADO.NET, Microsoft Office Excel, Microsoft Office Access e l'origine del file flat. Se si sceglie come destinazione una di queste origini dati, ignorare la parte restante della fase 4. Per i dettagli delle informazioni di connessione da fornire successivamente, consultare l'argomento relativo alla [scelta di una destinazione](http://msdn.microsoft.com/en-us/library/ms178430%28v=sql.110%29.aspx) nella documentazione di SQL Server.
1. In **Nome server**, digitare il nome di server dell'istanza database SQL Server di destinazione.
1. Scegliere il tipo di autenticazione appropriato. Digitare un nome utente e una password, se necessario.
1. Per **Database**, scegliere il nome del database di destinazione, oppure scegliere **Nuovo** per creare un nuovo database per i dati esportati.
Se si sceglie **Nuovo**, consultare [Crea database](http://msdn.microsoft.com/en-us/library/ms183323%28v=sql.110%29.aspx) nella documentazione di SQL Server per dettagli sulle informazioni di database da fornire.
1. Scegli **Next (Successivo)**.
1. Nella pagina **Copia tabella o query**, scegliere **Copia i dati da una o più tabelle o viste** oppure **Scrivi una query per specificare i dati da trasferire**. Scegli **Next (Successivo)**.
1. Se si sceglie **Scrivi una query per specificare i dati da trasferire**, viene visualizzata la pagina **Impostazione query di origine**. Digitare o incollare una query SQL, quindi scegliere **Analizza** per verificarla. Dopo la convalida della query, scegliere **Avanti**.
1. Nella pagina **Seleziona tabelle e viste di origine**, procedere come segue:
1. Selezionare le tabelle e le viste da esportare oppure verificare che la query fornita sia selezionata.
1. Scegliere **Modifica mapping** e specificare le informazioni di mapping delle colonne e di database. Per ulteriori informazioni, consulta [Mapping colonne](http://msdn.microsoft.com/en-us/library/ms189660%28v=sql.110%29.aspx) nella documentazione di SQL Server.
1. (Facoltativo) Per visualizzare un'anteprima dei dati da esportare, selezionare la tabella, la vista o la query, quindi scegliere **Anteprima**.
1. Scegli **Next (Successivo)**.
1. Nella pagina **Esegui pacchetto**, verificare che **Esegui immediatamente** sia selezionato. Scegli **Next (Successivo)**.
1. Nella pagina **Completamento della procedura guidata**, verificare che le informazioni di esportazione dei dati siano quelle previste. Scegli **Fine**.
1. Nella pagina **Esecuzione completata**, scegliere **Chiudi**.
### Procedura guidata Genera e pubblica script e utilità bcp di SQL Server
Puoi utilizzare la procedura guidata Genera e pubblica script di SQL Server per creare script per un intero database o per soltanto alcuni oggetti selezionati. Puoi eseguire questi script su un'istanza database SQL Server di destinazione per ricreare gli oggetti con script. Successivamente, puoi utilizzare l'utilità bcp per esportare in bulk i dati degli oggetti selezionati nell'istanza database di destinazione. Questa scelta è preferibile se intendi spostare un intero database (con oggetti che non siano tabelle) o grandi quantità di dati tra due istanze database SQL Server. Per una descrizione completa della sintassi della riga di comando di bcp, consulta [Utilità bcp](http://msdn.microsoft.com/en-us/library/ms162802%28v=sql.110%29.aspx) nella documentazione di Microsoft SQL Server.
La procedura guidata Genera e pubblica script di SQL Server è disponibile come parte di Microsoft SQL Server Management Studio. Il client SQL Server grafico è incluso in tutte le edizioni di Microsoft SQL Server ad eccezione di Express Edition. SQL Server Management Studio è disponibile solo come applicazione basata su Windows. SQL Server Management Studio Express è fornito da Microsoft come [download gratuito](http://www.microsoft.com/en-us/search/Results.aspx?q=sql%20server%20management%20studio).
**Per esportare dati mediante la procedura guidata Genera e pubblica script e l'utilità bcp di SQL Server**
1. In SQL Server Management Studio, connettersi all'istanza database RDS for SQL Server. Per informazioni dettagliate su come eseguire questa operazione, consulta [Connessione all’istanza database Microsoft SQL Server](USER_ConnectToMicrosoftSQLServerInstance.md).
1. In **Esplora oggetti**, espandere il nodo **Database** e selezionare il database di cui si intende creare lo script.
1. Seguire le istruzioni in [Procedura guidata Genera e pubblica script](http://msdn.microsoft.com/en-us/library/bb895179%28v=sql.110%29.aspx) nella documentazione di SQL Server per creare un file di script.
1. In SQL Server Management Studio, connettersi all'istanza database SQL Server di destinazione.
1. Con l'istanza database SQL Server di destinazione selezionata in **Object Explorer** (Esplora oggetti), seleziona **Open** (Apri) dal menu **File**, quindi seleziona **File** e apri il file di script.
1. Se si è eseguito lo script dell'intero database, esaminare l'istruzione CREATE DATABASE nello script. Assicurarsi che il database venga creato nella posizione e con i parametri desiderati. Per ulteriori informazioni, consulta [CREATE DATABASE](http://msdn.microsoft.com/en-us/library/ms176061%28v=sql.110%29.aspx) nella documentazione di SQL Server.
1. Se si creano utenti di database nello script, verificare se esistono account di accesso server sull'istanza database di destinazione per quegli utenti. In caso contrario, creare degli account di accesso per tali utenti, altrimenti i comandi con script per la creazione di utenti di database non riescono. Per ulteriori informazioni, consulta [Creazione di un account di accesso](http://msdn.microsoft.com/en-us/library/aa337562%28v=sql.110%29.aspx) nella documentazione di SQL Server.
1. Scegliere **\$1Execute** nel menu Editor SQL per eseguire il file di script e creare oggetti di database. Al termine dello script, verificare che tutti gli oggetti di database esistano come previsto.
1. Utilizza l'utilità bcp per esportare i dati dall'istanza database RDS for SQL Server in file. Aprire un prompt dei comandi e digitare il comando seguente.
```
bcp database_name.schema_name.table_name out data_file -n -S aws_rds_sql_endpoint -U username -P password
```
Il codice precedente include le seguenti opzioni:
+ *table\$1name* è il nome di una delle tabelle che è stata ricreata nel database di destinazione e che ora si intende popolare con dati.
+ *data\$1file* è il percorso completo e il nome del file di dati da creare.
+ `-n` specifica che la copia bulk utilizza i tipi di dati nativi dei dati da copiare.
+ `-S` specifica l'istanza database SQL Server da cui eseguire l'esportazione.
+ `-U` specifica il nome utente da utilizzare durante la connessione all'istanza database SQL Server.
+ `-P` specifica la password per l'utente specificato da `-U`.
Di seguito viene illustrato un esempio del comando .
```
bcp world.dbo.city out C:\Users\JohnDoe\city.dat -n -S sql-jdoe.1234abcd.us-west-2.rds.amazonaws.com,1433 -U JohnDoe -P ClearTextPassword
```
Ripetere questo passaggio fino ad avere file di dati per tutte le tabelle da esportare.
1. Preparare l'istanza database di destinazione per l'importazione bulk dei dati seguendo le istruzioni contenute in [Prepararsi all'importazione bulk dei dati](http://msdn.microsoft.com/en-us/library/ms189989%28v=sql.110%29.aspx) nella documentazione di SQL Server.
1. Decidere il metodo di importazione bulk da utilizzare dopo aver preso in considerazione le prestazioni e altri problemi descritti in [Informazioni sulle operazioni di importazione ed esportazione bulk](http://msdn.microsoft.com/en-us/library/ms187042%28v=sql.105%29.aspx) nella documentazione di SQL Server.
1. Importare in blocco i dati dai file di dati creati utilizzando l'utilità bcp. Per fare ciò, seguire le istruzioni contenute in [Importare ed esportare dati bulk con bcp](http://msdn.microsoft.com/en-us/library/aa337544%28v=sql.110%29.aspx) oppure nella sezione relativa all'[importazione di dati bulk utilizzando BULK INSERT o OPENROWSET(BULK...)](http://msdn.microsoft.com/en-us/library/ms175915%28v=sql.110%29.aspx) nella documentazione di SQL Server, a seconda del metodo di importazione scelto nella fase 11.
# Utilizzo dell’utilità BCP di Linux per importare ed esportare dati
L’utilità BCP (Bulk Copy Program) offre un modo efficiente per trasferire grandi quantità di dati tra l’istanza database RDS per SQL Server e i file di dati. Puoi utilizzare BCP da ambienti Linux per eseguire operazioni sui dati in blocco e usufruire così di utili funzionalità per la migrazione dei dati, i processi ETL e i trasferimenti periodici di dati.
BCP supporta sia l’importazione di dati da file in tabelle SQL Server sia l’esportazione di dati da tabelle SQL Server in file. Questa utilità è particolarmente efficace per il trasferimento di dati strutturati in vari formati, inclusi i file di testo delimitati.
## Prerequisiti
Prima di utilizzare BCP con l’istanza database RDS per SQL Server da un ambiente Linux, assicurati di disporre di quanto segue:
+ Un ambiente Linux con connettività di rete all’istanza database RDS per SQL Server
+ Strumenti a riga di comando di Microsoft SQL Server installati nel sistema Linux, tra cui:
+ sqlcmd: strumento per query a riga di comando di SQL Server
+ bcp: utilità Bulk Copy Program
+ Credenziali valide per l’istanza database RDS per SQL Server
+ Accesso alla rete configurato tramite gruppi di sicurezza per consentire connessioni sulla porta di SQL Server (in genere, la 1433)
+ Autorizzazioni di database appropriate per le operazioni da eseguire
## Installazione degli strumenti a riga di comando di SQL Server su Linux
Per utilizzare BCP da Linux, è necessario installare gli strumenti a riga di comando di Microsoft SQL Server. Per istruzioni di installazione dettagliate per la specifica distribuzione Linux, consulta la seguente documentazione Microsoft:
+ [Install sqlcmd and bcp the SQL Server command-line tools on Linux](https://docs.microsoft.com/en-us/sql/linux/sql-server-linux-setup-tools)
+ [bcp utility](https://docs.microsoft.com/en-us/sql/tools/bcp-utility): informazioni di riferimento complete per l’utilità BCP
Dopo l’installazione, assicurati che gli strumenti siano disponibili nella variabile PATH eseguendo quanto segue:
```
bcp -v
sqlcmd -?
```
## Esportazione di dati da Amazon RDS per SQL Server
Puoi utilizzare BCP per esportare dati dall’istanza database RDS per SQL Server in file sul sistema Linux. Questa funzionalità è utile per creare backup, eseguire l’analisi dei dati o preparare i dati per la migrazione.
### Sintassi di base per l’esportazione
Di seguito è riportata la sintassi di base per l’esportazione di dati tramite BCP:
```
bcp database.schema.table out output_file -S server_name -U username -P password [options]
```
Dove:
+ `database.schema.table`: il nome completo della tabella
+ `output_file`: il percorso e il nome del file di output
+ `server_name`: l’endpoint di RDS per SQL Server
+ `username`: il nome utente del database
+ `password`: la password del database
### Esempio di esportazione
L’esempio seguente esporta i dati da una tabella denominata `customers` nel database `sales`:
```
bcp sales.dbo.customers out /home/user/customers.txt \
-S mydb.cluster-abc123.us-east-1.rds.amazonaws.com \
-U admin \
-P mypassword \
-c \
-t "|" \
-r "\n"
```
Questo comando esegue le seguenti operazioni:
+ Esporta i dati dalla tabella `customers`.
+ Salva l’output in `/home/user/customers.txt`.
+ Utilizza il formato carattere (`-c`).
+ Utilizza la barra verticale (\$1) come delimitatore di campo (`-t "|"`).
+ Utilizza il carattere di nuova riga come delimitatore di riga (`-r "\n"`).
## Importazione di dati in RDS per SQL Server
Puoi utilizzare BCP per importare dati da file sul sistema Linux nell’istanza database RDS per SQL Server. Questa funzionalità è utile per la migrazione dei dati, il caricamento dei dati di test o gli aggiornamenti periodici dei dati.
### Sintassi di base per l’importazione
Di seguito è riportata la sintassi di base per l’importazione di dati tramite BCP:
```
bcp database.schema.table in input_file -S server_name -U username -P password [options]
```
Dove:
+ `database.schema.table`: il nome completo della tabella di destinazione
+ `input_file`: il percorso e il nome del file di input
+ `server_name`: l’endpoint di RDS per SQL Server
+ `username`: il nome utente del database
+ `password`: la password del database
### Esempio di importazione
L’esempio seguente importa i dati da un file in una tabella denominata `customers`:
```
bcp sales.dbo.customers in /home/user/customers.txt \
-S mydb.cluster-abc123.us-east-1.rds.amazonaws.com \
-U admin \
-P mypassword \
-c \
-t "|" \
-r "\n" \
-b 1000
```
Questo comando esegue le seguenti operazioni:
+ Importa i dati nella tabella `customers`.
+ Legge i dati da `/home/user/customers.txt`.
+ Utilizza il formato carattere (`-c`).
+ Utilizza la barra verticale (\$1) come delimitatore di campo (`-t "|"`).
+ Utilizza il carattere di nuova riga come delimitatore di riga (`-r "\n"`).
+ Elabora i dati in batch di 1.000 righe (`-b 1000`).
## Opzioni di BCP comuni
BCP offre numerose opzioni per controllare la formattazione e il comportamento di trasferimento dei dati. Nella seguente tabella sono descritte le opzioni più utilizzate:
| Opzione | Descrizione |
| --- | --- |
| -c | Utilizza il tipo di dati carattere per tutte le colonne |
| -n | Utilizza i tipi di dati nativi del database |
| -t | Specifica il delimitatore di campo (il valore predefinito è tab) |
| -r | Specifica il delimitatore di riga (il valore predefinito è newline) |
| -b | Specifica la dimensione del batch per le operazioni in blocco |
| -F | Specifica la prima riga da esportare o importare |
| -L | Specifica l’ultima riga da esportare o importare |
| -e | Specifica un file di errore per acquisire le righe rifiutate |
| -f | Specifica un file di formato per la formattazione dei dati |
| -q | Utilizza identificatori tra virgolette per i nomi degli oggetti |
## Best practice e considerazioni
Quando utilizzi BCP con RDS per SQL Server da Linux, tieni presenti le seguenti best practice:
+ **Utilizza l’elaborazione in batch**: per set di dati di grandi dimensioni, utilizza l’opzione `-b` per elaborare i dati in batch. In questo modo, puoi ottenere prestazioni più efficienti e un migliore ripristino da errori.
+ **Gestisci gli errori in modo corretto**: utilizza l’opzione `-e` per acquisire le informazioni sugli errori e le righe rifiutate in un file separato per l’analisi.
+ **Scegli i formati di dati appropriati**: utilizza il formato carattere (`-c`) per la compatibilità multipiattaforma o il formato nativo (`-n`) per prestazioni migliori quando sia l’origine che la destinazione sono SQL Server.
+ **Proteggi le credenziali**: evita di inserire le password direttamente nelle righe di comando. Prendi in considerazione l’opportunità di utilizzare variabili di ambiente o file di configurazione con le autorizzazioni appropriate.
+ **Esegui un test con set di dati di dimensioni ridotte**: prima di elaborare grandi quantità di dati, esegui un test dei comandi di BCP con set di dati di dimensioni più piccole per verificare la formattazione e la connettività.
+ **Monitora la connettività di rete**: assicurati di disporre di connessioni di rete stabili, soprattutto per trasferimenti di dati di grandi dimensioni. Prendi in considerazione la possibilità di utilizzare strumenti quali `screen` o `tmux` per le operazioni di lunga durata.
+ **Convalida l’integrità dei dati**: dopo il trasferimento dei dati, verifica il numero di righe e i dati campione per assicurarti che l’operazione sia stata completata correttamente.
## Risoluzione dei problemi comuni
Nella seguente tabella sono descritti i problemi comuni che potresti riscontrare durante l’utilizzo di BCP da Linux e le relative soluzioni:
| Problema | Soluzione |
| --- | --- |
| Timeout di connessione o errori di rete | Verifica l’endpoint di Amazon RDS, le impostazioni del gruppo di sicurezza e la connettività di rete. Assicurati che la porta di SQL Server (in genere, la 1433) sia accessibile dal sistema Linux. |
| Errori di autenticazione | Verifica il nome utente e la password. Assicurati che l’utente del database disponga delle autorizzazioni appropriate per le operazioni che stai eseguendo. |
| Errori di formato dei dati | Controlla i delimitatori di campo e di riga. Assicurati che il formato dei dati corrisponda a quello previsto da BCP. Utilizza file di formato per le strutture di dati complesse. |
| Errori di autorizzazione negata | Assicurati che l’utente del database disponga delle autorizzazioni INSERT per le importazioni o delle autorizzazioni SELECT per le esportazioni nelle tabelle di destinazione. |
| Problemi di gestione dei file di grandi dimensioni | Utilizza l’elaborazione in batch con l’opzione -b. Prendi in considerazione l’opportunità di suddividere i file di grandi dimensioni in blocchi più piccoli per migliorare le prestazioni e il ripristino da errori. |
| Problemi di codifica dei caratteri | Assicurati che i file di dati utilizzino una codifica dei caratteri compatibile. Utilizza l’opzione -c per il formato carattere o specifica le tabelle codici appropriate. |