Now we have Azure Function App with a Function (API) running. Lets us know write our API. There is no set rules or patterns to develop APIs on Azure Function App. One can have one-function-one-api or we can use popular framework like Flask or FastApi integrated with Azure Function. For this tutorial we will use Flask as that can help us migrate existing Flask App running on Virtual Machine or any Host to Azure Function.
  1. Let us add required modules in requirements.txt. We may not use all of them in this steps but let just add it as they are required as we move ahead.

  2. Click on Run Menu > Run Without Debugging. This will update venv with new packages.

  3. Create a folder src in root of project. (Not inside function folder functiondemo)

  4. Create a folder api in src.

  5. Under src/api, create a python file

    ├── host.json
    ├── local.settings.json
    ├── requirements.txt
    ├── functiondemo
    │   ├──
    │   ├── function.json
    │   └── sample.dat
    └── src
        └── api
  6. contains Flask code. It is very much similar to any flask code that we write.

    import time
    import requests
    from flask import Flask, jsonify, request, Response
    from flask import g
    from flask_cors import CORS, cross_origin
    import logging
    app = Flask(__name__)
    cors = CORS(origins='*', allow_headers=['Content-Type', 'Authorization'])
    logger = logging.getLogger(__name__)
    def before_request():
        g.start = time.time()
    def response_logger(response: Response):
        response_time = round(time.time() - g.start, 3) * 1000
        if request.headers.getlist("X-Forwarded-For"):
            ip = request.headers.getlist("X-Forwarded-For")[0]
            ip = request.remote_addr
        remote_addr = "-" if ip is None else ip
        remote_user = "-" if request.remote_user is None else request.remote_user
        method = request.method
        scheme = request.scheme
        query_string = "-" if request.query_string is None else request.query_string
        url = request.url
        status = response.status
        referrer = request.referrer
        user_agent = request.user_agent"addr={remote_addr} user={remote_user} method={method} scheme={scheme} url={url} "
                    f"query_string={query_string} referrer={referrer} user_agent={user_agent} "
                    f"response_time_ms={response_time}, status={status}")
        return response
    def handle_not_found(ex):
        return jsonify(message=f"Path {request.path} not found"), 404
    def handle_not_found(ex):
        return jsonify(message=f"Method {request.method} not allowed on {request.path}"), 405
    @app.route("/health", methods=['GET', 'HEAD'])
    def health():"Checking health of the function.")
            res = requests.get("", timeout=10)
            if res.status_code == 200:
                response = "Health Check Ok"
                status_code = res.status_code
                response = "Health Check Failed"
                status_code = res.status_code
            return jsonify(message=response), status_code
        except Exception as error:
            return jsonify(message=str(error)), 500
    @app.route("/vault", methods=['GET', 'HEAD'])
    def get_secret():
        args = request.args
        secret = args.get("secret")
        return jsonify(message=f"Vault Integration is currently not implemented to get value for {secret}"), 200
    if __name__ == '__main__':
  7. We now need to tell Azure Function to map incoming request to flask-app as created above. Lets update functiondemo/ with WsgiMiddleware

    import json
    import azure.functions as func
    import logging
    from src.api import app as application
    __version__ = "0.0.1"
    logger = logging.getLogger(__name__)
    def main(req: func.HttpRequest, context: func.Context) -> func.HttpResponse:"Receiving request for main handler.")
            http_response = func.WsgiMiddleware(application.wsgi_app).handle(req, context)
            http_response.headers["x-function-invocationId"] = context.invocation_id
            http_response.headers["x-function-version"] = __version__
            return http_response
        except Exception as error:
            return func.HttpResponse(
                json.dumps({"message": str(error)}),
  8. As we are now not having 1-1 relationship between Azure Function and routes i.e. A Single Function is handling multiple routes as defined in flask app, we need to update Function config to handle this. In functiondemo/function.json, add below route details

      "scriptFile": "",
      "bindings": [
          "authLevel": "anonymous",
          "type": "httpTrigger",
          "direction": "in",
          "name": "req",
          "methods": [
          "route": "{*route}"
          "type": "http",
          "direction": "out",
          "name": "$return"
  9. Run Function locally again. This will now expose api endpoint as http://localhost:7071/api/{*route}

  10. Let us remove /api from URL. To do so, we need to update host.json to remove routePrefix.

      "version": "2.0",
      "logging": {
        "applicationInsights": {
          "samplingSettings": {
            "isEnabled": true,
            "excludedTypes": "Request"
      "extensionBundle": {
        "id": "Microsoft.Azure.Functions.ExtensionBundle",
        "version": "[3.*, 4.0.0)"
      "extensions": {
        "http": {
            "routePrefix": ""
  11. Re-Run function locally. Now we will see that Function URL is exposed as http://localhost:7071/{*route} where {*route} is route exposed by flask app. For example, To access /health route of flask-app, we can simple use http://localhost:7071/health

  12. Push this code to origin to deploy in Azure Function App.

  13. Wait for Deployment to complete and then, test Azure Function Endpoint, or