Eseguire il backup e il ripristino di Reliable Services e Reliable ActorsBack up and restore Reliable Services and Reliable Actors

Azure Service Fabric è una piattaforma a disponibilità elevata che replica lo stato in più nodi per mantenere questa disponibilità elevata.Azure Service Fabric is a high-availability platform that replicates the state across multiple nodes to maintain this high availability. Anche in caso di errore di un nodo nel cluster, il servizio rimarrà quindi comunque disponibile.Thus, even if one node in the cluster fails, the services continue to be available. Anche se questa ridondanza predefinita fornita dalla piattaforma può essere sufficiente per alcune situazioni, in determinati casi è preferibile che il servizio esegua il backup dei dati in un archivio esterno.While this in-built redundancy provided by the platform may be sufficient for some, in certain cases it is desirable for the service to back up data (to an external store).

Nota

È fondamentale eseguire il backup e il ripristino dei dati (e verificare che funzionino come previsto) per poter eseguire il ripristino in caso di perdita di dati.It is critical to backup and restore your data (and test that it works as expected) so you can recover from data loss scenarios.

Ad esempio, è possibile che in un servizio sia consigliabile eseguire il backup dei dati per evitare gli scenari seguenti:For example, a service may want to back up data in order to protect from the following scenarios:

  • Perdita definitiva di un intero cluster di Service Fabric.In the event of the permanent loss of an entire Service Fabric cluster.
  • Perdita definitiva della maggior parte delle repliche di una partizione del servizio.Permanent loss of a majority of the replicas of a service partition
  • Errori amministrativi che provocano l'eliminazione o il danneggiamento accidentale dello stato.Administrative errors whereby the state accidentally gets deleted or corrupted. Ad esempio, questo problema può verificarsi se un amministratore con privilegi sufficienti elimina accidentalmente il servizio.For example, this may happen if an administrator with sufficient privilege erroneously deletes the service.
  • Bug nel servizio che provocano il danneggiamento dei dati.Bugs in the service that cause data corruption. Ad esempio, questo problema può verificarsi quando un aggiornamento del codice di servizio inizia a scrivere dati non corretti in una raccolta Reliable Collections.For example, this may happen when a service code upgrade starts writing faulty data to a Reliable Collection. In tal caso, potrebbe essere necessario ripristinare uno stato precedente sia per il codice che per i dati.In such a case, both the code and the data may have to be reverted to an earlier state.
  • Elaborazione dati offline.Offline data processing. Potrebbe essere utile eseguire offline l'elaborazione dei dati per la business intelligence separatamente dal servizio che genera i dati.It might be convenient to have offline processing of data for business intelligence that happens separately from the service that generates the data.

La funzionalità Backup/Ripristino consente ai servizi basati sull'API Reliable Services di creare e ripristinare i backup.The Backup/Restore feature allows services built on the Reliable Services API to create and restore backups. Le API di backup fornite dalla piattaforma consentono il backup dello stato di una partizione del servizio senza bloccare le operazioni di lettura o scrittura.The backup APIs provided by the platform allow backup(s) of a service partition's state, without blocking read or write operations. Le API di ripristino consentono il ripristino dello stato di una partizione del servizio da un backup specificato.The restore APIs allow a service partition's state to be restored from a chosen backup.

Tipi di backupTypes of Backup

Sono disponibili due opzioni di backup: completo e incrementale.There are two backup options: Full and Incremental. Un backup completo contiene tutti i dati necessari per ricreare lo stato della replica, ossia i checkpoint e tutti i record di log.A full backup is a backup that contains all the data required to recreate the state of the replica: checkpoints and all log records. Visto che contiene i checkpoint e il log, un backup completo può ripristinarsi autonomamente.Since it has the checkpoints and the log, a full backup can be restored by itself.

I problemi con i backup completi si verificano quando i checkpoint sono di grandi dimensioni.The problem with full backups arises when the checkpoints are large. Ad esempio, una replica con un stato di 16 GB avrà checkpoint che aggiungono circa 16 GB.For example, a replica that has 16 GB of state will have checkpoints that add up approximately to 16 GB. Se l'obiettivo del punto di ripristino è di 5 minuti, il backup della replica deve essere eseguito ogni 5 minuti.If we have a Recovery Point Objective of five minutes, the replica needs to be backed up every five minutes. A ogni backup, dovranno essere copiati 16 GB dei checkpoint oltre a 50 MB di log (configurabili usando CheckpointThresholdInMB).Each time it backs up it needs to copy 16 GB of checkpoints in addition to 50 MB (configurable using CheckpointThresholdInMB) worth of logs.

