The web server used by ``gearbox serve`` is configured in the ``.ini`` file.

  Create it with ``config-create`` using for example ``http_server=waitress``

  to get a configuration starting point for your choice of web server.

  (Gearbox will do like ``paste`` and use the WSGI application entry point

  ``kallithea.config.application:make_app`` as specified in ``setup.py``.)

- `Apache httpd`_ can serve WSGI applications directly using mod_wsgi_ and a

  simple Python file with the necessary configuration. This is a good option if

  Apache is an option.

- uWSGI_ is also a full web server with built-in WSGI module. Use

  ``config-create`` with ``http_server=uwsgi`` to get a ``.ini`` file with

  uWSGI configuration.

- IIS_ can also server WSGI applications directly using isapi-wsgi_.

- A `reverse HTTP proxy <https://en.wikipedia.org/wiki/Reverse_proxy>`_

  can be put in front of another web server which has WSGI support.

  Such a layered setup can be complex but might in some cases be the right

  option, for example to standardize on one internet-facing web server, to add

  encryption or special authentication or for other security reasons, to

  provide caching of static files, or to provide load balancing or fail-over.

  Nginx_, Varnish_ and HAProxy_ are often used for this purpose, often in front

  of a ``gearbox serve`` that somehow is wrapped as a service.

The best option depends on what you are familiar with and the requirements for

performance and stability. Also, keep in mind that Kallithea mainly is serving

dynamically generated pages from a relatively slow Python process. Kallithea is

also often used inside organizations with a limited amount of users and thus no

continuous hammering from the internet.

.. note::

   Kallithea, the libraries it uses, and Python itself do in several places use

   simple caching in memory. Caches and memory are not always released in a way

   that is suitable for long-running processes. They might appear to be leaking

   memory. The worker processes should thus regularly be restarted - for

   example after 1000 requests and/or one hour. This can usually be done by the

   web server or the tool used for running it as a system service.

.. _Python: http://www.python.org/

.. _Gunicorn: http://gunicorn.org/

.. _Gevent: http://www.gevent.org/

.. _Waitress: https://docs.pylonsproject.org/projects/waitress/

.. _Gearbox: https://turbogears.readthedocs.io/en/latest/turbogears/gearbox.html

.. _PyPI: https://pypi.python.org/pypi

.. _Apache httpd: http://httpd.apache.org/

.. _isapi-wsgi: https://github.com/hexdump42/isapi-wsgi

.. _uWSGI: https://uwsgi-docs.readthedocs.io/

.. _nginx: http://nginx.org/en/

.. _iis: http://en.wikipedia.org/wiki/Internet_Information_Services

.. _pip: http://en.wikipedia.org/wiki/Pip_%28package_manager%29

.. _WSGI: http://en.wikipedia.org/wiki/Web_Server_Gateway_Interface

.. _HAProxy: http://www.haproxy.org/

.. _Varnish: https://www.varnish-cache.org/

.. _npm: https://www.npmjs.com/