Документация к веб-серверу Tornado

Tornado - открытая версия масштабируемого, неблокирующего сервера и инструментов, которые используются сервисом FriendFeed. Приложение FriendFeed написано с использованием фреймворка, который выглядит как web.py или веб приложение Google, но имеет ряд дополнительных инструментов и оптимизаций с целью получения всех выгод от низлежащей неблокирующей инфраструктуры.

Обзор

Веб-сервер, который обслуживает сервис FriendFeed относительно простой, неблокирующий веб сервер, написанный на языке Python. Приложение FriendFeed написано с использованием веб фреймворка written using a web framework that looks a bit like web.py or Google's webapp, but with additional tools and optimizations to take advantage of the non-blocking web server and tools.

Tornado - открытая версия масштабируемого, неблокирующего сервера и инструментов, которые используются сервисом FriendFeed. Данный фреймворк отличается от большинства мейнстримовских (и, определенно, большинства Python фреймворков), потому что использование неблокирующего принципа дает достаточную быстроту. Благодаря этому, а также благодаря использованию epoll, он может обрабатывать тысячи одновременных соединений, что значит, этот фреймворк идеален для создания веб сервисов реального времени. Мы построили веб сервер специфиWe built the web server конкретно для того, чтобы обрабатывать функции сервиса FriendFeed в реальном времени — каждый активный пользователь сервися поддерживает открытое соединение с серверами. (Для получения дополнительной информации о масштабировании серверов для поддержки тисяч клиентов, прочитайте о проблеме C10K.)

Загрузка

Загрузите последнюю версию Tornado с GitHub:

• tornado-0.2.tar.gz

На GitHub Вы также можете просмореть исходники. Чтобы установить Tornado:

   1 tar xvzf tornado-0.2.tar.gz
   2 cd tornado-0.2
   3 python setup.py build
   4 sudo python setup.py install

После установки, вы получите возможность запустить любое из демонстрационных приложений из папки demos, которые включены в пакет Tornado.

   1 ./demos/helloworld/helloworld.py

Подготовка

Tornado тестировался на Python 2.5 и 2.6. Для того, чтобы использовать все функции Tornado, вам нужны библиотеки !PycURL !JSON, например simplejson. Полные инструкции по установке на Mac OS X и Ubuntu показаны ниже.

Mac OS X 10.5/10.6

   1 sudo easy_install setuptools pycurl==7.16.2.1 simplejson

Ubuntu Linux

   1 sudo apt-get install python-dev python-pycurl python-simplejson

Список модулей

Наиболее важный модуль - web, который является фреймворком, включающим в себя большую часть функционала пакета Tornado. Другие модули - это инструменты, которые делают модуль web богаче. Смотрите Руководство по Tornado ниже для более полной информации о пакете web.

Основные модули

• web - веб фреймворк, на котором построен FriendFeed. web содержит большинство важных функций Tornado

• escape - методы кодирование/декодирование XHTML, JSON и URL

• database - Простая обертка вокруг !MySQLdb для упрощения спользования СУБД MySQL

• template - язык шаблонов, в основе которого находится язык Python

• httpclient - неблокирующий HTTP клиент созданный для работы с модулями web и httpserver

• auth - реализация схем аутентификации и авторизации от третих разработчиков (Google OpenID/OAuth, Facebook Platform, Yahoo BBAuth, FriendFeed OpenID/OAuth, Twitter OAuth)

• locale - поддержка локализации/интернационализации

• options - синтаксический анализатор файлов настроек и аргументов коммандной строки, оптимизированный для использования в среде сервера

Низкоуровневые модули

• httpserver - очень простой HTTP сервер, на основе которого построен модуль web

• iostream - простая обертка вокруг неблокирующих сокетов для обеспечения общих шаблонов считывания и записи

• ioloop - основная петля ввода/вывода

Другие модули

• s3server - веб сервер, который реализует большую часть интерфейса Amazon S3, с локальным файловым хранилищем данных

Руководство

Обработчики и параметры запросов

Веб Приложение Tornado отображает (maps) URL или шаблоны URL в подклассы tornado.web.RequestHandler. Эти классы определяют get() и post() методы для обработки запросов HTTP GET и POST по этому URL.

