Sulu Bunny Cdn Bundle Laravel Package

Technical Evaluation

Architecture Fit

• Purpose Alignment: The bundle integrates BunnyCDN (a high-performance CDN) with Sulu CMS (built on Symfony) via FOSHttpCache, enabling tag-based cache invalidation (CDN-Tag header + wildcard purges). This is a niche but critical use case for headless CMS deployments where edge caching is required but traditional cache invalidation (e.g., full-path purges) is inefficient.
• Symfony/Sulu Compatibility: Leverages FOSHttpCache (a Symfony bundle for HTTP caching), ensuring alignment with Symfony’s ecosystem. Sulu’s modular architecture makes this a low-friction integration for CDN-aware content delivery.
• Edge-Cache Optimization: BunnyCDN’s tag-based invalidation (via CDN-Tag header) is more granular than traditional URL-based purges, reducing unnecessary cache flushes. This is ideal for dynamic content (e.g., marketing pages, product catalogs) where partial updates are frequent.

Integration Feasibility

• Core Dependencies:
  • Symfony 6.4+ (Sulu’s baseline).
  • FOSHttpCacheBundle (must be installed; not included by default in Sulu).
  • BunnyCDN API (requires API key, zone configuration).
• Key Features:
  • Automatic cache tagging: Content responses include CDN-Tag headers (e.g., sulu-page:homepage).
  • Wildcard purges: Supports * in purge tags (e.g., sulu-page:* to invalidate all page caches).
  • Fallback to URL purges: If tagging fails, reverts to URL-based invalidation.
• Limitations:
  • No built-in monitoring: Requires external tools (e.g., Prometheus, BunnyCDN dashboard) to track purge efficiency.
  • Sulu-specific: Assumes Sulu’s routing/content structure (e.g., sulu-page:* tags). Custom content types may need tag adjustments.
  • No async purge support: Purges are synchronous (blocking HTTP responses if misconfigured).

Technical Risk

Key Questions

1. Tagging Strategy:
   • How will content tags (e.g., sulu-page:*) map to business requirements? Are there non-page entities (e.g., media, blocks) needing invalidation?
2. Fallback Behavior:
   • What’s the acceptable trade-off between tag-based vs. URL-based purges? Should URL purges be disabled entirely?
3. Monitoring:
   • How will purge success/failure be tracked? (e.g., BunnyCDN webhooks, custom logs)
4. Sulu Customizations:
   • Does the project use custom routes or content types that require tag adjustments?
5. Cost Implications:
   • BunnyCDN’s purge API has usage limits; what’s the expected volume of invalidations?

Integration Approach

Stack Fit

• Symfony/Sulu Ecosystem:
  • FOSHttpCacheBundle: Already used in Sulu for HTTP caching. This bundle extends it for CDN integration.
  • BunnyCDN: Requires:
    • API key (stored in parameters.yaml or environment variables).
    • Zone ID (for the CDN endpoint).
  • Sulu CMS: Assumes standard Sulu routing (e.g., /en/{route}). Custom routes may need tag overrides.
• Alternatives Considered:
  • Varnish/Nginx Purge: More control but requires proxy setup.
  • Cloudflare Workers: For dynamic tagging logic, but adds complexity.
  • Symfony Cache Adapter: Less efficient for edge caching.

Migration Path

1. Prerequisites:
   • Install fos/http-cache-bundle (if not present).
   • Configure BunnyCDN API credentials in config/packages/sulu_bunny_cdn.yaml:

     sulu_bunny_cdn:
         api_key: '%env(BUNNY_API_KEY)%'
         zone: 'my-zone-id'
     

2. Core Integration:
   • Enable the bundle in config/bundles.php:

     Sulu\BunnyCdnBundle\SuluBunnyCdnBundle::class => ['all' => true],
     

   • Configure FOSHttpCache to use the CDN purger:

     fos_http_cache:
         purger:
             type: sulu_bunny_cdn
     

3. Testing:
   • Validate CDN-Tag headers in responses (e.g., curl -I https://example.com).
   • Test purge endpoints (/fos_http_cache/purge/{tag}).
   • Simulate high-traffic purges to check rate limits.

Compatibility

• Symfony Versions: Tested on 6.4+ (Sulu’s baseline). Backporting to older versions may require adjustments.
• Sulu Versions: Assumes Sulu 2.x (Symfony 6+). For Sulu 1.x, compatibility is untested.
• BunnyCDN Features:
  • Requires tag-based invalidation support (all modern BunnyCDN plans include this).
  • Wildcard purges (*) must be enabled in the zone.
• Edge Cases:
  • Static Assets: If using BunnyCDN for static files, ensure tags align with dynamic content (e.g., asset:hash).
  • Multi-Region CDN: BunnyCDN’s tagging works globally; no regional conflicts expected.

Sequencing

1. Phase 1: Proof of Concept (1–2 weeks)
   • Install bundle in a staging environment.
   • Test with a single content type (e.g., homepage).
   • Measure purge latency and cache hit ratios.
2. Phase 2: Full Rollout (2–3 weeks)
   • Extend tagging to all content types (pages, media, blocks).
   • Implement monitoring for purge failures.
   • Document tagging conventions for developers.
3. Phase 3: Optimization (Ongoing)
   • Tune wildcard usage (e.g., avoid * for large datasets).
   • Explore async purge queues if synchronous purges cause timeouts.

Operational Impact

Maintenance

• Configuration Drift:
  • Risk: BunnyCDN API keys or zone IDs may change.
  • Mitigation: Use environment variables and CI/CD validation.
• Bundle Updates:
  • Risk: Breaking changes in Sulu/Symfony 7+.
  • Mitigation: Subscribe to Sulu/BunnyCDN release notes; test updates in staging.
• Tag Management:
  • Risk: Ad-hoc tagging leads to inefficiencies (e.g., over-purges).
  • Mitigation: Enforce naming conventions (e.g., entity-type:uuid).

Support

• Debugging:
  • Tools Needed:
    • BunnyCDN dashboard for purge logs.
    • Symfony profiler to inspect CDN-Tag headers.
  • Common Issues:
    • Missing API keys → 500 errors.
    • Invalid tags → silent failures (log purges).
• Escalation Path:
  • BunnyCDN support for API limits.
  • Sulu community for Symfony integration issues.

Scaling

• Purge Volume:
  • Limitations: BunnyCDN’s free tier has purge limits (~100/day). Enterprise plans scale to 10,000+/day.
  • Workaround: Implement a queue (e.g., Symfony Messenger) for bulk purges.
• Performance:
  • Tag Header Overhead: CDN-Tag headers add ~50–100 bytes per response (negligible).
  • Purge Latency: Synchronous purges add ~100–300ms to responses. Async purges (future work) could reduce this.
• Multi-CDN:
  • Extensibility: Bundle is single-CDN; extending to Cloudflare/Akamai would require a custom purger.

Failure Modes