Strapi Performance Optimization — Caching, CDN, Database Tuning, and Clustering

# Install Redis and the Koa cache middleware
npm install koa-redis-cache

// config/middlewares.js — Add caching middleware
module.exports = [
  "strapi::logger",
  "strapi::errors",
  "strapi::security",
  "strapi::cors",
  "strapi::poweredBy",
  "strapi::query",
  "strapi::body",
  "strapi::session",
  "strapi::favicon",
  "strapi::public",
  {
    name: "strapi::compression",
    config: {
      enabled: true,
      threshold: 1024,  // Compress responses larger than 1KB
      gzip: true,
      br: false,
    },
  },
  {
    name: "global::api-cache",
    config: {
      enabled: true,
    },
  },
];

// src/middlewares/api-cache.js — Custom caching middleware
const cache = require("koa-redis-cache");

module.exports = (config, { strapi }) => {
  return cache({
    redis: {
      host: process.env.REDIS_HOST || "localhost",
      port: process.env.REDIS_PORT || 6379,
      password: process.env.REDIS_PASSWORD || undefined,
    },
    expire: 300,  // Cache for 5 minutes (in seconds)
    routes: [
      // Cache GET requests to API endpoints
      { path: "/api/articles", method: "GET" },
      { path: "/api/articles/(.*)", method: "GET" },
      { path: "/api/categories", method: "GET" },
      { path: "/api/categories/(.*)", method: "GET" },
      { path: "/api/homepage", method: "GET" },
      { path: "/api/global", method: "GET" },
    ],
    // Do not cache authenticated requests
    exclude: ["/api/users", "/api/auth"],
    // Cache key prefix for easy invalidation
    prefix: "strapi-cache",
    // Only cache successful responses
    onError: (error) => {
      strapi.log.error("Cache error:", error);
    },
  });
};

// Cache invalidation in lifecycle hooks
// src/api/article/content-types/article/lifecycles.js
module.exports = {
  async afterCreate(event) {
    // Invalidate the articles list cache when a new article is created
    const { strapi } = event;
    await clearCachePattern(strapi, "/api/articles*");
  },

  async afterUpdate(event) {
    // Invalidate both the list and individual article cache
    const { strapi, result } = event;
    await clearCachePattern(strapi, "/api/articles*");
    await clearCachePattern(strapi, `/api/articles/${result.id}*`);
  },

  async afterDelete(event) {
    const { strapi } = event;
    await clearCachePattern(strapi, "/api/articles*");
  },
};

async function clearCachePattern(strapi, pattern) {
  try {
    const redis = strapi.redis || require("redis");
    const client = redis.createClient({
      url: process.env.REDIS_URL || "redis://localhost:6379",
    });
    await client.connect();

    // Find all cache keys matching the pattern
    const keys = await client.keys(`strapi-cache${pattern}`);
    if (keys.length > 0) {
      await client.del(keys);
      strapi.log.debug(`Cleared ${keys.length} cache entries for ${pattern}`);
    }

    await client.quit();
  } catch (error) {
    strapi.log.warn("Cache invalidation failed:", error.message);
  }
}

Without CDN:
  User in Tokyo → request → Strapi server (US) → response (300ms latency)

With CDN:
  User in Tokyo → request → CDN edge (Tokyo) → response (10ms latency)

// config/plugins.js — Configure upload provider to use CDN URLs
module.exports = ({ env }) => ({
  upload: {
    config: {
      provider: "aws-s3",
      providerOptions: {
        accessKeyId: env("AWS_ACCESS_KEY_ID"),
        secretAccessKey: env("AWS_ACCESS_SECRET"),
        region: env("AWS_REGION", "us-east-1"),
        params: {
          Bucket: env("AWS_S3_BUCKET"),
        },
        // CDN URL for served files
        baseUrl: env("CDN_URL", "https://cdn.example.com"),
      },
    },
  },
});

