Comment appliquer le cache de sortie à Optimizely CMS 12

Introduire

Optimizely CMS 12 est une plate-forme pour les systèmes de gestion de contenu. Il est écrit par .NET 6.0. En fait, le concept de mise en cache de sortie n’a pas encore été intégré dans .NET 6.0, mais il existe un concept de mise en cache de réponse dans .NET6.0.

Vous pouvez utiliser le cache de réponse pour mettre en cache la sortie des contrôleurs MVC, les méthodes d’action MVC, les pages RAZOR. La mise en cache des réponses réduit la quantité de travail que le serveur Web effectue pour générer une réponse en renvoyant immédiatement le résultat du cache s’il existe au lieu d’exécuter les méthodes encore et encore. De cette manière, les performances sont améliorées et les ressources du serveur sont optimisées.

Étape pour appliquer le cache de réponse dans Optimizely CMS 12

• Étape 1 : Ajouter [ResponseCache] attribut à la page contrôleur/action/rasoir que vous voulez :

    public class StartPageController : PageControllerBase
    {
        [ResponseCache(Duration =30, Location = ResponseCacheLocation.Any)]
        public IActionResult Index(StartPage currentPage)
        {
            var model = PageViewModel.Create(currentPage);

            // Check if it is the StartPage or just a page of the StartPage type.
            if (SiteDefinition.Current.StartPage.CompareToIgnoreWorkID(currentPage.ContentLink))
            {
                // Connect the view models logotype property to the start page's to make it editable
                var editHints = ViewData.GetEditHints, StartPage>();
               editHints.AddConnection(m => m.Layout.Logotype, p => p.SiteLogotype);
               editHints.AddConnection(m => m.Layout.ProductPages, p => p.ProductPageLinks);
               editHints.AddConnection(m => m.Layout.CompanyInformationPages, p => p.CompanyInformationPageLinks);
               editHints.AddConnection(m => m.Layout.NewsPages, p => p.NewsPageLinks);
               editHints.AddConnection(m => m.Layout.CustomerZonePages, p => p.CustomerZonePageLinks);
           }

           return View(model);
       }
   }

Durée=30 mettra la page en cache pendant 30 secondes

Location=ResponseCacheLocation.Any mettra en cache la page dans les proxys et le client.

Si vous n’appliquez pas le cache de réponse pour certaines situations, vous pouvez utiliser Location= ResponseCacheLocation.None et NoStore=true

• Étape 2 : Ajoutez les services Response Cache Middleware à la collection de services avec la méthode d’extension AddResponseCaching :

    public void ConfigureServices(IServiceCollection services)
    {
        if (_webHostingEnvironment.IsDevelopment())
        {
            AppDomain.CurrentDomain.SetData("DataDirectory", Path.Combine(_webHostingEnvironment.ContentRootPath, "App_Data"));

            services.Configure(options => options.Enabled = false);
        }

        services
            .AddCmsAspNetIdentity()
            .AddCms()
            .AddCmsTagHelpers()
            .AddAlloy()
            .AddAdminUserRegistration()
            .AddEmbeddedLocalization();

        // Required by Wangkanai.Detection
        services.AddDetection();

        services.AddSession(options =>
        {
            options.IdleTimeout = TimeSpan.FromSeconds(10);
            options.Cookie.HttpOnly = true;
            options.Cookie.IsEssential = true;
        });
        services.AddControllers();
        services.AddResponseCaching();
    }

• Étape 3 : Configurez l’application pour utiliser le middleware avec la méthode d’extension UseResponseCaching :

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        // Required by Wangkanai.Detection
        app.UseDetection();
        app.UseSession();

        app.UseResponseCaching();

        app.UseStaticFiles();
        app.UseRouting();
        app.UseAuthentication();
        app.UseAuthorization();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapContent();
            endpoints.MapControllers();
        });
    }

Veuillez noter que si vous chargez une page en appuyant sur la touche F5 dans le navigateur, le cache de cette page est actualisé en ajoutant l’en-tête Cache-Control à la requête “max-age=0”. Pour éviter cela, vous pouvez ajouter le middleware suivant avant le middleware de cache de réponse :

   app.Use(async (context, next) =>
   {
        const string cc = "Cache-Control";

        if (context.Request.Headers.ContainsKey(cc) && string.Equals(context.Request.Headers[cc], "max-age=0", StringComparison.InvariantCultureIgnoreCase))
        {
              context.Request.Headers.Remove(cc);
        }
        await next();
   });

Comment invalider le cache lorsque le contenu est modifié