Этот код отображает корневой URL / в MainHandler, а шаблон URL /story/([0-9]+) в StoryHandler. Регулярные выражения передаются в качестве аргументов методам класс RequestHandler:

   1 class MainHandler(tornado.web.RequestHandler):
   2     def get(self):
   3         self.write("You requested the main page")
   4 
   5 class StoryHandler(tornado.web.RequestHandler):
   6     def get(self, story_id):
   7         self.write("You requested the story " + story_id)
   8 
   9 application = tornado.web.Application([
  10     (r"/", MainHandler),
  11     (r"/story/([0-9]+)", StoryHandler),
  12 ])

С помощью метода get_argument() вы можете получить аргументы строки запроса и распарсить тело POST запроса:

   1 class MainHandler(tornado.web.RequestHandler):
   2     def get(self):
   3         self.write('<html><body><form action="/" method="post">'
   4                    '<input type="text" name="message">'
   5                    '<input type="submit" value="Submit">'
   6                    '</form></body></html>')
   7 
   8     def post(self):
   9         self.set_header("Content-Type", "text/plain")
  10         self.write("You wrote " + self.get_argument("message"))

Если вы хотите отправить сообщение об ошибке клиенту, например, 403 Unauthorized, вам достаточно вызвать исключение tornado.web.HTTPError:

   1 if not self.user_is_logged_in():
   2     raise tornado.web.HTTPError(403)

Обработчик запросов имеет доступ к объекту, который отражает состояние текущего запроса через атрибут self.request. Объект HTTPRequest object содержит ряд полезных атрибутов, среди них:

• arguments - все аргументы GET и POST запроса

• files - все загруженные файлы (через запросы multipart/form-data POST)

• path - путь запроса (все, что находится в строке запроса перед ?)

• headers - заголовки запроса

Смотрите определение класса HTTPRequest в модуле httpserver для получения полного списка атрибутов.

Шаблоны

Вы можете использовать любой язык шаблонов, который поддерживает язык Python, но Tornado идет вместе со своим собственным, который намного быстрее и гибче чем множество популярных систем шаблонов. Для полной информации обратитесь к документации к модулю template.

Шаблон Tornado - простой (или другой текстовый формат) с вложенными управляющими последовательностями языка Python, которые являются выражениями, заключенными в разметку:

   1 <html>
   2    <head>
   3       <title>{{ title }}</title>
   4    </head>
   5    <body>
   6      <ul>
   7        {% for item in items %}
   8          <li>{{ escape(item) }}</li>
   9        {% end %}
  10      </ul>
  11    </body>
  12  </html>

Если вы сохранили этот шаблон как "template.html", и положили в ту же папку, что и файл Python, отобразите этот шаблон следующим образом:

   1 class MainHandler(tornado.web.RequestHandler):
   2     def get(self):
   3         items = ["Item 1", "Item 2", "Item 3"]
   4         self.render("template.html", title="My title", items=items)

Шаблоны Tornado поддерживают упаравляющие последовательности и выражения. Управляющие последовательности заключены в символы {% и %}, например, {% if len(items) > 2 %}. Выражения заключены в символы { { и } }, например, { { items[0] } }.

Управляющие последовательности более менее точно соответствують предложениям языка Python. Мы поддерживаем if, for, while, и try, каждое из которых заканчивается последовательностью символов {% end %}. Мы также поддерживаем наследование шаблонов через предложения extends и block, которые более детально описаны в документации к модулю template.

Выражения могут быть любыми, соответствующими языку Python, включая вызовы функций. Мы поддерживаем функции escape, url_escape, и json_encode по молчанию, но вы можете передать любые другие функции в шаблон через ключевые аргументы функции render модуля template:

   1 class MainHandler(tornado.web.RequestHandler):
   2     def get(self):
   3         self.render("template.html", add=self.add)
   4 
   5     def add(self, x, y):
   6         return x + y

Когда вы разрабатываете реальное приложение, вам не нужны все функции шаблонов Tornado, особенно наследование. Почитайте о всех функциях шаблонов в документации к модулю template.

Под капотом, шаблоны Tornado транслируются прямо в Python. Выражения из шаблонов копируются без изменений в Python функцию, которая представляет шаблон. Мы не пытаемся предостеречь вас от каких либо действий в языке шаблонов; мы создали его для того, чтобы обеспечивать гибкость, которая не свойственна другим, более строгим языкам шаблонов. Следовательно, если вы напишите внутри выражений какую нибудь несуразицу, то получите ошибки Python при выполнении шаблона.

Cookies и защищенные cookies

