Governance delle risorseResource governance

Quando si eseguono più servizi sullo stesso nodo o cluster, è possibile che uno di essi consumi molte risorse a scapito degli altri servizi del processo.When you're running multiple services on the same node or cluster, it's possible that one service might consume more resources, starving other services in the process. Questo problema prende il nome di "noisy neighbor effect".This problem is referred to as the "noisy neighbor" problem. Azure Service Fabric consente allo sviluppatore di specificare prenotazioni e limiti per servizio per poter garantire le risorse e limitarne l'utilizzo.Azure Service Fabric enables the developer to specify reservations and limits per service to guarantee resources and limit resource usage.

Prima di procedere con questo articolo, è consigliabile acquisire familiarità con il modello di applicazione di Service Fabric e il modello di hosting di Service Fabric.Before you proceed with this article, we recommend that you get familiar with the Service Fabric application model and the Service Fabric hosting model.

Metriche di governance delle risorseResource governance metrics

In Service Fabric la governance delle risorse è supportata in base al pacchetto servizio.Resource governance is supported in Service Fabric in accordance with the service package. Le risorse assegnate al pacchetto servizio possono essere ulteriormente divise tra pacchetti di codice.The resources that are assigned to the service package can be further divided between code packages. I limiti di risorse specificati implicano anche la prenotazione delle stesse.The resource limits that are specified also mean the reservation of the resources. Service Fabric supporta la specifica di CPU e memoria per pacchetto servizio con due metriche predefinite:Service Fabric supports specifying CPU and memory per service package, with two built-in metrics:

  • CPU (nome della metrica servicefabric:/_CpuCores): core logico disponibile sul computer host.CPU (metric name servicefabric:/_CpuCores): A logical core that's available on the host machine. Tutti i core in tutti i nodi hanno lo stesso peso.All cores across all nodes are weighted the same.

  • Memoria (nome della metrica servicefabric:/_MemoryInMB): la memoria viene espressa in megabyte ed esegue il mapping alla memoria fisica disponibile nel computer.Memory (metric name servicefabric:/_MemoryInMB): Memory is expressed in megabytes, and it maps to physical memory that is available on the machine.

Per queste due metriche, Cluster Resource Manager rileva la capacità totale del cluster, il carico presente su ciascun nodo e le restanti risorse del cluster.For these two metrics, Cluster Resource Manager tracks total cluster capacity, the load on each node in the cluster, and the remaining resources in the cluster. Queste due metriche sono equivalenti a qualsiasi altra metrica utente o personalizzata.These two metrics are equivalent to any other user or custom metric. Possono essere usate tutte le funzionalità esistenti:All existing features can be used with them:

  • Il cluster può essere bilanciato in base a queste due metriche (comportamento predefinito).The cluster can be balanced according to these two metrics (default behavior).
  • Il cluster può essere deframmentato in base a queste due metriche.The cluster can be defragmented according to these two metrics.
  • Quando si descrive un cluster, è possibile impostare il buffer di capacità per queste due metriche.When describing a cluster, buffered capacity can be set for these two metrics.

La creazione di report sul carico dinamico non è supportata per queste metriche e i relativi carichi vengono definiti al momento della creazione.Dynamic load reporting is not supported for these metrics, and loads for these metrics are defined at creation time.

Meccanismi di governance delle risorseResource governance mechanism

Il runtime di Service Fabric attualmente non fornisce la prenotazione delle risorse.The Service Fabric runtime currently does not provide reservation for resources. Quando si apre un processo o un contenitore, il runtime imposta i limiti delle risorse sui carichi definiti al momento della creazione.When a process or a container is opened, the runtime sets the resource limits to the loads that were defined at creation time. Inoltre, il runtime non esegue l'apertura di nuovi pacchetti servizio disponibili quando vengono superate le risorse.Furthermore, the runtime rejects the opening of new service packages that are available when resources are exceeded. Per comprendere meglio il funzionamento del processo, si prenda come esempio un nodo con due core CPU (il meccanismo per la governance della memoria è lo stesso):To better understand how the process works, let's take an example of a node with two CPU cores (mechanism for memory governance is equivalent):

  1. In primo luogo, un contenitore viene inserito nel nodo. È richiesto un core CPU.First, a container is placed on the node, requesting one CPU core. Il runtime apre il contenitore e imposta il limite della CPU su un core.The runtime opens the container and sets the CPU limit to one core. Il contenitore non potrà usare più di un core.The container won't be able to use more than one core.

  2. Successivamente, una replica di un servizio viene inserita nel nodo e il pacchetto servizio corrispondente specifica un limite di un core CPU.Then, a replica of a service is placed on the node, and the corresponding service package specifies a limit of one CPU core. Il runtime apre il pacchetto di codice e imposta il limite della CPU su un core.The runtime opens the code package and sets its CPU limit to one core.

