Procédure : inscrire un compteur de performance ou annuler l’inscription

Dernière modification : jeudi 3 mars 2011

S’applique à : SharePoint Foundation 2010

Cette rubrique explique comment inscrire un compteur de performance Windows Server 2008 pour une analyse par l’analyse des performances Microsoft SharePoint Foundation et la limitation des requêtes HTTP, et comment supprimer un compteur de performance du système.

Important

L’exemple de cette rubrique utilise une application console. Quel que soit le type du projet, il est très important de définir l’infrastructure .NET Framework et l’unité centrale cible correctes. Le projet doit cibler. et l’unité centrale cible correctes. Le projet doit cibler Microsoft .NET Framework 3.5 (et non pas .NET Framework 4). L’unité centrale cible doit être Any CPU ou x64. Pour plus d’informations sur le choix, voir Procédure : définir le Framework et l’unité centrale cibles adéquats. L’unité centrale cible est généralement x86 par défaut. Pour la changer, cliquez avec le bouton droit sur le nom du projet dans l’Explorateur de solutions et sélectionnez Propriétés. Vous pouvez changer l’unité centrale sur l’onglet Version en utilisant la liste déroulante Plateforme cible.

Persistance des compteurs et des calculatrices de score d’intégrité

Les compteurs de performance du système de limitation des requêtes HTTP sont créés à l’exécution, comme objets SPSystemPerformanceCounterMonitor, par l’infrastructure du système. Un tel objet est créé pour chaque objet SPPerformanceMonitorCreationData de la propriété persistante PerformanceMonitors de l’objet SPHttpThrottleSettings qui est lui-même persistant dans la propriété HttpThrottleSettings de l’application Web. Cependant, votre code n’appelle pas un constructeur pour la classe SPPerformanceMonitorCreationData. Il appelle à la place la méthode SPHttpThrottleSettings.AddPerformanceMonitor(). Cette méthode construit l’objet SPPerformanceMonitorCreationData et l’ajoute à la collection PerformanceMonitors. Une propriété importante de la classe SPPerformanceMonitorCreationData est AssociatedHealthScoreCalculator. La calculatrice de score d’intégrité est également créée pour vous par la méthode SPHttpThrottleSettings.AddPerformanceMonitor(). Votre code n’appelle le constructeur de SPBucketHealthScoreCalculator qu’une seule fois : lorsque vous créez une calculatrice afin de la permuter avec la calculatrice existante d’un compteur de performance déjà inscrit.

Pour créer la solution Visual Studio

1. Créez un projet d’application console dans Microsoft Visual Studio et définissez l’infrastructure .NET Framework et la plateforme d’unité centrale cibles.

2. Ajoutez une référence à Microsoft.SharePoint.dll au projet. Le fichier se trouve dans ISAPI %ProgramFiles%\Common Files\Microsoft Shared\web server extensions\14\.

3. Ouvrez le fichier program.cs, définissez un espace de noms et un nom de classe appropriés, puis ajoutez des instructions using pour System.Threading, Microsoft.SharePoint, Microsoft.SharePoint.Administration et Microsoft.SharePoint.Utilities. Votre code doit maintenant se présenter comme suit :

   using System;
   using Microsoft.SharePoint; 
   using Microsoft.SharePoint.Administration;
   using Microsoft.SharePoint.Utilities;
   
   namespace Contoso.SharePoint.Utilities
   {
       class PerformanceCounterRegistrar
       {
           static void Main(string[] args)
           {
   
           }
   // end Main
       }
   }
   

Pour ajouter un compteur de performance