cookies можно установить в обозревателе пользователя с помощью метода set_cookie:

   1 class MainHandler(tornado.web.RequestHandler):
   2     def get(self):
   3         if not self.get_cookie("mycookie"):
   4             self.set_cookie("mycookie", "myvalue")
   5             self.write("Your cookie was not set yet!")
   6         else:
   7             self.write("Your cookie was set!")

Часто бывает, что cookies очень просто подделываются зловредными клиентами. Если вам нужно установить cookies чтобы, например, сохранить идентификатор авторизованного пользователя, вам следует их подписать для предотвращения подделки. Tornado предоставляет такую возможность из коробки через использование методов set_secure_cookie и get_secure_cookie. Чтобы использовать эти методы, вы должны указать секретный ключ, который называется cookie_secret, когда создаете приложение. Для реализации этого вам нужно передать его в настройках приложения как ключевой аргумент:

   1 application = tornado.web.Application([
   2     (r"/", MainHandler),
   3 ], cookie_secret="61oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=")

Подписанные cookies содержат закодированное значение cookie плюс timestamp и подпись (сигнатуру) HMAC. Если cookie устарела, или подпись не совпадает, метод get_secure_cookie вернет None, как будто cookie не была установлена. Вот защищенная версия примера, приводимого выше:

   1 class MainHandler(tornado.web.RequestHandler):
   2     def get(self):
   3         if not self.get_secure_cookie("mycookie"):
   4             self.set_secure_cookie("mycookie", "myvalue")
   5             self.write("Your cookie was not set yet!")
   6         else:
   7             self.write("Your cookie was set!")

Аутентификация пользователей

Проверка подлинности пользователя доступна в каждом обработчике запроса как self.current_user, и в каждом шаблоне как current_user. По умолчанию current_user имеет значение None.

Для осуществления аутентификации в вашем приложении вам нужно переопределить метод get_current_user() в вашем обработчике запроса, чтобы определить текущего пользователя, например, значение куки. Ниже приведен пример, который позволяет пользователям войти в приложение просто указав ник, который потом сохраняется в куке:

   1 class BaseHandler(tornado.web.RequestHandler):
   2     def get_current_user(self):
   3         return self.get_secure_cookie("user")
   4 
   5 class MainHandler(BaseHandler):
   6     def get(self):
   7         if not self.current_user:
   8             self.redirect("/login")
   9             return
  10         name = tornado.escape.xhtml_escape(self.current_user)
  11         self.write("Hello, " + name)
  12 
  13 class LoginHandler(BaseHandler):
  14     def get(self):
  15         self.write('<html><body><form action="/login" method="post">'
  16                    'Name: <input type="text" name="name">'
  17                    '<input type="submit" value="Sign in">'
  18                    '</form></body></html>')
  19 
  20     def post(self):
  21         self.set_secure_cookie("user", self.get_argument("name"))
  22         self.redirect("/")
  23 
  24 application = tornado.web.Application([
  25     (r"/", MainHandler),
  26     (r"/login", LoginHandler),
  27 ], cookie_secret="61oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=")

Вы можете потребовать, чтобы пользователь аутентифицировался в приложении используя декоратор tornado.web.authenticated. Если запрос передается методу с этим декоратором и пользователь не залогинен он будет перенаправлен на login_url (который вы указываете в настройках приложения). Перепишем пример выше с использованием этого декоратора:

   1 class MainHandler(BaseHandler):
   2     @tornado.web.authenticated
   3     def get(self):
   4         name = tornado.escape.xhtml_escape(self.current_user)
   5         self.write("Hello, " + name)
   6 
   7 settings = {
   8     "cookie_secret": "61oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=",
   9     "login_url": "/login",
  10 }
  11 application = tornado.web.Application([
  12     (r"/", MainHandler),
  13     (r"/login", LoginHandler),
  14 ], **settings)

Если вы используете этот декоратор аутентификации для метода post() и пользователь не залогинен, то сервер пошлет в ответ ошибку 403.

Tornado поставляется со встроенной поддержкой схем аутентификации сторонних производителей, например Google OAuth. Посмотрите документуацию по модулю auth для получения подробной информации, либо раздел документации посвященный аутентификации с помощью сторонних разработчиков.

Также рекомендуем ознакомиться с демонстрационным приложением Blog, идущим в комплекте с Tornado, чтобы получить представление об устройстве приложения, использующего аутентификацию и сохраняющего пользовательские данные в БД MySQL

Защита от CSRF

