Modello di hosting di Service FabricService Fabric hosting model

Questo articolo offre una panoramica dei modelli di hosting delle applicazioni offerti da Service Fabric e descrive le differenze tra i modelli Processo condiviso ed Exclusive Process (Processo esclusivo).This article provides an overview of application hosting models provided by Service Fabric, and describes the differences between the Shared Process and Exclusive Process models. Descrive l'aspetto di un'applicazione in un nodo di Service Fabric e la relazione tra le repliche (o istanze) del servizio e il processo host del servizio.It describes how a deployed application looks on a Service Fabric node and relationship between replicas (or instances) of the service and the service-host process.

Prima di procedere, verificare di avere acquisito familiarità con il modello applicativo di Service Fabric e di aver compreso i diversi concetti e le relazioni esistenti tra di essi.Before proceeding further, make sure that you are familiar with Service Fabric Application Model and understand various concepts and relation among them.

Nota

In questo articolo, per semplicità, a meno che non indicato in modo esplicito:In this article, for simplicity, unless explicitly mentioned:

  • Tutti gli usi del termine replica si riferiscono sia a una replica di un servizio con stato che a un'istanza di un servizio senza stato.All uses of word replica refers to both a replica of a stateful service or an instance of a stateless service.
  • CodePackage viene trattato in modo equivalente al processo ServiceHost che registra un ServiceType e ospita repliche dei servizi di tale ServiceType.CodePackage is treated equivalent to ServiceHost process that registers a ServiceType and hosts replicas of services of that ServiceType.

Per comprendere il servizio di hosting, esaminare l'esempio seguente.To understand the hosting model, let us walk through an example. Si supponga di avere un ApplicationType 'MyAppType' con un ServiceType 'MyServiceType' fornito dal ServicePackage 'MyServicePackage' che ha un CodePackage 'MyCodePackage' che registra ServiceType 'MyServiceType' quando viene eseguito.Let us say, we have an ApplicationType 'MyAppType' which has a ServiceType 'MyServiceType' which is provided by ServicePackage 'MyServicePackage' which has a CodePackage 'MyCodePackage' which registers ServiceType 'MyServiceType' when it runs.

Si supponga inoltre di avere un cluster a 3 nodi e di creare un'applicazione fabric:/App1 di tipo 'MyAppType'.Let's say we have a 3 node cluster and we create an application fabric:/App1 of type 'MyAppType'. All'interno di questa applicazione fabric:/App1 viene creato un servizio fabric:/App1/ServiceA di tipo 'MyServiceType' con 2 partizioni, P1 & P2, e 3 repliche per partizione.Inside this application fabric:/App1 we create a service fabric:/App1/ServiceA of type 'MyServiceType' which has 2 partitions (say P1 & P2) and 3 replicas per partition. Il diagramma seguente mostra la visualizzazione di questa applicazione distribuita in un nodo.The following diagram shows the view of this application as it ends up deployed on a node.

Visualizzazione del nodo dell'applicazione distribuita
Node view of deployed application

Service Fabric ha attivato 'MyServicePackage' che ha avviato 'MyCodePackage'. Quest'ultimo ospita repliche da entrambe le partizioni, ovvero P1 & P2.Service Fabric activated 'MyServicePackage' which started 'MyCodePackage' which is hosting replicas from both the partitions i.e. P1 & P2. Si noti che tutti i nodi del cluster avranno la stessa visualizzazione poiché è stato scelto un numero di repliche per partizione uguale al numero di nodi del cluster.Note that all the nodes in the cluster will have same view since we chose number of replicas per partition equal to number of nodes in the cluster. Viene ora creato un altro servizio fabric:/App1/ServiceB nell'applicazione fabric:/App1 con una partizione, P3, e 3 repliche per partizione.Let's create another service fabric:/App1/ServiceB in application fabric:/App1 which has 1 partition (say P3) and 3 replicas per partition. Il diagramma seguente mostra la nuova visualizzazione del nodo:Following diagram shows the new view on the node:

Visualizzazione del nodo dell'applicazione distribuita
Node view of deployed application