Esempio di backup completo.

Per risolvere questo problema è possibile usare i backup incrementali, in cui il backup contiene solo i record del log modificati dopo l'ultimo backup.The solution to this problem is incremental backups, where backup only contains the changed log records since the last backup.

Esempio di backup incrementale.

I backup incrementali includono solo le modifiche successive all'ultimo backup, senza checkpoint, quindi tendono a essere più veloci ma non possono essere ripristinati in modo indipendente.Since incremental backups are only changes since the last backup (does not include the checkpoints), they tend to be faster but they cannot be restored on their own. Per ripristinare un backup incrementale, è necessaria l'intera catena di backup.To restore an incremental backup, the entire backup chain is required. Una catena di backup inizia con un backup completo e prosegue con diversi backup incrementali contigui.A backup chain is a chain of backups starting with a full backup and followed by a number of contiguous incremental backups.

Eseguire il backup di Reliable ServicesBackup Reliable Services

L'autore del servizio ha il controllo completo sul momento di esecuzione dei backup e sulla posizione in cui vengono archiviati.The service author has full control of when to make backups and where backups will be stored.

Per avviare un backup, il servizio deve chiamare la funzione membro ereditata BackupAsync.To start a backup, the service needs to invoke the inherited member function BackupAsync.
I backup possono essere eseguiti solo da repliche primarie e richiedono la concessione dello stato di scrittura.Backups can be made only from primary replicas, and they require write status to be granted.

Come mostrato di seguito, BackupAsync accetta un oggetto BackupDescription, in cui è possibile specificare un backup completo o incrementale, nonché una funzione di callback, Func<< BackupInfo, CancellationToken, Task<bool>>>, che viene chiamata quando la cartella di backup è stata creata in locale e può essere spostata in un archivio esterno.As shown below, BackupAsync takes in a BackupDescription object, where one can specify a full or incremental backup, as well as a callback function, Func<< BackupInfo, CancellationToken, Task<bool>>> that is invoked when the backup folder has been created locally and is ready to be moved out to some external storage.


BackupDescription myBackupDescription = new BackupDescription(backupOption.Incremental,this.BackupCallbackAsync);

await this.BackupAsync(myBackupDescription);

La richiesta di esecuzione di un backup incrementale può non riuscire con FabricMissingFullBackupException.Request to take an incremental backup can fail with FabricMissingFullBackupException. Questa eccezione segnala il verificarsi di una delle condizioni seguenti:This exception indicates that one of the following things is happening:

  • la replica non ha mai eseguito un backup completo dopo essere diventata primaria,the replica has never taken a full backup since it has become primary,
  • che alcuni dei record di log dall'ultimo backup sono stati troncati osome of the log records since the last backup has been truncated or
  • la replica ha superato il limite MaxAccumulatedBackupLogSizeInMB.replica passed the MaxAccumulatedBackupLogSizeInMB limit.

Gli utenti possono aumentare le probabilità di riuscire a eseguire i backup incrementali configurando MinLogSizeInMB o TruncationThresholdFactor.Users can increase the likelihood of being able to do incremental backups by configuring MinLogSizeInMB or TruncationThresholdFactor. Si noti che l'aumento di questi valori comporta un aumento dell'utilizzo del disco per replica.Note that increasing these values increases the per replica disk usage. Per altre informazioni, vedere Configurazione di Reliable ServicesFor more information, see Reliable Services Configuration

BackupInfo fornisce le informazioni relative al backup, incluso il percorso della cartella in cui il runtime ha salvato il backup (BackupInfo.Directory).BackupInfo provides information regarding the backup, including the location of the folder where the runtime saved the backup (BackupInfo.Directory). La funzione di callback può spostare BackupInfo.Directory in un archivio esterno o in un'altra posizione.The callback function can move the BackupInfo.Directory to an external store or another location. Questa funzione restituisce anche un valore booleano che indica se è riuscita a spostare la cartella di backup nel percorso di destinazione.This function also returns a bool that indicates whether it was able to successfully move the backup folder to its target location.

