Introduzione a Reliable ServicesGet started with Reliable Services

Questo articolo illustra le nozioni fondamentali di Reliable Services di Azure Service Fabric e le procedure per creare e distribuire una semplice applicazione Reliable Services scritta in Java.This article explains the basics of Azure Service Fabric Reliable Services and walks you through creating and deploying a simple Reliable Service application written in Java. Questo video di Microsoft Virtual Academy illustra anche come creare un servizio Reliable Services senza stato:

This Microsoft Virtual Academy video also shows you how to create a stateless Reliable service:


Installazione e configurazioneInstallation and setup

Prima di iniziare, assicurarsi che nel computer sia configurato l'ambiente di sviluppo di Service Fabric.Before you start, make sure you have the Service Fabric development environment set up on your machine. Se è necessario configurarlo, andare alla guida introduttiva per Mac o alla guida introduttiva per Linux.If you need to set it up, go to getting started on Mac or getting started on Linux.

Concetti di baseBasic concepts

Per iniziare a usare Reliable Services, è sufficiente comprendere solo alcuni concetti di base:To get started with Reliable Services, you only need to understand a few basic concepts:

  • Tipo di servizio: si tratta dell'implementazione del servizio.Service type: This is your service implementation. Viene definito dalla classe scritta che estende StatelessService e qualsiasi altro codice o dipendenze usate, insieme al nome e al numero della versione.It is defined by the class you write that extends StatelessService and any other code or dependencies used therein, along with a name and a version number.
  • Istanza di servizio denominata: per eseguire il servizio, si creano le istanze denominate del tipo di servizio, analogamente al modo in cui si creano le istanze di un oggetto di un tipo di classe.Named service instance: To run your service, you create named instances of your service type, much like you create object instances of a class type. Le istanze del servizio sono, di fatto, istanze di oggetto della classe del servizio che si scrive.Service instances are in fact object instantiations of your service class that you write.
  • Host del servizio: le istanze del servizio denominate che si creano devono essere eseguite all'interno di un host.Service host: The named service instances you create need to run inside a host. L'host del servizio è semplicemente un processo in cui eseguire le istanze del servizio.The service host is just a process where instances of your service can run.
  • Registrazione del servizio: la registrazione raccoglie tutti gli elementi.Service registration: Registration brings everything together. Il tipo di servizio deve essere registrato con il runtime di Service Fabric in un host del servizio per consentire a Service Fabric di creare istanze per l'esecuzione.The service type must be registered with the Service Fabric runtime in a service host to allow Service Fabric to create instances of it to run.

Creare un servizio senza statoCreate a stateless service

Iniziare a creare un'applicazione di Service Fabric.Start by creating a Service Fabric application. Service Fabric SDK per Linux include un generatore Yeoman per la creazione dello scaffolding per un'applicazione di Service Fabric con un servizio senza stato.The Service Fabric SDK for Linux includes a Yeoman generator to provide the scaffolding for a Service Fabric application with a stateless service. Iniziare eseguendo il comando Yeoman seguente:Start by running the following Yeoman command:

$ yo azuresfjava

Seguire le istruzioni per creare un servizio di Reliable Service senza stato.Follow the instructions to create a Reliable Stateless Service. Per questa esercitazione, denominare l'applicazione "HelloWorldApplication" e il servizio "HelloWorld".For this tutorial, name the application "HelloWorldApplication" and the service "HelloWorld". Il risultato include le directory per HelloWorldApplication e HelloWorld.The result includes directories for the HelloWorldApplication and HelloWorld.

HelloWorldApplication/
├── build.gradle
├── HelloWorld
│   ├── build.gradle
│   └── src
│       └── statelessservice
│           ├── HelloWorldServiceHost.java
│           └── HelloWorldService.java
├── HelloWorldApplication
│   ├── ApplicationManifest.xml
│   └── HelloWorldPkg
│       ├── Code
│       │   ├── entryPoint.sh
│       │   └── _readme.txt
│       ├── Config
│       │   └── _readme.txt
│       ├── Data
│       │   └── _readme.txt
│       └── ServiceManifest.xml
├── install.sh
├── settings.gradle
└── uninstall.sh

Implementare il servizioImplement the service

Aprire HelloWorldApplication/HelloWorld/src/statelessservice/HelloWorldService.java.Open HelloWorldApplication/HelloWorld/src/statelessservice/HelloWorldService.java. Questa classe definisce il tipo di servizio e può eseguire qualsiasi codice.This class defines the service type, and can run any code. L'API del servizio fornisce due punti di ingresso per il codice:The service API provides two entry points for your code:

  • Un metodo del punto di ingresso aperto denominato runAsync(), che consente di iniziare a eseguire qualsiasi carico di lavoro, inclusi carichi di lavoro di calcolo con esecuzione prolungata.An open-ended entry point method, called runAsync(), where you can begin executing any workloads, including long-running compute workloads.
@Override
protected CompletableFuture<?> runAsync(CancellationToken cancellationToken) {
    ...
}
  • Un punto di ingresso di comunicazione a cui è possibile collegare lo stack di comunicazione desiderato.A communication entry point where you can plug in your communication stack of choice. In questo punto è possibile iniziare a ricevere richieste da utenti e da altri servizi.This is where you can start receiving requests from users and other services.
@Override
protected List<ServiceInstanceListener> createServiceInstanceListeners() {
    ...
}

