Exporter (0) Imprimer
Développer tout

Procédure : utilisation d'Azure In-Role Cache dans Azure Cloud Service

Mis à jour: mai 2015

La mise en cache peut améliorer la performance des applications web dans vos projets de service cloud Azure en réduisant la nécessité de calculer de façon répétée les mêmes résultats. Lorsque vous utilisez la mise en cache, les contenus fréquemment demandés et d'autres données peuvent être calculés une fois et stockés plusieurs fois.

En suivant cette rubrique, vous pouvez ajouter la prise en charge de la mise en cache à vos projets de service cloud Azure. Avec Azure In-Role Cache, vous définissez des rôles qui sont dédiés à la mise en cache ou vous utilisez des ressources qui, autrement, seraient inutilisées dans un rôle pour la mise en cache. Par exemple, si votre rôle web utilise seulement la moitié des ressources disponibles dans chaque instance, vous pouvez utiliser ces ressources pour mettre en cache des données en sortie, d'état de session ou fréquemment utilisées.

Vous configurez la mise en cache dans les fichiers .cscfg et .csdef pour votre application de service cloud Azure. Vous pouvez effectuer cette configuration plus facilement en utilisant les paramètres de la page de propriétés Mise en cache pour un rôle. Pour utiliser un cache dans un rôle particulier, ajoutez des informations aux fichiers de configuration XML pour ce rôle. Dans un rôle web ASP.NET, le fichier de configuration approprié est web.config. Pour d'autres rôles, le fichier de configuration est app.config. Vous pouvez ajouter les informations au fichier de configuration manuellement ou via un package NuGet.

Vous pouvez configurer la mise en cache de deux manières. Vous pouvez ajouter la mise en cache pour un service cloud en ajoutant un rôle de travail du cache qui est dédié à la mise en cache, ou vous pouvez configurer la mise en cache pour utiliser la mémoire, l'UC et des ressources de bande passante sur un rôle déjà existant. Un cache dédié s'exécute comme rôle distinct. Cette option est appropriée si vous souhaitez que les ressources de vos instances soient dédiées exclusivement à l'exécution de ces instances. Un cache colocalisé s'exécute dans la même instance qu'un autre rôle. Cette option est un bon choix si vous avez des instances de rôles qui n'utilisent pas pleinement les ressources de l'ordinateur sur lequel elles s'exécutent.

Cette rubrique contient les sections suivantes.

Vous pouvez ajouter la mise en cache à un rôle existant, ou vous pouvez créer un rôle de travail du cache que vous pouvez utiliser à partir d'autres rôles.

  1. Ouvrez le menu contextuel du projet de service cloud Azure, puis choisissez Nouveau projet de rôle de travail.

  2. Dans la liste des modèles de projet, choisissez le modèle Rôle de travail du cache, puis spécifiez un nom pour le projet, par exemple RôleTravailCache1.

    Un projet de rôle de travail est créé.

  3. Sous le projet de service cloud Azure, développez le nœud Rôles, ouvrez le menu contextuel pour le rôle de travail du cache que vous venez de créer, puis choisissez Propriétés.

    Le concepteur de rôle pour ce projet apparaît.

  4. Sous l'onglet Configuration, définissez la taille appropriée de la machine virtuelle et le nombre d'instances de ce rôle.

  5. Sous l'onglet Mise en cache, notez que sous Paramètres du cluster de cache, Rôle dédié est sélectionné.

  6. Configurez le comportement souhaité pour le cache par défaut ou créez des caches nommés avec des propriétés personnalisées.

    Chaque cache nommé possède son propre ensemble de propriétés configurables. Pointez vers les en-têtes de tableau pour afficher des informations sur la façon dont vous pouvez configurer chaque cache nommé. Pour plus d'informations, consultez Procédure : configuration d'un cache Azure In-Role Cache.

  1. Dans le projet de service cloud Azure, développez le nœud Rôles, ouvrez le menu contextuel pour le rôle auquel vous voulez ajouter la mise en cache, puis choisissez Propriétés.

  2. Sous l'onglet Mise en cache, cochez la case Activer la mise en cache.

  3. Choisissez l'option Colocalisé, puis sélectionnez un pourcentage des ressources mémoire de la machine virtuelle qui héberge le rôle à dédier au cache. En général, ce nombre doit être compris entre 30 et 55 % pour une petite machine virtuelle et aller jusqu'à 80 % pour une très grande machine virtuelle. Optimisez ce nombre à l'aide du Bureau à distance pour vous connecter à la machine virtuelle lorsque votre service cloud s'exécute sous une charge normale, puis en utilisant le Gestionnaire des tâches pour afficher le pourcentage de mémoire physique. Vous pouvez utiliser le reste de la mémoire pour un cache colocalisé.

  4. Configurez le comportement souhaité pour le cache par défaut ou créez des caches nommés avec des propriétés personnalisées.