Come è possibile notare, Service Fabric posiziona la nuova replica per la partizione P3 del servizio fabric:/App1/ServiceB nell'attivazione esistente di 'MyServicePackage'.As we can see Service Fabric placed the new replica for partition P3 of service fabric:/App1/ServiceB in the existing activation of 'MyServicePackage'. Viene ora creata un'altra applicazione fabric:/App2 di tipo 'MyAppType'. All'interno di fabric:/App2 viene creato il servizio fabric:/App2/ServiceA con due partizioni, P4 & P5, e 3 repliche per partizione.Now lets create another application fabric:/App2 of type 'MyAppType' and inside fabric:/App2 create service fabric:/App2/ServiceA which has 2 partitions (say P4 & P5) and 3 replicas per partition. La figura seguente mostra la nuova visualizzazione del nodo:Following diagrams shows the new node view:

Visualizzazione del nodo dell'applicazione distribuita
Node view of deployed application

Questa volta Service Fabric ha attivato una nuova copia di 'MyServicePackage', che a sua volta avvia una nuova copia di 'MyCodePackage'. Repliche di entrambe le partizioni del servizio fabric:/App2/ServiceA, ovvero P4 & P5, vengono posizionate in questa nuova copia 'MyCodePackage'.This time Service Fabric has activated a new copy of 'MyServicePackage' which starts a new copy of 'MyCodePackage' and replicas from both partitions of service fabric:/App2/ServiceA (i.e. P4 & P5) are placed in this new copy 'MyCodePackage'.

Modello Processo condivisoShared process model

Quanto descritto in precedenza è il modello di hosting predefinito offerto da Service Fabric ed è denominato Processo condiviso.What we saw above is the default hosting model provided by Service Fabric and is referred to as Shared Process model. In questo modello, per una determinata applicazione soltanto una copia di un determinato ServicePackage viene attivata in un Nodo (che avvia tutti i CodePackage in esso contenuti). Tutte le repliche di tutti i servizi di un ServiceType specificato vengono posizionate nel CodePackage che registra tale ServiceType.In this model, for a given application, only one copy of a given ServicePackage is activated on a Node (which starts all the CodePackages contained in it) and all the replicas of all services of a given ServiceType are placed in the CodePackage that registers that ServiceType. In altre parole, tutte le repliche di tutti i servizi in un nodo con un determinato valore di ServiceType condividono lo stesso processo.In other words, all the replicas of all services on a node of a given ServiceType share the same process.

Modello Exclusive Process (Processo esclusivo)Exclusive process model

L'alto modello di hosting offerto da Service Fabric è il modello Exclusive Process (Processo esclusivo).The other hosting model provided by Service Fabric is Exclusive Process model. In questo modello, su un determinato Nodo, per posizionare ciascuna replica Service Fabric attiva una nuova copia di ServicePackage, che avvia tutti i CodePackage in esso contenuti. La replica viene posizionata nel CodePackage che ha registrato il ServiceType del servizio a cui la appartiene la replica.In this model, on a given Node, for placing each replica, Service Fabric activates a new copy of ServicePackage (which starts all the CodePackages contained in it) and replica is placed in the CodePackage that registered the ServiceType of the service to which replica belongs. In altri termini, ogni replica si trova nel proprio processo dedicato.In other words, each replica lives in its own dedicated process.

Questo modello è supportato a partire dalla versione 5.6 di Service Fabric.This model is supported starting version 5.6 of Service Fabric. È possibile scegliere il modello Exclusive Process (Processo esclusivo) al momento della creazione del servizio (mediante PowerShell, REST o FabricClient) specificando ServicePackageActivationMode come 'ExclusiveProcess'.Exclusive Process model can be chosen at the time of creating the service (using PowerShell, REST or FabricClient) by specifying ServicePackageActivationMode as 'ExclusiveProcess'.

PS C:\>New-ServiceFabricService -ApplicationName "fabric:/App1" -ServiceName "fabric:/App1/ServiceA" -ServiceTypeName "MyServiceType" -Stateless -PartitionSchemeSingleton -InstanceCount -1 -ServicePackageActivationMode "ExclusiveProcess"
var serviceDescription = new StatelessServiceDescription
{
    ApplicationName = new Uri("fabric:/App1"),
    ServiceName = new Uri("fabric:/App1/ServiceA"),
    ServiceTypeName = "MyServiceType",
    PartitionSchemeDescription = new SingletonPartitionSchemeDescription(),
    InstanceCount = -1,
    ServicePackageActivationMode = ServicePackageActivationMode.ExclusiveProcess
};

