I started to design a RESTful webservice with Flask and Python and I'm wondering how one would support multiple API versions in the same project.
I'm thinking of putting the requested API version in the URL like this:
/myapp/v1.1/Users <= Same as in v1
/myapp/v2/Users <= Changed in v2
/myapp/v2/Books <= Same as in v1.1
# do something
I am the author of the accepted answer on the question you referenced. I think the
/<version>/users approach is not very effective as you say. If you have to manage three or four different versions you'll end up with spaghetti code.
The nginx idea I proposed there is better, but has the drawback that you have to host two separate applications. Back then I missed to mention a third alternative, which is to use a blueprint for each API version. For example, consider the following app structure (greatly simplified for clarity):
my_project +-- api/ +-- v1/ +-- __init__.py +-- routes.py +-- v1_1/ +-- __init__.py +-- routes.py +-- v2/ +-- __init__.py +-- routes.py +-- __init__.py +-- common.py
Here you have a
api/common.py that implements common functions that all versions of the API need. For example, you can have an auxiliary function (not decorated as a route) that responds to your
/users route that is identical in v1 and v1.1.
routes.py for each API version define the routes, and when necessary call into
common.py functions to avoid duplicating logic. For example, your v1 and v1.1
routes.py can have:
from api import common @api.route('/users') def get_users(): return common.get_users()
api is a blueprint. Having each API version implemented as a blueprint helps to combine everything with the proper versioned URLs. Here is an example app setup code that imports the API blueprints into the application instance:
from api.v1 import api as api_v1 from api.v1_1 import api as api_v1_1 from api.v2 import api as api_v2 app.register_blueprint(api_v1, url_prefix='/v1') app.register_blueprint(api_v1_1, url_prefix='/v1.1') app.register_blueprint(api_v2, url_prefix='/v2')
This structure is very nice because it keeps all API versions separate, yet they are served by the same application. As an added benefit, when the time comes to stop supporting v1, you just remove the
register_blueprint call for that version, delete the
v1 package from your sources and you are done.
Now, with all of this said, you should really make an effort to design your API in a way that minimizes the risk of having to rev the version. Consider that adding new routes does not require a new API version, it is perfectly fine to extend an API with new routes. And changes in existing routes can sometimes be designed in a way that do not affect old clients. Sometimes it is less painful to rev the API and have more freedom to change things, but ideally that doesn't happen too often.