A questo punto, la somma dei limiti è uguale alla capacità del nodo.At this point, the sum of limits is equal to the capacity of the node. Un processo e un contenitore vengono eseguiti con un core ognuno e non interferiscono tra loro.A process and a container are running with one core each and not interfering with each other. Service Fabric non inserisce altri contenitori o repliche quando è specificato il limite di CPU.Service Fabric doesn't place any more containers or replicas when they are specifying the CPU limit.

Esistono tuttavia due casi in cui altri processi potrebbero contendersi la CPU.However, there are two situations in which other processes might contend for CPU. In queste situazioni, in un processo e in un contenitore dell'esempio potrebbe presentarsi il problema del noisy neighbor:In these situations, a process and a container from our example might experience the noisy neighbor problem:

  • Uso combinato di servizi e contenitori regolamentati e non regolamentati: se un utente crea un servizio senza specificare la governance delle risorse, il runtime ritiene che non consumi risorse e può inserirlo nel nodo dell'esempio precedente.Mixing governed and non-governed services and containers: If a user creates a service without any resource governance specified, the runtime sees it as consuming no resources, and can place it on the node in our example. In questo caso, il nuovo processo consuma CPU a spese dei servizi già in esecuzione sul nodo.In this case, this new process effectively consumes some CPU at the expense of the services that are already running on the node. Esistono due soluzioni a questo problema.There are two solution to this problem. Evitare l'uso combinato di servizi regolamentati e non regolamentati nello stesso cluster oppure usare vincoli di selezione host in modo che questi due tipi di servizi non vengano inseriti nello stesso set di nodi.Either don't mix governed and non-governed services on the same cluster, or use placement constraints so that these two types of services don't end up on the same set of nodes.

  • Quando un altro processo viene avviato nel nodo, al di fuori di Service Fabric (ad esempio, un servizio del sistema operativo): in questa situazione, anche il processo esterno a Service Fabric si contenderà la CPU con i servizi esistenti.When another process is started on the node, outside Service Fabric (for example, an OS service): In this situation, the process outside Service Fabric also contends for CPU with existing services. Per risolvere il problema, impostare correttamente le capacità del nodo per tenere conto del sovraccarico del sistema operativo, come descritto nella sezione seguente.The solution to this problem is to set up node capacities correctly to account for OS overhead, as shown in the next section.

Configurazione del cluster per l'abilitazione della governance delle risorseCluster setup for enabling resource governance

Quando un nodo viene avviato e aggiunto al cluster, Service Fabric rileva la quantità di memoria disponibile e il numero di core disponibili e quindi imposta le capacità del nodo per le due risorse.When a node starts and joins the cluster, Service Fabric detects the available amount of memory and the available number of cores, and then sets the node capacities for those two resources.

Per lasciare spazio nel buffer per il sistema operativo e per altri processi che potrebbero essere eseguiti nel nodo, Service Fabric usa solo l'80% delle risorse disponibili nel nodo.To leave buffer space for the operating system, and for other processes might be running on the node, Service Fabric uses only 80% of the available resources on the node. Questa percentuale è configurabile e può essere modificata nel manifesto del cluster.This percentage is configurable, and can be changed in the cluster manifest.

Di seguito è fornito un esempio di come impostare Service Fabric per usare il 50% della CPU disponibile e il 70% della memoria disponibile:Here is an example of how to instruct Service Fabric to use 50% of available CPU and 70% of available memory:

<Section Name="PlacementAndLoadBalancing">
    <!-- 0.0 means 0%, and 1.0 means 100%-->
    <Parameter Name="CpuPercentageNodeCapacity" Value="0.5" />
    <Parameter Name="MemoryPercentageNodeCapacity" Value="0.7" />
