Request buffering with reverse proxies

K Fuquay — Fri, 01 Jul 2022 17:14:52 +0000

What is a reverse proxy?

A reverse proxy is a server that forwards requests from the client to another server.

Why use reverse proxies

There are several reasons you might want to use a reverse proxy:

Load balancing - a reverse proxy can be used to distribute requests across a number of servers.
Caching - caching and serving content from a reverse proxy can increase performance.
Security - using a reverse proxy will obscure architectural details of your backend infrastructure as well as server identities (the IP of the origin server for instance).
Maintainability - in the event that your upstream server moves, you would only need to update the value of the upstream server in a single place.
Request buffering - Minimizes upstream server execution time.

A closer look at request buffering

Let’s take the example of a client on a slow connection trying to upload a large file (an image for instance) to a server. When the server receives this request it will be blocked until it receives the entire request & processes it. Essentially, the servers execution time will be directly affected by the connection speed of the client.

A reverse proxy will wait to receive all of the request from the client before forwarding it to the upstream server. This means that the actual execution time on the server is greatly reduced, as this server-to-server request is much faster than the client-to-server request.

This pattern can be particularly useful when your upstream server has strict execution time limitations. For example, Netlify’s synchronous serverless functions have an execution limit of 10 seconds, which begins as soon as the http connection is opened. Using a reverse proxy in this case could decrease the risk of hitting that execution limit.

Extending Python's JSON Encoder

K Fuquay — Fri, 11 Mar 2022 19:29:44 +0000

I recently ran into a situation where I needed to ensure consistent formatting of datetimes as I serialized a dict to JSON using python’s built-in json library.

The JSON specification does not specify how to handle dates - so it follows that the JSON encoder does not, by default, include any date formatting.

Attempting to convert a dict which includes a datetime to JSON using the default JSON Encoder will raise a TypeError.

import json
from datetime import datetime

obj = {
    "name": "test",
    "created": datetime.utcnow()
}

obj_default_encoder = json.dumps(obj)
print(obj_default_encoder)
# TypeError: Object of type datetime is not JSON serializable

I was able to achieve the behavior I wanted by defining a class which extends json.JSONEncoder. In this class I included instructions for handling dates - you could also include other modifications to the default behavior of JSONEncoder. Finally, I passed the custom encoder class to the cls kwarg of json.dumps

From the python docs:

To use a custom JSONEncoder subclass (e.g. one that overrides the default() method to serialize additional types), specify it with the cls kwarg; otherwise JSONEncoder is used.

Usage Example