Il codice seguente illustra in che modo è possibile usare il metodo BackupCallbackAsync per caricare il backup in Archiviazione di Azure:The following code demonstrates how the BackupCallbackAsync method can be used to upload the backup to Azure Storage:

private async Task<bool> BackupCallbackAsync(BackupInfo backupInfo, CancellationToken cancellationToken)
{
    var backupId = Guid.NewGuid();

    await externalBackupStore.UploadBackupFolderAsync(backupInfo.Directory, backupId, cancellationToken);

    return true;
}

Nell'esempio precedente ExternalBackupStore corrisponde alla classe di esempio usata per interfacciarsi con il servizio di archiviazione BLOB di Azure e UploadBackupFolderAsync è il metodo che comprime la cartella e la inserisce nell'archivio BLOB di Azure.In the preceding example, ExternalBackupStore is the sample class that is used to interface with Azure Blob storage, and UploadBackupFolderAsync is the method that compresses the folder and places it in the Azure Blob store.

Si noti che:Note that:

  • In un dato momento può essere in corso una sola operazione di backup per replica.There can be only one backup operation in-flight per replica at any given time. Se si hanno più chiamate BackupAsync simultanee, FabricBackupInProgressException limita a una le esecuzioni dei backup.More than one BackupAsync call at a time will throw FabricBackupInProgressException to limit inflight backups to one.
  • In caso di failover di una replica durante l'esecuzione di un backup, è possibile che il backup non venga completato.If a replica fails over while a backup is in progress, the backup may not have been completed. Al termine del failover, il servizio dovrà quindi riavviare il backup chiamando BackupAsync, se necessario.Thus, once the failover finishes, it is the service's responsibility to restart the backup by invoking BackupAsync as necessary.

Ripristinare Reliable ServicesRestore Reliable Services

In generale, i casi in cui potrebbe essere necessario eseguire un'operazione di ripristino rientrano in una di queste categorie:In general, the cases when you might need to perform a restore operation fall into one of these categories:

  • La partizione del servizio ha perso dati.The service partition lost data. Ad esempio, il disco per due su tre repliche per una partizione, inclusa la replica primaria, viene danneggiato o cancellato.For example, the disk for two out of three replicas for a partition (including the primary replica) gets corrupted or wiped. La nuova replica primaria potrebbe dover ripristinare i dati da un backup.The new primary may need to restore data from a backup.
  • L'intero servizio è andato perso.The entire service is lost. Ad esempio, un amministratore rimuove l'intero servizio ed è quindi necessario ripristinare il servizio e i dati.For example, an administrator removes the entire service and thus the service and the data need to be restored.
  • Il servizio ha replicato dati danneggiati dell'applicazione, ad esempio a causa di un bug dell'applicazione.The service replicated corrupt application data (for example, because of an application bug). Sarà quindi necessario aggiornare o ripristinare il servizio per rimuovere la causa del danneggiamento e ripristinare dati non danneggiati.In this case, the service has to be upgraded or reverted to remove the cause of the corruption, and non-corrupt data has to be restored.

Anche se sono possibili molti approcci, gli esempi seguenti sono basati sull'uso di RestoreAsync per il ripristino dagli scenari precedenti.While many approaches are possible, we offer some examples on using RestoreAsync to recover from the above scenarios.

Perdita di dati della partizione in Reliable ServicesPartition data loss in Reliable Services

In questo caso, il runtime rileva automaticamente la perdita dei dati e chiama l'API OnDataLossAsync.In this case, the runtime would automatically detect the data loss and invoke the OnDataLossAsync API.

L'autore del servizio deve eseguire le operazioni seguenti per il ripristino:The service author needs to perform the following to recover:

  • Eseguire l'override del metodo della classe base virtuale OnDataLossAsync.Override the virtual base class method OnDataLossAsync.
  • Trovare il backup più recente nella posizione esterna che include i backup del servizio.Find the latest backup in the external location that contains the service's backups.
  • Scaricare il backup più recente e decomprimerlo nella cartella di backup, se è compressoDownload the latest backup (and uncompress the backup into the backup folder if it was compressed).
  • Il metodo OnDataLossAsync restituisce RestoreContext.The OnDataLossAsync method provides a RestoreContext. Chiamare l'API RestoreAsync nel RestoreContext restituito.Call the RestoreAsync API on the provided RestoreContext.
  • Restituire true se il ripristino è stato completato.Return true if the restoration was a success.

