Enable WSGI for Python Function App

[Hazhzeng]

Acknowledgement

This feature is migrated from @vtbassmatt 's azf-wsgi project which enables wsgi feature for Azure Functions Python app. We've contacted @vtbassmatt and agreed to implement this feature on azure-functions-python-library. We greatly appreciate his contribution, helping us expand the Python user base in his own time.

Usage

1. Override the main entrypoint

import logging

import azure.functions as func
from ..FlaskApp.wsgi import application

main = func.WsgiMiddleware(application).main

2. Alternatively, use the old syntax as demonstrated in azf-wsgi

import logging

import azure.functions as func
from ..FlaskApp.wsgi import application

def main(req: func.HttpRequest, context: func.Context) -> func.HttpResponse:
    return func.WsgiMiddleware(application).handle(req, context)

Fixes

This PR also includes some fixes from the original repository
Thanks

• @caffeinate for creating the body_encoding fix fixed: parsing body_encoding from http 'Content-Type' header vtbassmatt/azf-wsgi#6
• @james1293 for creating the BytesIO fix Change StringIO to BytesIO vtbassmatt/azf-wsgi#5

Limitation

• The azure functions architecture does not support data streaming since it requires http persistent connection.
• The Python function app is running on a single process, to spawn multiple processes from the same host, set FUNCTIONS_WORKER_PROCESS_COUNT app setting to a higher value (10).

Todos

Since the feature is not officially released, feature-wise this PR is ready for review, and of course, we need to verify the following features before we release this WSGI change.

1. Client app logging ✔
2. Client app routing (query_params) ✔
3. Environment variable propagating (from host to client app) ✔
4. Content-Length (binary, application/json, text/plain) ✔
5. Chunked data transfer ✔
6. Response headers ✔
7. Client app error emissions ✔
8. Client app exception handling ✔

resolves: Azure/azure-functions-python-worker#165

[vtbassmatt]

This is awesome, thanks folks! I'll deprecate the separate project in favor of this 😁

[rolexsanches]

Hello

Its aready able to run Django Applications too?

Thanks!

[Hazhzeng]

Hey @rolexsanches,

Yes, Django also accept wsgi request via WSGI interface.
The following code should do the trick.

import logging

import azure.functions as func
from ..Django.wsgi import DjangoApplication

main = func.WsgiMiddleware(DjangoApplication).main

Please wait for the next Python release to enable this feature.

[ankitkumarr]

getattr might be slightly slower (due to reflection) than regular get, but may not be a big deal. Just a note.

[elasticdotventures]

The following code should do the trick. ?? (Ha! not exactly)

import logging

import azure.functions as func
from ..Django.wsgi import DjangoApplication

main = func.WsgiMiddleware(DjangoApplication).main

So I expended a few neurons trying to wrap my head around Azure Functions & Django and WSGI at the same time and this helpful snippet makes little/no sense to me.
(Perhaps I'm being too literal) @Hazhzeng do you mean to use "..Django.wsgi" or is that just a lazy notation? I'm not sure what the ".." operator does in Python, so I'm going to assume it's a typo/invalid and it's not equivalent to the javascript spread operator, maybe your python-fu is stronger than mine.

I'm going to assume that code snippet belongs in __init__.py (or whatever file is referenced by the function.json), and that it's bindings should be of "type": "httpTrigger" and probably "authLevel":"anonymous"

It's not manage.py is the command line utility for admin tasks, but for some reason my Azure Function deployment script wants to deploy that. I've added manage.py to the .funcignore

I think the __init__.py should probably look something more like:

import os
import azure.functions as func
from django.core.wsgi import get_wsgi_application
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'myapp.settings')
application = get_wsgi_application()
 
def main(req: func.HttpRequest, context: func.Context) -> func.HttpResponse:
    return func.WsgiMiddleware(application).handle(req, context)

^^^ note: YMMV .. I haven't actually gotten this working YET (so the lines above may be totally wrong), though I'm pretty confident the earlier sample above doesn't work either, so hoping somebody might see this.

I'm also going to assume that on Azure functions the host.json needs to have the routePrefix disabled such as:

    "extensions": {
        "http": {
            "routePrefix": ""
        }
    }

as described in the "Customize the http endpoint" section of the Azure Functions reference
https://docs.microsoft.com/en-us/azure/azure-functions/functions-bindings-http-webhook-trigger?tabs=python#customize-the-http-endpoint

In functions.json

{
  {
  "bindings":[
     "route":"myapp/{*route}",
  ]
  }
}

And that sorta works, but not really. Because for my purpose the django urls.py is still pretty upset about running within an Azure Function.

The *route is a kludge, maybe better answers here: https://docs.microsoft.com/en-us/aspnet/web-api/overview/web-api-routing-and-actions/attribute-routing-in-web-api-2#constraints

So I can't figure out how to get Django to load from an Azure function but I've put in sufficient time in this fools errand so I'm giving up and heading back to a Docker instance.

[DharakOne]

How do create wsgi object in flask?

Could someone to give me example?

from ..FlaskApp.wsgi import application

import logging

import azure.functions as func
from ..FlaskApp.wsgi import application

[stefanushinardi]

@DharakOne this example might clear out some things: https://github.com/Hazhzeng/functions-wsgi-demo. Let me know if it is not clear

[echennells]

@DharakOne this example might clear out some things: https://github.com/Hazhzeng/functions-wsgi-demo. Let me know if it is not clear

Isn't the example using the azf-wsgi library and the old style?

https://github.com/Hazhzeng/functions-wsgi-demo/blob/master/HttpTrigger/__init__.py

[eelwk]

For anyone wishing for a very simple starting example implementation, try this:

app.py file (this is your simple hello world flask app)
path to file ..function-flask/api/app.py

import json

application = Flask(__name__)

@application.route("/api/httpTrigger")
def home():
    return "Hello, from Flask!"

I used an http Trigger function, cleverly named httpTrigger, thus the routing above.
My function app's __init.py__
path to file ..function-flask/httpTrigger/init.py

import logging

import azure.functions as func
from api.app import application

def main(req: func.HttpRequest, context: func.Context) -> func.HttpResponse:
    return func.WsgiMiddleware(application).handle(req, context)

Running the function app locally using the function runtime core tools, if I hit this URL:
http://localhost:7071/api/httpTrigger

The response I get back is a 200 OK and "Hello, from Flask!"

[ivan-ferrante]

Hi guys! 👋
For those looking for an easy implementation example with flask_restx and API registration: https://github.com/IvanFerrante92/azfunc-wsgi-example/tree/main/Azfn-Wsgi/AzfnWSGI

[wanghaisheng]

@eelwk
hey there i got my app.py like this, how to adjust this

import json

application = Flask(__name__)

def tiktoka():
    return "Hello, from Flask!"


if __name__ == "__main__":

    app.add_url_rule('/', 'webio_view', webio_view(partial(tiktoka, lang='')),
                     methods=['GET', 'POST', 'OPTIONS'])
   app.run()

then init.py it always start a random port instead of func 7071 default port

from .app  import tiktoka
app = Flask(__name__)

app.add_url_rule('/', 'webio_view', webio_view(partial(tiktoka, lang='')()),
                    methods=['GET', 'POST', 'OPTIONS'])

def main(req: func.HttpRequest, context: func.Context) -> func.HttpResponse:

    return func.WsgiMiddleware(app).handle(req, context)