En fait, le middleware de cache de réponse utilise MemoryResponseCache par défaut et cette implémentation ne prend pas en charge l’effacement du cache. Ainsi, vous pouvez faire rapidement et salement pour obtenir un nouveau cache en utilisant la version du cache de contenu comme clé de requête pour faire varier le cache. La version du cache de contenu est augmentée une fois qu’un contenu est modifié.

Voici les étapes que vous pouvez suivre pour y parvenir :

• Ajouter ContentCacheVersion pour varier selon l’attribut des clés de requête

   [ResponseCache(Duration =30, Location = ResponseCacheLocation.Any, VaryByQueryKeys = new string[] { "ContentCacheVersion"})]
   public IActionResult Index(StartPage currentPage)
   {
       var model = PageViewModel.Create(currentPage);
       // Check if it is the StartPage or just a page of the StartPage type.
       if (SiteDefinition.Current.StartPage.CompareToIgnoreWorkID(currentPage.ContentLink))
       {

• Ajoutez un middleware avant Response Caching Middleware pour ajouter la version du cache de contenu à la chaîne de requête et ajoutez un middleware après Response Caching Middleware pour le supprimer de la chaîne de requête.

   app.Use(async (context, next) =>
        {
            var contentCacheVersion = ServiceLocator.Current.GetInstance();

            context.Request.QueryString = context.Request.QueryString.Add("ContentCacheVersion", contentCacheVersion.Version.ToString());
           
            await next();
        });

        app.UseResponseCaching();

        app.Use(async (context, next) =>
        {
            var nameValueCollection = System.Web.HttpUtility.ParseQueryString(context.Request.QueryString.ToString());
            nameValueCollection.Remove("ContentCacheVersion");
            context.Request.QueryString = new QueryString($"?{nameValueCollection}");
            
            await next();
        });

Comment faire varier le cache de réponse par groupe de visiteurs

C’est la même chose que dans le cas d’un contenu modifié, vous pouvez faire rapidement et salement pour ajouter un groupe de visiteurs en tant que clé de requête variable comme ceci :

• Ajouter VisitorGroup pour varier selon l’attribut des clés de requête

    [ResponseCache(Duration =30, Location = ResponseCacheLocation.Any, VaryByQueryKeys = new string[] { "VisitorGroup"})]
    public IActionResult Index(StartPage currentPage)
    {
        var model = PageViewModel.Create(currentPage);

        // Check if it is the StartPage or just a page of the StartPage type.
        if (SiteDefinition.Current.StartPage.CompareToIgnoreWorkID(currentPage.ContentLink))
        {

• Ajoutez un middleware avant Response Caching Middleware pour ajouter le groupe de visiteurs actuel à la chaîne de requête et ajoutez un middleware après Response Caching Middleware pour le supprimer de la chaîne de requête.

   app.Use(async (context, next) =>
        {
            context.Request.QueryString = context.Request.QueryString.Add("VisitorGroup", GetCurrentVisitorGroups(context));
           
            await next();
        });
        app.UseResponseCaching();
        app.Use(async (context, next) =>
        {
            var nameValueCollection = System.Web.HttpUtility.ParseQueryString(context.Request.QueryString.ToString());
            nameValueCollection.Remove("VisitorGroup");
            context.Request.QueryString = new QueryString($"?{nameValueCollection}");
            await next();
        });

• Ajouter la méthode GetCurrentVisitorGroups pour obtenir des groupes de visiteurs en fonction du contexte actuel

    private string GetCurrentVisitorGroups(HttpContext context)
    {
        var  principalAccessor = ServiceLocator.Current.GetInstance();
        var  visitorGroupRepository = ServiceLocator.Current.GetInstance();
        var  visitorGroupRoleRepository = ServiceLocator.Current.GetInstance();

        var roleNames = visitorGroupRepository.List().Select(x => x.Name);

        var currentGroups = new List();
        foreach (var roleName in roleNames)
        {
            if (visitorGroupRoleRepository.TryGetRole(roleName, out var role))
            {
                if (role.IsMatch(principalAccessor.Principal, context))
                {
                    currentGroups.Add(roleName);
                }
            }
        }
        return string.Join("|", currentGroups);
    }

C’est ça. En utilisant cette approche, vous pouvez appliquer rapidement le cache de réponse intégré dans Optimizely CMS 12 sans trop personnaliser ni utiliser de packages tiers. Vous pouvez voir un autre sujet sur l’utilisation du package de mise en cache de sortie tiers ici

17 mars 2023