Aggiornamento di un'applicazione di Service Fabric mediante PowerShell

Il metodo di aggiornamento consigliato usato più frequentemente è l'aggiornamento in sequenza in modalità monitorata (Monitored). Azure Service Fabric monitora l'integrità dell'applicazione che viene aggiornata in base a un set di criteri di integrità. Dopo che un dominio di aggiornamento è stato aggiornato, Service Fabric valuta l'integrità dell'applicazione e poi o passa al dominio di aggiornamento successivo o annulla l'aggiornamento in base ai criteri di integrità.

L'aggiornamento di un'applicazione in modalità monitorata può essere eseguito usando le API gestite o native, PowerShell, l'interfaccia della riga di comando di Azure, Java o REST. Per istruzioni su come eseguire un aggiornamento usando Visual Studio, vedere Esercitazione sull'aggiornamento di un'applicazione di Service Fabric tramite Visual Studio.

L'aggiornamento in sequenza in modalità monitorata di Service Fabric consente all'amministratore di applicazioni di configurare i criteri di valutazione dell'integrità usati da Service Fabric per determinare se l'applicazione è integra. Inoltre, l'amministratore può configurare l'azione da eseguire quando la valutazione dell'integrità ha esito negativo ,ad esempio eseguendo un rollback automatico. Questa sezione illustra un aggiornamento monitorato per uno degli esempi di SDK che usa PowerShell.

Vedere questa pagina per un video di training che illustra anche l'aggiornamento di un'applicazione:

$myApplication = Get-ServiceFabricApplication -ApplicationName fabric:/myApplication
$appParamCollection = $myApplication.ApplicationParameters

$applicationParameterMap = @{}
foreach ($pair in $appParamCollection)
{
    $applicationParameterMap.Add($pair.Name, $pair.Value);
}

Start-ServiceFabricApplicationUpgrade -ApplicationName fabric:/myApplication -ApplicationTypeVersion 2.0.0 -ApplicationParameter $applicationParameterMap -Monitored -FailureAction Rollback

Passaggio 1: creare e distribuire l'esempio di oggetti visivi

Compilare e pubblicare l'applicazione facendo clic con il pulsante destro del mouse sul progetto dell'applicazione, VisualObjectsApplication, e selezionando il comando Pubblica. Per altre informazioni, vedere Esercitazione sull'aggiornamento di un'applicazione di Service Fabric tramite Visual Studio. In alternativa, è possibile usare PowerShell per distribuire l'applicazione.

Dopo aver compilato il progetto in Visual Studio è possibile usare il comando di PowerShell Copy-ServiceFabricApplicationPackage per copiare il pacchetto dell'applicazione in ImageStore. Se si desidera verificare il pacchetto dell'applicazione in locale, usare il cmdlet Test-ServiceFabricApplicationPackage. Il passaggio successivo consiste nel registrare l'applicazione nel runtime di Service Fabric usando il cmdlet Register-ServiceFabricApplicationType. Il passaggio seguente consiste nell'avviare un'istanza dell'applicazione con il cmdlet New-ServiceFabricApplication. Questi tre passaggi sono analoghi all'uso della voce di menu Distribuisci in Visual Studio. Al termine del provisioning, è consigliabile pulire il pacchetto dell'applicazione copiato dall'archivio immagini per ridurre le risorse utilizzate. Se un tipo di applicazione non è più necessario, è consigliabile annullarne la registrazione per lo stesso motivo. Per altre informazioni, vedere Distribuire e rimuovere applicazioni con PowerShell.

È ora possibile usare Service Fabric Explorer per visualizzare il cluster e l'applicazione. L'applicazione dispone di un servizio Web a cui è possibile accedere in Internet Explorer digitando http://localhost:8081/visualobjects nella barra degli indirizzi. Verranno visualizzati alcuni oggetti visivi mobili sullo schermo. È anche possibile usare Get-ServiceFabricApplication per verificare lo stato dell'applicazione.

Passaggio 2: aggiornare l'applicazione Oggetti visivi di esempio

È possibile osservare che con la versione distribuita al passaggio 1 gli oggetti visivi non ruotano. L'applicazione può essere aggiornata in modo che gli oggetti visivi ruotino.

Selezionare il progetto VisualObjects.ActorService nella soluzione VisualObjects e aprire il file StatefulVisualObjectActor.cs. All'interno del file passare al metodo MoveObject, impostare come commento this.State.Move() e rimuovere il commento this.State.Move(true). Questa modifica fa ruotare gli oggetti dopo l'aggiornamento del servizio.