1. Dans la méthode Main, déclarez un tableau de valeurs Double qui définissent les limites des compartiments que la calculatrice de score d’intégrité utilise pour affecter des scores d’intégrité aux valeurs. Les compartiments sont des sous-plages des valeurs possibles des compteurs. Le tableau doit remplir les conditions suivantes :

   • Les valeurs des éléments doivent être correctement ordonnées, de la plus petite à la plus grande ou de la plus grande à la plus petite.

   • Les valeurs doivent aussi être correctement ordonnées de la plus intègre à la moins intègre. Ainsi, si buckets est le nom de l’objet tableau, buckets[0] est une valeur plus intègre que buckets[1], buckets[1] est plus intègre que buckets[2], et ainsi de suite. Par conséquent, buckets[buckets.Length-1] doit toujours être la valeur la moins intègre de buckets.

   Un tableau de 10 éléments, taille standard des tableaux qui définissent les compartiments de performance, crée 11 compartiments : les valeurs plus intègres que buckets[0] se trouvent dans le premier compartiment, tandis que les valeurs moins intègres que buckets[10] se trouvent dans le onzième compartiment. La calculatrice de score d’intégrité attribuera un score d’intégrité à une valeur (ou au résultat d’une fonction sur plusieurs valeurs) en fonction du compartiment auquel la valeur appartient. Le score sera un Int32 compris entre 0 et 10. Les valeurs du compartiment le plus intègre obtiennent 0 et celles du compartiment le moins intègre 10. Le tableau peut avoir moins de 10 éléments. Par exemple, imaginons que les valeurs possibles d’un hypothétique compteur de performance soient comprises entre 0 et 50,0 (avec les valeurs basses indiquant l’intégrité), et que les nombres 10,0, 20,0, 30,0 et 40,0 soient utilisés comme limites des compartiments. Dans ce scénario, un objet de la classe de la calculatrice de score d’intégrité standard, SPBucketHealthScoreCalculator, génère les scores d’intégrité selon les règles suivantes :

   • 0 pour les valeurs de performance inférieures à 10

   • 3 pour les valeurs comprises entre 10,0 et 20,0

   • 5 pour les valeurs comprises entre 20,0 et 30,0

   • 8 pour les valeurs comprises entre 30,0 et 40,0

   • 10 pour les valeurs supérieures à 40,0

   Lors de la construction de votre tableau de compartiments, il importe de garder présent à l’esprit que le système de limitation des requêtes ne passe en mode limitation que si au moins un compteur analysé possède un score égal à 10 (basé sur une moyenne pondérée de plusieurs échantillons du compteur). Par conséquent, pour un tableau de 10 éléments ou moins, le choix de la valeur du dernier élément du tableau est crucial. Il doit s’agir d’une valeur qui indique un degré d’intégrité médiocre suffisamment extrême pour justifier le blocage de certaines requêtes HTTP. De même, pour un tableau de 20 éléments, les valeurs qui sont moins intègres que l’avant-dernier élément obtiennent un score de 10.

   Notes

   Le tableau peut avoir juste un élément, auquel cas les valeurs moins intègres que la valeur de l’élément unique obtiennent un score d’intégrité égal à 10 et tous les autres un score de 0. Comme aucune valeur inférieure à 10 ne déclenchera la limitation, pourquoi se préoccuper d’avoir plus d’un élément dans le tableau ? Autrement dit, pourquoi ne pas avoir un système binaire de scores d’intégrité : « intègre » et « non intègre » ? La réponse est que le score d’intégrité du compteur le moins intègre est ajouté à l’en-tête de l’objet réponse HTTP, même s’il est inférieur à 10 et, ainsi, il n’y a aucune limitation. Si cette valeur peut varier sur une plage de valeurs plus étendue que deux, les clients peuvent utiliser la valeur rapportée pour noter les tendances d’intégrité de la batterie. Les applications clientes peuvent aussi utiliser le score d’intégrité pour améliorer la synchronisation avec le serveur. Par exemple, une application cliente pourrait définir un plus long intervalle de synchronisation pour les scores d’intégrité plus élevés (intégrité moindre). (Certaines applications Microsoft Office procèdent ainsi.) En revanche, le fait d’avoir plus de 10 éléments dans le tableau présente peu d’intérêt, car il n’y a que onze scores d’intégrité possibles, d’autant plus que la présence de 11 compartiments se traduirait par le même score d’intégrité pour les valeurs de deux compartiments consécutifs ou plus. Comme signalé ci-dessus, toutefois, vous pouvez avoir moins de 10 éléments, situation qui peut être appropriée pour certains types de compteurs de performance.

   Le code suivant montre la déclaration d’un tableau qui est destiné à créer des compartiments pour le compteur Windows Server 2008 appelé « Processeur\% Temps processeur\_Total ». Ce compteur indique, en pourcentage, le temps passé par les processeurs du serveur sur les processus autres que le processus système inactif. Pour plus d’informations sur ce compteur, voir Objet processeur (éventuellement en anglais).

   double[] busyProcessorBuckets = new double[10] {20.0, 28.8, 37.6, 46.4, 55.2, 64.0, 72.8, 81.6, 90.4, 99.2}; 
   

   Dans cet exemple, la différence entre deux valeurs quelconques est la même. Cela n’a pas nécessairement besoin d’être le cas. Pour certains types de compteurs, il peut être approprié d’avoir des valeurs qui progressent de façon exponentielle. Notez, aussi, que, dans cet exemple, les valeurs sont en ordre croissant. Cependant, pour certains types de compteurs de performance, les valeurs plus élevées sont plus intègres que les valeurs plus basses. Comme le tableau des compartiments doit être ordonné du plus intègre au moins intègre, les valeurs doivent, pour ce type de compteur, y être classées par ordre décroissant.