var fabricClient = new FabricClient(clusterEndpoints);
await fabricClient.ServiceManager.CreateServiceAsync(serviceDescription);

Se nel manifesto dell'applicazione è presente un servizio predefinito, è possibile scegliere il modello Exclusive Process (Processo esclusivo) specificando l'attributo ServicePackageActivationMode, come mostrato di seguito:If you have a default service in your application manifest, you can choose Exclusive Process model by specifying ServicePackageActivationMode attribute as shown below:

<DefaultServices>
  <Service Name="MyService" ServicePackageActivationMode="ExclusiveProcess">
    <StatelessService ServiceTypeName="MyServiceType" InstanceCount="1">
      <SingletonPartition/>
    </StatelessService>
  </Service>
</DefaultServices>

Continuando con l'esempio precedente, viene ora creato un altro servizio fabric:/App1/ServiceC nell'applicazione fabric:/App1 che ha 2 partizioni, P6 & P7, e 3 repliche per partizione con ServicePackageActivationMode impostato su 'ExclusiveProcess'.Continuing with our example above, lets create another service fabric:/App1/ServiceC in application fabric:/App1 which has 2 partitions (say P6 & P7) and 3 replicas per partition with ServicePackageActivationMode set to 'ExclusiveProcess'. Il diagramma seguente mostra la nuova visualizzazione del nodo:Following diagram shows new view on the node:

Visualizzazione del nodo dell'applicazione distribuita
Node view of deployed application

Come è possibile notare, Service Fabric ha attivato due nuove copie di 'MyServicePackage', una per ciascuna replica dalle partizioni P6 & P7, e ha posizionato ciascuna replica nella relativa copia dedicata di CodePackage.As you can see, Service Fabric activated two new copies of 'MyServicePackage' (one for each replica from partition P6 & P7) and placed each replica in its dedicated copy of CodePackage. Un altro aspetto da sottolineare e che, quando si usa il modello Exclusive Process (Processo esclusivo), per una determinata applicazione possono essere attive in un Nodo più copie di un ServicePackage specificato.Another thing to note here is, when Exclusive Process model is used, for a given application, multiple copies of a given ServicePackage can be active on a Node. Nell'esempio precedente è possibile notare che le tre copie di 'MyServicePackage' sono attive per fabric:/App1.In above example, we see that three copies of 'MyServicePackage' are active for fabric:/App1. A ciascuna di queste copie di "MyServicePackage" è associato un valore ServicePackageActivationId che identifica la copia nell'applicazione fabric:/App1.Each of these active copies of 'MyServicePackage' has a ServicePackageActivationId associated with it which identifies that copy within application fabric:/App1.

Quando viene usato solo il modello Processo condiviso per un'applicazione, ad esempio fabric:/App2 nell'esempio precedente, c'è una sola copia attiva di ServicePackage in un Nodo e il valore di ServicePackageActivationId per questa attivazione di ServicePackage è "empty string".When only Shared Process model is used for an application, like fabric:/App2 in above example, there is only one active copy of ServicePackage on a Node and ServicePackageActivationId for this activation of ServicePackage is 'empty string'.

Nota

  • Con il modello di hosting Processo condiviso, ServicePackageActivationMode è uguale a SharedProcess.Shared Process hosting model corresponds to ServicePackageActivationMode equal SharedProcess. Si tratta del modello di hosting predefinito e non è necessario specificare il valore di ServicePackageActivationMode al momento della creazione del servizio.This is the default hosting model and ServicePackageActivationMode need not be specified at the time of creating the service.

  • Con il modello di hosting Exclusive Process (Processo esclusivo), ServicePackageAtivationMode è uguale a ExclusiveProcess e deve essere specificato in modo esplicito al momento della creazione del servizio.Exclusive Process hosting model corresponds to ServicePackageActivationMode equal ExclusiveProcess and need to be explicitly specified at the time of creating the service.

  • Per conoscere il modello di hosting di un servizio, è possibile eseguire una query relativa alla descrizione del servizio e cercare il valore di ServicePackageActivationMode.Hosting model of a service can be known by querying the service description and looking at value of ServicePackageActivationMode.

Utilizzo del pacchetto del servizio distribuitoWorking with deployed service package