Vous pouvez ajouter les références de mise en cache à votre projet de service cloud manuellement, comme le décrit cette section, ou vous pouvez utiliser NuGet, comme décrit dans Utilisation de NuGet pour ajouter la mise en cache à un rôle plus loin dans cette rubrique. L'ajout manuel des références vous permet de voir où les assemblys existent sur le disque, mais cette opération est plus fastidieuse.

  1. Dans le menu contextuel du nœud Références, sous le projet de service cloud qui contient le rôle où vous voulez utiliser un cache, choisissez Ajouter une référence.

  2. Dans la boîte de dialogue Ajouter une référence, cochez les cases appropriées pour ajouter des références aux assemblys suivants, puis cliquez sur le bouton OK :

    • Microsoft.ApplicationServer.Caching.AzureClientHelper

    • Microsoft.ApplicationServer.Caching.Client

    • Microsoft.ApplicationServer.Caching.Core

    • Microsoft.Web.DistributedCache

  3. Dans le projet qui contient le rôle auquel vous souhaitez ajouter la mise en cache, ouvrez le fichier web.config d'un projet de rôle web ou ouvrez le fichier app.config pour d'autres types de projet.

  4. Si la section configSections n'existe pas, ajoutez-la. Dans cette section, ajoutez une déclaration de la section de mise en cache, comme le montre le code suivant.

    <configSections>
        <section name="dataCacheClients" type="Microsoft.ApplicationServer.Caching.DataCacheClientsSection, Microsoft.ApplicationServer.Caching.Core" allowLocation="true" allowDefinition="Everywhere"/>
      </configSections>
    
    
  5. Ajoutez du code XML qui identifie le cache nommé à utiliser.

    <dataCacheClients>
        <tracing sinkType="DiagnosticSink" traceLevel="Verbose"/>
        <dataCacheClient name="default">
          <autoDiscover isEnabled="true" identifier="WebRole1"/>
        </dataCacheClient>
      </dataCacheClients>
    
    

    Si vous déclarez un seul cache, le nom peut être default, comme le montre l'exemple précédent. Si vous déclarez plusieurs caches, ajoutez une section dataCacheClient distincte pour chaque cache et donnez un nom unique à chaque cache. Le cache qui est nommé par défaut est retourné lorsque, dans le code, vous appelez la méthode GetDefaultCache sur l'objet DataCacheFactory. L'attribut identifier spécifie le nom du projet de rôle web auquel vous avez ajouté la prise en charge de la mise en cache ou un rôle de travail du cache.

    Maintenant que vous avez configuré un cache distribué dans ce rôle, accédez-y à partir d'un code en créant un DataCacheFactory et un objet DataCache.

  6. Dans un fichier code-behind, ajoutez des déclarations à votre classe Page et ajoutez un générateur de nombres aléatoires afin d'avoir des données pour tester le cache.

            static DataCacheFactory myFactory;
            static DataCache myCache;
            static Random randomizer = new Random();
    
    
  7. Pour créer une application web qui utilise le cache, remplacez le code dans la page web Default.aspx par le code suivant.

    <%@ Page Title="Home Page" Language="C#" MasterPageFile="~/Site.master" AutoEventWireup="true"
        CodeBehind="Default.aspx.cs" Inherits="WebRole1._Default" %>
    
    <asp:Content ID="HeaderContent" runat="server" ContentPlaceHolderID="HeadContent">
    </asp:Content>
    <asp:Content ID="BodyContent" runat="server" ContentPlaceHolderID="MainContent">
     
         <p style="font-size:large; height: 283px;">
            <asp:Label ID="Label0" runat="server" Text="Text for the cache:   " />
            <asp:TextBox runat="server" ID="TextBox1" Width="125" /> <br /> <br />
    
            <asp:Button runat="server" onclick="OnPutInCache" Text="Put in Cache" id="AddCachedItemsButton" /> &nbsp;&nbsp;&nbsp;
            <asp:Button runat="server" onclick="OnGetFromCache" Text="Get from Cache" id="GetCachedItemsButton" /> &nbsp;&nbsp;&nbsp;
            <asp:Label ID="Label1" runat="server" Width="500" />
    
            <br /> <br />  <br /> 
        
            Cached Datestamp: <%= DateTime.Now.ToString() %><br />
            Fresh Datestamp: <asp:Substitution runat="server" methodname="GetFreshDateTime" id="UnCachedArea" /><br /><br />
        </p>
    
    </asp:Content>
    
    
    
  8. Ajoutez du code pour initialiser le cache.

            protected void Page_Load(object sender, EventArgs e)
            {
                try
                {
                    //Get a named cache (or default cache)
                    if (myCache == null)
                    {
                        // You should initialize the data cache factory
                        // once and keep reusing the same object.
                        myFactory = new DataCacheFactory();
                        myCache = myFactory.GetDefaultCache();
                        // If you want to get a handle to a named cache
                        // that is not the default cache, supply the
                        // cache's name from the configuration file:
                        // myCache = myFactory.GetCache("anotherNamedCache");
                    }
                }
                catch (DataCacheException dce)
                {
                    Label1.Text = dce.ToString();
                }
            }
    
    

    Ce code d'initialisation doit être appelé avant toute tentative d'utilisation du cache. Par exemple, vous pouvez ajouter ce code au gestionnaire d'événements Page_Load. Sinon, un handle vers le cache est créé à l'aide de la méthode de fabrique du cache GetDefaultCache(). Si aucun nom de cache n'est spécifié, le cache nommé Défaut est utilisé. L'exception DataCacheException peut être levée chaque fois que vous travaillez avec des méthodes de cache. Le code précédent intercepte cette exception et l'affiche à l'utilisateur sur un contrôle Label.

  9. Ajoutez le code pour utiliser le cache.

            /// <summary>
            /// Adds the value of the TextBox to the cache
            /// </summary>
            protected void OnPutInCache(object sender, EventArgs e)
            {
                try
                {
                    myCache.Put("MyKey", TextBox1.Text);
                    Label1.Text = " \" " + TextBox1.Text + "\" has been added to the cache.";
                }
                catch (DataCacheException dce)
                {
                    Label1.Text = dce.ToString();
                }
            }
    
    

    L'exemple qui précède suppose un simple formulaire web comprenant une zone de texte et un bouton, mais vous pouvez utiliser le même code pour mettre en cache n'importe quelles données. Comme le montre l'exemple, vous utilisez la méthode Put pour ajouter des données dans le cache. Le cache fonctionne comme un dictionnaire. Le premier argument est la clé ; le second argument correspond aux données que vous souhaitez mettre en cache.

  10. Récupérez des données de la mise en cache en appelant la méthode Get et en fournissant la clé.

            /// <summary>
            /// Gets the cached item (that was added from the TextBox)
            /// </summary>
            protected void OnGetFromCache(object sender, EventArgs e)
            {
                try
                {
                    string outputFromCache = myCache.Get("MyKey") as string;
                    Label1.Text = "\"" + outputFromCache + "\" has been retrieved from the cache.";
                }
                catch (DataCacheException dce)
                {
                    Label1.Text = dce.ToString();
                }
            }
    
    

