Pip install uwsgi windows

Installing from a distribution package¶

uWSGI is available as a package in several OS/distributions.

Installing from source¶

To build uWSGI you need Python and a C compiler (gcc and clang are
supported). Depending on the languages you wish to support you will need their
development headers. On a Debian/Ubuntu system you can install them (and the
rest of the infrastructure required to build software) with:

apt-get install build-essential python

And if you want to build a binary with python/wsgi support (as an example)

apt-get install python-dev

On a Fedora/Redhat system you can install them with:

yum groupinstall "Development Tools"
yum install python

For python/wsgi support:

If you have a variant of make available in your system you can simply run
make. If you do not have make (or want to have more control) simply run:

python uwsgiconfig.py --build

You can also use pip to install uWSGI (it will build a binary with python support).

# Install the latest stable release:
pip install uwsgi
# ... or if you want to install the latest LTS (long term support) release,
pip install https://projects.unbit.it/downloads/uwsgi-lts.tar.gz

Or you can use ruby gems (it will build a binary with ruby/rack support).

# Install the latest stable release:
gem install uwsgi

At the end of the build, you will get a report of the enabled features. If
something you require is missing, just add the development headers and rerun
the build. For example to build uWSGI with ssl and perl regexp support you
need libssl-dev and pcre headers.

Alternative build profiles¶

For historical reasons when you run ‘make’, uWSGI is built with Python as the
only supported language. You can build customized uWSGI servers using build
profiles, located in the buildconf/ directory. You can use a specific
profile with:

python uwsgiconfig.py --build <profile>

Or you can pass it via an environment variable:

UWSGI_PROFILE=lua make
# ... or even ...
UWSGI_PROFILE=gevent pip install uwsgi

Modular builds¶

This is the approach your distribution should follow, and this is the approach
you MUST follow if you want to build a commercial service over uWSGI (see
below). The vast majority of uWSGI features are available as plugins. Plugins
can be loaded using the –plugin option. If you want to give users the maximum
amount of flexibility allowing them to use only the minimal amount of
resources, just create a modular build. A build profile named “core” is
available.

python uwsgiconfig.py --build core

This will build a uWSGi binary without plugins. This is called the “server
core”. Now you can start building all of the plugins you need. Check the
plugins/ directory in the source distribution for a full list.

python uwsgiconfig.py --plugin plugins/psgi core
python uwsgiconfig.py --plugin plugins/rack core
python uwsgiconfig.py --plugin plugins/python core
python uwsgiconfig.py --plugin plugins/lua core
python uwsgiconfig.py --plugin plugins/corerouter core
python uwsgiconfig.py --plugin plugins/http core
...

Remember to always pass the build profile (‘core’ in this case) as the third
argument.

Installing¶

uWSGI has multiple ways to install it. The most straightforward is to
install the pyuwsgi package, which provides precompiled wheels for
common platforms. However, it does not provide SSL support, which can be
provided with a reverse proxy instead.

Create a virtualenv, install your application, then install pyuwsgi.

$ cd hello-app
$ python -m venv venv
$ . venv/bin/activate
$ pip install .  # install your application
$ pip install pyuwsgi

If you have a compiler available, you can install the uwsgi package
instead. Or install the pyuwsgi package from sdist instead of wheel.
Either method will include SSL support.

$ pip install uwsgi

# or
$ pip install --no-binary pyuwsgi pyuwsgi

Running¶

The most basic way to run uWSGI is to tell it to start an HTTP server
and import your application.

$ uwsgi --http 127.0.0.1:8000 --master -p 4 -w hello:app

*** Starting uWSGI 2.0.20 (64bit) on [x] ***
*** Operational MODE: preforking ***
mounting hello:app on /
spawned uWSGI master process (pid: x)
spawned uWSGI worker 1 (pid: x, cores: 1)
spawned uWSGI worker 2 (pid: x, cores: 1)
spawned uWSGI worker 3 (pid: x, cores: 1)
spawned uWSGI worker 4 (pid: x, cores: 1)
spawned uWSGI http 1 (pid: x)

If you’re using the app factory pattern, you’ll need to create a small
Python file to create the app, then point uWSGI at that.

from hello import create_app

app = create_app()

$ uwsgi --http 127.0.0.1:8000 --master -p 4 -w wsgi:app

The --http option starts an HTTP server at 127.0.0.1 port 8000. The
--master option specifies the standard worker manager. The -p
option starts 4 worker processes; a starting value could be CPU * 2.
The -w option tells uWSGI how to import your application

Binding Externally¶

uWSGI should not be run as root with the configuration shown in this doc
because it would cause your application code to run as root, which is
not secure. However, this means it will not be possible to bind to port
80 or 443. Instead, a reverse proxy such as nginx or
Apache httpd should be used in front of uWSGI. It is possible to
run uWSGI as root securely, but that is beyond the scope of this doc.

uWSGI has optimized integration with Nginx uWSGI and
Apache mod_proxy_uwsgi, and possibly other servers, instead of using
a standard HTTP proxy. That configuration is beyond the scope of this
doc, see the links for more information.

You can bind to all external IPs on a non-privileged port using the
--http 0.0.0.0:8000 option. Don’t do this when using a reverse proxy
setup, otherwise it will be possible to bypass the proxy.

$ uwsgi --http 0.0.0.0:8000 --master -p 4 -w wsgi:app

0.0.0.0 is not a valid address to navigate to, you’d use a specific
IP address in your browser.

Async with gevent¶

The default sync worker is appropriate for many use cases. If you need
asynchronous support, uWSGI provides a gevent worker. This is not the
same as Python’s async/await, or the ASGI server spec. You must
actually use gevent in your own code to see any benefit to using the
worker.

When using gevent, greenlet>=1.0 is required, otherwise context locals
such as request will not work as expected. When using PyPy,
PyPy>=7.3.7 is required.

$ uwsgi --http 127.0.0.1:8000 --master --gevent 100 -w wsgi:app

*** Starting uWSGI 2.0.20 (64bit) on [x] ***
*** Operational MODE: async ***
mounting hello:app on /
spawned uWSGI master process (pid: x)
spawned uWSGI worker 1 (pid: x, cores: 100)
spawned uWSGI http 1 (pid: x)
*** running gevent loop engine [addr:x] ***