Una copia attiva di un ServicePackage su un nodo viene definita pacchetto del servizio distribuito.An active copy of a ServicePackage on a node is referred as deployed service package. Come illustrato in precedenza, quando per la creazione di servizi viene usato il modello Exclusive Process (Processo esclusivo), per una determinata applicazione possono essere presenti più pacchetti del servizio distribuiti per lo stesso ServicePackage.As previously mentioned above, when Exclusive Process model is used for creating services, for a given application, there could be multiple deployed service packages for the same ServicePackage. Durante l'esecuzione di operazioni specifiche del pacchetto del servizio distribuito, ad esempio la creazione di report sull'integrità di un pacchetto del servizio distribuito o il riavvio di un pacchetto di codice di un pacchetto del servizio distribuito e così via, per identificare uno specifico pacchetto del servizio distribuito è necessario specificare il ServicePackageActivationId.While performing operations specific to deployed service package like reporting health of a deployed service package or restarting code package of a deployed service package etc., ServicePackageActivationId needs to be provided to identify a specific deployed service package.

È possibile ottenere il ServicePackageActivationId di un pacchetto del servizio distribuito eseguendo una query sull'elenco di pacchetti del servizio distribuiti su un nodo.ServicePackageActivationId of a deployed service package can be obtained by querying the list of deployed service packages on a node. Quando si eseguono query sui tipi di servizi distribuiti, le repliche distribuite e i pacchetti di codice distribuiti su un nodo, il risultato della query contiene anche il ServicePackageActivationId del pacchetto del servizio distribuito padre.When querying deployed service types, deployed replicas and deployed code packages on a node, the query result also contains the ServicePackageActivationId of parent deployed service package.

Nota

  • In base al modello di hosting Processo condiviso, in un determinato nodo per un'applicazione specificata viene attivata una sola copia di un ServicePackage.Under Shared Process hosting model, on a given node, for a given application, only one copy of a ServicePackage is activated. Il ServicePackageActivationId di tale copia è uguale a empty string e non è necessario specificarlo quando si eseguono operazioni correlate al pacchetto del servizio distribuito.It has ServicePackageActivationId equal to empty string and need not be specified while performing deployed service package related operations.

  • In base al modello di hosting Exclusive Process (Processo esclusivo), in un determinato nodo per un'applicazione specificata possono essere attive una o più copie di un ServicePackage.Under Exclusive Process hosting model, on a given node, for a given application, one or more copies of a ServicePackage can be active. Ciascuna attivazione ha un ServicePackageActivationId non-empty, che deve essere specificato quando si eseguono operazioni correlate al pacchetto del servizio distribuito.Each activation has a non-empty ServicePackageActivationId and needs to be specified while performing deployed service package related operations.

  • Se si omette ServicePackageActivationId, viene usata l'impostazione predefinita "empty string".If ServicePackageActivationId is omitted it defaults to 'empty string'. Se è presente un pacchetto del servizio distribuito attivato in base al modello Processo condiviso, l'operazione verrà eseguita su tale pacchetto. In caso contrario, tale operazione avrà esito negativo.If a deployed service package that was activated under Shared Process model is present, then operation will be performed on it, otherwise the operation will fail.

  • Non è consigliabile eseguire una query e quindi memorizzare nella cache il ServicePackageActivationId. Questo infatti viene generato dinamicamente e può cambiare per diversi motivi.It is not recommended to query once and cache ServicePackageActivationId as it is dynamically generated and can change for various reasons. Prima di eseguire un'operazione che richiede il valore di ServicePackageActivationId, è necessario eseguire una query sull'elenco di pacchetti del servizio distribuiti in un nodo e quindi usare il valore di ServicePackageActivationId del risultato della query per eseguire l'operazione originale.Before performing an operation that needs ServicePackageActivationId, you should first query the list of deployed service packages on a node and then use ServicePackageActivationId from query result to perform the original operation.

Applicazioni eseguibili guest e contenitoreGuest executable and container applications

Service Fabric tratta le applicazioni di tipo eseguibile guest e contenitore come servizi senza stato indipendenti. In altri termini, in ServiceHost non è presente alcun runtime di Service Fabric (processo o contenitore).Service Fabric treats Guest executable and container applications as statless services which are self-contained i.e. there is no Service Fabric runtime in ServiceHost (a process or container). Dal momento che si tratta di servizi indipendenti, il numero di repliche per ServiceHost non è applicabile.Since these services are self-contained, number of replicas per ServiceHost is not applicable for these services. La configurazione usata più comunemente con questi servizi è una partizione singola con InstanceCount uguale a -1. In altri termini, su ciascun nodo del cluster è in esecuzione una copia del codice del servizio.The most common configuration used with these services is single-partition with InstanceCount equal to -1 (i.e. one copy of the service code running on each node of cluster).