Cloudflare configuration for Strapi:
1. Point DNS to your Strapi server IP
2. Enable "Proxied" (orange cloud) for API domain
3. Create cache rules:
   - Cache API GET responses for 5 minutes
   - Bypass cache for admin routes (/admin/*)
   - Bypass cache for authenticated requests
4. Enable Auto Minify for HTML, CSS, JS
5. Enable Brotli compression
6. Set security level to Medium

Cloudflare Cache Rule:
  URL: api.example.com/api/*
  Cache level: Cache Everything
  Edge TTL: 5 minutes
  Bypass cookie: *token*, *jwt*, *session*

Slow query example:
  SELECT * FROM articles WHERE published_at IS NOT NULL
  ORDER BY created_at DESC
  -- Took 850ms, scanning 50,000 rows

Optimized query with index:
  CREATE INDEX idx_articles_published_created
    ON articles(published_at, created_at DESC);
  -- Took 15ms, using index scan

# Connect to PostgreSQL and create indexes
psql strapi_production

# Index for filtered queries
CREATE INDEX idx_articles_published
  ON articles(published_at)
  WHERE published_at IS NOT NULL;

# Index for sorting
CREATE INDEX idx_articles_created_desc
  ON articles(created_at DESC);

# Index for relation queries
CREATE INDEX idx_articles_author
  ON articles(author_id);

# Index for text search (if using search)
CREATE INDEX idx_articles_title_search
  ON articles
  USING gin(to_tsvector('english', title));

// Optimize API queries by limiting returned fields
// Instead of:
// GET /api/articles (returns all fields)

// Use field selection:
// GET /api/articles?fields[0]=title&fields[1]=createdAt&populate[author][fields][0]=name

// Frontend receives only needed data, reducing payload size

// src/api/article/controllers/article.js
const { createCoreController } = require("@strapi/strapi").factories;

module.exports = createCoreController("api::article.article", ({ strapi }) => ({
  async find(ctx) {
    // Add pagination defaults if not provided
    if (!ctx.query.pagination) {
      ctx.query.pagination = { page: 1, pageSize: 10 };
    }

    // Limit populate to only needed relations
    if (!ctx.query.populate) {
      ctx.query.populate = {
        author: { fields: ["name", "avatar"] },
        tags: { fields: ["name"] },
      };
    }

    const { data, meta } = await super.find(ctx);
    return { data, meta };
  },

  async findOne(ctx) {
    // Populate everything for single article view
    ctx.query.populate = {
      author: { populate: ["profile"] },
      tags: { fields: ["name"] },
      category: true,
      comments: {
        populate: ["user"],
        sort: { createdAt: "desc" },
        pagination: { page: 1, pageSize: 50 },
      },
    };

    const { data, meta } = await super.findOne(ctx);
    return { data, meta };
  },
}));

// ecosystem.config.js — Cluster mode
module.exports = {
  apps: [
    {
      name: "strapi",
      script: "npm",
      args: "start",
      env: { NODE_ENV: "production" },
      exec_mode: "cluster",
      instances: "max",  // Use all CPU cores
      max_memory_restart: "500M",
      error_file: "./logs/strapi-error.log",
      out_file: "./logs/strapi-out.log",
      merge_logs: true,
      log_date_format: "YYYY-MM-DD HH:mm:ss",
      autorestart: true,
      watch: false,
      max_restarts: 10,
      restart_delay: 4000,
      kill_timeout: 5000,
      env_file: ".env.production",
      // Health monitoring
      instance_var: "INSTANCE_ID",
    },
  ],
};

# Start with cluster mode
pm2 start ecosystem.config.js

# Check cluster status
pm2 status
# Output:
# ┌─────┬────────┬────────┬─────┬────────┬──────────┐
# │ id  │ name   │ mode   │ ↺   │ status │ cpu      │
# ├─────┼────────┼────────┼─────┼────────┼──────────┤
# │ 0   │ strapi │ cluster│ 0   │ online │ 35%      │
# │ 1   │ strapi │ cluster│ 0   │ online │ 42%      │
# │ 2   │ strapi │ cluster│ 0   │ online │ 28%      │
# │ 3   │ strapi │ cluster│ 0   │ online │ 31%      │
# └─────┴────────┴────────┴─────┴────────┴──────────┘

// config/middlewares.js — Enable compression
module.exports = [
  // ... other middlewares
  {
    name: "compression",
    config: {
      enabled: true,
      threshold: 1024,  // Only compress responses larger than 1KB
      gzip: true,
      br: false,  // Brotli (disable if nginx handles it)
    },
  },
];

Compression results:
  Without compression: 150KB JSON response
  With gzip: 22KB (85% reduction)
  With brotli: 18KB (88% reduction)

  Frontend load time (3G): 1.2s → 0.3s

// config/admin.js — Enable performance tracking
module.exports = ({ env }) => ({
  // ... other config
  api: {
    responses: {
      maxPageSize: 100,
    },
  },
  admin: {
    // Enable admin panel performance monitoring
    watchIgnoreFiles: [],
  },
});

// Custom middleware for request timing
// src/middlewares/request-timing.js
module.exports = (config, { strapi }) => {
  return async (ctx, next) => {
    const start = Date.now();
    const method = ctx.method;
    const path = ctx.path;

    await next();

    const duration = Date.now() - start;
    strapi.log.info(`${method} ${path} - ${duration}ms`);

    // Alert on slow requests
    if (duration > 1000) {
      strapi.log.warn(
        `Slow request detected: ${method} ${path} took ${duration}ms`
      );
    }

    // Add timing header for frontend debugging
    ctx.set("X-Response-Time", `${duration}ms`);
  };
};