Оптимизация стадии инициализации Django

https://habrahabr.ru/post/345856/
  • Python
  • Django


Если у вас Django проект работает на синхронных воркерах и вы периодически их перезапускаете (например, в gunicorn это опция --max-requests), полезно было бы знать, что по-умолчанию после каждого перезапуска воркера, первый запрос к нему обрабатывается гораздо дольше, чем последующие.


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


В статье будут приведены примеры для gunicorn wsgi сервера. Но они актуальны при любых способах запуска проекта на синхронных воркерах. Тоже самое актуально и для uWSGI и mod_wsgi.


Недавно перенесли наш Django проект в Kubernetes кластер. Там есть readiness/liveness probes, которые могут дёргать каждый запущенный экземпляр wsgi сервера (в нашем случае это gunicorn) за указанную http ручку. У нас это /api/v1/status:


class StatusView(views.APIView):
    @staticmethod
    def get(request):
        overall_ok = True

        try:
            with django.db.connection.cursor() as cursor:
                cursor.execute('SELECT version()')
                cursor.fetchone()
        except Exception:
            log.exception('Database failure')
            db = 'fail'
            overall_ok = False
        else:
            db = 'ok'

        try:
            cache.set('status', 1)
        except Exception:
            log.exception('Redis failure')
            redis = 'fail'
            overall_ok = False
        else:
            redis = 'ok'

        if overall_ok:
            s = status.HTTP_200_OK
        else:
            s = status.HTTP_500_INTERNAL_SERVER_ERROR

        return Response({
            'web': 'ok',
            'db': db,
            'redis': redis,
        }, status=s)

Так вот, до переезда в Kubernetes у нас стоял Zabbix, который каждую минуту делал запрос на /api/v1/status через loadbalancer. И этот health check особо никогда не фэйлился. Но после переезда, когда проверки стали выполняться для каждого отдельного gunicorn инстанса и с большей частотой, вдруг оказалось, что иногда мы не укладываемся в таймаут 5 секунд.


Тем не менее все работало нормально, проблем у пользователей не было. Поэтому особо внимание этому не уделял, но поставил себе фоновую задачу все таки разобраться в чем же дело. И вот что удалось выяснить:


По-умолчанию gunicorn запускает master процесс, который форкает количество процессов указанное аргументом --workers. Причем модуль wsgi, переданный gunicorn в качестве основного аргумента, загружается каждым воркером уже после форка. Но есть опция --preload. Если её задать, модуль wsgi будет загружен ДО форка. Отсюда правило:


На проде всегда запускай gunicorn с опцией --preload, что позволит сократить время инициализации каждого воркера. В результате инициализация по большей части будет происходить только в мастер процессе, далее будут форкаться уже инициализированные worker процессы.

Повторюсь, что большая часть этих оптимизаций имеет смысл, если у вас Django проект работает на синхронных воркерах и вы периодически их перезапускаете (--max-requests).


Тем не менее, удалось выяснить, что использование --preload недостаточно, и первый запрос к свежезапущеному воркеру все равно занимает больше времени чем последующие. Трейс показал, что предзагрузка wsgi мало что даёт, и большая часть Django инициализируется лишь во время первого запроса. Поэтому родилось решение "в лоб":


В инициализацию wsgi довавьте фейковый запрос к health/status эндпоинту, чтобы сразу проинициализировать максимум подсистем.

Например, я добавил в wsgi.py следующее:


# make request to /api/v1/status to prepare everything for first user request
def make_init_request():
    from django.conf import settings
    from django.test import RequestFactory

    f = RequestFactory()
    request = f.request(**{
        'wsgi.url_scheme': 'http',
        'HTTP_HOST': settings.SITE_DOMAIN,
        'QUERY_STRING': '',
        'REQUEST_METHOD': 'GET',
        'PATH_INFO': '/api/v1/status',
        'SERVER_PORT': '80',
    })

    def start_response(*args):
        pass

    application(request.environ, start_response)

if os.environ.get('WSGI_FULL_INIT'):
    make_init_request()

В результате воркеры стали инициализироваться на порядок быстрее, т.к. уже форкались полностью готовыми к следующему запросу.


По трейсам проблемы с инициализацией прекратились… почти. К своему стыду я не знал об этой особенности. Оказывается, по-умолчанию, Django при каждом запросе переподключается к БД. За это отвечает настройка CONN_MAX_AGE, которая только лишь(?) по историческим причинам заставляет ваше Django приложение работать как php скрипт из нулевых. Так что правило:


В настройки Django БД адаптера добавить CONN_MAX_AGE=None, чтобы подключения были постоянными.

Я бы даже и не заметил этого. Но, по какой-то причине, вызов psycopg2.connect иногда подвисает ровно на 5 секунд. Вот в этом я до конца не разобрался. Параллельно запущенный скрипт, который вызывает эту функцию раз в 10 секунд работал стабильно и подключался к БД быстрее чем за секунду за все время пока был запущен.


Но эти два правила конфиликтуют друг с другом, т.к. перед форком в основном процессе создаются подключения к БД и кешу. Дочерние процессы наследуют открытые сокеты основного процесса. В результате, это приводит к неопределённому поведению, когда несколько процессов будут одновременно работать с одним сокетом. Поэтому, перед форком, нужно закрыть все подключения:


# Close connections to database and cache before or after forking.
# Without this, child processes will share these connections and this is not supported.
def close_network_connections():
    from django import db
    from django.core import cache
    from django.conf import settings

    for conn in db.connections:
        db.connections[conn].close()

    django_redis_close_connection = getattr(settings, 'DJANGO_REDIS_CLOSE_CONNECTION', False)
    settings.DJANGO_REDIS_CLOSE_CONNECTION = True
    cache.close_caches()
    settings.DJANGO_REDIS_CLOSE_CONNECTION = django_redis_close_connection

if os.environ.get('WSGI_FULL_INIT'):
    make_init_request()
    # in case wsgi module preloaded in master process (i.e. `gunicorn --preload`)
    if os.environ.get('WSGI_FULL_INIT_CLOSE_CONNECTIONS'):
        close_network_connections()

Т.о. при использовании --preload и WSGI_FULL_INIT, нужно еще задать WSGI_FULL_INIT_CLOSE_CONNECTIONS.


В результате, аномальные задержки были полностью исключены. Но есть пара крайних случаев, когда они все же могут возникнуть:


Если все воркеры начнут перезапускаться одновременно. Это вполне вероятная ситуация, т.к. если запросы между воркерами распределяются приблизительно равномерно, то и max-requests наступит приблизительно в одно и то же время. Поэтому:


Запускай gunicorn c max-requests-jitter, чтобы воркеры не перезапускались одновременно, даже если они это делают достаточно быстро.

Также задержка может возникнуть во время первого запроса, когда создаются подключения к БД и другим внешним системам.


Это можно решить, но у меня нет идей как написать код независимый от используемого wsgi сервера. В gunicorn можно добавить обработчик для post_worker_init и там еще раз вызвать make_init_request(), тогда воркер перед получением первого запроса будет готов на 100%. Чтобы не усложнять, было решено пока что обойтись без этого, ведь мы и так добились того, что больше задержек на практике не наблюдается.

Ещё не оценен

Последние записи

Архив

2018
2017
2016
2015
2014

Категории

Авторы

Ленты

RSS / Atom