Il valore ServicePackageActivationMode predefinito per questi servizi è SharedProcess: Service Fabric attiva una sola copia di ServicePackage su un Nodo per una determinata applicazione. Questo significa che una sola copia del codice del servizio sarà in esecuzione su un Nodo.The default ServicePackageActivationMode for these services is SharedProcess in which case Service Fabric only activates one copy of ServicePackage on a Node for a given application which means only one copy of service code will run a Node. Se quando si creano più servizi (da Service1 a ServiceN) di ServiceType (specificato in ServiceManifest) si vuole che su un Nodo vengano eseguite più copie del codice del servizio oppure, se il servizio ha più partizioni, al momento della creazione del servizio è necessario specificare ServicePackageActivationMode come ExclusiveProcess.If you want multiple copies of your service code to run on a Node when you create multiple services (Service1 to ServiceN) of ServiceType (specified in ServiceManifest) or when your service is multi-partitioned, you should specify ServicePackageActivationMode as ExclusiveProcess at the time of creating the service.

Modifica del modello di hosting di un servizio esistenteChanging hosting model of an existing service

La modifica del modello di hosting di un servizio esistente da Processo condiviso a Exclusive Process (Processo esclusivo) e viceversa tramite un meccanismo di aggiornamento (o una specifica predefinita del servizio nel manifesto dell'applicazione) non è attualmente supportata.Changing hosting model of an existing service from Shared Process to Exclusive Process and vice-versa through upgrade or update mechanism (or in default service specification in application manifest) is currently not supported. Il supporto per questa funzionalità è previsto per una versione futura.Support for this feature will come in future versions.

Scelta tra i modelli Processo condiviso ed Exclusive Process (Processo esclusivo)Choosing between shared process and exclusive process model

Entrambi questi modelli di hosting presentano vantaggi e svantaggi e gli utenti devono scegliere quello più adatto alle specifiche esigenze.Both these hosting models have its pros and cons and user needs to evaluate which one fits their requirements best. Il modello Processo condiviso consente un migliore utilizzo delle risorse del sistema operativo in quanto viene generato un numero minore di processi, più repliche all'interno dello stesso processo possono condividere le porte e così via. Se, tuttavia, una delle repliche genera un errore per cui l'host del servizio deve essere arrestato, tale errore avrà un impatto negativo su tutte le altre repliche nello stesso processo.Shared Process model enables better utilization of OS resources because fewer processes are spawned, multiple replicas in the same process can share ports, etc. However, if one of the replicas hits an error where it needs to bring down the service host, it will impact all other replicas in same process.

Il modello Exclusive Process (Processo esclusivo) offre un migliore isolamento con ciascuna replica in un proprio processo e un errore di una replica non avrà conseguenze sulle altre repliche.Exclusive Process model provides better isolation with every replica in its own process and a misbehaving replica will not impact other replicas. Questo risulta utile nei casi in cui la condivisione delle porte non è supportata dal protocollo di comunicazione.It comes in handy for cases where port sharing is not supported by the communication protocol. Rende inoltre più semplice l'applicazione della governance delle risorse a livello di replica.It facilitates the ability to apply resource governance at replica level. D'altra parte, il modelloExclusive Process (Processo esclusivo) utilizza una maggiore quantità di risorse del sistema operativo e genera un processo per ciascuna replica sul nodo.On the other hand, Exclusive Process will consume more OS resources as it spawns one process for each replica on the node.

Considerazioni sul modello Exclusive Process (Processo esclusivo) e sul modello dell'applicazioneExclusive process model and application model considerations

Il metodo consigliato per modellare l'applicazione in Service Fabric consiste nel mantenere un ServiceType per ServicePackage. Questo modello offre buoni risultati per la maggior parte delle applicazioni.The recommended way to model your application in Service Fabric is to keep one ServiceType per ServicePackage and this model works well for most of the applications.

Service Fabric è destinato a determinati casi d'uso e consente più di un valore ServiceType per ogni oggetto ServicePackage (e un oggetto CodePackage può registrare più di un valore di ServiceType).Intended for certain use cases, Service Fabric also allows more than one ServiceType per ServicePackage (and one CodePackage can register more than one ServiceType). Di seguito sono descritti alcuni scenari in cui queste configurazioni possono essere utili:The following are some of the scenarios where these configurations can be useful:

  • Si desidera ottimizzare l'utilizzo delle risorse del sistema operativo generando un minor numero di processi e aumentando la densità di replica per processo.You want to optimize OS resource utilization by spawning fewer processes and having higher replica density per process.
  • Le repliche da diversi ServiceType devono condividere alcuni dati comuni caratterizzati da un alto costo di inizializzazione o memoria.Replicas from different ServiceTypes need to share some common data that has a high initialization or memory cost.
  • Si usa una versione gratuita di un servizio e si vuole limitare l'utilizzo delle risorse inserendo tutte le repliche del servizio nello stesso processo.You have a free service offering and you want to put a limit on resource utilization by putting all replicas of the service in same process.

Il modello di hosting Exclusive Process (Processo esclusivo) non è coerente con il modello dell'applicazione con più ServiceType per ServicePackage.Exclusive Process hosting model is not coherent with application model having multiple ServiceTypes per ServicePackage. Questo si verifica perché la configurazione con più ServiceType per ServicePackage è progettata per ottenere una maggiore condivisione delle risorse e consentire un aumento della densità di replica per processo.This is because multiple ServiceTypes per ServicePackage is designed to achieve higher resource sharing among replicas and enables higher replica density per process. Si tratta dell'opposto del risultato per cui è stato progettato il modello Exclusive Process (Processo esclusivo).This is contrary to what Exclusive Process model is designed to achieve.

Si consideri il caso di più ServiceType per ServicePackage con un diverso CodePackage che registra ciascun ServiceType.Consider the case of multiple ServiceTypes per ServicePackage with different CodePackage registering each ServiceType. Si supponga di avere un ServicePackage 'MultiTypeServicePackge' con due CodePackage:Let's say we have a ServicePackage 'MultiTypeServicePackge' which has two CodePackages:

  • 'MyCodePackageA', che registra il ServiceType 'MyServiceTypeA'.'MyCodePackageA' which registers ServiceType 'MyServiceTypeA'.
  • 'MyCodePackageB', che registra il ServiceType 'MyServiceTypeB'.'MyCodePackageB' which registers ServiceType 'MyServiceTypeB'.

A questo punto viene creata un'applicazione fabric:/SpecialApp. All'interno di fabric:/SpecialApp vengono quindi creati i due servizi seguenti con il modello Exclusive Process (Processo esclusivo):Now, lets say, we create an application fabric:/SpecialApp and inside fabric:/SpecialApp we create following two services with Exclusive Process model:

  • Servizio fabric:/SpecialApp/ServiceA di tipo 'MyServiceTypeA' con due partizioni, P1 e P2, e 3 repliche per partizione.Service fabric:/SpecialApp/ServiceA of type 'MyServiceTypeA' with two partitions (say P1 and P2) and 3 replicas per partition.
  • Servizio fabric:/SpecialApp/ServiceB di tipo 'MyServiceTypeB' con due partizioni, P3 e P4, e 3 repliche per partizione.Service fabric:/SpecialApp/ServiceB of type 'MyServiceTypeB' with two partitions (say P3 and P4) and 3 replicas per partition.

Su un determinato nodo, i servizi avranno due repliche ciascuno.On a given node, both the services will have two replicas each. Poiché per creare i servizi è stato usato il modello Exclusive Process (Processo esclusivo), Service Fabric attiverà una copia di 'MyServicePackge' per ogni replica.Since we used Exclusive Process model to create the services, Service Fabric will activate a new copy of 'MyServicePackge' for each replica. Ogni attivazione di 'MultiTypeServicePackge' avvierà una copia di 'MyCodePackageA' e 'MyCodePackageB'.Each activation of 'MultiTypeServicePackge' will start a copy of 'MyCodePackageA' and 'MyCodePackageB'. Tuttavia, solo uno tra 'MyCodePackageA' e 'MyCodePackageB' ospiterà la replica per la quale è stato attivato 'MultiTypeServicePackge'.However, only one of 'MyCodePackageA' or 'MyCodePackageB' will host the replica for which 'MultiTypeServicePackge' was activated. Il diagramma seguente mostra la visualizzazione del nodo:Following diagram shows the node view:

Visualizzazione del nodo dell'applicazione distribuita
Node view of deployed application

Come si può notare, nell'attivazione di 'MultiTypeServicePackge' per la replica della partizione P1 del servizio fabric:/SpecialApp/ServiceA, 'MyCodePackageA' ospita la replica mentre 'MyCodePackageB' è semplicemente in esecuzione.As we can see, in the activation of 'MultiTypeServicePackge' for replica of partition P1 of service fabric:/SpecialApp/ServiceA, 'MyCodePackageA' is hosting the replica and 'MyCodePackageB' is just up and running. Analogamente, nell'attivazione di 'MultiTypeServicePackge' per la replica della partizione P3 del servizio fabric:/SpecialApp/ServiceB, 'MyCodePackageB' ospita la replica mentre 'MyCodePackageA' è semplicemente in esecuzione.Similarly, in activation of 'MultiTypeServicePackge' for replica of partition P3 of service fabric:/SpecialApp/ServiceB, 'MyCodePackageB' is hosting the replica and 'MyCodePackageA' is just up and running and so on. Di conseguenza, più alto è il numero di CodePackage (che registrano ServiceType differenti) per ServicePackage, più elevato sarà l'utilizzo ridondante delle risorse.Hence, more the number of CodePackages (registering different ServiceTypes) per ServicePackage, higher will be redundant resource usage.

D'altra parte, se si creano i servizi fabric:/SpecialApp/ServiceA e fabric:/SpecialApp/ServiceB con il modello Processo condiviso, Service Fabric attiverà soltanto una copia di 'MultiTypeServicePackge' per l'applicazione fabric:/SpecialApp (come mostrato in precedenza).On the other hand if we create services fabric:/SpecialApp/ServiceA and fabric:/SpecialApp/ServiceB with Shared Process model, Service Fabric will activate only one copy of 'MultiTypeServicePackge' for application fabric:/SpecialApp (as we saw previously). 'MyCodePackageA' ospiterà tutte le repliche del servizio fabric:/SpecialApp/ServiceA (o, per maggiore precisione, di qualsiasi servizio di tipo 'MyServiceTypeA') e 'MyCodePackageB' ospiterà tutte le repliche del servizio fabric:/SpecialApp/ServiceB (o, per maggiore precisione, di qualsiasi servizio di tipo 'MyServiceTypeB').'MyCodePackageA' will host all replicas for service fabric:/SpecialApp/ServiceA (or of any service of type 'MyServiceTypeA' to be more precise) and 'MyCodePackageB' will host all replicas for service fabric:/SpecialApp/ServiceB (or of any service of type 'MyServiceTypeB' to be more precise). Il diagramma seguente mostra la visualizzazione del nodo in questa impostazione:Following diagram shows the node view in this setting:

Visualizzazione del nodo dell'applicazione distribuita
Node view of deployed application

Nell'esempio precedente, si potrebbe pensare che, se 'MyCodePackageA' registra sia 'MyServiceTypeA' che 'MyServiceTypeB' e non è presente alcun 'MyCodePackageB', non sarà in esecuzione alcun CodePackage ridondante.In the above example, you might think if 'MyCodePackageA' registers both 'MyServiceTypeA' and 'MyServiceTypeB' and there is no 'MyCodePackageB', then there will be no redundant CodePackage running. Si tratta di una considerazione corretta, ma, come indicato in precedenza, questo modello di applicazione non è coerente con il modello di hosting Exclusive Process (Processo esclusivo).This is correct, however, as mentioned previously, this application model does not align with Exclusive Process hosting model. Se l'obiettivo consiste nell'inserire ogni replica in un proprio processo dedicato, la registrazione di entrambi i ServiceType da parte dello stesso CodePackage non è necessaria e l'inserimento di ciascun ServiceType nel proprio ServicePacakge è una scelta più naturale.If goal is to put each replica in its own dedicated process then registering both ServiceTypes from same CodePackage is not needed and putting each ServiceType in its own ServicePacakge is a more natural choice.

Passaggi successiviNext steps

Creare il pacchetto di un'applicazione e prepararlo per la distribuzione.Package an application and get it ready to deploy.

Distribuire e rimuovere applicazioni con PowerShell: descrive come usare PowerShell per gestire le istanze dell'applicazione.Deploy and remove applications describes how to use PowerShell to manage application instances.