Cross-site request forgery, или XSRF (CSRF) - обычная проблема персонализированных веб приложений. Смотрите статью в википедии для получения более полной информации о, как работает XSRF.

Общепринятое решение для предотвращения XSRF - устанавливать cookie для каждого пользователя с непредсказуемым значением и включать это значение как дополнительный аргумент в каждую форму на вашем сайте. Если cookie и ее значение при отправке формы не совпадают, то запрос определяется как подделанный.

Tornado содержит встроенную защиту от XSRF. Для ее активирования, включите опцию xsrf_cookies в настройках приложения:

   1 settings = {
   2     "cookie_secret": "61oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=",
   3     "login_url": "/login",
   4     "xsrf_cookies": True,
   5 }
   6 application = tornado.web.Application([
   7     (r"/", MainHandler),
   8     (r"/login", LoginHandler),
   9 ], **settings)

Если xsrf_cookies установлена, веб приложение Tornado будет устанавливать _xsrf cookie для всех пользователей и отклонять все POST запросы, которые не содержать верного значения _xsrf. Если вы включите эту опцию, вы должны включить поле во все формы, которые отправляются на сервер посредством POST запроса. Сделать это можно специальной функцией xsrf_form_html(), которая доступна во всех шаблонах по умолчанию:

   1 <form action="/login" method="post">
   2   {{ xsrf_form_html() }}
   3   <div>Username: <input type="text" name="username"/></div>
   4   <div>Password: <input type="password" name="password"/></div>
   5   <div><input type="submit" value="Sign in"/></div>
   6 </form>

Если вы отправляете AJAX POST запросы, вам также следует включить в JavaScript значение _xsrf при выполнении каждого запроса. Нже показана функция jQuery, которая используется в FriendFeed для AJAX POST запросов, автоматически добавляя значение _xsrf во все запросы:

   1 function getCookie(name) {
   2     var r = document.cookie.match("\\b" + name + "=([^;]*)\\b");
   3     return r ? r[1] : undefined;
   4 }
   5 
   6 jQuery.postJSON = function(url, args, callback) {
   7     args._xsrf = getCookie("_xsrf");
   8     $.ajax({url: url, data: $.param(args), dataType: "text", type: "POST",
   9         success: function(response) {
  10         callback(eval("(" + response + ")"));
  11     }});
  12 };

Статические файлы и агрессивное кеширование файлов

Вы можете обслуживать статические файлы с помощью Tornado, через указание настройки static_path в вашем приложении.

   1 settings = {
   2     "static_path": os.path.join(os.path.dirname(__file__), "static"),
   3     "cookie_secret": "61oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=",
   4     "login_url": "/login",
   5     "xsrf_cookies": True,
   6 }
   7 application = tornado.web.Application([
   8     (r"/", MainHandler),
   9     (r"/login", LoginHandler),
  10 ], **settings)

Эта настройка автомтически сделает все запросы, которые начинаются со /static/ обслуживаемыми из директории для статичных файлов, например http://localhost:8888/static/foo.png использует foo.png из директории static_path. Также Tornado автоматически обслужвает файлы /robots.txt и /favicon.ico из директории статики (даже если перфикс /static/ не указан).

В случае с браузерами, то неплохой идеей для увеличения производительности является агрессивное кэширование ресурсов, так чтобы не посылать ненужные запросы If-Modified-Since или Etag, ожидание обработки которых блокирует отображение страницы. Торнадо, будучи развернутым, сразу предоставляет такую возможность с помощью контроля версий статического контента.

Чтобы использовать эту особенность нужно вызвать метод static_url() из вашего шаблона вместо того, чтобы вводить напрямую путь к статичному файлу в HTML:

   1 <html>
   2    <head>
   3       <title>FriendFeed - {{ _("Home") }}</title>
   4    </head>
   5    <body>
   6      <div><img src="{{ static_url("images/logo.png") }}"/></div>
   7    </body>
   8  </html>

Функция static_url() преобразует относительный путь в URI вроде /static/images/logo.png?v=aae54. Аргумент v - это хэш содержимого logo.png, и его наличие говорит Tornado отослать заголовки браузеру пользователя, что, в свою очередь, заставляет браузер кэшировать статичный файл на неопределенно долгове время.

Так как аргумент v основан на содержимом файла, то если вы изменяете файл и перезапускаете сервер, начинает передаваться новое значение v и браузер пользователя загрузит новую версию файла. Если содержимое файла не изменилось, браузер продолжит использовать локальный кэш даже не проверяя изменения на сервере, что существенно увеличивает скорость отображения страницы.