La mise en cache de sortie améliore les performances d'un site web en réduisant le besoin de régénérer les données qui ont déjà été récupérées. En modifiant le fichier de configuration de l'application web, vous pouvez utiliser le cache distribué pour mettre en cache la sortie d'une application ASP.NET sans modifier le code de votre programme. Consultez Procédure : configuration d'un cache Azure In-Role Cache pour plus d'informations.

  1. Ouvrez le fichier web.config pour l'application ASP.NET pour laquelle vous souhaitez configurer la mise en cache de sortie.

  2. Ajoutez les lignes suivantes pour configurer la mise en cache de la sortie afin d'utiliser le cache distribué.

        <caching>
          <outputCache defaultProvider="defaultProvider" >
            <providers>
              <add cacheName="default"
                   name="defaultProvider"
                   dataCacheClientName="nameOfDataCacheClient"
                   applicationName="<unique-appId>"
                   type= "Microsoft.Web.DistributedCache.DistributedCacheOutputCacheProvider, Microsoft.Web.DistributedCache" />
            </providers>
          </outputCache>
        </caching>
    
    

    Pour le nom de cache, spécifiez le nom du cache nommé approprié, qui est hébergé par le dataCacheClient spécifié. L'attribut dataCacheClient spécifie le rôle qui héberge le cache.

  3. Ajoutez la directive OutputCache dans les pages où vous souhaitez mettre en cache la sortie.

    <%@ OutputCache Duration="60" VaryByParam="*" %>
    

    La durée est l'intervalle de temps, en secondes, pendant lequel les données doivent rester dans le cache. VaryByParam indique qu'une version différente de la page doit être mise en cache pour chaque combinaison de paramètres. L'astérisque (*) dans ce contexte signifie varier selon tous les paramètres. Vous pouvez aussi spécifier des paramètres par nom. Pour une description complète des options disponibles, consultez Directive OutputCache

    Vous avez configuré le cache de sortie.

