Data Caching

Caching Mechanisms in Drupal

Drupal provides multiple caching layers to optimize performance and reduce load times. These mechanisms help improve both front-end and back-end performance. Here’s an overview of the key caching mechanisms in Drupal:

1. Page Cache

• Stores the entire rendered HTML output of a page.
• Works best for anonymous users (not logged in).
• Controlled via the Internal Page Cache module.
• Can be stored in the database or an external cache system like Varnish.

✅ Use when: Serving anonymous users with static content.

2. Dynamic Page Cache

• Stores rendered page content while keeping certain elements dynamic.
• Works for both anonymous and authenticated users.
• Controlled via the Dynamic Page Cache module.
• Uses cache contexts to vary cache by user roles, permissions, languages, etc.

✅ Use when: You need partial caching while maintaining some level of personalization.

3. Render Cache

• Caches individual rendered elements (blocks, views, entities, etc.).
• Uses cache tags to invalidate specific elements when needed.
• Useful for avoiding repeated rendering of the same elements.

✅ Use when: You need efficient caching of specific page elements.

4. Entity Cache

• Caches database queries for entities (nodes, taxonomy terms, users, etc.).
• Helps avoid repeated database lookups for the same entities.
• Works alongside cache tags to ensure updates invalidate stale cache.

✅ Use when: You need to optimize entity queries.

5. Twig Template Cache

• Caches compiled Twig templates to speed up page rendering.
• Controlled via cache:rebuild and development settings.

✅ Use when: Optimizing template rendering for better performance.

6. View Cache

• Caches the output of Views queries and rendering.
• Supports time-based expiration and manual invalidation.
• Can be configured via the Views UI.

✅ Use when: You need to optimize complex Views queries.

7. Opcode Cache (PHP OPcache)

• Caches compiled PHP scripts to avoid reinterpreting them on every request.
• Controlled via PHP settings (opcache.enable=1 in php.ini).

✅ Use when: Boosting PHP execution performance.

8. External Cache Systems

• Redis / Memcached: Store cache in memory for faster access.
• Varnish: Acts as a reverse proxy for serving cached pages quickly.
• CDN (Cloudflare, Akamai, etc.): Distributes cached content globally.

✅ Use when: You need high-performance caching beyond Drupal’s built-in system.

Choosing the Right Caching Approach

Use this decision framework:

1. For anonymous users → Use Page Cache, Dynamic Page Cache, and Varnish/CDN.
2. For authenticated users → Use Dynamic Page Cache, Render Cache, and Entity Cache.
3. For specific components (blocks, entities) → Use Render Cache & Entity Cache.
4. For heavy database queries (Views) → Use Views Cache.
5. For overall PHP performance → Use OPcache, Redis, or Memcached.

Handling caching for dynamic content in Drupal, especially when personalization is involved, requires a fine balance between performance and freshness of data. Drupal provides several techniques to manage this effectively.

Key Approaches for Handling Dynamic Content Caching

1. Use Cache Contexts for Personalization

• Cache contexts allow Drupal to vary the cache based on specific conditions like user roles, languages, or session data.
• This ensures that dynamic content is cached properly while maintaining personalized elements.

Example: Vary cache based on user role

$build['custom_block'] = [
  '#markup' => $some_dynamic_content,
  '#cache' => [
    'contexts' => ['user.roles'],
  ],
];

✅ Use When: Personalization is based on user role, session, or other contextual factors.

2. Use Cache Tags for Selective Cache Invalidation

• Cache tags allow Drupal to invalidate cache when specific content updates.
• This is useful when dynamic content depends on nodes, users, or other entities.

Example: Invalidate cache when a specific node updates

$build['custom_block'] = [
  '#markup' => $some_dynamic_content,
  '#cache' => [
    'tags' => ['node:123'], // Automatically invalidates when node 123 is updated
  ],
];

✅ Use When: The content depends on specific entities and should update when they change.

3. Use Cache Max-Age for Time-Based Expiration