Di seguito è riportato un esempio di implementazione del metodo OnDataLossAsync.Following is an example implementation of the OnDataLossAsync method:

protected override async Task<bool> OnDataLossAsync(RestoreContext restoreCtx, CancellationToken cancellationToken)
{
    var backupFolder = await this.externalBackupStore.DownloadLastBackupAsync(cancellationToken);

    var restoreDescription = new RestoreDescription(backupFolder);

    await restoreCtx.RestoreAsync(restoreDescription);

    return true;
}

Il metodo RestoreDescription passato alla chiamata RestoreContext.RestoreAsync contiene un membro chiamato BackupFolderPath.RestoreDescription passed in to the RestoreContext.RestoreAsync call contains a member called BackupFolderPath. Quando si ripristina un singolo backup completo, BackupFolderPath deve essere impostato sul percorso locale della cartella che contiene il backup completo.When restoring a single full backup, this BackupFolderPath should be set to the local path of the folder that contains your full backup. Quando si ripristina un backup completo e alcuni backup incrementali, BackupFolderPath deve essere impostato sul percorso locale della cartella che contiene sia il backup completo che tutti i backup incrementali.When restoring a full backup and a number of incremental backups, BackupFolderPath should be set to the local path of the folder that not only contains the full backup, but also all the incremental backups. La chiamata RestoreAsync può generare FabricMissingFullBackupException se il metodo BackupFolderPath restituito non contiene un backup completo.RestoreAsync call can throw FabricMissingFullBackupException if the BackupFolderPath provided does not contain a full backup. Può anche generare ArgumentException se BackupFolderPath contiene una catena interrotta di backup incrementali,It can also throw ArgumentException if BackupFolderPath has a broken chain of incremental backups. ad esempio, se contiene il backup completo e il primo e il terzo backup incrementale, ma non il secondo.For example, if it contains the full backup, the first incremental and the third incremental backup but no the second incremental backup.

Nota

Il valore RestorePolicy è Safe per impostazione predefinita.The RestorePolicy is set to Safe by default. L'API RestoreAsync non riuscirà con ArgumentException se rileva che la cartella di backup include uno stato precedente o uguale allo stato contenuto nella replica.This means that the RestoreAsync API will fail with ArgumentException if it detects that the backup folder contains a state that is older than or equal to the state contained in this replica. Per ignorare questo controllo di sicurezza è possibile usare RestorePolicy.Force.RestorePolicy.Force can be used to skip this safety check. Viene specificato come parte di RestoreDescription.This is specified as part of RestoreDescription.

Servizio eliminato o persoDeleted or lost service

Se un servizio viene rimosso, per ripristinare i dati sarà prima di tutto necessario ricrearlo.If a service is removed, you must first re-create the service before the data can be restored. È importante creare il servizio con la stessa configurazione, ad esempio con lo stesso schema di partizionamento, in modo che sia possibile ripristinare i dati senza problemi.It is important to create the service with the same configuration, for example, partitioning scheme, so that the data can be restored seamlessly. Quando il servizio è attivo, è necessario chiamare l'API per il ripristino dei dati (OnDataLossAsync, come indicato sopra) su ogni partizione del servizio.Once the service is up, the API to restore data (OnDataLossAsync above) has to be invoked on every partition of this service. A tale scopo, usare FabricClient.TestManagementClient.StartPartitionDataLossAsync in ogni partizione.One way of achieving this is by using FabricClient.TestManagementClient.StartPartitionDataLossAsync on every partition.

A partire da questo punto, l'implementazione è uguale a quella dello scenario precedente.From this point, implementation is the same as the above scenario. Ogni partizione deve ripristinare il backup rilevante più recente dall'archivio esterno.Each partition needs to restore the latest relevant backup from the external store. Occorre prestare attenzione al fatto che ora l'ID della partizione potrebbe essere diverso, perché il runtime crea dinamicamente gli ID delle partizioni.One caveat is that the partition ID may have now changed, since the runtime creates partition IDs dynamically. Il servizio deve quindi archiviare le informazioni sulla partizione e il nome del servizio appropriati per identificare il più recente backup corretto da ripristinare per ogni partizione.Thus, the service needs to store the appropriate partition information and service name to identify the correct latest backup to restore from for each partition.