</Section>

Se è necessario configurare manualmente le capacità del nodo, è possibile usare il meccanismo standard per descrivere i nodi nel cluster.If you need full manual setup of node capacities, you can use the regular mechanism for describing the nodes in the cluster. Di seguito è riportato un esempio di come configurare il nodo con quattro core e 2 GB di memoria:Here is an example of how to set up the node with four cores and 2 GB of memory:

    <NodeType Name="MyNodeType">
      <Capacities>
        <Capacity Name="servicefabric:/_CpuCores" Value="4"/>
        <Capacity Name="servicefabric:/_MemoryInMB" Value="2048"/>
      </Capacities>
    </NodeType>

Se è abilitato il rilevamento automatico delle risorse disponibili e le capacità del nodo sono definite manualmente nel manifesto del cluster, Service Fabric controlla che il nodo abbia risorse sufficienti per soddisfare la capacità definita dall'utente:When auto-detection of available resources is enabled, and node capacities are manually defined in the cluster manifest, Service Fabric checks that the node has enough resources to support the capacity that the user has defined:

  • Se le capacità del nodo definite nel manifesto sono inferiori o uguali alle risorse disponibili nel nodo, Service Fabric usa le capacità specificate nel manifesto.If node capacities that are defined in the manifest are less than or equal to the available resources on the node, then Service Fabric uses the capacities that are specified in the manifest.

  • Se le capacità del nodo definite nel manifesto sono superiori alle risorse disponibili, Service Fabric usa le risorse disponibili come capacità del nodo.If node capacities that are defined in the manifest are greater than available resources, Service Fabric uses the available resources as node capacities.

Se non è necessario, è possibile disattivare il rilevamento automatico delle risorse disponibili.Auto-detection of available resources can be turned off if it is not required. Per disattivarlo, modificare l'impostazione seguente:To turn it off, change the following setting:

<Section Name="PlacementAndLoadBalancing">
    <Parameter Name="AutoDetectAvailableResources" Value="false" />
</Section>

Per ottenere prestazioni ottimali, nel manifesto del cluster è necessario attivare anche l'impostazione seguente:For optimal performance, the following setting should also be turned on in the cluster manifest:

<Section Name="PlacementAndLoadBalancing">
    <Parameter Name="PreventTransientOvercommit" Value="true" /> 
    <Parameter Name="AllowConstraintCheckFixesDuringApplicationUpgrade" Value="true" />
</Section>

Specificare la governance delle risorseSpecify resource governance

I limiti di governance delle risorse vengono specificati nel manifesto dell'applicazione (sezione ServiceManifestImport) come mostrato nell'esempio seguente:Resource governance limits are specified in the application manifest (ServiceManifestImport section) as shown in the following example:

<?xml version='1.0' encoding='UTF-8'?>
<ApplicationManifest ApplicationTypeName='TestAppTC1' ApplicationTypeVersion='vTC1' xsi:schemaLocation='http://schemas.microsoft.com/2011/01/fabric ServiceFabricServiceModel.xsd' xmlns='http://schemas.microsoft.com/2011/01/fabric' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>
  <Parameters>
  </Parameters>
  <!--
  ServicePackageA has the number of CPU cores defined, but doesn't have the MemoryInMB defined.
  In this case, Service Fabric sums the limits on code packages and uses the sum as 
  the overall ServicePackage limit.
  -->
  <ServiceManifestImport>
    <ServiceManifestRef ServiceManifestName='ServicePackageA' ServiceManifestVersion='v1'/>
    <Policies>
      <ServicePackageResourceGovernancePolicy CpuCores="1"/>
      <ResourceGovernancePolicy CodePackageRef="CodeA1" CpuShares="512" MemoryInMB="1000" />
      <ResourceGovernancePolicy CodePackageRef="CodeA2" CpuShares="256" MemoryInMB="1000" />
    </Policies>
  </ServiceManifestImport>

