Update – I have also posted an alternative method that preserves the ability to have full page caching enabled. Please find it at WordPress ActivityPub and Cloudflare.
In a previous post I discussed how to deal with the fact the ActivityPub plugin for WordPress must return author pages in a different format depending on the value of the Accept header. A browser hitting an author page is going to be looking for HTML to be returned, while Mastodon will expect a JSON instead. If you use any kind of caching system be it a CDN, special plugin or combination of the two then you may run into an issue where the wrong content is being cached for each Accept header type. You might see this in your site health report with:
Your author URL does not return valid JSON for application/activity+json. Please check if your hosting supports alternate Accept headers.
In this post I will discuss a method for dealing with this while not totally losing the ability to cache the response. This is useful for busy sites or as a way to help mitigate some forms of DoS attack. The example I provide here is meant for Nginx with php-fpm but you can apply this same sort of thinking anywhere else where you have enough control over the configuration to make it work.
Assuming you followed the previous post and have created an exception for your author URL in your CDN then it is on your server to render author pages each time a request is made. This is a waste of resources and doesn’t provide an ideal experience for end users. To enable caching on this endpoint, we will leverage Nginx’s built in caching capability while setting the cache key based on the Accept header.
To start, let’s setup basic Nginx caching. At the top of your configuration file, outside of the server{} block, (advanced users can adjust as desired) add the following:
fastcgi_cache_path /etc/nginx/cache levels=1:2 keys_zone=wordpress:100m inactive=10m max_size=100m;
You can adjust the path if you want but in essence we are defining a path of /etc/nginx/cache with a name of wordpress. We are limiting it to 100MB and saying delete anything older than 10 minutes if it hasn’t been accessed. /etc/nginx/cache must exist and must be owned by the same user that runs Nginx. If you have multiple servers know that this cache is unlikely to be shared so each server will have a unique cache.
Next, add a map that to define what Accept headers we want to Vary on:
map $http_accept $vary_key {
default "default";
"~application/activity\+json" "json";
}
This block will create a new variable we can use later called $vary_key. Notice here that we will only create a different cache entry when application/activity+json is sent included in the list.
Now inside the server{} block for your site, let’s add a nice header we can use to ensure our caching is working properly. Adding add_header X-Nginx-Cache $upstream_cache_status; to this section will cause Nginx to output a header we can see to know the cache status. It will be BYPASS, MISS or HIT in response headers.
Next, inside the location block that is handling PHP requests, add the following config options:
# cache key fastcgi_cache_key "$vary_key$host$request_method$request_uri"; # matches keys_zone in fastcgi_cache_path fastcgi_cache wordpress; # don't cache pages defined earlier fastcgi_no_cache $no_cache; #defines the default cache time fastcgi_cache_valid any 10m; # misc additional settings fastcgi_cache_use_stale updating error timeout invalid_header http_500; fastcgi_cache_lock on; fastcgi_cache_lock_timeout 10s;
The next settings depend on what you want to do. If you are using a CDN and are only exposing author pages then you can use the following settings
# Cache nothing by default
set $no_cache 1;
# Only cache author pages
if ($request_uri ~* "/author/") {
set $no_cache 0;
}
If instead, you want to cache everything your CDN might miss then you can use this (this is what I use):
# Cache everything by default
set $no_cache 0;
# Don't cache logged in users or commenters
if ( $http_cookie ~* "comment_author_|wordpress_(?!test_cookie)|wp-postpass_" ) {
set $no_cache 1;
}
# Don't cache the following URLs
if ($request_uri ~* "/(wp-admin/|wp-login.php)") {
set $no_cache 1;
}
If done correctly then hitting an author page will result in different results depending on the Accept header being used. To verify, take an author page and load it up in a browser. You should get a proper HTML page. Copy the URL out and, using curl, send the following:
curl -I https://dustinrue.com/author/ruedu/ -H "Accept: application/activity+json" x-nginx-cache: MISS
Your Nginx cache status may already be HIT if someone recently searched for you. It should be HIT if you send the request again.
Debugging
It is important that you debug and properly resolve this endpoint. Failing to do so will result in failed searches of your author/user from ActivityPub clients. To be clear, the following must return different content:
curl -I https://dustinrue.com/author/ruedu curl -I https://dustinrue.com/author/ruedu -H "Accept: application/activity+json"
Adjust these URLs for your author page URLs and ensure the first curl returns HTML content while the second one returns JSON content. While writing this post I noticed that the plugin is still outputting that the content type is text/html when it should say application/activity+json. Despite this inconsistency, clients will use the returned content.
If the curl calls are returning different content, next pay attention to the x-nginx-cache header to ensure that it is actually caching. You can add another utility header to your Nginx config to assist with this:
add_header x-accept $vary_key always;
This add_header will output what value the map landed on so you can ensure things are being picked up properly.
Conclusion
I hope this is enough to help guide you in improving your WordPress + ActivityPub experience.