Enabling API caching

      Last updated June 08, 2017

    Application Programming Interfaces (APIs) allow you to retrieve data from a variety of web services. Fastly makes it possible for you to cache your API so you can accelerate the performance of your service-oriented architecture. It optimizes your API's performance by efficiently handling traffic bursts and reducing latency.

    An example

    Let's look at an example to learn how API caching works. Imagine we're an online magazine with articles on which users can make comments. Each article can have many comments, and each comment is created by exactly one user.

    Relational schema for the database of the website.

    We'll design a RESTful API specification and use it to manipulate and retrieve comments:

    The create, read, update, and delete (CRUD) methods ensure the API can perform its basic operations, but they don't expose the relational aspect of the data. To do so, you would add a couple of relational endpoints:

    Endpoints like these allow programmers to get the information they need to do things like render the HTML page for an article, or display comments on a user's profile page. While there are many other possible endpoints we could construct, this set should suffice for the purposes of this guide. Let's assume that the API has been programmed to use an Object-Relational Mapper (ORM), such as ActiveRecord, when interacting with the database.

    Determining which API endpoints to cache

    Start by identifying the URLs you want to cache. We recommend splitting the specification endpoints into two groups.

    The first group, called "accessors," retrieves or accesses the comment data. These are the endpoints you want to cache using Fastly. Using the example, four endpoints match this description:

    The second group, called "mutators," changes or mutates the comment data. These endpoints are always dynamic, and are therefore uncacheable. Using the example, three endpoints match this description:

    You should see a pattern emerging. Because the example API is RESTful, we can use a simple rule to identify the accessor and mutator endpoints: GET endpoints can be cached, but PUT, POST, and DELETE endpoints cannot.

    Once you've gathered this information, you're ready to program the API to configure PURGE requests.

    Configuring PURGE requests

    Don't be tempted to point at the PUT, POST, and DELETE endpoints as the place where data is modified. In most modern APIs, these endpoints represent an interface to the actual model code responsible for handling the database modifications.

    In the example, we assumed that we'd be using an ORM to perform the actual database work. Most ORMs allow programmers to set special "callbacks" on models that will fire when certain actions have been performed (e.g., before or after validation, or after creating a new record).

    For purging, we are interested in whether a model has saved information to the database — whether it's a new record, an update to an existing record, or the deleting of a record. At this point, we'd add a callback that tells the API to send a PURGE request to Fastly for each of the cacheable endpoints.

    For an ActiveRecord comments model, you could do something like this:

    require 'fastly'
    class Comment < ActiveRecord::Base
      fastly = Fastly.new(api_key: 'FASTLY_API_TOKEN')
      after_save do
        fastly.purge "/comment"
        fastly.purge "/comment/#{self.id}"
        fastly.purge "/article/#{self.article_id}/comments"
        fastly.purge "/user/#{self.user_id}/comments"

    Keep two things in mind when creating the callback:

    With the model code in place, the API is now ready to be cached.

    Setting up Fastly

    The final step to enabling API caching involves setting up Fastly. You'll need to:

    In addition, you can optionally create rules that tell Fastly how to work with the specific elements that are exclusive to your API.

    Creating a new service

    Follow the instructions for creating a new service. You'll add specific details about your API server when you fill out the Create a new service fields:

    Adding the domain

    Follow these instructions to add the API's domain name to your Fastly service:

    1. On the Configure page, click the Configuration button and then select Clone active. The Domains page appears.
    2. Click the Create domain button. The Create a domain page appears.

      The Create a domain page.

    3. Fill out the Create a domain fields as follows:
      • In the Domain Name field, type the domain name for the API.
      • In the Comment field, type an optional comment that describes your domain.
    4. Click Create. Your API's domain name appears in the list of domains.

    Adding the origin server

    Follow the instructions for connecting to origins. You'll add specific details about your API server when you fill out the Create a host fields:

    Back to Top