In questo esempio il pacchetto servizio denominato ServicePackageA ottiene un core nei nodi in cui viene inserito.In this example, the service package called ServicePackageA gets one core on the nodes where it is placed. Il pacchetto servizio contiene due pacchetti di codice, CodeA1 e CodeA2, che specificano entrambi il parametro CpuShares.This service package contains two code packages (CodeA1 and CodeA2), and both specify the CpuShares parameter. La proporzione CpuShares 512:256 divide la memoria centrale tra i due pacchetti di codice.The proportion of CpuShares 512:256 divides the core across the two code packages.

Di conseguenza, in questo esempio CodeA1 ottiene due terzi di un core e CodeA2 ne ottiene un terzo, oltre a una prenotazione con garanzia flessibile dello stesso core.Thus, in this example, CodeA1 gets two-thirds of a core, and CodeA2 gets one-third of a core (and a soft-guarantee reservation of the same). Se CpuShares non viene specificato per i pacchetti di codice, Service Fabric divide i core in parti uguali tra di essi.If CpuShares are not specified for code packages, Service Fabric divides the cores equally among them.

I limiti di memoria sono assoluti, motivo per cui i pacchetti di codice sono limitati a 1024 MB di memoria, con prenotazione a garanzia flessibile.Memory limits are absolute, so both code packages are limited to 1024 MB of memory (and a soft-guarantee reservation of the same). I pacchetti di codice (contenitori o pacchetti) non possono allocare una quantità di memoria superiore a questo limite. Un'operazione di questo tipo genererebbe un'eccezione di memoria insufficiente.Code packages (containers or processes) can't allocate more memory than this limit, and attempting to do so results in an out-of-memory exception. Perché l'imposizione di un limite di risorse funzioni, è necessario che tutti i pacchetti di codice inclusi in un pacchetto del servizio abbiano limiti di memoria specificati.For resource limit enforcement to work, all code packages within a service package should have memory limits specified.

Altre risorse per i contenitoriOther resources for containers

Oltre alla CPU e alla memoria, è possibile specificare i limiti di altre risorse per i contenitori.Besides CPU and memory, it's possible to specify other resource limits for containers. Questi limiti sono specificati a livello di pacchetto di codice e vengono applicati quando il contenitore viene avviato.These limits are specified at the code-package level and are applied when the container is started. A differenza di CPU e memoria, Cluster Resource Manager non riconosce queste risorse e non esegue verifiche della capacità o il bilanciamento del carico.Unlike with CPU and memory, Cluster Resource Manager isn't aware of these resources, and won't do any capacity checks or load balancing for them.

  • MemorySwapInMB: quantità di memoria di scambio che un contenitore può usare.MemorySwapInMB: The amount of swap memory that a container can use.
  • MemoryReservationInMB: limite flessibile per la governance della memoria che viene applicato solo quando si verificano problemi di contesa della memoria sul nodo.MemoryReservationInMB: The soft limit for memory governance that is enforced only when memory contention is detected on the node.
  • CpuPercent: percentuale di CPU che il contenitore può usare.CpuPercent: The percentage of CPU that the container can use. Se vengono specificati dei limiti di CPU per il pacchetto del servizio, questo parametro viene ignorato.If CPU limits are specified for the service package, this parameter is effectively ignored.
  • MaximumIOps: numero massimo di IOPS che un contenitore può usare (lettura e scrittura).MaximumIOps: The maximum IOPS that a container can use (read and write).
  • MaximumIOBytesps: I/O massimo (byte al secondo) che un contenitore può usare (lettura e scrittura).MaximumIOBytesps: The maximum IO (bytes per second) that a container can use (read and write).
  • BlockIOWeight: peso di I/O del blocco rispetto agli altri contenitori.BlockIOWeight: The block IO weight for relative to other containers.

Queste risorse possono essere usate in combinazione con CPU e memoria.These resources can be combined with CPU and memory. Di seguito è riportato un esempio di come specificare risorse aggiuntive per i contenitori:Here is an example of how to specify additional resources for containers:

    <ServiceManifestImport>
        <ServiceManifestRef ServiceManifestName="FrontendServicePackage" ServiceManifestVersion="1.0"/>
        <Policies>
            <ResourceGovernancePolicy CodePackageRef="FrontendService.Code" CpuPercent="5"
            MemorySwapInMB="4084" MemoryReservationInMB="1024" MaximumIOPS="20" />
        </Policies>
    </ServiceManifestImport>

Passaggi successiviNext steps