2. Toujours dans la méthode Main, obtenez une référence à l’application Web, puis obtenez une référence aux paramètres d’accélération en appelant la méthode GetHttpThrottleSettings(SPPersistedObject). C’est ce que montre l’exemple suivant :

   Uri webApplicationUri = new Uri("Http://localhost/");
   SPWebApplication webApplication = SPWebApplication.Lookup(webApplicationUri);
   SPHttpThrottleSettings throttleSettings = SPHttpThrottleSettings.GetHttpThrottleSettings(webApplication);
   

3. Toujours dans la méthode Main, appelez la méthode SPHttpThrottleSettings.AddPerformanceMonitor(), en passant comme paramètres le nom du compteur, sa catégorie, son instance et le tableau des compartiments. Passez true ou false comme dernier paramètre, selon que le tableau est en ordre croissant ou en ordre décroissant. L’exemple se poursuit avec le code suivant.

   throttleSettings.AddPerformanceMonitor("Processor",
                                          "% Processor Time",
                                          "_Total",
                                          busyProcessorBuckets,
                                          true);
   

   Conseil
   La méthode SPHttpThrottleSettings.AddPerformanceMonitor() ne contrôle pas s’il existe déjà un compteur de performance qui analyse la même instance du même compteur. Les appels suivants de la méthode, avec les mêmes paramètres, inscrivent les objets de compteur de performance redondants.

Pour vérifier que le compteur de performance a été inscrit

• Utilisez l’SharePoint Management Shellapplet de commandeGet-SPWebApplicationHttpThrottlingMonitor pour obtenir la liste des compteurs de performance inscrits pour l’application Web. Le code suivant illustre la syntaxe de l’appel de l’applet de commande :

  Get-SPWebApplicationHttpThrottlingMonitor –identity http://<Web application URL>
  

  La sortie du compteur de performance nouvellement inscrit se présente comme suit :

  Category                        : Processor
  Counter                         : % Processor Time
  Instance                        : _Total
  AssociatedHealthScoreCalculator : [20.0,28.8,37.6,46.4,55.2,64.0,72.8,81.6,90.4,99.2]
  

Pour annuler l’inscription d’un compteur de performance

• L’annulation de l’inscription d’un compteur de performance est similaire à l’inscription, à la différence que votre code appelle RemovePerformanceMonitor(). Une surcharge de cette méthode annule l’inscription de tous les compteurs de performance qui ont une catégorie, un compteur et un nom d’instance spécifiques. Comme une seconde surcharge annule l’inscription de tous les compteurs avec une catégorie et un nom de compteur donnés, si différents compteurs analysent différentes instances d’un compteur spécifique, ils peuvent tous être supprimés en un seul appel. L’exemple suivant illustre l’utilisation de la méthode RemovePerformanceMonitor() pour supprimer le compteur de l’exemple proposé :

  Uri webApplicationUri = new Uri("Http://localhost/");
  SPWebApplication webApplication = SPWebApplication.Lookup(webApplicationUri);
  SPHttpThrottleSettings throttleSettings = SPHttpThrottleSettings.GetHttpThrottleSettings(webApplication);
  
  // Remove the monitor. 
  throttleSettings.RemovePerformanceMonitor("Processor",
                                            "% Processor Time",
                                            "_Total");
  

Voir aussi

Concepts

Limitation des requêtes