Cette section vous montre comment mettre en cache les informations d'état de session d'une application web ASP.NET sans modifier son code.

  1. Ouvrez le fichier web.config pour l'application web ASP.NET pour laquelle vous souhaitez configurer la mise en cache d'état de session.

  2. Ajoutez les lignes suivantes et spécifiez le nom du cache que vous souhaitez utiliser (dans ce cas, « default »), le nom du fournisseur, le nom de dataCacheClient et l'appId de l'application.

        <!--Set up custom session state provider -->
        <sessionState mode="Custom" customProvider="defaultProvider">
          <providers>
            <add cacheName="default"
                 name="defaultProvider"
                 dataCacheClientName="nameOfDataCacheClient"
                 applicationName="<unique-appId>"
                 type= "Microsoft.Web.DistributedCache.DistributedCacheSessionStateStoreProvider, Microsoft.Web.DistributedCache"/>
          </providers>
        </sessionState>
    
    

Vous pouvez créer et configurer plusieurs caches nommés à des fins différentes. Par exemple, vous pouvez utiliser un cache de sortie et un cache par programme pour les données.

  1. Ouvrez l'onglet Mise en cache du concepteur de rôle pour un rôle.

  2. Sous Caches nommés, ajoutez un cache nommé pour la sortie et un autre pour les informations d'état de session.

  3. Dans la table Caches nommés, définissez les propriétés pour les caches nommés.

    Par exemple, vous pouvez définir la politique d'éviction sur TTL pour le cache de sortie et sur Aucun pour le cache d'état de session.

  4. Ouvrez le fichier web.config, puis utilisez les nouvelles valeurs pour les attributs cacheName dans les sections outputCache et sessionState.

Vous pouvez ajouter la mise en cache à un rôle existant plus facilement à l'aide de NuGet, qui est un gestionnaire de package. Une fois que vous avez installé Azure Tools, NuGet peut ajouter les références appropriées et apporter les modifications nécessaires à vos fichiers de configuration.

  1. Assurez-vous d'avoir la dernière version de NuGet installée.

    Pour plus d'informations et obtenir des instructions d'installation, consultez NuGet.

  2. Dans l'Explorateur de solutions, ouvrez le menu contextuel pour le nœud de projet du rôle auquel vous souhaitez ajouter la mise en cache, puis choisissez Gérer les packages NuGet.

    La boîte de dialogue Gérer les packages NuGet s'affiche.

  3. Dans la galerie en ligne, sélectionnez Azure In-Role Cache, puis cliquez sur le bouton Installer.

    Le projet est modifié, des références aux assemblys de mise en cache sont ajoutées et des fichiers de configuration sont mis à jour pour configurer un cache.

  4. Dans le fichier de configuration pour le projet, recherchez l'élément dataCacheClient qui a un élément enfant autoDiscover.

  5. Dans cet élément enfant, modifiez la valeur de l'attribut identifier en le remplaçant par le nom du rôle qui fournit le cache.

        <dataCacheClient name="default">
          <autoDiscover isEnabled="true" identifier="CacheWorkerRole1"/>
        </dataCacheClient>
    
    
  6. Pour démarrer l'utilisation du cache, modifiez votre code comme décrit précédemment dans cette rubrique.

    Pour activer un cache d'état de session ou un cache de sortie, modifiez le fichier de configuration pour le rôle approprié et apportez d'autres modifications comme décrit précédemment dans cette rubrique. Pour utiliser le cache par programme, ajoutez le code approprié à vos fichiers code-behind pour créer un cache, puis ajoutez et récupérez les données.

  7. (Facultatif) Pour gérer les packages NuGet pour une solution complète et ajouter le support de la mise en cache à plusieurs projets simultanément, ouvrez le menu contextuel pour le nœud solution, puis choisissez Gérer les packages NuGet.

Voir aussi

Afficher:
© 2015 Microsoft