В производстве вы возможно захотите обслуживать статику более оптимизированным для этой цели сервером вроде ngnix. Вы можете сконфигурировать почти любой web-сервер так, чтобы он поддерживал подобную семантику кэширования. Вот пример конфигурации ngnix, который мы изпользуем в проекте FriendFeed

   1 location /static/ {
   2    root /var/friendfeed/static;
   3    if ($query_string) {
   4        expires max;
   5    }
   6 }

Локализация

Локаль каждого пользователя (неважно вошел он в приложение он или нет) доступна всегда как атрибут self.locale обработчика запросов и как locale в шаблонах. Название локали (например, en_US) доступно через locale.name, а переводить строки вы можете методом locale.translate. Шаблоны также содержат глобальную функцию _(), с помощью которой также можно выполнять переводы строк. Функция translate имеет две формы:

   1 _("Translate this string")

которая переводит строку используя текущую локаль, и

   1 _("A person liked this", "%(num)d people liked this", len(people)) % {"num": len(people)}

которая переводит строку, которая может быть единичной или множественной, основываясь на значении третьего аргумента. В примере выше перевод первой строки будет осуществлен, если len(people) равно 1, в противном случае будет выполнен перевод второй строки.

Наиболее общий шаблон для переводов - использовать именованные заполнители (placeholders) Python для переменных, (например, как %(num)d в примере the example above).

Вот правильно локализованный шаблон:

   1 <html>
   2    <head>
   3       <title>FriendFeed - {{ _("Sign in") }}</title>
   4    </head>
   5    <body>
   6      <form action="{{ request.path }}" method="post">
   7        <div>{{ _("Username") }} <input type="text" name="username"/></div>
   8        <div>{{ _("Password") }} <input type="password" name="password"/></div>
   9        <div><input type="submit" value="{{ _("Sign in") }}"/></div>
  10        {{ xsrf_form_html() }}
  11      </form>
  12    </body>
  13  </html>

По умолчанию мы определяем пользовательскую локаль используя заголовок Accept-Language, который отсылается обозревателем. Если такого заголовка нет, то устанавливается локаль en_US. Если вы разрешите пользователям устанавливать свои предпочтения к локали, переопределите выборку локали по умолчанию, переопределив метод get_user_locale в обработчике запросов:

   1 class BaseHandler(tornado.web.RequestHandler):
   2     def get_current_user(self):
   3         user_id = self.get_secure_cookie("user")
   4         if not user_id: return None
   5         return self.backend.get_user_by_id(user_id)
   6 
   7     def get_user_locale(self):
   8         if "locale" not in self.current_user.prefs:
   9             # Use the Accept-Language header
  10             return None
  11         return self.current_user.prefs["locale"]

Если get_user_locale возвращает None, мы обращаемся к заголовку запроса Accept-Language.