• Cache max-age determines how long content remains cached before being refreshed.
• Setting max-age = 0 disables caching for highly dynamic content.

Example: Cache content for 5 minutes

$build['custom_block'] = [
  '#markup' => $some_dynamic_content,
  '#cache' => [
    'max-age' => 300, // Cache for 300 seconds (5 minutes)
  ],
];

✅ Use When: You need temporary caching but want updates at regular intervals.

4. Use Lazy Builders for Late-Stage Content Rendering

• Lazy builders allow rendering dynamic content only when needed, preventing it from being cached prematurely.

Example: Implementing a Lazy Builder

$build['custom_block'] = [
  '#lazy_builder' => ['my_module.lazy_builder:getDynamicContent', []],
  '#create_placeholder' => TRUE,
];

In MyModuleLazyBuilder.php:

public function getDynamicContent() {
  return [
    '#markup' => $this->generateDynamicContent(),
    '#cache' => ['max-age' => 0], // No caching
  ];
}

✅ Use When: The content is user-specific and changes frequently.

5. Leverage Dynamic Page Cache for Partial Caching

• Dynamic Page Cache stores pages with placeholders for dynamic content.
• Drupal automatically replaces placeholders for logged-in users while keeping the rest of the page cached.

✅ Use When: You want to cache most of the page while keeping certain sections dynamic.

6. Use AJAX or JavaScript for Dynamic Content

• If a part of the page needs frequent updates, load it dynamically using AJAX.
• This avoids caching issues and keeps content fresh.

Example: Load a block via AJAX

$build['custom_block'] = [
  '#markup' => '<div id="dynamic-content">Loading...</div>',
  '#attached' => [
    'library' => ['my_module/custom_ajax'],
  ],
];

Then in custom_ajax.js:

Drupal.behaviors.customAjax = {
  attach: function (context, settings) {
    $.get('/my-dynamic-endpoint', function(data) {
      $('#dynamic-content').html(data);
    });
  }
};

✅ Use When: The content updates frequently, such as notifications, live updates, or user-specific messages.

Choosing the Right Approach

Integrating Redis or Memcached with Drupal for Improved Caching

Drupal supports Redis and Memcached as external caching systems to improve performance by reducing database queries and speeding up page loads.

1️⃣ Redis Integration with Drupal

Configuration in settings.php

Add the following in settings.php to configure Redis as the caching backend:

$settings['redis.connection']['interface'] = 'PhpRedis'; // Use PhpRedis extension $settings['redis.connection']['host'] = '127.0.0.1'; // Redis server host $settings['redis.connection']['port'] = 6379; // Default Redis port

// Use Redis for caching instead of the database $settings['cache']['default'] = 'cache.backend.redis';

// Register Redis service in Drupal $settings['container_yamls'][] = 'modules/contrib/redis/redis.services.yml';

// Prevent Redis from caching certain bins $settings['cache']['bins']['bootstrap'] = 'cache.backend.chainedfast';
$settings['cache']['bins']['discovery'] = 'cache.backend.chainedfast';
$settings['cache']['bins']['config'] = 'cache.backend.redis';

Verify Redis Integration

Run:

or

to check if Redis is storing cache.

✅ Redis is now integrated and handles cache efficiently.

2️⃣ Memcached Integration with Drupal

Configuration in settings.php

Modify settings.php to use Memcached as a caching backend:

$settings['memcache']['servers'] = ['127.0.0.1:11211' => 'default'];
$settings['memcache']['bins'] = ['default' => 'default'];
$settings['memcache']['key_prefix'] = 'drupal_';

// Use Memcached for caching instead of the database $settings['cache']['default'] = 'cache.backend.memcache';

// Register Memcache service in Drupal $settings['container_yamls'][] = 'modules/contrib/memcache/memcache.services.yml';

Verify Memcached Integration

Run:

✅ Memcached is now integrated and handling cache efficiently.

Redis vs Memcached: Which One to Choose?

💡 Best Choice?

• Use Redis if you need advanced caching & persistence.
• Use Memcached if you need simple and high-speed caching.