È anche necessario aggiornare il file ServiceManifest.xml (in PackageRoot) del progetto VisualObjects.ActorService. Aggiornare CodePackage e la versione del servizio alla versione 2.0, nonché le righe corrispondenti nel file ServiceManifest.xml. È possibile usare l'opzione Edit Manifest Files (Modifica file manifesto) di Visual Studio dopo aver fatto clic con il pulsante destro del mouse sulla soluzione per apportare le modifiche al file manifesto.

Dopo aver apportato le modifiche, il manifesto dovrebbe essere simile al seguente (le parti evidenziate indicano le modifiche):

<ServiceManifestName="VisualObjects.ActorService" Version="2.0" xmlns="http://schemas.microsoft.com/2011/01/fabric" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance">

<CodePackageName="Code" Version="2.0">

A questo punto il file ApplicationManifest.xml, disponibile nel progetto VisualObjects della soluzione VisualObjects, viene aggiornato alla versione 2.0 del progetto VisualObjects.ActorService. Anche la versione dell'applicazione viene aggiornata a 2.0.0.0 da 1.0.0.0. Il file ApplicationManifest.xml sarà simile al seguente frammento di codice:

<ApplicationManifestxmlns:xsd="https://www.w3.org/2001/XMLSchema" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" ApplicationTypeName="VisualObjects" ApplicationTypeVersion="2.0.0.0" xmlns="http://schemas.microsoft.com/2011/01/fabric">

 <ServiceManifestRefServiceManifestName="VisualObjects.ActorService" ServiceManifestVersion="2.0" />

A questo punto compilare il progetto selezionando solo il progetto ActorService e quindi facendo clic con il pulsante destro del mouse e scegliendo l'opzione Compila in Visual Studio. Se si seleziona Ricompila tutto, è necessario aggiornare le versioni per tutti i progetti, poiché il codice è stato modificato. È quindi possibile aggiungere l'applicazione aggiornata al pacchetto facendo clic con il pulsante destro del mouse sul progetto VisualObjectsApplication, scegliendo il menu Service Fabric e quindi Pacchetto. In questo modo viene creato un pacchetto dell'applicazione che può essere distribuito. L'applicazione aggiornata è pronta per essere distribuita.

Passaggio 3: Scegliere i criteri di integrità e i parametri di aggiornamento

È consigliabile acquisire familiarità con i parametri di aggiornamento dell'applicazione e con il processo di aggiornamento per conoscere i diversi parametri di aggiornamento, valori di timeout e criteri di integrità applicati. Per questa procedura dettagliata i criteri predefiniti di valutazione dell'integrità dei servizi sono impostati con i valori consigliati, quindi tutti i servizi e tutte le istanze saranno integri dopo l'aggiornamento.

Aumentare tuttavia il valore di HealthCheckStableDuration impostandolo su 180 secondi, in modo che i servizi siano integri per almeno 120 secondi prima che il processo di aggiornamento passi al dominio di aggiornamento successivo. Impostare quindi UpgradeDomainTimeout su 1200 secondi e UpgradeTimeout su 3000 secondi.

Infine impostare anche UpgradeFailureAction in modo che venga eseguito il rollback. Questa opzione richiede che Service Fabric esegua il rollback dell'applicazione alla versione precedente se riscontra problemi durante l'aggiornamento. Perciò, all'avvio dell'aggiornamento (al passaggio 4), vengono specificati i parametri seguenti:

FailureAction = Rollback

HealthCheckStableDurationSec = 180

UpgradeDomainTimeoutSec = 1200

UpgradeTimeout = 3000

Passaggio 4: preparare l'applicazione per l'aggiornamento

L'applicazione ora è compilata e pronta per l'aggiornamento. Se si apre una finestra di PowerShell come amministratore e si digita Get-ServiceFabricApplication, verrà indicato che è stato distribuito il tipo di applicazione 1.0.0.0 di VisualObject.

Il pacchetto dell'applicazione viene archiviato nel percorso relativo seguente in cui è stato decompresso Service Fabric SDK: Samples\Services\Stateful\VisualObjects\obj\x64\Debug. In questa directory deve essere disponibile una cartella "Package", dove è archiviato il pacchetto dell'applicazione. Controllare i timestamp per assicurarsi che si tratti dell'ultima build. Potrebbe essere anche necessario modificare i percorsi in base alle esigenze.