Nota

Non è consigliabile usare FabricClient.ServiceManager.InvokeDataLossAsync su ogni partizione per ripristinare l'intero servizio perché può danneggiare lo stato del cluster.It is not recommended to use FabricClient.ServiceManager.InvokeDataLossAsync on each partition to restore the entire service, since that may corrupt your cluster state.

Replica di dati dell'applicazione danneggiatiReplication of corrupt application data

Se l'aggiornamento dell'applicazione appena distribuito include un bug, potrebbe provocare il danneggiamento dei dati.If the newly deployed application upgrade has a bug, that may cause corruption of data. È ad esempio possibile che l'aggiornamento di un'applicazione inizi ad aggiornare ogni record relativo a numeri di telefono in un oggetto ReliableDictionary specificando un prefisso non valido.For example, an application upgrade may start to update every phone number record in a Reliable Dictionary with an invalid area code. In questo caso, i numeri di telefono non validi verranno replicati, perché Service Fabric non conosce la natura dei dati archiviati.In this case, the invalid phone numbers will be replicated since Service Fabric is not aware of the nature of the data that is being stored.

Dopo avere rilevato un bug così grave da causare il danneggiamento dei dati, è prima di tutto necessario bloccare il servizio a livello di applicazione e, se possibile, eseguire l'aggiornamento alla versione del codice dell'applicazione che non include il bug.The first thing to do after you detect such an egregious bug that causes data corruption is to freeze the service at the application level and, if possible, upgrade to the version of the application code that does not have the bug. Anche dopo la correzione del codice del servizio è tuttavia possibile che i dati siano ancora danneggiati e che sia necessario ripristinarli.However, even after the service code is fixed, the data may still be corrupt, and thus data may need to be restored. In questi casi potrebbe non essere sufficiente ripristinare il backup più recente, perché è possibile che anche i backup più recenti siano danneggiati.In such cases, it may not be sufficient to restore the latest backup, since the latest backups may also be corrupt. È quindi necessario trovare il backup più recente eseguito prima del danneggiamento dei dati.Thus, you have to find the last backup that was made before the data got corrupted.

Se non si sa con esattezza quali siano i backup danneggiati, è possibile distribuire un nuovo Service Fabric Cluster e ripristinare i backup delle partizioni interessate con la stessa procedura dello scenario "Servizio eliminato o perso" precedente.If you are not sure which backups are corrupt, you could deploy a new Service Fabric cluster and restore the backups of affected partitions just like the above "Deleted or lost service" scenario. Per ogni partizione, avviare il ripristino dei backup dal più recente al meno recente.For each partition, start restoring the backups from the most recent to the least. Dopo aver trovato un backup non danneggiato, spostare o eliminare tutti i backup della partizione più recenti di quel backup.Once you find a backup that does not have the corruption, move/delete all backups of this partition that were more recent (than that backup). Ripetere questo processo per ogni partizione.Repeat this process for each partition. Quando OnDataLossAsync viene chiamata sulla partizione nel cluster di produzione, il backup più recente trovato nell'archivio esterno verrà selezionato dal processo precedente.Now, when OnDataLossAsync is called on the partition in the production cluster, the last backup found in the external store will be the one picked by the above process.

È ora possibile usare la procedura illustrata nella sezione "Servizio eliminato o perso" per ripristinare lo stato del servizio sul valore precedente al danneggiamento da parte del codice con bug.Now, the steps in the "Deleted or lost service" section can be used to restore the state of the service to the state before the buggy code corrupted the state.