Вы можете загрузить все переводы приложения используя метод tornado.locale.load_translations. Он берет из папки, которая должна содержать CSV файлы, файлы, которые названы за именем локали, например, es_GT.csv или fr_CA.csv. Метод загружает все переводы из этих CSV файлов и files and выводит список поддерживаемых локалей исходя из наличия CSV файлов. Обычно вы будете вызывать этот метод один раз в теле метода main() своего сервера:

   1 def main():
   2     tornado.locale.load_translations(
   3         os.path.join(os.path.dirname(__file__), "translations"))
   4     start_server()

   1 class Entry(tornado.web.UIModule):
   2     def render(self, entry, show_comments=False):
   3         return self.render_string(
   4             "module-entry.html", show_comments=show_comments)

   1 class HomeHandler(tornado.web.RequestHandler):
   2     def get(self):
   3         entries = self.db.query("SELECT * FROM entries ORDER BY date DESC")
   4         self.render("home.html", entries=entries)
   5 
   6 class EntryHandler(tornado.web.RequestHandler):
   7     def get(self, entry_id):
   8         entry = self.db.get("SELECT * FROM entries WHERE id = %s", entry_id)
   9         if not entry: raise tornado.web.HTTPError(404)
  10         self.render("entry.html", entry=entry)
  11 
  12 settings = {
  13     "ui_modules": uimodules,
  14 }
  15 application = tornado.web.Application([
  16     (r"/", HomeHandler),
  17     (r"/entry/([0-9]+)", EntryHandler),
  18 ], **settings)

   1 {% for entry in entries %}
   2   {{ modules.Entry(entry) }}
   3 {% end %}

   1 {{ modules.Entry(entry, show_comments=True) }}

   1 class Entry(tornado.web.UIModule):
   2     def embedded_css(self):
   3         return ".entry { margin-bottom: 1em; }"
   4 
   5     def render(self, entry, show_comments=False):
   6         return self.render_string(
   7             "module-entry.html", show_comments=show_comments)

   1 class MainHandler(tornado.web.RequestHandler):
   2     @tornado.web.asynchronous
   3     def get(self):
   4         self.write("Hello, world")
   5         self.finish()

   1 class MainHandler(tornado.web.RequestHandler):
   2     @tornado.web.asynchronous
   3     def get(self):
   4         http = tornado.httpclient.AsyncHTTPClient()
   5         http.fetch("http://friendfeed-api.com/v2/feed/bret",
   6                    callback=self.async_callback(self.on_response))
   7 
   8     def on_response(self, response):
   9         if response.error: raise tornado.web.HTTPError(500)
  10         json = tornado.escape.json_decode(response.body)
  11         self.write("Fetched " + str(len(json["entries"])) + " entries "
  12                    "from the FriendFeed API")
  13         self.finish()

   1 class GoogleHandler(tornado.web.RequestHandler, tornado.auth.GoogleMixin):
   2     @tornado.web.asynchronous
   3     def get(self):
   4         if self.get_argument("openid.mode", None):
   5             self.get_authenticated_user(self.async_callback(self._on_auth))
   6             return
   7         self.authenticate_redirect()
   8 
   9     def _on_auth(self, user):
  10         if not user:
  11             self.authenticate_redirect()
  12             return
  13         # Save the user with, e.g., set_secure_cookie()

   1 ab -n 100000 -c 25 http://10.0.1.x/

   1 user nginx;
   2 worker_processes 1;
   3 
   4 error_log /var/log/nginx/error.log;
   5 pid /var/run/nginx.pid;
   6 
   7 events {
   8     worker_connections 1024;
   9     use epoll;
  10 }
  11 
  12 http {
  13     # Enumerate all the Tornado servers here
  14     upstream frontends {
  15         server 127.0.0.1:8000;
  16         server 127.0.0.1:8001;
  17         server 127.0.0.1:8002;
  18         server 127.0.0.1:8003;
  19     }
  20 
  21     include /etc/nginx/mime.types;
  22     default_type application/octet-stream;
  23 
  24     access_log /var/log/nginx/access.log;
  25 
  26     keepalive_timeout 65;
  27     proxy_read_timeout 200;
  28     sendfile on;
  29     tcp_nopush on;
  30     tcp_nodelay on;
  31     gzip on;
  32     gzip_min_length 1000;
  33     gzip_proxied any;              
  34     gzip_types text/plain text/html text/css text/xml
  35                application/x-javascript application/xml
  36                application/atom+xml text/javascript;
  37 
  38     # Only retry if there was a communication error, not a timeout
  39     # on the Tornado server (to avoid propagating "queries of death"
  40     # to all frontends)
  41     proxy_next_upstream error;
  42 
  43     server {
  44         listen 80;
  45 
  46         # Allow file uploads
  47         client_max_body_size 50M;
  48 
  49         location ^~ /static/ {
  50             root /var/www;
  51             if ($query_string) {
  52                 expires max;
  53             }
  54         }
  55         location = /favicon.ico {
  56             rewrite (.*) /static/favicon.ico;
  57         }
  58         location = /robots.txt {
  59             rewrite (.*) /static/robots.txt;
  60         }
  61 
  62         location / {
  63             proxy_pass_header Server;
  64             proxy_set_header Host $http_host;
  65             proxy_redirect false;
  66             proxy_set_header X-Real-IP $remote_addr;
  67             proxy_set_header X-Scheme $scheme;
  68             proxy_pass http://frontends;
  69         }
  70     }
  71 }

   1 import tornado.web
   2 import tornado.wsgi
   3 import wsgiref.handlers
   4 
   5 class MainHandler(tornado.web.RequestHandler):
   6     def get(self):
   7         self.write("Hello, world")
   8 
   9 if __name__ == "__main__":
  10     application = tornado.wsgi.WSGIApplication([
  11         (r"/", MainHandler),
  12     ])
  13     wsgiref.handlers.CGIHandler().run(application)