Copiare ora il pacchetto applicazione aggiornato in ImageStore di Service Fabric (dove Service Fabric archivia i pacchetti applicazione). Il parametro ApplicationPackagePathInImageStore indica a Service Fabric dove è contenuto il pacchetto applicazione. L'applicazione aggiornata è stata inserita in "VisualObjects_V2" con il comando seguente (potrebbe essere necessario modificare di nuovo i percorsi in modo appropriato).

Copy-ServiceFabricApplicationPackage -ApplicationPackagePath .\Samples\Services\Stateful\VisualObjects\VisualObjects\obj\x64\Debug\Package -ApplicationPackagePathInImageStore "VisualObjects\_V2"

Il passaggio successivo consiste nel registrare l'applicazione con Service Fabric, operazione che può essere eseguita usando il comando Register-ServiceFabricApplicationType:

Register-ServiceFabricApplicationType -ApplicationPathInImageStore "VisualObjects\_V2"

Se il comando precedente non riesce, è probabile che si debbano ricompilare tutti i servizi. Come indicato nel passaggio 2, potrebbe essere necessario aggiornare anche la versione di WebService.

Al termine della registrazione dell'applicazione, è consigliabile rimuovere il pacchetto dell'applicazione. L'eliminazione dei pacchetti di applicazioni dall'archivio immagini consente di liberare risorse di sistema. Conservando pacchetti inutilizzati, viene occupato spazio di archiviazione su disco e si verificano problemi di prestazioni delle applicazioni.

Remove-ServiceFabricApplicationPackage -ApplicationPackagePathInImageStore "VisualObjects\_V2" -ImageStoreConnectionString fabric:ImageStore

Passaggio 5: avviare l'aggiornamento dell'applicazione

Ora è tutto pronto per avviare l'aggiornamento dell'applicazione usando il comando Start-ServiceFabricApplicationUpgrade:

Start-ServiceFabricApplicationUpgrade -ApplicationName fabric:/VisualObjects -ApplicationTypeVersion 2.0.0.0 -HealthCheckStableDurationSec 60 -UpgradeDomainTimeoutSec 1200 -UpgradeTimeout 3000   -FailureAction Rollback -Monitored

Il nome dell'applicazione è lo stesso descritto nel file ApplicationManifest.xml . Service Fabric usa questo nome per identificare l'applicazione che viene aggiornata. Se si imposta un valore di timeout troppo breve, è possibile che venga visualizzato un messaggio di errore che indica il problema. Vedere la sezione relativa alla risoluzione dei problemi o aumentare i valori di timeout.

Man mano che l'aggiornamento dell'applicazione procede, è possibile monitorarlo con Service Fabric Explorer oppure con il comando di PowerShell Get-ServiceFabricApplicationUpgrade:

Get-ServiceFabricApplicationUpgrade fabric:/VisualObjects

In pochi minuti lo stato ottenuto usando il comando di PowerShell precedente indicherà che sono stati aggiornati (completati) tutti i domini di aggiornamento. Inoltre gli oggetti visivi nella finestra del browser hanno iniziato a ruotare.

Come esercizio provare a effettuare l'aggiornamento dalla versione 2 alla versione 3 o dalla versione 2 alla versione 1: anche il passaggio dalla versione 2 alla versione 1 è considerato un aggiornamento. Esercitarsi inoltre con i timeout e i criteri di integrità per acquisire familiarità anche con questi concetti. Quando si esegue la distribuzione in un cluster di Azure, è necessario impostare i parametri in modo appropriato. È consigliabile impostare i timeout su valori contenuti.

Passaggi successivi

Esercitazione sull'aggiornamento di un'applicazione di Service Fabric tramite Visual Studio descrive la procedura di aggiornamento di un'applicazione con Visual Studio.

Controllare l'aggiornamento dell'applicazione tramite Parametri di aggiornamento.

Rendere compatibili gli aggiornamenti dell'applicazione imparando a usare la serializzazione dei dati.

Per informazioni su come usare funzionalità avanzate durante l'aggiornamento dell'applicazione, vedere Argomenti avanzati.

Per informazioni su come risolvere problemi comuni negli aggiornamenti dell'applicazione, vedere i passaggi indicati in Risoluzione dei problemi relativi agli aggiornamenti dell'applicazione.