Si noti che:Note that:

  • Quando si esegue il ripristino è possibile che il backup ripristinato sia precedente allo stato della partizione prima della perdita dei dati.When you restore, there is a chance that the backup being restored is older than the state of the partition before the data was lost. È quindi necessario procedere al ripristino solo come ultima risorsa per recuperare la quantità maggiore possibile di dati.Because of this, you should restore only as a last resort to recover as much data as possible.
  • La stringa che rappresenta il percorso della cartella di backup e i percorsi dei file nella cartella di backup può superare i 255 caratteri, in base al percorso FabricDataRoot e alla lunghezza del nome del tipo di applicazione.The string that represents the backup folder path and the paths of files inside the backup folder can be greater than 255 characters, depending on the FabricDataRoot path and Application Type name's length. Questo approccio può far sì che alcuni metodi .NET, come Directory.Move, generino l'eccezione PathTooLongException.This can cause some .NET methods, like Directory.Move, to throw the PathTooLongException exception. Una soluzione alternativa consiste nel chiamare direttamente le API kernel32, come CopyFile.One workaround is to directly call kernel32 APIs, like CopyFile.

Eseguire il backup e il ripristino di Reliable ActorsBackup and restore Reliable Actors

Reliable Actors Framework si basa su Reliable Services.Reliable Actors Framework is built on top of Reliable Services. L'ActorService che ospita l'attore o gli attori è un servizio Reliable con stato.The ActorService, which hosts the actor(s) is a stateful reliable service. Di conseguenza, tutte le funzionalità di backup e ripristino disponibili in Reliable Services sono disponibili anche per Reliable Actors (tranne i comportamenti specifici per il provider di stato).Hence, all the backup and restore functionality available in Reliable Services is also available to Reliable Actors (except behaviors that are state provider specific). Poiché i backup verranno eseguiti per partizione, verrà eseguito il backup degli stati per tutti gli attori in quella partizione (il ripristino è simile e verrà eseguito anch'esso per partizione).Since backups will be taken on a per-partition basis, states for all actors in that partition will be backed up (and restoration is similar and will happen on a per-partition basis). Per eseguire il backup/ripristino, il proprietario del servizio deve creare un servizio Actor personalizzato che deriva da ActorService e quindi eseguire il backup/ripristino analogamente a quanto descritto nella sezione precedente per Reliable Services.To perform backup/restore, the service owner should create a custom actor service class that derives from ActorService class and then do backup/restore similar to Reliable Services as described above in previous sections.

class MyCustomActorService : ActorService
{
     public MyCustomActorService(StatefulServiceContext context, ActorTypeInformation actorTypeInfo)
            : base(context, actorTypeInfo)
     {                  
     }

    //
   // Method overrides and other code.
    //
}

Quando si crea una classe di servizio Actor personalizzata, è necessario registrarla insieme all'attore.When you create a custom actor service class, you need to register that as well when registering the actor.

ActorRuntime.RegisterActorAsync<MyActor>(
   (context, typeInfo) => new MyCustomActorService(context, typeInfo)).GetAwaiter().GetResult();

Il provider di stato predefinito per Reliable Actors è KvsActorStateProvider.The default state provider for Reliable Actors is KvsActorStateProvider. Per impostazione predefinita, il backup incrementale non è abilitato per KvsActorStateProvider.Incremental backup is not enabled by default for KvsActorStateProvider. È possibile abilitare il backup incrementale creando KvsActorStateProvider con l'impostazione appropriata nel relativo costruttore e quindi passandolo al costruttore ActorService come illustrato nel frammento di codice seguente:You can enable incremental backup by creating KvsActorStateProvider with the appropriate setting in its constructor and then passing it to ActorService constructor as shown in following code snippet:

class MyCustomActorService : ActorService
{
     public MyCustomActorService(StatefulServiceContext context, ActorTypeInformation actorTypeInfo)
            : base(context, actorTypeInfo, null, null, new KvsActorStateProvider(true)) // Enable incremental backup
     {                  
     }

    //
   // Method overrides and other code.
    //
}

Dopo aver abilitato il backup incrementale, quest'ultimo può avere esito negativo con FabricMissingFullBackupException per uno dei motivi seguenti. Sarà pertanto necessario eseguire un backup completo prima di effettuarne di incrementali:After incremental backup has been enabled, taking an incremental backup can fail with FabricMissingFullBackupException for one of following reasons and you will need to take a full backup before taking incremental backup(s):

  • La replica non ha mai eseguito un backup completo dopo essere diventata primaria.The replica has never taken a full backup since it became primary.
  • Alcuni dei record di log sono stati troncati in seguito all'ultimo backup.Some of the log records were truncated since last backup was taken.

Quando è abilitato il backup incrementale, KvsActorStateProvider non usa il buffer circolare per gestire i propri record di log e lo tronca periodicamente.When incremental backup is enabled, KvsActorStateProvider does not use circular buffer to manage its log records and periodically truncates it. Se in 45 minuti non viene eseguito alcun backup da parte dell'utente, il sistema tronca automaticamente i record di log.If no backup is taken by user for a period of 45 minutes, the system automatically truncates the log records. Questo intervallo può essere configurato specificando logTrunctationIntervalInMinutes nel costruttore KvsActorStateProvider, in maniera simile a quando si abilita il backup incrementale.This interval can be configured by specifying logTrunctationIntervalInMinutes in KvsActorStateProvider constructor (similar to when enabling incremental backup). I record di log potrebbero essere troncati anche se la replica primaria deve creare un'altra replica inviando tutti i propri dati.The log records may also get truncated if primary replica needs to build another replica by sending all its data.

Quando si esegue il ripristino da una catena di backup, in maniera simile a Reliable Services, BackupFolderPath deve contenere sottodirectory con una di queste contenente il backup completo e le altre contenenti i backup incrementali.When doing restore from a backup chain, similar to Reliable Services, the BackupFolderPath should contain subdirectories with one subdirectory containing full backup and others subdirectories containing incremental backup(s). Se la convalida della catena di backup non riesce, l'API di ripristino genererà FabricException con un messaggio di errore appropriato.The restore API will throw FabricException with appropriate error message if the backup chain validation fails.

Nota

Al momento l'opzione RestorePolicy.Safe viene ignorata da KvsActorStateProvider.KvsActorStateProvider currently ignores the option RestorePolicy.Safe. Il supporto per questa funzionalità è pianificato per una versione futura.Support for this feature is planned in an upcoming release.

Test del backup e del ripristinoTesting Backup and Restore

È importante assicurarsi che i dati critici vengano sottoposti a backup e che possano essere ripristinati.It is important to ensure that critical data is being backed up, and can be restored from. Per farlo, chiamare il cmdlet Start-ServiceFabricPartitionDataLoss in PowerShell che può indurre la perdita di dati in una determinata partizione per verificare se la funzionalità di backup e ripristino dei dati per il servizio funziona nel modo previsto.This can be done by invoking the Start-ServiceFabricPartitionDataLoss cmdlet in PowerShell that can induce data loss in a particular partition to test whether the data backup and restore functionality for your service is working as expected. Si può anche richiamare la perdita e il ripristino dei dati a livello di codice da tale evento.It is also possible to programmatically invoke data loss and restore from that event as well.

Nota

Nell'app di riferimento Web su GitHub è disponibile un esempio di implementazione della funzionalità di backup e ripristino.You can find a sample implementation of backup and restore functionality in the Web Reference App on GitHub. Per informazioni più dettagliate, vedere il servizio Inventory.Service.Please look at the Inventory.Service service for more details.

Approfondimento: altri dettagli sul backup e ripristinoUnder the hood: more details on backup and restore

Ecco altri dettagli sul backup e ripristino.Here's some more details on backup and restore.

BackupBackup

Reliable State Manager consente di creare backup coerenti senza bloccare alcuna operazione di lettura o scrittura.The Reliable State Manager provides the ability to create consistent backups without blocking any read or write operations. A questo scopo, utilizza un checkpoint e un meccanismo di persistenza dei log.To do so, it utilizes a checkpoint and log persistence mechanism. Reliable State Manager accetta checkpoint fuzzy (semplici) in determinati punti per ridurre la pressione sul log transazionale e migliorare i tempi di ripristino.The Reliable State Manager takes fuzzy (lightweight) checkpoints at certain points to relieve pressure from the transactional log and improve recovery times. Quando si chiama BackupAsync, Reliable State Manager indica a tutti gli oggetti Reliable di copiare i file di checkpoint più recenti in una cartella di backup locale.When BackupAsync is called, the Reliable State Manager instructs all Reliable objects to copy their latest checkpoint files to a local backup folder. Reliable State Manager copia quindi tutti i record del log a partire dal "puntatore iniziale" fino all'ultimo record del log nella cartella di backup.Then, the Reliable State Manager copies all log records, starting from the "start pointer" to the latest log record into the backup folder. Nel backup sono inclusi tutti i record di log fino all'ultimo e Reliable State Manager conserva i log write-ahead, di conseguenza Reliable State Manager assicura che nel backup siano incluse tutte le transazioni di cui viene eseguito il commit, ovvero di cui viene restituito correttamente CommitAsync.Since all the log records up to the latest log record are included in the backup and the Reliable State Manager preserves write-ahead logging, the Reliable State Manager guarantees that all transactions that are committed (CommitAsync has returned successfully) are included in the backup.

Eventuali transazioni di cui viene eseguito il commit dopo la chiamata di BackupAsync potrebbero essere incluse o meno nel backup.Any transaction that commits after BackupAsync has been called may or may not be in the backup. Dopo il popolamento della cartella di backup locale da parte della piattaforma, ovvero dopo un backup locale completato dal runtime, verrà richiamato il callback del backup del servizio.Once the local backup folder has been populated by the platform (that is, local backup is completed by the runtime), the service's backup callback is invoked. Il callback è responsabile dello spostamento della cartella di backup in una posizione esterna, ad esempio nell'Archiviazione di Azure.This callback is responsible for moving the backup folder to an external location such as Azure Storage.

RestoreRestore

Reliable State Manager consente di eseguire il ripristino da un backup con l'API RestoreAsync.The Reliable State Manager provides the ability to restore from a backup by using the RestoreAsync API.
È possibile chiamare il metodo RestoreAsync su RestoreContext solo all'interno del metodo OnDataLossAsync.The RestoreAsync method on RestoreContext can be called only inside the OnDataLossAsync method. Il valore booleano restituito da OnDataLossAsync indica se il servizio ha ripristinato il rispettivo stato da un'origine esterna.The bool returned by OnDataLossAsync indicates whether the service restored its state from an external source. Se OnDataLossAsync restituisce true, Service Fabric ricompila tutte le altre repliche sulla base di questa replica primaria.If the OnDataLossAsync returns true, Service Fabric will rebuild all other replicas from this primary. Service Fabric fa in modo che le repliche che ricevono la chiamata OnDataLossAsync eseguano prima la transizione al ruolo primario, senza che venga concesso lo stato di lettura o scrittura.Service Fabric ensures that replicas that will receive OnDataLossAsync call first transition to the primary role but are not granted read status or write status. Per i responsabili dell'implementazione di StatefulService significa che RunAsync viene chiamato solo dopo il completamento corretto di OnDataLossAsync.This implies that for StatefulService implementers, RunAsync will not be called until OnDataLossAsync finishes successfully. OnDataLossAsync viene quindi chiamato nella nuova replica primaria.Then, OnDataLossAsync will be invoked on the new primary. Fino a quando un servizio non completa correttamente l'API, restituendo true o false, e non viene completata la relativa riconfigurazione, l'API continuerà a essere chiamata singolarmente.Until a service completes this API successfully (by returning true or false) and finishes the relevant reconfiguration, the API will keep being called one at a time.

RestoreAsync rilascia prima di tutto ogni stato esistente nella replica primaria in cui è stato chiamato.RestoreAsync first drops all existing state in the primary replica that it was called on. Reliable State Manager crea quindi tutti gli oggetti Reliable esistenti nella cartella di backup.Then the Reliable State Manager creates all the Reliable objects that exist in the backup folder. Viene quindi indicato agli oggetti Reliable di eseguire il ripristino dai rispettivi checkpoint nella cartella di backup.Next, the Reliable objects are instructed to restore from their checkpoints in the backup folder. Reliable State Manager ripristina infine il proprio stato dai record dei log nella cartella di backup ed esegue il ripristino.Finally, the Reliable State Manager recovers its own state from the log records in the backup folder and performs recovery. Come parte del processo di ripristino, le operazioni a partire dal "punto iniziale" con record di log di commit nella cartella di backup vengono riprodotte negli oggetti Reliable.As part of the recovery process, operations starting from the "starting point" that have commit log records in the backup folder are replayed to the Reliable objects. Questo passaggio assicura che lo stato ripristinato sia coerente.This step ensures that the recovered state is consistent.

Passaggi successiviNext steps