Questa esercitazione si concentra sul metodo runAsync() del punto di ingresso.In this tutorial, we focus on the runAsync() entry point method. In questo punto è possibile iniziare immediatamente a eseguire il codice.This is where you can immediately start running your code.

RunAsyncRunAsync

La piattaforma chiama questo metodo quando si inserisce un'istanza di un servizio pronta per l'esecuzione.The platform calls this method when an instance of a service is placed and ready to execute. Per un servizio senza stato, la piattaforma chiama il metodo quando l'istanza del servizio viene aperta.For a stateless service, that simply means when the service instance is opened. Viene fornito un token di annullamento che determina quando è necessario chiudere l'istanza del servizio.A cancellation token is provided to coordinate when your service instance needs to be closed. In Service Fabric questo ciclo di apertura e chiusura di un'istanza del servizio può verificarsi più volte per tutta la durata del servizio nel suo complesso.In Service Fabric, this open/close cycle of a service instance can occur many times over the lifetime of the service as a whole. Questa situazione può verificarsi per vari motivi, tra cui:This can happen for various reasons, including:

  • Il sistema sposta le istanze del servizio per il bilanciamento delle risorse.The system moves your service instances for resource balancing.
  • Si verificano errori nel codice.Faults occur in your code.
  • Viene aggiornato il sistema o l'applicazione.The application or system is upgraded.
  • Si verifica un'interruzione nell'hardware sottostante.The underlying hardware experiences an outage.

Questa orchestrazione viene gestita da Service Fabric per assicurare l'elevata disponibilità e il corretto bilanciamento del servizio.This orchestration is managed by Service Fabric to keep your service highly available and properly balanced.

runAsync() non deve bloccarsi in modo sincrono.runAsync() should not block synchronously. L'implementazione di runAsync deve restituire un valore CompletableFuture per consentire al runtime di procedere.Your implementation of runAsync should return a CompletableFuture to allow the runtime to continue. Se il carico di lavoro deve implementare un'attività a esecuzione prolungata, tale operazione deve essere completata entro il valore specificato da CompletableFuture.If your workload needs to implement a long running task that should be done inside the CompletableFuture.

AnnullamentoCancellation

L'annullamento del carico di lavoro è un'operazione cooperativa coordinata dal token di annullamento fornito.Cancellation of your workload is a cooperative effort orchestrated by the provided cancellation token. Il sistema attende la fine dell'attività (per esito positivo, annullamento o errore) prima di continuare.The system waits for your task to end (by successful completion, cancellation, or fault) before it moves on. È importante rispettare il token di annullamento, completare le operazioni e chiudere runAsync() il più rapidamente possibile quando viene richiesto l'annullamento dal sistema.It is important to honor the cancellation token, finish any work, and exit runAsync() as quickly as possible when the system requests cancellation. L'esempio seguente mostra come gestire un evento di annullamento:The following example demonstrates how to handle a cancellation event:

    @Override
    protected CompletableFuture<?> runAsync(CancellationToken cancellationToken) {

        // TODO: Replace the following sample code with your own logic
        // or remove this runAsync override if it's not needed in your service.

        CompletableFuture.runAsync(() -> {
          long iterations = 0;
          while(true)
          {
            cancellationToken.throwIfCancellationRequested();
            logger.log(Level.INFO, "Working-{0}", ++iterations);

            try
            {
              Thread.sleep(1000);
            }
            catch (IOException ex) {}
          }
        });
    }

Registrazione del servizioService registration

I tipi del servizio devono essere registrati nel runtime di Service Fabric.Service types must be registered with the Service Fabric runtime. Il tipo di servizio è definito nel ServiceManifest.xml e nella classe di servizio che implementa StatelessService.The service type is defined in the ServiceManifest.xml and your service class that implements StatelessService. La registrazione del servizio viene eseguita nel punto di ingresso principale del processo.Service registration is performed in the process main entry point. In questo esempio il punto di ingresso principale del processo è HelloWorldServiceHost.java:In this example, the process main entry point is HelloWorldServiceHost.java:

public static void main(String[] args) throws Exception {
    try {
        ServiceRuntime.registerStatelessServiceAsync("HelloWorldType", (context) -> new HelloWorldService(), Duration.ofSeconds(10));
        logger.log(Level.INFO, "Registered stateless service type HelloWorldType.");
        Thread.sleep(Long.MAX_VALUE);
    }
    catch (Exception ex) {
        logger.log(Level.SEVERE, "Exception in registration:", ex);
        throw ex;
    }
}

Eseguire l'applicazioneRun the application

Lo scaffolding Yeoman include uno script Gradle per compilare l'applicazione e script Bash per distribuire ed eliminare l'applicazione.The Yeoman scaffolding includes a gradle script to build the application and bash scripts to deploy and remove the application. Per eseguire l'applicazione, prima di tutto compilarla con Gradle:To run the application, first build the application with gradle:

$ gradle

Questa operazione genera un pacchetto dell'applicazione Service Fabric che può essere distribuito tramite l'interfaccia della riga di comando di Service Fabric.This produces a Service Fabric application package that can be deployed using Service Fabric CLI.

Distribuire con l'interfaccia della riga di comando di Service FabricDeploy with Service Fabric CLI

Lo script install.sh contiene i comandi dell'interfaccia della riga di comando di Service Fabric necessari per distribuire il pacchetto dell'applicazione.The install.sh script contains the necessary Service Fabric CLI commands to deploy the application package. Eseguire lo script install.sh per distribuire l'applicazione.Run the install.sh script to deploy the application.

$ ./install.sh

Passaggi successiviNext steps