Используйте кэш браузера для следующих ресурсов: «Используйте кэш браузера». Рекомендация от Google. Пoдскажите добрым словом?

Содержание

HTTP-кеширование — HTTP | MDN

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

Техника кеширования заключается в сохранении копии полученного ресурса для возврата этой копии в ответ на дальнейшие запросы. Запрос на ресурс, уже имеющийся в веб-кеше, перехватывается, и вместо обращения к исходному серверу выполняется загрузка копии из кеша. Таким образом снижается нагрузка на сервер, которому не приходится самому обслуживать всех клиентов, и повышается производительность — кеш ближе к клиенту и ресурс передаётся быстрее. Кеширование является основным источником повышения производительности веб-сайтов. Однако, кеш надо правильно сконфигурировать: ресурсы редко остаются неизменными, так что копию требуется хранить только до того момента, как ресурс изменился, но не дольше.

Существует несколько видов кешей, которые можно разделить на две основные категории: приватные кеши и кеши совместного использования. В кешах совместного использования (shared cache) хранятся копии, которые могут направляться разным пользователям. Приватный кеш (private cache) предназначен для отдельного пользователя. Здесь будет говориться в основном о кешах браузеров и прокси, но существуют также кеши шлюзов, CDN, реверсные прокси кеши и балансировщики нагрузки, разворачиваемые на серверах для повышения надёжности, производительности и масштабируемости веб-сайтов и веб-приложений.

 

Приватный (private) кеш браузера

Приватный кеш предназначен для отдельного пользователя. Вы, возможно, уже видели параметры кеширования в настройках своего браузера. Кеш браузера содержит все документы, загруженные пользователем по HTTP. Он используется для доступа к ранее загруженным страницам при навигации назад/вперёд, позволяет сохранять страницы, или просматривать их код, не обращаясь лишний раз к серверу. Кроме того, кеш полезен при отключении от сети.

Общий (shared) прокси-кеш

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

Кеширование в HTTP не является обязательным, однако в большинстве случаев бывает полезно повторно использовать ранее сохранённые ресурсы. Тем не менее, стандартные кеши HTTP обычно способны кешировать только ответы на запросы методом GET, а другие отклоняют.

Первичный ключ состоит из метода запроса и запрашиваемого URI (зачастую используется только URI, поскольку целью кеширования являются только GET-запросы). Вот примеры того, что обычно записывается в кеш:

  • Успешно загруженные ресурсы: ответ 200 OK на запрос методом GET HTML-документов, изображений или файлов.
  • Постоянные перенаправления: ответ 301 Moved Permanently («перемещено навсегда»).
  • Сообщения об ошибках: ответ 404 Not Found («не найдено»).
  • Неполные результаты: ответ 206 Partial Content («частичное содержимое»).
  • Ответы на запросы отличные от GET, если есть что-либо, подходящее для использования в качестве ключа кеша.

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

Заголовок

Cache-control

Поле Cache-Control общего заголовка HTTP/1.1 используется для задания инструкций по механизму кеширования как в запросах, так и в ответах. Применяется для задания политик кеширования.

Полное отсутствие кеширования

В кеше не должно сохраняться ничего — ни по запросам клиента, ни по ответам сервера. Запрос всегда отправляется на сервер, ответ всегда загружается полностью.

Cache-Control: no-store
Cache-Control: no-cache, no-store, must-revalidate
Кешировать, но проверять актуальность

Перед тем, как выдать копию, кеш запрашивает исходный сервер на предмет актуальности ресурса.

Cache-Control: no-cache
Приватные (private) и общие (public) кеши

Директива «public» указывает, что ответ можно сохранять в любом кеше. Это бывает полезно, если возникает потребность сохранить страницы с HTTP-аутентификацией, или такими кодами ответа, которые обычно не кешируются. Директива же «private» указывает, что ответ предназначен отдельному пользователю и не должен храниться в кеше совместного использования. В этом случае ответ может сохраняться приватным кешем браузера.

Cache-Control: private
Cache-Control: public
Срок действия (Expiration)

Самой важной здесь является директива «max-age=<seconds>» — максимальное время, в течение которого ресурс считается «свежим». В отличие от директивы

Expires, она привязана к моменту запроса. К неизменяющимся файлам приложения обычно можно применять «агрессивное» кеширование. Примером таких статических файлов могут быть изображения, файлы стилей (CSS) или скриптов (JavaScript).

Подробнее об этом рассказывается в разделе Свежесть ресурса.

Cache-Control: max-age=31536000
Проверка актуальности

При использовании директивы «must-revalidate» кеш обязан проверять статус ресурсов с истёкшим сроком действия. Те копии, что утратили актуальность, использоваться не должны. Подробнее об этом рассказано ниже, в разделе Валидация кеша.

Cache-Control: must-revalidate

Заголовок

Pragma

Pragma является заголовком HTTP/1.0. Он не описан для HTTP-ответов и, таким образом, не может служить надёжной заменой общему заголовку Cache-Control протокола HTTP/1.1, хотя его поведение аналогично «Cache-Control: no-cache» когда поле заголовка Cache-Control опущено в запросе. Использовать его следует только для совместимости с клиентами HTTP/1.0.

Однажды попав в кеш, ресурс, теоретически, может храниться там вечно. Однако, поскольку объем хранилища конечен, записи периодически приходится оттуда удалять.  Этот процесс называют вытеснением данных из кеша (cache eviction). Кроме того, ресурсы могут изменяться на сервере, поэтому кеш требуется обновлять. Поскольку HTTP является клиент-серверным протоколом, сервера не могут сами обращаться к кешам и клиентам при изменении ресурса; им необходимо договориться о сроке действия сохранённой копии. До его истечения ресурс считается

свежим (fresh), после — устаревшим (stale). Алгоритмы вытеснения отдают предпочтение «свежим» ресурсам. Тем не менее, копия ресурса не удаляется из кеша сразу же по истечении её срока действия; при получении запроса на устаревший ресурс кеш передаёт его дальше с заголовком If-None-Match (en-US) на случай, если копия все ещё актуальна. Если это так, сервер возвращает заголовок 304 Not Modified («не изменялось»), а тело ресурса не посылает, экономя тем самым трафик.

Вот пример того, как протекает этот процесс при использовании совместного кеша прокси:

Срок действия (freshnessLifetime) вычисляется на основании нескольких заголовков. Если задан заголовок «Cache-control: max-age=N», то срок действия равен N. Если его нет, а это бывает очень часто, проверяется заголовок Expires, и, если он есть, то срок действия берётся равным значению заголовка Expires минус значение заголовка Date. Наконец, если нет ни того ни другого, смотрят заголовок Last-Modified.  Если он есть, то срок действия равен значению заголовка Date минус значение заголовка Last-modified разделить на 10.

Время устаревания (expirationTime) вычисляется следующим образом:

expirationTime = responseTime + freshnessLifetime - currentAge

где responseTime — это время получения ответа по часам браузера, а currentAge — текущий возраст кеша.

Обновление статических ресурсов (Revved resources)

Чем больше ресурсов может быть взято из кеша, тем быстрее сайт реагирует на запросы и тем выше его производительность. Из этих соображений их «срок годности» имеет смысл делать как можно большим. Однако, возникает проблема с ресурсами, которые обновляются редко и нерегулярно. Как раз их кеширование даёт больше всего выгоды, но сильно затрудняет обновление. Такие ресурсы можно найти на любой веб-странице: файлы скриптов (JavaScript) и стилей (CSS) изменяются редко, но уж если это произошло, обновление надо произвести как можно быстрее.

Веб-разработчики разработали метод, который Стив Сандерс (Steve Sounders) назвал revving[1], что можно перевести как «оборачиваемость». Для редко обновляемых файлов используют особый способ именования: в их URL, обычно в имя файла, добавляют номер релиза или версии. Таким образом, каждая новая версия считается отдельным ресурсом, срок устаревания которого отодвинут далеко в будущее, как правило, на год, или больше. Недостатком этого метода является то, что для получения новых версий ресурса приходится обновлять все ссылки на него — это некоторое усложнение, справиться с которым разработчику помогает цепочка инструментов. Обновление статических ресурсов влечёт за собой обновление и часто изменяемых ресурсов. Когда считываются первые, считываются и новые версии вторых.

Этот метод имеет дополнительное достоинство: одновременное обновление двух кешированных ресурсов не приводит к ситуации, при которой устаревшая версия одного ресурса используется вместе с новой версией другого. Это очень важно для сайтов с взаимосвязанными файлами стилей CSS или JS-скриптов — связь может возникнуть, например, из-за ссылок на одни и те же элементы HTML-страницы.

Номер версии, добавляемый к статическому ресурсу, не обязательно записывать в виде стандартного номера версии наподобие 1.1.3, или другого возрастающего числового значения. Это может быть что угодно, позволяющее избежать совпадений — например, дата.

Валидация кеша запускается при нажатии пользователем кнопки перезагрузки. Кроме того, она может выполняться в ходе обычного просмотра страниц, если кешированный ответ включает заголовок «Cache-control: must-revalidate». Другим фактором являются настройки кеширования браузера — можно потребовать принудительной валидации при каждой загрузке документа.

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

Заголовки ETag

Заголовок ответа ETag является непрозрачным для клиентского приложения (агента) значением, которое можно использовать в качестве сильного валидатора. Суть в том, что клиент, например, браузер, не знает, что представляет эта строка и не может предсказать, каким будет её значение. Если в ответе присутствует заголовок ETag, клиент может транслировать его значение через заголовок If-None-Match (en-US) будущих запросов для валидации кешированного ресурса.

Заголовок ответа Last-Modified можно использовать в качестве слабого валидатора. Слабым он считается из-за того, что имеет 1-секундное разрешение. Если в ответе присутствует заголовок Last-Modified, то для валидации кешированного документа клиент может выводить в запросах заголовок  If-Modified-Since.

При запросе на валидацию сервер может либо проигнорировать валидацию и послать стандартный ответ 200 OK, либо вернуть ответ 304 Not Modified (с пустым телом), тем самым указывая браузеру взять копию из кеша. В последнем случае в ответ могут входить также заголовки для обновления срока действия кешированного ресурса.

Заголовок HTTP-ответа Vary определяет, как по заголовкам будущих запросов понять, может ли быть использована копия из кеша, или нужно запросить новые данные у сервера.

Если кеш получает запрос, который можно удовлетворить сохранённым в кеше ответом с заголовком Vary, то использовать этот ответ можно только при совпадении всех указанных в Vary полей заголовка исходного (сохранённого в кеше) запроса и нового запроса.

Это может быть полезно, например, при динамическом предоставлении контента. При использовании заголовка Vary: User-Agent кеширующие сервера, принимая решение об использовании страницы из кеша, должны учитывать агент пользователя. Так можно избежать ситуации, когда пользователи мобильных устройств по ошибке получат десктопную версию вашего сайта. Вдобавок, это может помочь Google и другим поисковым системам обнаружить мобильную версию страницы, и может также указать им на то, что здесь нет никакой подмены контента с целью поисковой оптимизации (Cloaking).

Vary: User-Agent

Поскольку значение заголовка User-Agent различается («varies») у мобильных и десктопных клиентов, закешированный мобильный контент не будет по ошибке отсылаться пользователям десктопов и наоборот.

Предотвращение кэшинга в Internet Explorer

  • Статья
  • Чтение занимает 4 мин
  • 2 contributors

Были ли сведения на этой странице полезными?

Да Нет

Хотите оставить дополнительный отзыв?

Отзывы будут отправляться в корпорацию Майкрософт. Нажав кнопку «Отправить», вы разрешаете использовать свой отзыв для улучшения продуктов и служб Майкрософт. Политика конфиденциальности.

Отправить

В этой статье

Важно!

Приложение Internet Explorer 11 для ПК будет выведено из использования и снято с поддержки 15 июня 2022 г. (список других вопросов, см. в разделе Вопросы и ответы). Те же приложения и сайты IE11, которые вы используете сегодня, могут открываться в Microsoft Edge режиме Internet Explorer. Подробнее см. здесь.

В этой статье описывается использование http-загонщиков для управления кэшингом веб-страниц в Internet Explorer.

Оригинальная версия продукта:   Internet Explorer
Исходный номер КБ:   234067

Сводка

С помощью Microsoft Internet Information Server (IIS) можно легко отметить высокостабильную или чувствительную страницу с помощью следующего сценария в крайнем начале определенных страниц ASP (ASP):

<% Response.CacheControl = "no-cache" %>
<% Response.AddHeader "Pragma", "no-cache" %>
<% Response.Expires = -1 %>

Истечение срока действия и заглавная дата истечения срока действия

Настоятельно рекомендуется, чтобы все веб-серверы использовали схему для истечения срока действия всех веб-страниц. Это плохая практика для веб-сервера, чтобы не поставлять информацию о сроках действия через http expires ответ загона для каждого ресурса, возвращаемой к запрашивающих клиентов. Большинство браузеров и промежуточных прокси сегодня уважают эту информацию о сроках действия и используют ее для повышения эффективности коммуникаций по сети.

Всегда используйте заглавную папку Expires, чтобы указать наиболее разумное время, когда определенный файл на сервере должен быть обновлен клиентом. При регулярном обновлении страниц наиболее эффективным является следующий период обновления. Возьмем, например, ежедневную страницу новостей в Интернете, которая обновляется каждый день в 5 утра. Веб-сервер для этой страницы новостей должен возвращать заготвка Expires со значением для 5 утра. на следующий день. После этого браузеру не нужно снова связываться с веб-сервером, пока страница не изменится.

Страницы, которые не должны изменяться, должны быть помечены со сроком действия около одного года.

Во многих случаях веб-серверы имеют одну или несколько волатильных страниц на сервере, которые содержат сведения, которые подлежат немедленному изменению. Эти страницы должны быть помечены сервером со значением «-1» для загона Expires. В случае будущих запросов пользователя Internet Explorer обычно обращается к веб-серверу для обновления этой страницы с помощью условного запроса If-Modified-Since. Однако страница остается в кэше диска (Временные файлы Интернета). И страница используется в соответствующих ситуациях без контакта с удаленным веб-сервером, например:

  • когда кнопки BACK и FORWARD используются для доступа к истории навигации.
  • когда браузер находится в автономном режиме.

Заглавная Cache-Control

Однако некоторые страницы настолько неустойчивы или чувствительны, что не требуют кэшинга дисков. С этой целью Internet Explorer поддерживает http 1.1 Cache-Control. Этот загон предотвращает все кэшы определенного веб-ресурса, если значение без кэша задано сервером HTTP 1.1.

Страницы, которые не находятся в кэше, недоступны до тех пор, пока браузер не сможет повторно отреагировать на веб-сервер. Таким образом, серверы должны использовать Cache-Control заготку экономно. В большинстве случаев предпочтительнее использовать expires: -1.

Загон Pragma: No-Cache

К сожалению, устаревшие серверы HTTP 1.0 не могут использовать Cache-Control. Для обратной совместимости с серверами HTTP 1.0 Internet Explorer поддерживает специальное использование загона HTTP Pragma: без кэша. Если клиент взаимодействует с сервером по безопасному подключению () и сервер возвращает загон Pragma: нет кэша с ответом, Internet Explorer не кэшировать https:// ответ.

Однако загон Pragma: no-cache не был предназначен для этой цели. Согласно спецификациям HTTP 1.0 и 1.1, этот заготок определяется только в контексте запроса, а не в ответе. Она предназначена для прокси-серверов, которые могут препятствовать достижению определенных важных запросов до конечного веб-сервера. Для будущих приложений Cache-Control является подходящим средством для управления кэшингом.

HtmL-страницы позволяют использовать специальную форму тега META HTTP-EQUIV, которая указывает определенные заголовки HTTP из документа HTML. Вот краткий пример HTML-страницы, которая использует как Pragma: нет кэша, так и истекает: -1:

<HTML>
    <HEAD>
        <META HTTP-EQUIV="Pragma" CONTENT="no-cache">
        <META HTTP-EQUIV="Expires" CONTENT="-1">
    </HEAD>
<BODY>
</BODY>
</HTML>

Pragma: отсутствие кэша предотвращает кэшинг только при их использования над безопасным подключением. Тег META без кэша рассматривается одинаково с Expires: -1, если используется на небезопасной странице. Страница будет кэшированы, но помечена как истекла.

Cache-Control ТЕГИ META HTTP-EQUIV игнорируются и не влияют на версии Internet Explorer 4 или 5. Чтобы использовать Cache-Control, этот заготчик должен быть указан с помощью http-заготчиков, как описано в разделе Cache-Control выше.

Примечание

Использование стандартных http-заглавных заглавных команд предпочтительнее тегов META. Теги META обычно должны отображаться в верхней части РАЗДЕЛА HTML HEAD. И есть по крайней мере одна известная проблема с тегом МЕТА Pragma HTTP-EQUIV.

Параметры сервера для кэшинга

Если Cache-Control для использования на страницах, не включаемых в ASP, может потребоваться использовать параметры конфигурации сервера для автоматического добавления этого загона. В процессе добавления http-headers в ответы сервера для определенного каталога обратитесь к документу сервера. Например, в IIS 4 выполните следующие действия:

  1. Запустите диспетчер IIS.
  2. В дереве компьютера и служб откройте веб-сервер по умолчанию или веб-сервер, о чем идет речь. Найдите каталог, содержащий содержимое, необходимое Cache-Control загона.
  3. Откройте диалоговое окно Properties для этого каталога.
  4. Выберите вкладку http Headers.
  5. Выберите кнопку Добавить в настраиваемой группе http Headers и добавьте Cache-Control имя и отсутствие кэша для значения загона.

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

Контрольный список проблем

Если вы применяли методы в этой статье и у вас по-прежнему возникают проблемы с кэшингом и internet Explorer, просмотрите этот удобный контрольный список шаг за шагом, прежде чем обращаться в Корпорацию Майкрософт за технической поддержкой:

  • Используете ли вы Cache-Control с свойством ASP или через Response.CacheControl возвращенный http-загон? Это единственный способ по-настоящему предотвратить кэшинг в Internet Explorer.
  • Используете ли вы Internet Explorer 4.01 Пакет обновления 2 или более? Полностью предотвратить кэшинг в более ранних версиях браузера не удалось.
  • Вы дважды проверили, включен ли веб-сервер HTTP 1.1 и возвращает ответы HTTP 1.1 в Internet Explorer? Cache-Control недействительны в ответах HTTP 1.0.
  • Если вы используете CGI/ISAPI/Servlets на стороне сервера, следует ли вам точно следовать спецификации HTTP 1.1, в частности о прекращении CRLF http-заголовок? В интересах производительности Internet Explorer обычно не прощает ответы, нарушающие спецификацию HTTP 1.1. Обычно это приводит к игнорированию заглавных заглавок или сообщений о непредвиденных ошибках сервера.
  • Правильно ли написаны заглавные протоколы HTTP?

Дополнительные ресурсы

Использование внешнего кэша в службе управления API Azure

  • Статья
  • Чтение занимает 4 мин

Были ли сведения на этой странице полезными?

Да Нет

Хотите оставить дополнительный отзыв?

Отзывы будут отправляться в корпорацию Майкрософт. Нажав кнопку «Отправить», вы разрешаете использовать свой отзыв для улучшения продуктов и служб Майкрософт. Политика конфиденциальности.

Отправить

В этой статье

Помимо использования встроенного кэша служба управления API Azure также позволяет кэшировать ответы во внешнем кэше, совместимом с Redis. Например в Кэше Azure для Redis.

Использование внешнего кэша позволяет обойти ряд ограничений встроенного кэша:

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

Более подробные сведения о кэшировании см. в разделе политики кэширования управления API и настраиваемое кэширование в службе управления API Azure.

Из этого руководства вы узнаете, как выполнять такие задачи:

  • Добавление внешнего кэша в службу управления API

Предварительные требования

Для работы с этим руководством вам потребуется следующее:

Создание кэша Azure для Redis

В этом разделе описано, как создать в Azure кэш Redis для Azure. Если у вас уже есть кэш Redis для Azure в Azure или за пределами, вы можете пропустить этот раздел.

  1. Чтобы создать кэш, войдите на портал Azure и выберите Создать ресурс.

  2. На странице Создание выберите Базы данных, а затем Кэш Azure для Redis.

  3. На странице Новый кэш Redis настройте параметры для нового кэша.

    Параметр Выбор значения Описание
    Подписка Раскройте список и выберите нужную подписку. В этой подписке будет создан новый экземпляр кэша Redis для Azure.
    Группа ресурсов Раскройте список и выберите группу ресурсов или нажмите Создать и введите имя для новой группы ресурсов. Имя группы ресурсов, в которой будут созданы кэш и другие ресурсы. Поместив все ресурсы приложения в одну группу ресурсов, вы сможете легко управлять ими и/или удалить их вместе.
    DNS-имя Укажите уникальное имя. Имя кэша должно быть строкой длиной от 1 до 63 символов и содержать только цифры, буквы и дефисы. Имя должно начинаться и заканчиваться цифрой или буквой и не может содержать более одного дефиса подряд. Имя узла для экземпляра кэша будет иметь имя DNS . Redis.Cache.Windows.NET.
    Расположение Откройте список и выберите расположение. Выберите оптимальный регион для других служб, которые будут использовать кэш.
    Тип кэша В раскрывающемся списке выберите уровень. Уровень определяет размер, производительность кэша и доступные функции. Дополнительные сведения см. в обзоре предложения «Кэш Redis для Azure».
  4. Выберите вкладку Сети или нажмите кнопку Сети в нижней части страницы.

  5. На вкладке Сети выберите способ подключения.

  6. Выберите вкладку Далее: дополнительно или нажмите в нижней части страницы кнопку Далее: дополнительно.

  7. На вкладке Дополнительно для экземпляра кэша уровня «Базовый» или «Стандартный» установите переключатель, чтобы включить порт, отличный от TLS. Вы также можете выбрать версию Redis, которую хотите использовать, например 4 или 6.

  8. На вкладке Дополнительно для экземпляра кэша уровня «Премиум» настройте параметры для портов, отличных от TLS, а также кластеризацию и сохраняемость данных. Вы также можете выбрать версию Redis, которую хотите использовать, например 4 или 6.

  9. Выберите вкладку Далее: теги или нажмите в нижней части страницы кнопку Далее: теги.

  10. При необходимости на вкладке Теги введите имя и значение, чтобы классифицировать ресурс.

  11. Выберите Проверить и создать. Вы будете перенаправлены на вкладку «Просмотр и создание», где Azure проверит вашу конфигурацию.

  12. Когда отобразится сообщение «Проверка пройдена» зеленого цвета, выберите Создать.

На создание кэша требуется некоторое время. Вы можете отслеживать ход выполнения на странице обзорных сведений кэша Azure для Redis. Когда Состояние примет значение Running (Выполняется), кэш будет готов к использованию.

Развертывание кэша Redis в Kubernetes

При кэшировании локальные шлюзы полагаются исключительно на внешние кэши. Чтобы кэширование было эффективным, локальные шлюзы и используемый ими кэш должны располагаться рядом друг с другом, чтобы задержки при поиске и сохранении были минимальными. Лучше всего развертывать кэш Redis в том же кластере Kubernetes или в отдельном кластере поблизости. Перейдите по этой ссылке, чтобы узнать, как развернуть кэш Redis в кластере Kubernetes.

Добавление внешнего кэша

Выполните описанные ниже действия, чтобы добавить внешний кэш Redis для Azure в Управление API Azure.

Примечание

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

Например, если служба управления API размещена в регионах «Восточная часть США», «Юго-Восточная Азия» и «Западная Европа», и существуют два настроенных кэша, один Default (По умолчанию) и второй для региона Юго-Восточная Азия, служба управления API в регионе Юго-Восточная Азия будет использовать собственный кэш, а два других региона — запись кэша Default (По умолчанию).

Добавление кэша Redis для Azure из той же подписки

  1. Перейдите к экземпляру службы управления API на портале Azure.
  2. Выберите вкладку External cache (Внешний кэш) в меню слева.
  3. Щелкните + Добавить.
  4. В раскрывающемся поле Cache instance (Экземпляр кэша) выберите свой кэш.
  5. Выберите вариант Default (По умолчанию) или укажите нужный регион в поле с раскрывающимся списком Use from (Использовать из).
  6. Нажмите Сохранить.

Добавление кэша Redis для Azure, размещенного за пределами текущей подписки Azure или Azure

  1. Перейдите к экземпляру службы управления API на портале Azure.
  2. Выберите вкладку External cache (Внешний кэш) в меню слева.
  3. Щелкните + Добавить.
  4. В раскрывающемся поле Cache instance (Экземпляр кэша) выберите Custom (Настраиваемый).
  5. Выберите вариант Default (По умолчанию) или укажите нужный регион в поле с раскрывающимся списком Use from (Использовать из).
  6. В поле Строка подключения укажите строку подключения к кэшу Redis для Azure.
  7. Нажмите Сохранить.

Добавление кэша Redis к локальному шлюзу

  1. Перейдите к экземпляру службы управления API на портале Azure.
  2. Выберите вкладку External cache (Внешний кэш) в меню слева.
  3. Щелкните + Добавить.
  4. В раскрывающемся поле Cache instance (Экземпляр кэша) выберите Custom (Настраиваемый).
  5. Укажите нужное расположение локального шлюза или выберите пункт По умолчанию в поле с раскрывающимся списком Использовать из.
  6. В поле Connection string (Строка подключения) укажите строку подключения к кэшу Redis.
  7. Нажмите Сохранить.

Использование внешнего кэша

Как только внешний кэш в службе управления API Azure настроен, его можно использовать через политики кэширования. Подробные инструкции см. в разделе Добавление кэширования для повышения производительности в службе управления API Azure.

Следующие шаги

Обслуживайте статические ресурсы сайта с помощью эффективной политики кеширования

— Обновлено

Appears in: Аудиты производительности

HTTP-кеширование может ускорить загрузку вашей страницы при повторных посещениях.

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

Причины плохих результатов проверки политики кеширования в Lighthouse #

Lighthouse отмечает все статические ресурсы, которые не кешируются:

Lighthouse считает ресурс кешируемым, если выполняются все следующие условия:

  • ресурс — это шрифт, изображение, медиафайл, скрипт или таблица стилей;
  • ресурс имеет код состояния HTTP 200, 203 или 206;
  • у ресурса нет явной политики отсутствия кеширования.

Если страница не проходит проверку, Lighthouse отображает результаты в таблице с тремя столбцами:

Как кешировать статические ресурсы с помощью HTTP-кеширования #

Настройте свой сервер так, чтобы он возвращал заголовок HTTP-ответа Cache-Control:

Cache-Control: max-age=31536000

max-age сообщает браузеру, как долго он должен кешировать ресурс в секундах. В этом примере устанавливается продолжительность 31536000, что соответствует 1 году: 60 секунд × 60 минут × 24 часа × 365 дней = 31536000 секунд.

По возможности кешируйте неизменяемые статические ресурсы на долгое время, например на год или дольше.

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

Если ресурс часто меняется и важна его актуальность, используйте no-cache, чтобы воспользоваться преимуществами кеширования с точки зрения скорости загрузки. Браузер по-прежнему кеширует ресурс, для которого установлено значение no-cache, но сначала проверяет его на сервере, чтобы убедиться, что ресурс всё еще актуален.

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

Существует множество директив для настройки того, как браузер кеширует различные ресурсы. Дополнительные сведения о кешировании ресурсов см. в статьях «HTTP-кеширование: руководство по первой линии обороны» и «Codelab для настройки поведения HTTP-кеширования».

Чтобы узнать, какие ресурсы браузер получает из своего кеша, откройте вкладку Network в Chrome DevTools:

  1. Откройте DevTools, нажав Control+Shift+J (или Command+Option+J, если у вас Mac).
  2. Перейдите на вкладку Сеть.

Столбец Size в Chrome DevTools может помочь вам убедиться, что ресурс был кеширован:

Chrome обслуживает наиболее запрашиваемые ресурсы из кеша памяти, который работает очень быстро, но очищается при закрытии браузера.

Чтобы убедиться, что заголовок ресурса Cache-Control установлен должным образом, проверьте данные его HTTP-заголовка:

  1. Щелкните URL-адрес запроса в столбце Name таблицы запросов.
  2. Щелкните вкладку Headers.
Проверка заголовка Cache-Control на вкладке Headers.

Рекомендации по стекам #

Drupal #

Установите максимальный возраст кеша браузера и прокси-сервера на странице Administration > Configuration > Development. См. статью «Сведения по оптимизации производительности Drupal».

Joomla #

См. статью «Кеш».

WordPress #

См. статью «Кеширование в браузере».

Ресурсы #

Последнее обновление: — Улучшить статью

Система кэширования Django — Документация Django 1.9

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

Для большинства веб приложений такие лишние вычисления не особо заметны. Эти приложения не являются сайтами washingtonpost.com или slashdot.org. Это сайты небольшого или среднего размера с небольшим трафиком. Но для более крупных сайтов становится очень важна экономия ресурсов.

С этого момента в дело вступает кэширование.

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

given a URL, try finding that page in the cache
if the page is in the cache:
    return the cached page
else:
    generate the page
    save the generated page in the cache (for next time)
    return the generated page

Django поставляется с надёжной системой кэширования, которая позволяет вам сохранять динамические страницы так, что не потребуется их создавать для каждого запроса. Для удобства, Django даёт возможность тонкого управления уровнем кэширования: вы можете кэшировать результат работы представления, вы можете кэшировать только те куски, которые трудно вычислять или вы можете кэшировать весь ваш сайт.

Django также может работать с «даунстрим» кэшами, такими как Squid и кэшами браузеров. Это такие типы кэшей, которые вы не можете контролировать напрямую, но можете определять их поведение подсказками (через HTTP заголовки) о том, какую часть вашего сайта следует кэшировать и как.

Настройка кэша

Система кэширования требует небольшой настройки. А именно, надо указать где должны располагаться закэшированные данные – в базе данных, на файловой системе или прямо в памяти. Это важное решение, которое повлияет на производительность вашего кэша. Да, типы кэшей различаются по скорости работы.

Настройки кэша определяются параметром конфигурации CACHES. Ниже приведено объяснение всех возможных значений этого параметра.

Memcached

Самый быстрый и эффективный тип кэша, доступный Django, Memcached является кэшем, который полностью располагается в оперативной памяти, он был разработан для LiveJournal.com и позднее переведён в опенсорс компанией Danga Interactive. Он используется такими сайтами как Facebook и Wikipedia для снижения нагрузки на базу данных и значительного увеличения производительности сайта.

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

После установкам самого Memcached, следует установить его пакет для Python. Существует несколько таких пакетов; два наиболее используемых — python-memcached и pylibmc.

Для использования Memcached с Django:

  • Установите BACKEND в django.core.cache.backends.memcached.MemcachedCache или django.core.cache.backends.memcached.PyLibMCCache (зависит от выбранного пакета).

  • Определите для LOCATION значение ip:port (где ip — это IP адрес, на котором работает демон Memcached, port — его порт) или unix:path (где path является путём к файлу-сокету Memcached).

В этом примере Memcached запущен на localhost (127.0.0.1) порт 11211, используя python-memcached:

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
        'LOCATION': '127.0.0.1:11211',
    }
}

В этом примере Memcached доступен через локальный файл-сокет /tmp/memcached.sock, используя python-memcached:

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
        'LOCATION': 'unix:/tmp/memcached.sock',
    }
}

При использовании pylibmc, не включайте префикс unix:/:

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
        'LOCATION': '/tmp/memcached.sock',
    }
}

Одной из замечательных особенностей Memcached является возможность распределять кэш по нескольким серверам. Это означает, что вы можете запустить демоны Memcached на нескольких машинах и программа будет рассматривать эту группу машин как единый кэш, без необходимости копирования всех значений кэша на каждую машину. Для того, чтобы воспользоваться этой особенностью, укажите адреса всех машин в LOCATION, в виде списка или строки, разделённой запятыми.

В данном примере, кэш распределён по экземплярам Memcached, работающим на IP адресах 172.19.26.240 и 172.19.26.242, на порту 11211 оба:

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
        'LOCATION': [
            '172.19.26.240:11211',
            '172.19.26.242:11211',
        ]
    }
}

В следующем примере, кэш распределён по экземплярам Memcached, работающим на IP адресах 172.19.26.240 (порт 11211), 172.19.26.242 (порт 11212) и на 172.19.26.244 (порт 11213):

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
        'LOCATION': [
            '172.19.26.240:11211',
            '172.19.26.242:11212',
            '172.19.26.244:11213',
        ]
    }
}

В конце рассказа о Memcached следует сказать, что этот тип кэша имеет один недостаток: Кэш располагается в оперативной памяти и уничтожается при сбое сервера. Очевидно, что оперативная память не предназначена для постоянного хранения информации, поэтому не следует на неё рассчитывать в этом смысле. Несомненно, ни один из модулей кэширования не должен использоваться как постоянное хранилище — они предназначены для кэширования, не для хранения — мы особенно это отмечаем для данного типа кэша.

Кэширование в базу данных

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

Для использования таблицы базы данных в качестве бэкэнда кэша:

  • Установите BACKEND в django.core.cache.backends.db.DatabaseCache

  • Установите LOCATION в tablename, имя таблицы базы данных. Это имя может быть любым, пока оно не противоречит правилам именования таблиц в вашей базе данных и не занято другой таблицей.

В данном примере, именем таблицы для кэша будет my_cache_table:

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
        'LOCATION': 'my_cache_table',
    }
}
Создание таблицы для кэша

Для того, чтобы использовать таблицу базы данных в качестве кэша, сначала надо её создать с помощью следующей команды:

python manage.py createcachetable

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

При использовании нескольких БД кэшей, команда createcachetable создаст по одной таблице для каждого кэша.

Если вы используете множество баз данных, то команда createcachetable обратится к методу allow_migrate() роутера вашей базы данных (см. далее).

Аналогично команде migrate, команда createcachetable не внесёт изменения в существующую таблицу. Она создаёт только отсутствующие таблицы.

Чтобы вывести SQL, который был бы выполнен, без его выполнения, используйте опцию --dry-run.

Множество баз данных

Если у вас несколько баз данных и вы планируете использовать кэширование, потребуется прописать инструкции роутинга для таблицы кэширования. В целях роутинга таблица кэширования представлена моделью CacheEntry в приложении django_cache. Эта модель не отобразится в модельном кэше, но содержимое модели может быть использовано для роутинга.

Например, представленный ниже роутер будет перенаправлять все операции чтения из кэша на cache_replica, а всё операции записи на cache_primary. Таблица кэширования будет синхронизироваться только с cache_primary:

class CacheRouter(object):
    """A router to control all database cache operations"""

    def db_for_read(self, model, **hints):
        "All cache read operations go to the replica"
        if model._meta.app_label == 'django_cache':
            return 'cache_replica'
        return None

    def db_for_write(self, model, **hints):
        "All cache write operations go to primary"
        if model._meta.app_label == 'django_cache':
            return 'cache_primary'
        return None

    def allow_migrate(self, db, app_label, model_name=None, **hints):
        "Only install the cache model on primary"
        if app_label == 'django_cache':
            return db == 'cache_primary'
        return None

Если вы не настроите роутинг для кэширования, то модуль кэширования будет использовать базу default.

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

Кэширование на файловую систему

Файловый бэкэнд сериализует и сохраняет каждое закэшированное значение в отдельном файле. Для использования этого бэкэнда, установите BACKEND в "django.core.cache.backends.filebased.FileBasedCache", а для LOCATION укажите подходящий каталог. Например, для хранения закэшированных данных в /var/tmp/django_cache, используйте такую настройку:

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
        'LOCATION': '/var/tmp/django_cache',
    }
}

Если вы используете Windows, то подставьте букву диска в начало пути, вот так:

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
        'LOCATION': 'c:/foo/bar',
    }
}

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

Следует удостовериться, что указанный каталог существует и доступен для чтения и записи для пользователя, от которого работает ваш веб сервер. Продолжая предыдущий пример, если ваш веб сервер запущен от пользователя apache, проверьте, что каталог /var/tmp/django_cache существует и доступен для чтения и записи пользователю apache.

Кэширование в оперативной памяти

Это стандартный кэш, который применяется, если другой не определён в вашем файле конфигурации. Если вам требуется высокая скорость работы кэша, но у вас нет возможности развернуть Memcached, рассмотрите вариант использования кэша в оперативной памяти. Этот кэш по-процессный (см. далее) и потокобезопасный. Для его использования надо параметру конфигурации BACKEND присвоить значение "django.core.cache.backends.locmem.LocMemCache". Например:

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
        'LOCATION': 'unique-snowflake',
    }
}

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

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

Псевдокэширование (для разработки)

Наконец, Django поставляется с «псевдо» кэшем, который не выполняет собственно кэширование. Он просто реализует интерфейс кэша, не делая больше ничего.

Он полезен в случае, когда у вас есть боевой сайт , который плотно использует кэширование в различных местах, а также окружение разработки или тестирование, где кэшировать ничего не надо. Для активации псевдо кэширования, установите BACKEND:

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.dummy.DummyCache',
    }
}

Использование собственного модуля кэширования

Несмотря на то, что Django предоставляет ряд модулей кэширования, вам может потребоваться использовать свой кэширующий модуль. Для подключения внешнего кэширующего модуля используйте путь до него в качестве значения BACKEND параметра конфигурации CACHES, вот так:

CACHES = {
    'default': {
        'BACKEND': 'path.to.backend',
    }
}

При создании своего кэширующего модуля вы можете использовать стандартные модули в качестве примера. Их код располагается в каталоге django/core/cache/backends/ исходного кода Django.

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

Параметры кэша

После определения типа кэша и имени для каждого из них, для каждого модуля можно указать дополнительные аргументы для управления поведением кэша. Эти аргументы представляются в виде дополнительных ключей в параметре конфигурации CACHES. Приведём список допустимых аргументов:

  • TIMEOUT: время устаревания кэша по умолчанию, в секундах. По умолчанию 300 секунд (5 минут). Вы можете установить TIMEOUT в None, тогда кэш никогда не устареет. Если указать 0, все ключи будут сразу устаревать (таким образом можно заставить “не кэшировать”).

  • OPTIONS: Любая опция, которая должна быть передана модулю. Список допустимых опций варьируется от модуля к модулю и передается непосредственно в библиотеку для кэширования.

    Модули кэширования, которые реализуют собственную стратегию очистки (т.е., модули locmem, filesystem и database) учитывают следующие опции:

    • MAX_ENTRIES: максимальное количество элементов в кэше перед началом удаления старых значений. Обычно, 300 элементов.

    • CULL_FREQUENCY: Часть элементов, которые надо удалить при достижении MAX_ENTRIES. Обычное соотношение — 1/CULL_FREQUENCY, таким образом, надо установить CULL_FREQUENCY в 2, чтобы удалять половину значений кэша при достижении MAX_ENTRIES. Аргумент должен быть целым числом и по умолчанию равен 3.

      Значение 0 для CULL_FREQUENCY означает, что весь кэш должен быть сброшен при достижении MAX_ENTRIES. Это делает очистку значительно быстрее для определенных бэкендов(в частности database) ценой увеличения промахов кэша.

  • KEY_PREFIX: Строка, которая автоматически включается (предваряет, по умолчанию) во все ключи кэша, используемые сервером Django.

    Обратитесь к документации на кэш для подробностей.

  • VERSION: Номер версии про умолчанию для ключей кэша, созданных сервером Django.

    Обратитесь к документации на кэш для подробностей.

  • KEY_FUNCTION Строка, содержащая путь до функции, которая определяет правила объединения префикса, версии и ключа в итоговый ключ кэша.

    Обратитесь к документации на кэш для подробностей.

В этом примере, модуль кэширования на файловую систему настроен на таймаут в 60 секунд и ёмкость в 1000 элементов:

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
        'LOCATION': '/var/tmp/django_cache',
        'TIMEOUT': 60,
        'OPTIONS': {
            'MAX_ENTRIES': 1000
        }
    }
}

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

Кэш для каждого сайта

После настройки кэша, простейшим способом его использования будет кэширование всего сайта. Вам надо будет добавить 'django.middleware.cache.UpdateCacheMiddleware' и 'django.middleware.cache.FetchFromCacheMiddleware' в параметр конфигурации MIDDLEWARE_CLASSES, как это показано в примере:

MIDDLEWARE_CLASSES = [
    'django.middleware.cache.UpdateCacheMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.cache.FetchFromCacheMiddleware',
]

Примечание

Нет, это не ошибка: мидлварь “update” должна идти первой в списке, а мидлварь “fetch” — последней. Подробности тут не приводятся, обратитесь к Порядку классов MIDDLEWARE, проведенному далее, если они вам нужны.

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

  • CACHE_MIDDLEWARE_ALIAS – Метка кэша, используемая для хранилища.

  • CACHE_MIDDLEWARE_SECONDS – Количество секунд хранения каждой закэшированной страницы.

  • CACHE_MIDDLEWARE_KEY_PREFIX – Если кэш разделён между несколькими сайтами внутри одной инсталляции Django, установите в имя сайта или любую другую строку, которая уникальна для этой инсталляции, чтобы предотвратить совпадения. Используйте пустую строку, если это не ваш случай.

Мидлварь FetchFromCacheMiddleware кэширует GET и HEAD отклики со статусом 200, если заголовки запроса и отклика это позволяют. Ответы на запросы для одного URL с разными параметрами запроса считаются уникальными и кэшируются раздельно. Мидлварь кэша ожидает, что запрос HEAD возвращает такие же заголовки, как и соответствующий GET запрос; в этом случае он может вернуть закэшированный GET отклик для запроса HEAD.

Также, мидлварь UpdateCacheMiddleware автоматически устанавливает несколько заголовков в каждом HttpResponse:

  • Устанавливает заголовок Last-Modified с текущими датой и временем при запросе свежей (незакэшированной) версии страницы.

  • Устанавливает в заголовке Expires текущие дату и время, добавляя к ним значение, определённое в CACHE_MIDDLEWARE_SECONDS.

  • Устанавливает заголовок Cache-Control, определяя максимальный возраст для страницы, также используя значение из параметра конфигурации CACHE_MIDDLEWARE_SECONDS.

Обратитесь к Промежуточный слой (Middleware) для подробностей.

Если представление устанавливает собственное время кэширования (т.е. определяет значение max-age в заголовке Cache-Control), то страница будет закэширована на указанное время, вместо CACHE_MIDDLEWARE_SECONDS. Используя декораторы из django.views.decorators.cache, вы можете легко определять время кэширования представлений (с помощью декоратора cache_control) или отключать кэширование для представления (с помощью декоратора never_cache). Обратитесь к разделу Использование других заголовков для получения дополнительной информации об этих декораторах.

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

Ключи кэша также включают в себя активный язык в случаях, когда USE_L10N установлен в True, а также включают в себя текущий часовой пояс, если USE_TZ установлен в True.

Кэширование на уровне представлений

django.views.decorators.cache.cache_page()

Более детальный способ использования системы кэширования возможен за счет кэширования вывода отдельных представлений. Модуль django.views.decorators.cache определяет декоратор cache_page, который автоматически кэширует вывод представления. Использовать его несложно:

from django.views.decorators.cache import cache_page

@cache_page(60 * 15)
def my_view(request):
    ...

Декоратор cache_page принимает единственный аргумента: длительность кэширования, в секундах. В предыдущем примере, результат представления my_view() будет закэширован на 15 минут.foo/([0-9]{1,2})/$’, my_view), ]

то запросы к /foo/1/ и /foo/23/ будут закэшированы отдельно, как вы могли предполагать. Но как только определённый URL (например, /foo/23/) будет запрошен, следующие запросы к этому URL будут использовать кэш.

Декоратор cache_page также может принимать необязательный именованный аргумент, cache, который указывает декоратору использовать определённый кэш (из списка параметра конфигурации CACHES) для кэширования результатов. По умолчанию используется кэш default, но вы можете указать любой:

@cache_page(60 * 15, cache="special_cache")
def my_view(request):
    ...

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

@cache_page(60 * 15, key_prefix="site1")
def my_view(request):
    ...

Аргументы key_prefix и cache можно указать вместе. Аргумент key_prefix и параметр KEY_PREFIX настройки CACHES будут объединены.

Определение кэша уровня представления в URLconf

Примеры из предыдущей секции содержат жёсткое определение кэширования представления, так как декоратор cache_page меняет поведение функции my_view. Такое подход связывает ваше представление с системой кэширования, что не всегда подходит по нескольким причинам. Например, вы можете пожелать распространять представления людям, которые захотят использовать их вне системы кэширования. Решением такой проблемы является указание кэширования в URLconf для каждого представления, а не у каждой функции.

Сделать это несложно: просто оберните функцию представления с помощью cache_page, при обращении к ней в URLconf.foo/([0-9]{1,2})/$’, cache_page(60 * 15)(my_view)), ]

Кэширование фрагментов шаблона

Если требуется более тонкий контроль, вы также можете кэшировать фрагменты шаблона с помощью шаблонного тега cache. Для работы данного тега необходимо указать {% load cache %} в начале шаблона.

Шаблонный тег {% cache %} кэширует содержимое блока на указанный период времени. Он принимает как минимум два аргумента: время кэширования в секундах и имя для закэшированного фрагмента. Имя будет использовано как есть, не используйте переменную. Например:

{% load cache %}
{% cache 500 sidebar %}
    .. sidebar ..
{% endcache %}

Временами требуется кэшировать многочисленные копии одного фрагмента, различающиеся только небольшим куском динамических данных. Например, может потребоваться кэширование копии сайдбара из предыдущего примера для каждого пользователя вашего сайта. Это можно сделать, передав дополнительные аргументы в шаблонный тег {% cache %}, что однозначно будет идентифицировать фрагмент:

{% load cache %}
{% cache 500 sidebar request.user.username %}
    .. sidebar for logged in user ..
{% endcache %}

Чем больше аргументов вы используете для идентификации фрагмента, тем лучше. Просто указывайте для {% cache %} столько аргументов, сколько считаете нужным.

Если параметр конфигурации USE_I18N установлен в True, то мидлварь кэширования сайта будет учитывать активных язык. Для шаблонного тега cache можно использовать одну из переменных, предназначенных для перевода, доступных шаблонам для достижения того же результата:

{% load i18n %}
{% load cache %}

{% get_current_language as LANGUAGE_CODE %}

{% cache 600 welcome LANGUAGE_CODE %}
    {% trans "Welcome to example.com" %}
{% endcache %}

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

{% cache 600 sidebar %} ... {% endcache %}
{% cache my_timeout sidebar %} ... {% endcache %}

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

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

{% cache 300 local-thing ...  using="localcache" %}

Указание имени несконфигурированного кэша является ошибкой.

django.core.cache.utils.make_template_fragment_key(fragment_name, vary_on=None)

Чтобы получить ключ кэша для кэшированного фрагменты шаблона, можно использовать функцию make_template_fragment_key. fragment_name – второй аргумент, передаваемый в тег cache, vary_on – список дополнительных аргументов, передаваемых в тег. Эту функцию можно использовать для переназначения или удаления кэшированных фрагментов шаблона:

>>> from django.core.cache import cache
>>> from django.core.cache.utils import make_template_fragment_key
# cache key for {% cache 500 sidebar username %}
>>> key = make_template_fragment_key('sidebar', [username])
>>> cache.delete(key) # invalidates cached template fragment

API низкого уровня для кэширования

Временами кэширование всей созданной страницы не даёт нужного результата и обычно является неудобным излишеством.

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

Для подобных случаев Django предоставляет простой API кэширования низкого уровня. Вы можете использовать этот API для хранения объектов в кэше с любым уровнем детализации. Вы можете поместить в кэш любой объект Python, который может быть безопасно сериализован (“pickled”): строки, словари, списки объектов модели и так далее. (То есть, речь идёт о большинстве объектов языка Python, обратитесь к соответствующей документации.)

Доступ к кэшу

django.core.cache.caches

Вы можете иметь доступ к кэшам, определённым в параметре конфигурации CACHES, через словарно-подобный объект django.core.cache.caches. Повторяющиеся запросы по одинаковому псевдониму в одном и том же потоке будут возвращать одинаковый результат.

>>> from django.core.cache import caches
>>> cache1 = caches['myalias']
>>> cache2 = caches['myalias']
>>> cache1 is cache2
True

Если указанного именованного ключа не существует, то будет вызвано исключение InvalidCacheBackendError.

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

django.core.cache.cache

Для простоты, стандартный кэш доступен через django.core.cache.cache:

>>> from django.core.cache import cache

Этот объект эквивалентен caches['default'].

Использование

Основной интерфейс прост: set(key, value, timeout) и get(key):

>>> cache.set('my_key', 'hello, world!', 30)
>>> cache.get('my_key')
'hello, world!'

Аргумент timeout является необязательным и обычно равен аргументу timeout соответствующего бэкенда кэша из параметре конфигурации CACHES (читайте выше). Аргумент определяет период в секундах, в течение которого значение должно храниться в кэше. Передав None в timeout можно закэшировать данные навсегда. При timeout равном 0 значение никогда не будет кэшироваться.

Если объект отсутствует в кэше, то cache.get() возвращает None:

# Wait 30 seconds for 'my_key' to expire...

>>> cache.get('my_key')
None

Мы не советуем хранить в кэше литеральное значение None, так как вы не сможете определить разницу между сохранённым значением None и отсутствием значения в кэше, о чём сигнализирует возвращение значения None.

Метод cache.get() принимает аргумент default. Он определяет значение, которое будет возвращено, если указанного объекта нет в кэше:

>>> cache.get('my_key', 'has expired')
'has expired'

Для того, чтобы добавить элемент в кэш только в случае, когда его там нет, следует использовать метод add(). Он принимает такие же параметры, как и метод set(), но не будет пытаться изменить значение, если оно уже присутствует в кэше:

>>> cache.set('add_key', 'Initial value')
>>> cache.add('add_key', 'New value')
>>> cache.get('add_key')
'Initial value'

Если вам надо определить сохранил ли метод add() значение в кэше, вы можете проверить значение, которое он возвращает. True указывает, что значение было сохранено, а False – наоборот.

Если вы хотите получить значение ключа, или установить его, если ключа нет в кэше, используйте метод get_or_set(). Принимает аргументы аналогичные get(), но default также записывается в кэш:

>>> cache.get('my_new_key')  # returns None
>>> cache.get_or_set('my_new_key', 'my new value', 100)
'my new value'

Вы также можете передать функцию как значение по умолчанию:

>>> import datetime
>>> cache.get_or_set('some-timestamp-key', datetime.datetime.now)
datetime.datetime(2014, 12, 11, 0, 15, 49, 457920)
Изменено в Django 1.9:

Был добавлен метод get_or_set().

С помощью методы get_many() можно получить ряд значений из кэша за один запрос. Этот метод возвращает словарь со всеми запрошенными ключами, которые действительно присутствуют в кэше (и имеют актуальный срок действия):

>>> cache.set('a', 1)
>>> cache.set('b', 2)
>>> cache.set('c', 3)
>>> cache.get_many(['a', 'b', 'c'])
{'a': 1, 'b': 2, 'c': 3}

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

>>> cache.set_many({'a': 1, 'b': 2, 'c': 3})
>>> cache.get_many(['a', 'b', 'c'])
{'a': 1, 'b': 2, 'c': 3}

Аналогично методу cache.set(), метод set_many() принимает необязательный параметр timeout.

Вы можете явно удалять значения из кэша с помощью метода delete(). Это простейший способ очистки кэша для определённого объекта:

Для одновременного удаления множества значений надо использовать метод delete_many(), который принимает список ключей, подлежащих удалению:

>>> cache.delete_many(['a', 'b', 'c'])

Наконец, для полной очистки кэша надо использовать метод cache.clear(). Будьте осторожными с этим методом. Метод удаляет из кэша всё, не только ключи, установленные вашим приложением.

Вы также можете увеличивать или уменьшать значение ключа, находящегося в кэше, с помощью методов incr() или desc() соответственно. По-умолчанию, значение в кэше будет увеличено или уменьшено на единицу. Другой шаг изменения величины может быть указан с помощью соответствующего аргумента методов. При попытке изменения несуществующего в кэше значения будет выброшено исключение ValueError.:

>>> cache.set('num', 1)
>>> cache.incr('num')
2
>>> cache.incr('num', 10)
12
>>> cache.decr('num')
11
>>> cache.decr('num', 5)
6

Примечание

Методы incr() и decr() не гарантируют атомарность операции. Тут всё зависит от бэкенда. К примеру, Memcached гарантирует атомарность этих операций. Другие бэкенды делают это через двойную операцию считывания и сохранения нового значения.

Можно закрыть подключение к кэшу методом close(), если бэкенд кэширования предоставляет его.

Примечание

Если кэш не реализует метод close, он будет пустым.

Прификсы ключей кэша

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

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

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

Версионирование кэша

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

Django предоставляет отличный способ выделения отдельных значений в кэше. Система кэширования Django обладает глобальным идентификатором версии, определённым в параметре кэша VERSION. Значение этого параметра автоматически объединяется с префиксом кэша и пользователем, которые предоставил ключ, получая итоговый ключ для обращения к кэшу.

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

# Set version 2 of a cache key
>>> cache.set('my_key', 'hello world!', version=2)
# Get the default version (assuming version=1)
>>> cache.get('my_key')
None
# Get version 2 of the same key
>>> cache.get('my_key', version=2)
'hello world!'

Версия нужного ключа может быть увеличена или уменьшена с помощью методов incr_version() и decr_version(). Эти методы позволяет изменять версии нужных ключей, не затрагивая остальные ключи. Продолжая наш предыдущий пример:

# Increment the version of 'my_key'
>>> cache.incr_version('my_key')
# The default version still isn't available
>>> cache.get('my_key')
None
# Version 2 isn't available, either
>>> cache.get('my_key', version=2)
None
# But version 3 *is* available
>>> cache.get('my_key', version=3)
'hello world!'

Преобразование ключа кэша

Как описано в предыдущих двух разделах, система кэширования никогда не использует напрямую ключ, предоставленный пользователем. Ключ всегда комбинируется с префиксом кэша и версией ключа. По-умолчанию, эти три части объединяются через двоеточия, создавая итоговый ключ:

def make_key(key, key_prefix, version):
    return ':'.join([key_prefix, str(version), key])

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

Параметр кэша KEY_FUNCTION определяет путь в точечной нотации к функции, соответствующей прототипу make_key() из предыдущего примера. При наличии такой функции она будет использоваться вместо стандартной функции построения итогового ключа.

Предупреждения о проблемах с ключами

Memcached, наиболее используемый в продакшене бэкенд кэширования, не поддерживает ключи длиной более 250 символов или содержащих пробелы или управляющие символы. Использование таких ключей приводит к вызову исключения. Для обеспечения уверенности в портируемости кода между кэширующими бэкендами и для уменьшения количества неприятных сюрпризов, другие встроенные кэширующие бэкенды выбрасывают предупреждение (django.core.cache.backends.base.CacheKeyWarning), если используемый ключ может привести к ошибке при работе с Memcached.

Если вы используете на продакшене кэширующий бэкенд, который может принимать широкий диапазон ключей (собственный бэкенд или один из встроенных бэкендов, кроме Memcached), и не желаете видеть подобные предупреждения, вы можете заглушить CacheKeyWarning с помощью следующего кода в модуле management одного из ваших приложений:

import warnings

from django.core.cache import CacheKeyWarning

warnings.simplefilter("ignore", CacheKeyWarning)

Если вам требуется изменить логику проверки ключа для одного из встроенных бэкендов кэширования, вы можете унаследовать свой класс от него и переопределить метод validate_key. Затем следуйте инструкциям по использованию собственного бэкенда кэширования. Например, для реализации подобного для бэкенда locmem, поместите следующий код в модуль:

from django.core.cache.backends.locmem import LocMemCache

class CustomLocMemCache(LocMemCache):
    def validate_key(self, key):
        """Custom validation, raising exceptions or warnings as needed."""
        # ...

…и используйте путь в точечной нотации к этому классу в ключе BACKEND параметра конфигурации CACHES.

“Даунстрим” кэши

До этого момента данный документ описывал кэширование ваших собственных данных. Но есть ещё один тип кэширования, относящийся к веб разработке: кэширование, выполняемое “даунстрим” кэшами. Это такие системы, которые кэшируют страницы для пользователей так, что они даже не обращаются к вашему сайту.

Рассмотрим несколько примеров таких “даунстрим” кэшей:

  • Ваш провайдер может кэшировать определённые страницы, т.е. если вы запросите страницу с https://example.com/, то провайдер пришлёт её вам без обращения к самому сайту. Основатели данного сайта даже не будут знать о таком кэшировании, так как провайдер находится между вашим браузером и сайтом, незаметно выполняя кэширование.

  • Ваше Django приложение может находится за прокси-кэшем, таким как Squid Web Proxy Cache (http://www.squid-cache.org/), который кэширует страницы для обеспечения производительности. В таком случае, каждый запрос сначала будет обработан прокси, а затем при необходимости будет передан вашему приложению.

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

“Даунстрим” кэширование – неплохой ускоритель, но с ним есть одна проблема: содержимое большинства веб страниц различается в зависимости от аутентификации и других настроек и кэширующие системы, которые слепо сохраняют страницы, основываясь в основном на URL, могут выдать неправильные или секретные данные следующим посетителям этих страниц.

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

К счастью, протокол HTTP предоставляет решение для этой проблемы. Существует ряд HTTP заголовков, которые инструктируют “даунстрим” кэши как именно следует различать страницы в зависимости от определённых переменных, также указывая что некоторые страницы кэшировать вообще не следует. Мы рассмотрим некоторые из этих заголовков в следующих секциях.

Порядок записей в MIDDLEWARE_CLASSES

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

UpdateCacheMiddleware работает во время выдачи отклика, там где мидлвари применяются с конца списка, т.е. элемент наверху списка выполняется последним. Таким образом, надо удостовериться, что UpdateCacheMiddleware указан до любых мидлварей, которые могут добавить что-то в заголовок Vary. Следующие модули как раз такие:

  • SessionMiddleware добавляет Cookie

  • GZipMiddleware добавляет Accept-Encoding

  • LocaleMiddleware добавляет Accept-Language

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

Настройка кэширования через файл.htaccess

Читая данную статью вы узнаете про то как устранить пункт: используйте кэш браузера от нашего друга гула по PageSpeed Insights. Рассматривать проблему будем на примере одного знакомого мне блога.

Статья длинная, буду показывать по частям, и введу содержание.

Правильно используем кэш браузера и устраняем проблему «не указан срок действия»

Смотрите (снимок ниже) в рамке обозначенной цифрой 1, подгружаются файлы js сторонних сервисов, но вы же не можете им сказать эй давайте включайте кэширование браузерами для своих ресурсов. Увы, в этом случае ничего не поделаешь, и эти нарекания не удалишь.

Сейчас рассмотрим три шага, которые состоят в следующем:


И вот вам первый совет. По возможности, никогда не используйте внешние ресурсы на своих сайтах, это очень тормозит. Так как у большинства не собственные сервера, то эта проблема актуальна. У меня стояла форма обратной связи от одного портала, но я ее убрал, js код тормозил страницу, решать вам.

Переходим к рамке 2, тут указаны замечания для следующих ресурсов, в основном это css, js и изображения. Разберемся, что это за срок действия. Дело в том, когда посетитель заходит на сайт, то его браузер скачивает себе файлы (это мы уже и так знаем из определения выше). Чтобы знать сколько хранить эти файлы у себя в памяти и нужно указывать это время.

Шаг 1. Скачиваем.htaccess

Первым шагом надо скачать.htaccess, все делаетя быстро, через менеджер FTP. В начале нужно будет узнать, на чем работает ваш сервер, точнее его обеспечение. Оно должно быть Apache (95% работают именно на нем, но проверить стоит).

У следующих ресурсов nginx параметры включения данной функции разные, чем у apache, так что я не зря сказал проверить на чем работает сайт.

Дальше, заходим в корневой каталог сайта (через FTP, я использую FileZilla) в папку pablic_html, там находится весь движок вордпресс. Здесь в идеале располагается файл.htaccess, он стандартный от Apache. Он регулирует загрузку и доступы, если его нет то создаем его. Будем его рассматривать в более тематических статьях, пока что нам надо сделать кэширование.

Шаг 2. Вносим mod-header в файл

Вторым шагом будем вносить директивы mod-header в.htaccess. Если он есть, то просто вставляем до закрывающего тега #endwordpress, вот этот код.

Header unset Cache-Control

Если же сделан по новой, то вставляем вот это и закидываем его в корневой каталог.

# BEGIN WordPress Header set Cache-Control «max-age=43200» Header set Cache-Control «max-age=604800» Header set Cache-Control «max-age=2592000» Header unset Cache-Control # END WordPress

Разбор строчек кода, за что они отвечают

Теперь надо разобраться за что отвечают все эти строки кода. Все тривиально, вы можете видеть в строчках разные расширения png, jpg и им подобные, и напротив этих расширений указаны числа, это и есть временной отрывок в котором будут храниться эти файлы. Например число 43200, указывает на то что фалы этих расширений будут держаться в кэше один день.

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

Плагин для кэширования граватаров NIX Gravatar Cache

Плагин nix gravatar cache- это находка для меня. Я маленько приврал, когда сказал, что не возможно избавиться от загружаемых скриптов с других сервисов. В списке внешних ресурсов вы сможете найти сайт граватара, это условие срабатывает если у вас к статье есть комментарии и к ним прикреплен gravatar. Как не странно, но тут можно включить кэш браузера wordpress для данных картинок.

Я человек дотошный, и все таки нашел решение, оттуда идет только картинка, и соответственно ее можно кэшировать и приделать к ней срок действия.

Решение нашел в плагине NIX Gravatar Cache, я знаю что это есть зло, но от него вообще нет почти нагрузки. Признаюсь, перепробовал три плагина, но только этот делает изображения в jpg, а те в непонятно какие форматы. Все настройки сводятся к двум пунктам, они указаны на скриншоте.

Первая галочка включен или выключен, и второй сколько хранить кэш.

В чем вся прелесть? В том что посетитель оставляет свой комментарий, а плагин автоматом скачивает его граватар на хостинг, и потом уже идет загрузка не из сайта граватара, вот и все. Ставьте обязательно, потому как, лучше один плагин чем сотня запросов (при условии что у вас сотня комментариев).

Кэшируем весь сайт

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

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

Подведем итог, что мы узнали и какой порядок действий

  1. Узнали на чем работает сайт (apache, nginx и тому подобное).
  2. Научились закачивать.htaccess на компьютер.
  3. Отредактировали файл доступов.
  4. Смогли закинуть обратно на сервер.
  5. Поставили плагин nix gravatar cache.

P.S. Если что-то не получилось то смело пишите комментарии, отвечу и помогу.

  • htaccess кэширование сохраняет содержимое веб-страницы на локальном компьютере, когда пользователь посещает ее;
  • Использование кэша браузера – веб-мастер дает указания браузерам, как следует рассматривать ресурсы.

Когда браузер отображает веб-страницу, он должен загрузить логотип, CSS файл и другие ресурсы:

Кэш браузера «запоминает » ресурсы, которые браузер уже загрузил. Когда посетитель переходит на другую страницу сайта, логотип, CSS файлы и т.д. не должны загружаться снова, потому что браузер уже «запомнил » их (сохранил ). В этом заключается причина того, почему во время первого посещения загрузка веб-страницы занимает больше времени, чем при повторных.

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

Как включить кэширование в браузере

  • Измените заголовки запроса ресурсов, чтобы использовать кэширование;
  • Оптимизируйте свою стратегию кэширования.

Изменение заголовков запроса

Для большинства людей единственный способ кэширования сайта htaccess заключается в том, чтобы добавить код в файл .htaccess на веб-сервере.

Файл .htaccess контролирует многие важные настройки для вашего сайта.

Кэширование браузера через файл.htaccess

Приведенный ниже код указывает браузеру, что именно кэшировать и как долго это «запоминать «. Его следует добавить в начало файла .htaccess :

## EXPIRES CACHING ## ExpiresActive On ExpiresByType image/jpg «access 1 year» ExpiresByType image/jpeg «access 1 year» ExpiresByType image/gif «access 1 year» ExpiresByType image/png «access 1 year» ExpiresByType text/css «access 1 month» ExpiresByType text/html «access 1 month» ExpiresByType application/pdf «access 1 month» ExpiresByType text/x-javascript «access 1 month» ExpiresByType application/x-shockwave-flash «access 1 month» ExpiresByType image/x-icon «access 1 year» ExpiresDefault «access 1 month» ## EXPIRES CACHING ##

Сохраните файл .htaccess , а затем обновите веб-страницу.

Как установить время кэширования для различных типов файлов

В приведенном выше коде заданы промежутки времени. Например, 1 year (1 год ) или 1 month (1 месяц ). Они связаны с типами файлов. Приведенный выше код устанавливает, что .jpg файлы (изображения ) следует кэшировать в течение года.

Если бы вы хотели изменить это, чтобы и JPG изображения кэшировались в течение месяца, то вы бы просто заменили «1 год » на «1 месяц «. Указанные выше значения кэширования через htaccess оптимальны для большинства веб-страниц.

Метод альтернативного кэширования для.htaccess

Описанный выше метод называется «Expires «, он помогает с кэшированием большинству новичков. После того, как вам станет проще работать с кэшированием, можете попробовать другой метод кэширования Cache-Control , который дает больше возможностей.

Возможно, что метод Expires не сработает на вашем сервере, в этом случае вы возможно захотите попробовать использовать Cache-Control .

Cache-Control

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

Пример использования в файле .htaccess :

# 1 Month for most static assets Header set Cache-Control «max-age=2592000, public»

Приведенный выше код устанавливает заголовок Cache-Control в зависимости от типа файла.

Как работает Cache-Control

Рассмотрим упомянутую выше строку кода кэширования в браузере htaccess :

# 1 Month for most static assets

Данная строка — просто примечание. Файл .htaccess игнорирует строки, начинающиеся с символа # . Это примечание рекомендуется, так как у вас может быть несколько различных наборов данных в качестве решения для кэширования файлов:

Упомянутая выше строка говорит, что, «если файл будет одним из этих типов, то мы сделаем что-то с ним… »

Самое важное в этой строке то, что в ней перечислены различные типы файлов (CSS , JS , JPEG , PNG и т.д. ) и что инструкции кэширования следует применять к этим типам файлов. Например, если вы не хотите, чтобы JPG файлы кэшировались в течение указанного периода времени, можете удалить «JPG «. Если вы хотите добавить HTML , то нужно в этой строке указать «HTML «:

Header set Cache-Control «max-age=2592000, public»

В упомянутой выше строке установлены фактические заголовки и значения:

  • Часть «Header set Cache-Control » — устанавливает заголовок;
  • Переменная «max-age=2592000 » – указывает, сколько времени займет процесс кэширования (в секундах ). В этом случае мы осуществляем кэширование в течение одного месяца (2592000 ) секунд;
  • Часть «public » сообщает о том, что это общедоступно.

FilesMatch>

Эта строка кэширования через htaccess закрывает оператор и заканчивает блок кода.

Общая проблема кэширования

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

Цифровой отпечаток URL

Получение нового (некэшируемого) файлового ресурса возможно при наличии уникального имени. Например, если файл CSS назван «main.css», то вместо этого мы могли бы назвать его «main_1.css». В следующий раз, когда мы поменяем его имя, мы можем назвать файл «main_2.css». Это полезно для файлов, которые периодически изменяются.

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

Ускорить загрузку Вашего сайта можно с помощью кэширования. Для решения этой задачи Вы можете воспользоваться модулем headers веб-сервера Apache. Он позволяет контролировать и изменять заголовки HTTP-запросов и HTTP-ответов. Вся суть в этом случае сводится к тому, что бы заставить браузер загрузить редко-изменяемые данные с сервера в локальный кэш всего один раз, а далее, при заходе на сайт, использовать данные из кэша. Можно установить кэширование для определенных типов файлов на строго определенное время, по истечению которого файлы будут загружены с сервера вновь. Делается это достаточно просто:

Header set Cache-Control «max-age=2592000»

Для файлов с указанными расширениями в конструкции FilesMatch устанавливается отдаваемый сервером заголовок Cache-Control и переменная max-age , в которой указывается время сохранения файлов в кеше в секундах. Добавьте или удалите расширения файлов, которые для Вас будут уместны в данном случае.

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

Header unset Cache-Control

Как видно, здесь указаны расширения файлов, которые не требуется кэшировать, просто укажите требуемые типы файлов.

Еще одни способ управлять кэшированием — это воспользоваться модулем expires . Этот модуль контролирует установку HTTP-заголовков для кэширования данных на стороне браузера. Продолжительность хранения данных в кэше может быть установлена по времени, по последнему изменению файла или по времени доступа клиента.

Ниже представлен простой пример использования модуля expires в файле .htaccess :

ExpiresActive On ExpiresDefault «access plus 1 month» ExpiresByType image/gif «access plus 2 months» ExpiresByType image/jpeg «access plus 2 months»

В этом примере мы включаем модуль, устанавливаем кэширование по умолчанию на 1 месяц, а далее назначаем для файлов с расширением gif и jpg врема хранения в кэше plus 2 months . Время можно указать в годах, месяцах, неделях, днях, часах, минутах, секундах. В том числе можно использовать вариант вида:

ExpiresByType text/html «access plus 1 month 15 days 2 hours» ExpiresByType image/gif «modification plus 5 hours 3 minutes»

В качестве типов файлов можно указывать различные MIME types , вот некоторые из них в качестве примера:

Image/x-icon image/jpeg image/png image/gif application/x-shockwave-flash text/css text/javascript application/javascript application/x-javascript text/html application/xhtml+xml

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

Поэтому в этой статья я решил собрать топ-10 советов о том, как же можно увеличить скорость загрузки веб-странички и сайта в целом. Статья не претендует на гениальность и рассчитана на новичков.

Итак, поехали:

1. Уменьшите количество HTTP-запросов

80% загрузки страницы ориентировано на загрузку компонентов страницы: скриптов, фотографий, файлов CSS, flash. Спецификация HTTP/1.1 советует, чтобы браузеры параллельно загружали не более 2-х компонентов веб-страницы с одного хоста. Уменьшив количество этих компонентов мы уменьшаем количество HTTP-запросов к серверу и как результат увеличиваем скорость загрузки страницы.

Но как уменьшить количество запросов к серверу не затрагивая внешний вид страницы?

2. Помещайте CSS файлы в начале страницы

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

Если размещать CSS файлы внизу страницы, то это не позволяет многим браузерам рендерить страницу постепенно. Это объясняется тем, что браузер «не хочет» перерисовывать элементы, у которых после загрузки страницы может измениться стиль. Так что все свои CSS файлы всегда подключайте в верхней части страницы в секции HEAD.

3. Помещайте javascript в конец страницы

Помещая javascript-файлы вниз страницы мы позволяем браузеру загрузить страницу с контентом в первую очередь, а уже потом начать загрузку javascript-файлов. Если же Ваш сайт идет в ногу со временем и содержит все возможные интерактивные «примочки», то этих javascript-файлов может быть несколько и весить они могут несколько сотен килобайт, поэтому перед загрузкой страницы заставлять пользователя ждать пока загрузятся все Ваши javascipt-файлы губительно.

Кроме того, внешние.js-файлы блокируют параллельную загрузку. Спецификация HTTP/1.1 советует, чтобы браузеры параллельно загружали не более 2-х компонентов веб-страницы с одного хоста. Таким образом, если картинки для вашего сайта располагаются на разных хостах, вы получите более 2-х параллельных загрузок. А когда загружается скрипт, браузер не будет начинать никаких других загрузок, даже с других хостов.

4. Минимизируйте css и javascript

Минимизация файла — это удаление из кода всех несущественных символов с целью уменьшения объема файла и ускорения его загрузки. В минимизированном файле удаляются все комментарии и незначащие пробелы, переносы строк, символы табуляции. Здесь все просто. Чем меньше объем файла, тем меньше времени понадобится браузеру на его загрузку. А минимизировать Ваш код помогут вот эти 24 онлайн-сервиса для сжатия и оптимизации CSS кода
5. Используйте поддомены для параллельного скачивания

Как я уже говорил Выше, согласно спецификации HTTP/1.1 на браузеры накладываются ограничения на количество одновременно загружаемых компонентов сайта, а именно не более 2-х компонентов с одного хоста. Поэтому если на Вашем сайте много графики, то ее лучше вынести на отдельный поддомен или поддомены. Для Вас это будет один и тот же сервер, а для браузера – разные. Чем больше поддоменов Вы создадите, тем больше файлов браузер сможет одновременно загрузить и тем быстрее загрузится вся страница сайта. Вам остается лишь изменить адрес картинок на новый. Очень простой, но действенный способ.

6. Используйте кэш браузера

Кеширование становится крайне важным для современных веб-сайтов, которые используют обширное подключение JavaScript и CSS. Дело в том, что когда посетитель зашел на Ваш сайт в первый раз, то браузер выполнит загрузку всех javascript и css-файлов, также загрузит всю графику и флэш, однако правильно выставив HTTP-заголовок Expires, вы сделаете компоненты страницы кешируемыми. Таким образом, когда посетитель зайдет на Ваш сайт снова или перейдет на следующую страницу Вашего сайта, в кэше его браузера уже будут находится некоторые нужные файлы и браузеру не потребуется загружать их снова. Отсюда и выигрыш в скорости загрузки сайта.

Поэтому выставляйте HTTP-заголовок Expires везде, где только это возможно, на несколько дней или даже месяцев вперед. Для того, чтобы веб-сервер Apache отдавал соответствующие рекомендациям HTTP-заголовки Expires, необходимо добавить в файл.htaccess, находящийся в корневой папке сайта, следующие строки:
Header append Cache-Control «public» FileETag MTime Size ExpiresActive On ExpiresDefault «access plus 0 minutes» ExpiresByType image/ico «access plus 1 years» ExpiresByType text/css «access plus 1 years» ExpiresByType text/javascript «access plus 1 years» ExpiresByType image/gif «access plus 1 years» ExpiresByType image/jpg «access plus 1 years» ExpiresByType image/jpeg «access plus 1 years» ExpiresByType image/bmp «access plus 1 years» ExpiresByType image/png «access plus 1 years»
Данный фрагмент файла конфигурации Веб-сервера Apache проверяет наличие модуля mod_expires и, если модуль mod_expires доступен, включает отдачу HTTP-заголовков Expires, которые устанавливают срок хранения перечисленных выше объектов в кэше браузеров и прокси-серверов равный одному году с момента первой загрузки. Установив такой срок жизни кэша браузера, может возникнуть сложность с обновлением файлов. Поэтому если Вы изменили содержимое css или javascript-файла и хотите, чтобы эти изменения обновились в кэше браузера, то необходимо изменить название самого файла. Обычно в название файла добавляют его версию, например так: styles.v1.css

7. Используйте CDN для загрузки популярных JavaScript библиотек

Если на Вашем сайте используется популярный javascript фреймворк, например jQuery, то для его подключения лучше использовать CDN.

8. Оптимизируйте ваши изображения

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

  • GIF – идеально подходят для изображений с несколькими цветами, например логотип.
  • JPEG – отлично подходят для детализированых изображений с большим количеством цветов, такие как фотографии.
  • PNG – ваш выбор, когда вам нужно высококачественное изображение с прозрачностью.
Оптимизировать изображение можно двумя способами: используя программы или онлайн сервисы в Интеренете для сжатия изображений. В первом случае от Вас потребуются определенные знания для работы с той или иной программой, а вот воспользоваться онлайн сервисами может каждый. От Вас лишь требуется загрузить нужные изображения, а сервис сам оптимизирует их и выдаст ссылку на скачивание уже сжатиых файлов.

Вот несколько онлайн сервисов для оптимизации изображений:

9. Не масштабируйте изображения

Не изменяйте размер изображения при помощи атрибутов width и height тега, либо при помощи CSS. Это тоже негативно влияет на скорость загрузки страницы. Если у Вас есть изображение размером 500x500px, а вставить на сайт Вы хотите изображение с размером 100x100px, то лучше изменить размер оригинальной картинки при помощи графического редактора Photoshop, или любого другого. Чем меньший вес картинки, тем меньше времени потребуется для её загрузки.

10. Используйте Gzip- сжатие

Как показали проведенные исследования, gzip-сжатие текстового файла «на лету» в 95–98% случаев позволяет сократить время на передачу файла браузеру. Если хранить архивированные копии файлов на сервере (в памяти proxy-сервера или просто на диске), то соединение в общем случае удается освободить в 3-4 раза быстрее.

Начиная с версии протокола HTTP/1.1, веб-клиенты указывают, какие типы сжатия они поддерживают, устанавливая заголовок Accept-Encoding в HTTP-запросе.

Accept-Encoding: gzip, deflate

Если веб-сервер видит такой заголовок в запросе, он может применить сжатие ответа одним из методов, перечисленных клиентом. При выдаче ответа посредством заголовка Content-Encoding сервер уведомляет клиента о том, каким методом сжимался ответ.

Content-Encoding: gzip

Переданные таким образом данные меньше первоначальных примерно в 5 раз, и это существенно ускоряет их доставку. Однако здесь есть один недостаток: увеличивается нагрузка на веб-сервер. Но вопрос с сервером всегда можно решить. Так что не будем обращать на это внимание.

Для того, чтобы включить GZIP-сжатие на своем сайте, необходимо в файле.htaccess прописать следующие строки кода:
AddOutputFilterByType DEFLATE text/html AddOutputFilterByType DEFLATE application/javascript AddOutputFilterByType DEFLATE text/javascript AddOutputFilterByType DEFLATE text/css BrowserMatch ^Mozilla/4 gzip-only-text/html BrowserMatch ^Mozilla/4\.Mozilla/4.0 no-gzip BrowserMatch bMSIE !no-gzip !gzip-only-text/html mod_gzip_on Yes mod_gzip_item_include file \.js$ mod_gzip_item_include file \.css$

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

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

Если что-то упустил или у Вас есть, что добавить – пишите свое мнение в комментариях ниже к этому посту. Спасибо за внимание!

Кэширование важно для оптимизации веб-сайта, созданного на WordPress, поскольку оно увеличивает скорость загрузки страниц. Посетителям сайта не понравится его долгая загрузка, в результате чего они могут просто покинуть ваш сайт, не дождавшись информации, тем самым увеличивая количество отказов. Такие поведенческие параметры плохо отражаются на ранжировании сайта поисковыми системами, которые понижают его позиции в поисковой выдаче. Чтобы этого не произошло, подключите плагин WordPress Super Cache, который автоматически выполнит работу по кэшированию страниц.

Описание и возможности плагина

Кэш представляет собой временное хранилище для содержимого веб-страницы. Вместо того чтобы загружать данные страниц (например, изображения) с сервера при повторном посещении сайта, они будут подгружаться в браузер из кэша, что существенно ускорит загрузку сайта. Эффективным инструментом для кэширования под WordPress является специальный плагин WordPress Super Cache.

Плагин генерирует статические страницы сайта и сохраняет их кэшированные версии на сервере. После этого сервер вашего хостинг-провайдера будет «отдавать» посетителям статические файлы вместо того, чтобы каждый раз обращаться к базе данных для получения элементов страниц.

Что еще умеет делать WordPress Super Cache плагин:

  • Позволяет вместе с кэшированием использовать сеть доставки контента (CDN), перераспределяя наиболее часто запрашиваемые материалы с сервера, ближайшего к посетителю.
  • Поддерживает кэширование версий страниц для планшетов и смартфонов.
  • Использует сжатие страниц, чтобы уменьшить время загрузки сайта.
  • Поддерживает несколько типов кэширования.
  • Предоставляет возможность восстановления кэша, при этом вы можете просматривать кэшированные страницы, даже когда создается новый кэш.

Виртуальный хостинг сайтов для популярных CMS:

Установка плагина WP Super Cache

Плагин можно найти в репозитории WordPress. Для этого войдите в админ-панель под своим логином и паролем.

  • Выберите меню «Плагины» (1) и нажмите «Добавить новый» (2).
  • В строке поиска напечатайте название плагина WP Super Cache (3).
  • Найдите в появившемся списке нужный вариант и нажмите кнопку «Установить» (4).
  • После установки активируйте плагин, нажав соответствующую кнопку.

Даже после активации плагин WP Super Cache по умолчанию отключен, поэтому вверху экрана вы увидите соответствующее предупреждение.

Чтобы его включить перейдите по предложенной ссылке на страницу управления плагином либо выберите команду «Настройки», которая расположена сразу под названием плагина.

На странице с настройками вы можете увидеть еще одно уведомление об изменении файла wp-config.php, после обновления страницы оно исчезнет.

Чтобы заставить плагин работать:

  1. Выберите опцию «Кэширование включено»
  2. Нажмите кнопку «Обновить».
  3. Затем выполните проверку правильности подключения плагина, используя кнопку «Проверить».

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

В противном случае сообщение выводится красным цветом и необходимо будет искать причину неполадки.

Настройки плагина WordPress Super Cache — как включить и настроить кеширование

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

Убедитесь, что кэширование включено, и выберите один из трех режимов обслуживания кэша:

  1. mod_rewrite – это самый быстрый вариант, который позволяет WordPress обслуживать статические страницы из кэша без обращения к PHP интерпретатору на сервере;
  2. режим PHP используется по умолчанию и потребляет больше ресурсов, что может оказаться невыгодным в случае большой загруженности сервера;
  3. упрощенное кэширование менее производительное, чем предыдущие варианты, но и ресурсов затребует минимум.

Следующие параметры требуют настройки в разделе «Разное».

  1. Опция «Сжимать файлы кэша» может конфликтовать с другими алгоритмами сжатия. Если к сайту подключены еще плагины, обеспечивающие сжатие, не устанавливайте этот флажок .
  2. Кэширование страниц не требуется для авторизованных пользователей или тех, кто оставляет комментарии на сайте. Включите эту опцию, чтобы разрешить таким посетителям просмотр страницы в ее текущем виде.
  3. Автоматическая перестройка кэша не нужна, если на сайте имеется часто обновляемая информация. В противном случае посетители увидят устаревшие страницы.
  4. Ошибка 304 возникает, когда сервер сообщает браузеру, что со времени последнего визита содержимое страницы не изменилось. В этом случае загрузка происходит из кэша браузера, что дополнительно ускоряет работу сайта.
  5. На странице с параметром GET присутствует поиск по определенным критериям (даты, цена), специфичным при каждом посещении. Такие страницы кэшировать не нужно.
  6. Если зарегистрированные пользователи считаются анонимными, кэшированые страницы будут выдаваться всем без исключения.
  7. Последняя опция в этом разделе – это реклама плагина со встроенной в футере ссылкой на автора.

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

  1. Если на сайте присутствуют динамические элементы, при кэшировании некоторые из них могут работать неправильно. В этом случае потребуется режим упрощенного или PHP-кэширования и включенная опция динамического кэширования.
  2. Для сайтов, разработанных специально для мобильных устройств, потребуется включить поддержку, если шаблон не является адаптивным.
  3. Опция «Убрать поддержку UTF-8» не требуется, если все символы на сайте отображаются нормально.
  4. Очистку файлов кэша при новых публикациях можно включить, если сайт часто обновляется.
  5. Дополнительная сверка понадобится, если возникают проблемы с кэшированием какой-либо страницы.
  6. Если посетитель оставил комментарий на странице, после его модерации кэш обновится.
  7. Посмотреть кэшированные страницы можно на владке «Состояние кэша», поэтому опция необязательна.
  8. Опция замедляет работу файлов, предупреждая возможную проблему на сервере при кэшировании страниц.
  9. Опция для разработчиков загружает кэш только после загрузки WordPress.

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

Если вы выбрали способ кэширования страниц методом mod-rewrite, плагин запросит обновление прав на запись. Для этого прокрутите страницу вниз до кнопки «Обновить правила Mod-Rewrite» и нажмите ее.

Затем установите время и период, в течение которого кэшированные данные на сервере будут действительны. Начните со значения 3600 секунд (1 час). Если на вашем сайте большое количество статей, возможно, понадобится задать большее время вплоть до нескольких суток, после чего кэш будет считаться устаревшим. Там же можно запланировать очистку кэша по расписанию, настраивая таймер и интервал обновления. Для неменяющихся сайтов сборку мусора можно отменить совсем, устанавливая значение таймаута, равное нулю.

Вы можете запретить кэширование определенной информации на сайте (например, раздел с постоянно обновляющейся информацией), установив флажок в нужном разделе «Допустимые имена и Запрещенные адреса» или вручную дописать адреса страниц.

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

На вкладке «Настройка CDN» подключается платный сервис для эффективного распределения информации при выдаче из кэша. Вкладка «Состояние кэша» покажет, какие страницы кэшируются, их можно вручную удалять из списка.

Перейдите на вкладку «Общий кэш», чтобы настроить параметры режима предварительной загрузки. Для чего может понадобиться использовать полностью статический контент?

  • Для экономии ресурсов сервера.
  • Чтобы повысить скорость загрузки сайта.
  • Чтобы обслуживать старый сайт, контент которого больше не обновляется.

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

Вкладка «Плагины» понадобится, только если вы собираетесь подключить другие плагины, не влияющие на кэширование файлов.

Имейте в виду, некоторые из них работают только в режиме PHP-кэширования. Для специалистов на вкладке «Обслуживание» включается режим отладки и опция сохранения логов.

Использование кеша браузера, как почистить кеш ВордПресс

Через некоторое время работы плагина WP Super Cache вы заметите формирование кэша для сайта. Правильная настройка плагина значительно улучшит время загрузки сайта. Кэшированные страницы хранятся в виде HTML или PHP файлов на сервере вашего хостинга. Обычно сервер знает, какие страницы были обновлены, и выдает пользователю свежую версию. Однако, если возникают проблемы с отображением обновленной информации, можно вручную очистить кэш. Удалите кэшированные страницы с сервера, используя команду на панели управления «Удалить весь кэш» или нажав на такую же кнопку в настройках плагина.

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

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

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

Как использовать Cache-Control | open2web

По данным приведенного опроса только 4% разработчиков утверждают, что разбираются в кэшировании и заголовке Cache-Control, а 54% вообще не понимают, как работает этот заголовок.

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

Cache-Control

HTTP-заголовок Cache-Control – наиболее распространенный и эффективный способ управлять кэшированием ваших ресурсов. Заголовок применяется к отдельным ресурсам, то есть кэширование будет выборочным. С таким объемом контроля можно реализовать сложные и мощные стратегии кэширования.

Он может выглядеть следующим образом:

Cache-Control: public, max-age=604800

public и max-age=604800 называются директивами. Заголовок Cache-Control может принимать одну или более директив. Подробнее о директивах, их значение и примеры применения поговорим в этой статье.

public и private

Директива public указывает, что любой кэш может хранить копию ответа. Это могут быть CDN, прокси-серверы и т.д.. Часто нет необходимости указывать public, так как наличие таких директив как max-age является неявной указанием, что кэш может хранить копию.

С другой стороны, private явно указывает, что только конечный получатель (клиент или браузер) может хранить копию файла. Хотя директива private сама по себе не относится к фич безопасности, она предотвращает хранению ответа, который содержит уникальные пользовательские данные, в общедоступных кэшах (например: CDN).

max-age

max-age определяет промежуток времени в секундах (относительно времени запроса), в течение которого ответ считается «свежим».

Cache-Control: max-age=60

Эта директива Cache-Control указывает браузеру, что он может использовать файл из кэша следующие 60 секунд и не беспокоиться о повторной проверке. Когда 60 секунд пройдут, браузер повторно обратится к серверу, чтобы подтвердить актуальность файла.

Если на сервере есть новый файл, вернется ответ со статусом 200, а браузер загрузит его. Старый файл будет извлечен из HTTP-кэша, а новый заменит его и будет использовать его заголовки для кэширования.

Если на сервере нет более свежей копии для загрузки – вернется ответ со статусом 304, потребности загружать новый файл не будет, а для кэшированной копии будут обновлены заголовки. То есть к файлу с заголовком Cache-Control: max-age=60 отсчет времени начнется сначала. Имеем 120 секунд общего времени кэширования для одного файла.

Будьте осторожны: при использовании max-age стоит обратить внимание на один важный нюанс. max-age указывает браузеру, что данный ресурс является устаревшим, но не указывает, что браузер абсолютно не может использовать устаревшую копию. В браузера могут быть собственные алгоритмы, по которым он решает использовать устаревшую копию файла без повторной валидации. Такое поведение не определено, поэтому довольно трудно точно предсказать как поступит браузер. Для этого существует перечень более четких директив, которые могут дополнить max-age.

s-maxage

Директива s-maxage иметь преимущество над maxage, но только в контексте общих кэшей. Используя maxage и s-maxage вместе, вы получите разные промежутки времени «свежести» файлов для частных и публичных кэшей (то есть прокси, CDN).

no-store

Cache-Control: no-store

Если же мы не хотим кэшировать файл? Что если файл содержит конфиденциальную информацию? Например, HTML-страница с банковскими реквизитами. Или актуальность информации очень зависит от времени. Например, страница с курсами акций. Мы вовсе не хотим сохранять или обрабатывать такие ответы из кэша: мы исключаем конфиденциальную информацию и стремимся получать самую свежую информацию. Для таких случаев используем no-store.

no-store – строгая директива, не позволяет хранить информацию в любом кэше, частном или любом другом. Любой ресурс директиве no-store попадет в сеть, несмотря ни на что.

no-cache

Cache-Control: no-cache

no-cache на самом деле не означает «не кэшировать», что может сбить с толку. Директива означает «не обрабатывать копию из кэша, пока вы не подтвердите ее на сервере, который позволит использование копии». Пожалуй, название must-revalidate подошла бы этой директиве больше.

no-cache – достаточно разумный способ всегда гарантировать свежий контент с возможностью использовать кэшированную копию. no-cache всегда обращаться к сети, так как перед выпуском кэшированной копии (если нет свежего экземпляра), ее необходимо повторно проверить на сервере. Если же ответ сервера удовлетворительный, сетью передаются только заголовки файла: тело можно взять из кэша, чтобы не перезагружать.

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

Использование no-cache будет уместным для почти любой динамической HTML-страницы. Вспомните главную страницу сайта с новостями: нет необходимости в режиме реального времени, нет конфиденциальной информации, но в идеале мы хотели бы, чтобы страница всегда показывала свежий контент. Можно использовать cache-control: no-cache, чтобы указать браузеру сначала проверить ресурс на сервере, и если «свежей» версии нет (статус 304), использовать кэшированную версию. Если же сервер предложит свежий контент, он пришлет ответ со статусом 200 и новый файл.

Совет: Нет смысла отправлять директиву max-age вместе с no-cache, потому что лимит времени для повторной валидации составит 0 секунд.

must-revalidate

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

Cache-Control: must-revalidate, max-age=900

must-revalidate необходимо использовать с max-age (выше мы установили значение последней 15 минут).

no-cache сразу повторно проверит копию на сервере, и использует кэшированное вариант только с разрешения сервера. must-revalidate похожа на no-cache с отсрочкой. Вернемся к нашему примеру: первые 15 минут браузер не будет повторно проверять ресурс на сервере. По завершению указанного периода он обратится к серверу, и если для нас ничего нового нет, вернется ответ со статусом 304, а для кэшированного файла будут применены новые заголовки Cache-Control. Наши 15 минут начинаются сначала: если их завершению на сервере появилась новая версия файла, получим ответ со статусом 200 и телом, а локальный кэш обновится.

must-revalidate пригодится для статических страниц, редко меняются. Конечно, желательно иметь актуальный контент, но учитывая частоту изменений в страницах, нет необходимости такого контроля, как с no-cache. Зато, предположим, что в течение этих 15 минут нам не нужно будет делать новый запрос.

proxy-revalidate

Подобно s-maxage, proxy-revalidate – версия must-revalidate для публичных кэшей. Она просто игнорируется частными кэшами.

Immutable

immutable — достаточно новая директива, дает браузеру немного больше информации о типе содержимого направленного файла: изменен он или нет. Прежде чем поговорим о immutable, определим проблемы, которые решает директива.

Когда пользователь перезагружает страницу, браузер повторно проверяет «свежесть» файла, так как перезагрузка свидетельствует об одной из двух причин:

— что-то пошло не так на странице;
— ее содержание выглядит устаревшим.

Если на сервере появился более новый файл, мы обычно хотим загрузить его. Таким образом, мы получим ответ 200, свежий файл – и проблема решена. Если же на сервере не оказалось нового файла, он вернет ответ со статусом 304 без нового файла. Если мы будем повторно проверять файл и сервер часто отправлять нам 304, все закончится ненужными затратами на ожидание.

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

Что мы подразумеваем под постоянным или изменяемом файлом?

— style.css: когда мы меняем содержимое файла, мы не трогаем его название. Файл всегда существует, а его содержание всегда меняется. Это пример изменяемого файла.

— style.ae3f66.css: такой файл уникален, потому что в его названии есть отпечаток браузера, зависит от содержимого файла. Если его содержание меняется, мы получаем совершенно новый файл. А это пример неизменяемого файла.

Если мы можем как-то сообщить браузеру, что наш файл неизменяемый, тогда можем сообщить, что браузеру не нужно беспокоиться о проверке более свежей версии: он никогда не будет «свежий», поскольку файл просто перестает существовать в момент изменения его содержания.

Здесь на помощь приходит директива immutable:

Cache-Control: max-age=31536000, immutable

В браузерах, поддерживающих immutable, перезагрузка не приведет к повторной валидации файла в пределах периода «свежести». То есть нет необходимости в ожидании 304 ответа от сервера, потенциально экономит нам много задержек на важном этапе (CSS блокирует рендеринг). При соединениях с высокой задержкой такая экономия может быть ощутимой.

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

stale-while-revalidate

О повторной валидации уже было сказано много: браузер осуществляет запрос к серверу, чтобы проверить наличие свежей копии файла. При соединениях с высокой задержкой, продолжительность такой проверки может быть ощутимой. То есть мы напрасно теряем время, пока не получим от сервера разрешение на использование кэшированной копии (304) или загрузим новый файл (200).

stale-while-revalidate определяет дополнительный период, время на протяжении которого браузер может использовать устаревший ресурс, пока мы проверяем наличие свежей версии.

Cache-Control: max-age=31536000, stale-while-revalidate=86400

Здесь мы говорим браузеру: «этот файл актуален в течение года, но по истечению этого срока, у тебя есть дополнительная неделя, чтобы обслуживать устаревший ресурс, пока ты проверяешь наличие новой версии в фоновом режиме». stale-while-revalidate — отличный выбор для некритично важных ресурсов, если мы хотим иметь самую свежую версию, но знаем, что не будет никакого вреда, если будем пользоваться устаревшей версией, пока ждем обновления.

stale-if-error

Подобно stale-while-revalidate, stale-if-error дает браузеру дополнительный период, в течение которого он может использовать устаревший ресурс, если его повторная проверка, завершается ошибками 5xx.

Cache-Control: max-age=2419200, stale-if-error=86400

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

Сброс кэша

Было бы неправильно не коснуться в этой статье темы сброса кэша. По мнению автора, стратегию сброса кэша стоит продумать в первую очередь.

Сброс кэша решает такой вид проблемы: «я указал браузеру использовать файл в течение следующего года, но я только изменил его и не хочу, чтобы пользователи ждали год перед получением свежей копии. Как можно исправить это?»

Первый вариант – без сброса: style.css

Худший подход: совершенно не сбрасывать кэш, если имеем дело с изменяемым файлом.

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

HTML-страницы также важно контролировать. Мы не можем изменить имя файла веб-страницы (представьте, какой хаос это вызовет!), Поэтому мы стараемся не хранить их в кэше.

Второй вариант – строка запроса: style.css?v=5.7.89

Здесь у нас также изменяемый файл, но со строкой запроса в пути. Лучше, чем ничего, но все еще не идеально. Если строка с запросом удаляется, мы снова столкнемся с отсутствием сброса кэша. Многие прокси-серверов и CDN НЕ будут кешировать файлы имеющие строку запроса или через собственную конфигурацию (например, документации Cloudflare: «запрос style.css?123456789 будет нормализована к обычному style.css при обработке из кэша») или защиты (строка запроса может содержать информацию, касающуюся конкретного ответа).

Третий вариант – отпечаток браузера: style.z777ro.css

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

Cache-Control: max-age=31536000, immutable

Особенность реализации

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

— /dist/style. z777ro.css: сброс с хэш-кодом содержимого файла;
— /dist/style. 5.7.89.css: сброс версии выпуска;
— /dist/5.7.89/style.css: сброс путем замены директории URL.

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

Clear-Site-Data

Инвалидация кэша — это сложно, как уже хорошо известно. На данный момент существует спецификация, помогает разработчикам полностью очистить кэш сайта одним махом: Clear-Site-Data.

В статье мы не будем много останавливаться на Clear-Site-Data, потому что это полностью другой HTTP-заголовок, который не касается Cache-Control.

Clear-Site-Data: "cache"

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

Поддержка браузерами на момент написания ограничивается Chrome, Android Webview, Firefox и Opera.

Совет: существует ряд директив, которые принимает Clear-Site-Data: cookies, storage, executionContexts и *, что означает «все вышеперечисленное».

Примеры и советы

Рассмотрим какие заголовки Cache-Control применять на реальных примерах.

Страница онлайн-банкинга

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

Попробуем такой вариант:

Request URL: /account/
Cache-Control: no-store

Согласно спецификации этого было бы достаточно, чтобы браузер не сохранял ответ на диск вообще, через частные и общие кэше:

Директива ответы no-store указывает, что кэш НЕ ДОЛЖЕН хранить любую часть запроса или ответа. Применяется в частных и общих кэшей. «НЕ ДОЛЖЕН хранить» в данном контексте означает, что кэш НЕ ДОЛЖЕН преднамеренно хранить информацию в энергонезависимой хранилище, а ДОЛЖЕН сделать все возможное, чтобы удалить информацию с энергозависимого хранилища как можно скорее после ее отправки.

Но если вы хотите максимально защититься, попробуйте такой вариант:

Request URL: /account/
Cache-Control: private, no-cache, no-store

Так вы явно указываете не хранить что-либо в публичных кэшах (например, CDN), чтобы всегда работать с самой свежей копией и не хранить ее в памяти.

Страница расписания поездов

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

Request URL: /live-updates/
Cache-Control: no-cache

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

Данное решение стандартное почти для всех веб-страниц: получаем последний контент, но при возможности используем кэш.

Страница FAQ

Страницы, вроде FAQ, обычно обновляются редко и их содержимое не чувствительно ко времени (в отличие от спортивных результатов в реальном времени или статусов полета). В таком случае мы можем кэшировать HTML-страницу на некоторое время и периодически проверять наличие свежего контента. Реализуем следующим образом:

Request URL: /faqs/
Cache-Control: max-age=604800, must-revalidate

Здесь мы указали браузера кэшировать HTML-страницу в течение недели, и по окончании указанного срока проверить сервер на наличие обновлений.

Заметьте: Различные стратегии кэширования для разных страниц одного сайта могут привести к проблеме, когда ваша домашняя страница с no-cache направляет запрос свежей версии файла style.f4fa2b.css, на который она имеет ссылки, а ваша страница FAQ с трехдневным периодом кэширования до сих пор ссылается на style.ae3f66.css. Последствия могут быть незначительными, но вы должны знать о таком нюансе.

Статический JS (или CSS) пакет приложений

Представим, что файл app.[Fingerprint].js обновляется достаточно часто (потенциально с каждым выпуском), но мы также организовали создания отпечатка каждый раз, когда файл меняется. В таком случае можем сделать что-то подобное:

Request URL: /static/app.1be87a.js
Cache-Control: max-age=31536000, immutable

Не важно как часто мы обновляем наш JS: с надежной стратегией сброса кэша, мы можем кэшировать файл сколь угодно долго. Здесь в качестве периода кэширования указано 1 год. Во-первых, это достаточно долгий промежуток времени, а, во-вторых, очень маловероятно, что браузер так долго будет сохранять файл (браузеры имеют ограниченный объем хранилища, которое они могут использовать для HTTP-кэша, поэтому они периодически очищают его, пользователи также могут очистить кэш своего браузера). Если указать период, превышающий 1 год, мы вряд ли добьемся увеличения эффективности.

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

Изображение

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

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

Request URL: /content/masthead.jpg
Cache-Control: max-age=2419200, must-revalidate, stale-while-revalidate=86400

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

Ключевые моменты

— Сброс кэша чрезвычайно важно. Разработайте стратегию сброса кэша в первую очередь.

— Как правило, кэширование HTML – плохая идея. URL-адреса HTML не могут быть разорваны, и поскольку ваша HTML-страница обычно ссылается на другие ресурсы страницы, вы также будете кэшировать ссылки на них. Пользы от такого подхода мало.

— Если вы собираетесь кэшировать какие-либо HTML-файлы с различными стратегиями кэширования, это приведет к несогласованности: одни данные будут браться из кэша, а другие будут всегда свежими.

— Если вы можете организовать надежную стратегию сброса кэша статических ресурсов (используя отпечаток), можно установить период кэширования как год, одновременно с использованием директивы immutable.

— Некритически важный контент может иметь дополнительный период кэширования директивам, вроде stale-while-revalidate.

— immutable и stale-while-revalidate не только дают нам классические преимущества кэша, но и позволяют избежать задержки при повторной валидации ресурса.

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

Источник

Кэширование

HTTP — HTTP | MDN

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

Кэширование — это метод, который сохраняет копию заданного ресурса и возвращает ее по запросу. Когда веб-кэш имеет запрошенный ресурс в своем хранилище, он перехватывает запрос и возвращает копию сохраненного ресурса вместо повторной загрузки ресурса с исходного сервера.Это позволяет достичь нескольких целей: снизить нагрузку на сервер, поскольку ему не нужно самому обслуживать всех клиентов, и повысить производительность за счет приближения к клиенту. Другими словами, на обратную передачу ресурса уходит меньше времени. Для веб-сайта веб-кэширование является основным компонентом достижения высокой производительности. Однако функциональность кэширования должна быть настроена правильно, так как не все ресурсы остаются одинаковыми навсегда: важно кэшировать ресурс только до тех пор, пока он не изменится, а не дольше.

Существует несколько типов кэшей.Их можно разделить на две основные категории: общие и частные кэши. Общий кэш — это кэш, в котором хранятся ответы для повторного использования несколькими пользователями. Частный кэш предназначен для одного пользователя. На этой странице в основном речь пойдет о кэшах браузера и прокси-серверов, но есть также кэши шлюзов, CDN, кэши обратных прокси-серверов и балансировщики нагрузки, которые развернуты на веб-серверах для повышения надежности, производительности и масштабирования веб-сайтов и веб-приложений.

Частный кэш браузера

Частный кэш предназначен для одного пользователя.Возможно, вы уже видели «кеширование» в настройках вашего браузера. Кэш браузера содержит все документы, которые пользователь загружает через HTTP. Этот кэш используется, чтобы сделать посещенные документы доступными для навигации вперед/назад, сохранения, просмотра в качестве источника и т. д. без необходимости дополнительного обращения к серверу. Это также улучшает автономный просмотр кэшированного контента.

Общие кэши прокси-серверов

Общий кэш — это кэш, в котором хранятся ответы для повторного использования несколькими пользователями. Например, поставщик услуг Интернета (ISP) или ваша компания могут настроить веб-прокси как часть инфраструктуры своей локальной сети для обслуживания множества пользователей, чтобы многократно использовать популярные ресурсы, уменьшая сетевой трафик и задержку.

Кэширование HTTP является необязательным, но обычно желательным. Кэши HTTP обычно ограничиваются кэшированием ответов на метод запроса GET ; они могут отказаться от других методов. Первичный ключ кэша состоит из метода запроса и целевого URI (часто используется только URI, поскольку только запроса GET являются целями кэширования).

Общие формы записей кэширования:

  • Успешные результаты запроса на получение: ответ 200 (ОК) на запрос GET , содержащий ресурс, такой как HTML-документы, изображения или файлы.
  • Постоянные перенаправления: ответ 301 (перемещен навсегда).
  • Ответы на ошибку: страница результатов 404 (не найдено).
  • Неполные результаты: ответ 206 (частичное содержимое).
  • Ответы, отличные от GET , если определено что-то подходящее для использования в качестве ключа кэша.

Запись кэша может также состоять из нескольких сохраненных ответов, различающихся вторичным ключом, если запрос является целью согласования содержимого.Дополнительные сведения см. в информации о заголовке Vary ниже.

Поле общего заголовка Cache-Control HTTP/1.1 используется для указания директив для механизмов кэширования как в запросах, так и в ответах. Используйте этот заголовок, чтобы определить политики кэширования с различными директивами, которые он предоставляет.

Без кэширования

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

 Cache-Control: нет сохранения
 
Кэшировать, но перепроверить

Кэш отправит запрос на исходный сервер для проверки перед выпуском кэшированной копии.

 Cache-Control: нет кэша
 
Частные и общедоступные кэши

Директива public указывает, что ответ может кэшироваться любым кэшем. Это может быть полезно, если страницы с HTTP-аутентификацией или кодами состояния ответа, которые обычно не кэшируются, теперь должны кэшироваться.

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

 Кэш-Контроль: частный
Кэш-Контроль: общедоступный
 
Срок действия

Наиболее важной здесь является директива max-age= , которая представляет собой максимальное количество времени, в течение которого ресурс будет считаться свежим. Эта директива зависит от времени запроса и переопределяет заголовок Expires (если он установлен). Для файлов в приложении, которые не будут изменяться, обычно можно использовать агрессивное кэширование.Сюда входят статические файлы, такие как изображения, файлы CSS и файлы JavaScript.

Подробнее см. также в разделе «Свежесть».

 Управление кэшем: max-age=31536000
 
Валидация

При использовании директивы » must-revalidate » кэш должен проверять состояние устаревших ресурсов перед их использованием. Не следует использовать просроченные ресурсы. Дополнительные сведения см. в разделе Проверка кэша.

 Cache-Control: необходимо перепроверить
 

Pragma — это HTTP/1.0 заголовок. Pragma: no-cache похож на Cache-Control: no-cache тем, что заставляет кэши отправлять запросы на исходный сервер для проверки перед выпуском кэшированной копии. Однако Pragma не указан для ответов HTTP и поэтому не является надежной заменой общего заголовка HTTP/1.1 Cache-Control .

Pragma следует использовать только для обратной совместимости с кэшами HTTP/1.0, где Cache-Control HTTP/1.1 заголовка еще нет.

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

Кроме того, некоторые ресурсы на сервере могут измениться, поэтому при этом следует обновить кеш. Поскольку HTTP является клиент-серверным протоколом, серверы не могут связываться с кэшем и клиентами при изменении ресурса; они должны сообщить время истечения срока действия ресурса.До истечения этого срока ресурс свежий ; по истечении срока действия ресурс становится устаревшим ресурсом .

Алгоритмы вытеснения часто отдают предпочтение новым ресурсам по сравнению с устаревшими.

Обратите внимание, что устаревший ресурс не удаляется и не игнорируется; когда кеш получает запрос на устаревший ресурс, он пересылает этот запрос с заголовком If-None-Match , чтобы проверить, действительно ли он все еще свежий. Если это так, сервер возвращает заголовок 304 (не изменено), не отправляя тело запрошенного ресурса, что позволяет сэкономить некоторую полосу пропускания.

Вот пример этого процесса с прокси-сервером общего кэша:

Время жизни ответа

Время жизни ответа — это время между его генерацией исходным сервером и временем истечения срока действия. Время жизни ответа рассчитывается на основе нескольких заголовков:

  1. Если кеш является общим и присутствует заголовок Cache-Control с директивой s-maxage=N , время жизни составляет N .
  2. Если присутствует заголовок Cache-Control с директивой max-age=N , срок действия N .
  3. Если присутствует заголовок Expires , время жизни актуальности равно его значению минус значение заголовка Date .
  4. В противном случае в ответе не указано явное время истечения срока действия. Может быть применим эвристический подход к проверке свежести

Дополнительные сведения см. в разделе Расчет времени жизни в спецификации HTTP.

Эвристическая проверка актуальности

Если исходный сервер явно не указывает актуальность (например, используя заголовок Cache-Control или Expires ), то можно использовать эвристический подход.

В этом случае найдите заголовок Last-Modified . Если заголовок присутствует, то время жизни кэша равно значению заголовка Date минус значение заголовка Last-modified , деленное на 10.Срок годности рассчитывается следующим образом:

 expireTime = responseTime + freshnessLifetime - currentAge
 

, где responseTime — время получения ответа в соответствии с браузером, а freshnessLifetime — время жизни свежести.

Дополнительные сведения см. в разделе Расчет эвристической актуальности в спецификации HTTP.

Revved resources

Чем больше мы используем кэшированных ресурсов, тем выше скорость отклика и производительность веб-сайта.Чтобы оптимизировать использование кэшированных ресурсов, передовой опыт рекомендует устанавливать время истечения срока действия как можно дальше в будущем. Это возможно для ресурсов, которые обновляются регулярно или часто, но проблематично для ресурсов, которые обновляются редко или редко. Последние — это ресурсы, которые больше всего выиграют от кэширования ресурсов, но их очень сложно обновить. Это типично для технических ресурсов, включенных и связанных с каждой веб-страницей: файлы JavaScript и CSS меняются нечасто, но когда они меняются, вы хотите, чтобы они обновлялись быстро.

Веб-разработчики изобрели метод, который Стив Содерс назвал «оживлением». Редко обновляемые файлы именуются особым образом: в их URL, обычно в имени файла, добавляется номер редакции (или версии). Таким образом, каждая новая версия ресурса считается отдельным ресурсом, который никогда не изменяется и который может иметь срок действия очень далеко в будущем, обычно один год или даже больше. Для получения новых версий необходимо изменить все ссылки на ресурсы. В этом недостаток этого метода: дополнительная сложность, о которой обычно заботится цепочка инструментов, используемая веб-разработчиками.Когда изменяются редко изменяемые ресурсы, они вызывают дополнительные изменения в ресурсах, которые часто изменяются. При чтении последних также считываются новые версии первых.

Этот метод имеет дополнительное преимущество: одновременное обновление двух кэшированных ресурсов не приведет к ситуации, когда устаревшая версия одного ресурса будет использоваться в сочетании с новой версией другого. Это очень важно, когда на веб-сайтах есть таблицы стилей CSS или сценарии JS, которые имеют взаимные зависимости, то есть они зависят друг от друга, поскольку ссылаются на одни и те же элементы HTML.

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

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

Повторная проверка запускается, когда пользователь нажимает кнопку «Обновить». Он также запускается во время обычного просмотра, если кэшированный ответ включает заголовок « Cache-Control: must-revalidate ». Вы также можете использовать настройки проверки кэша на панели настроек Advanced->Cache , которая предлагает возможность принудительной проверки каждый раз при загрузке ресурса.

ETags

Заголовок ответа ETag представляет собой значение , непрозрачное для агента пользователя , которое можно использовать в качестве надежного средства проверки.Это означает, что пользовательский агент HTTP, такой как браузер, не знает, что представляет собой эта строка, и не может предсказать, каким будет ее значение. Если заголовок ETag был частью ответа для ресурса, клиент может выдать If-None-Match в заголовке будущих запросов для проверки кэшированного ресурса.

Last-Modified

Заголовок ответа Last-Modified можно использовать в качестве слабого средства проверки. Он считается слабым, потому что имеет разрешение всего в 1 секунду.Если в ответе присутствует заголовок Last-Modified , то клиент может выдать заголовок запроса If-Modified-Since для проверки кэшированного документа.

Когда сделан запрос на проверку, сервер может либо проигнорировать запрос на проверку и ответить обычным 200 OK , либо вернуть 304 Не изменено (с пустым телом), чтобы указать браузеру использовать его кешированную копию. Последний ответ может также включать заголовки, обновляющие время истечения срока действия кэшированного ресурса.

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

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

Эта функция обычно используется, чтобы разрешить кэширование ресурса в несжатой и (различной) сжатой формах и обслуживать его надлежащим образом для пользовательских агентов на основе кодировок, которые они поддерживают.Например, сервер может установить Vary: Accept-Encoding , чтобы обеспечить кэширование отдельной версии ресурса для всех запросов, в которых указана поддержка определенного набора кодировок, например, Accept-Encoding: gzip,deflate, сдч .

 Варьируется: Accept-Encoding
 

Примечание: Используйте Vari с осторожностью. Это может легко снизить эффективность кэширования! Кэширующий сервер должен использовать нормализацию, чтобы уменьшить дублирование записей в кэше и ненужные запросы к исходному серверу.Это особенно верно, когда вы используете Vary с заголовками и значениями заголовков, которые могут иметь много значений.

Заголовок Vary также может быть полезен для предоставления разного контента пользователям компьютеров и мобильных устройств или позволяет поисковым системам обнаруживать мобильную версию страницы (и, возможно, также сообщать им, что маскировка не предусмотрена). Обычно это достигается с помощью заголовка Vary: User-Agent и работает, поскольку значение заголовка User-Agent отличается для мобильных и настольных клиентов.

 Варьируется: User-Agent
 

Нормализация

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

Например, по умолчанию все следующие результаты приводят к отдельному запросу к источнику и отдельной записи в кэше: Кодировка: gzip .Это верно даже при том, что исходный сервер, вероятно, ответит и сохранит один и тот же ресурс для всех запросов (gzip)!

Во избежание ненужных запросов и дублирования записей кэша серверы кэширования должны использовать нормализацию для предварительной обработки запроса и кэширования только тех файлов, которые необходимы. Например, в случае Accept-Encoding вы можете проверить gzip и другие типы сжатия в заголовке, прежде чем выполнять дальнейшую обработку, и в противном случае отменить установку заголовка.В «псевдокоде» это может выглядеть так:

.
 // Нормализовать Accept-Encoding
если (req.http.Accept-Encoding) {
  если (req.http.Accept-Encoding ~ "gzip") {
    установить req.http.Accept-Encoding = "gzip";
  }
  // иначе, если другие типы кодировки для проверки
  еще {
    отключить req.http.Accept-Encoding;
  }
}
 

User-Agent имеет еще больше вариаций, чем Accept-Encoding . Таким образом, если вы используете Vary: User-Agent для кэширования мобильных/настольных вариантов файлов, вы должны аналогичным образом проверить наличие «мобильный» и «рабочий стол» в заголовке запроса User-Agent , а затем очистить его.

Что такое кэш браузера и почему он важен?

Вы уже слышали слово «кеш», но не знаете точно, что оно означает в контексте Интернета. В просторечии кеширование означает размещение чего-либо в хранилище (обычно в секрете) на случай, если оно может пригодиться позже (например, тайник с оружием). Браузер или веб-кеш делают именно это, за исключением ресурсов программы и веб-сайта. Когда вы посещаете веб-сайт, ваш браузер берет фрагменты страницы и сохраняет их на жестком диске вашего компьютера.Вот некоторые из активов, которые будет хранить ваш браузер:

  • Изображения — логотипы, изображения, фоны и т. д.
  • HTML
  • CSS
  • JavaScript

Короче говоря, браузеры обычно кэшируют так называемые «статические активы» — части веб-сайта, которые не меняются при посещении. посетить.

Что кэшировать и на какой срок определяется сайтом. Некоторые активы удаляются с вашего компьютера через несколько дней, а другие могут оставаться в кэше до года.

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

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

Преимущества кэширования

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

Этот процесс использует полосу пропускания. Некоторым веб-страницам потребуется много времени, чтобы полностью загрузиться и стать функциональными, потому что они состоят из большого количества частей или их активы велики.

Например, вы можете заметить, что при первом открытии веб-страницы текст появляется перед изображениями. Это связано с тем, что текст небольшой и его загрузка занимает мало времени, в то время как для заполнения высококачественного изображения может потребоваться несколько секунд (вечность в вычислительном времени).

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

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

Наряду с большими изображениями на сложных сайтах используются большие файлы JavaScript, необходимые для таких приложений, как корзины покупок, интерактивные изображения и списки пожеланий. Представьте, как негативно повлияет на коэффициент конверсии, если пользователю придется ждать от пяти до десяти секунд, пока кнопка «Купить сейчас» не появится под продуктом.Быстрый и плавный просмотр необходим для того, чтобы клиенты чувствовали себя комфортно и поощряли конверсию. Кроме того, при следующем посещении кэшированного сайта электронной коммерции эти активы по-прежнему будут доступны на вашем устройстве для более быстрой загрузки.

Мобильные устройства часто ограничены пропускной способностью. Некоторые тарифные планы мобильных данных также имеют ограничения пропускной способности или взимают плату. Чем меньше пользователю приходится загружать веб-сайт, тем лучше для него.

Некоторые подводные камни

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

Если вы правильно выполнили замену образа, проблема обычно связана с кэшированием.

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

Старые версии кэшированных файлов вызывают всевозможные проблемы у пользователей, если на их устройствах не установлена ​​последняя версия файла — несоответствующее форматирование, неработающий JavaScript и неправильные изображения — это лишь некоторые из них.

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

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

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

Как очистить кэш для всех основных браузеров

Кто-то постоянно говорит вам «очистить кеш браузера»? Это важная диагностика, когда у вас возникают проблемы (например, ошибка 304) с веб-сайтом. Но что на самом деле означает очистка кеша вашего браузера и как вы это делаете для своего конкретного браузера?

Как очистить кэш

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

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

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

Что такое кэш? Изучите эту распространенную и сложную технологию

Зачем нужно очищать кеш браузера?

Большую часть времени вы даже не замечаете кэширование браузера.Он работает полностью за кулисами, и обычно не влияет на работу в Интернете. Но… иногда что-то может пойти не так.

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

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

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

Как принудительно обновить одну страницу

Прежде чем приступить к очистке всего кеша браузера, вы можете попробовать одну хитрость, которая называется «принудительное обновление». Обычно, когда вы обновляете страницу, ваш браузер по-прежнему обслуживает кешированную версию страницы, а не загружает все ресурсы снова. Но на самом деле вы можете обойти кеш и принудительно выполнить полное обновление, используя несколько простых горячих клавиш:

  • Браузеры Windows и Linux : CTRL + F5
  • Apple Safari: SHIFT + Перезагрузить Кнопка панели инструментов
  • Chrome и Firefox для Mac : CMD + SHIFT + R

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

Как очистить кэш браузера для Google Chrome

Чтобы очистить кеш для Google Chrome, нажмите на значок Three Dots в правом верхнем углу окна браузера.Затем найдите параметр Дополнительные инструменты и выберите Очистить данные просмотра… в подменю:

Подпишитесь на информационный бюллетень

Хотите узнать, как мы увеличили трафик более чем на 1000%?

Присоединяйтесь к более чем 20 000 других пользователей, которые получают нашу еженедельную рассылку с советами по WordPress, посвященными инсайдерской информации!

Подпишитесь сейчас Меню очистки данных браузера Google Chrome

Кроме того, вы также можете использовать комбинацию горячих клавиш: CTRL + SHIFT + DEL. Chrome откроет новую вкладку со всплывающим окном под названием Очистить данные просмотра . Убедитесь, что только установлен флажок Кэшированные изображения и файлы . В противном случае вы можете случайно очистить историю посещенных страниц, сохраненные пароли, файлы cookie и многое другое:

. Очистить кеш браузера в Google Chrome

Вы также можете изменить временные рамки вверху, хотя обычно значение по умолчанию 4 недели вполне нормально. Затем нажмите кнопку Очистить данные просмотра , чтобы очистить кеш. Вот и все — кеш вашего браузера Chrome теперь пуст.

Очистка кеша браузера также является решением проблемы ERR_SPDY_PROTOCOL_ERROR.

Как очистить кэш для Mozilla Firefox

Чтобы очистить кеш браузера для Mozilla Firefox, нажмите значок Hamburger в правом верхнем углу и выберите История:

Меню истории Mozilla Firefox

Затем в появившемся меню выберите Очистить недавнюю историю…

Mozilla Firefox очистить недавнюю историю

Вы также можете получить доступ к меню с помощью сочетания клавиш: CTRL + SHIFT + DEL. Firefox откроет всплывающее окно. В раскрывающемся списке Временной диапазон для очистки: выберите Все . Затем убедитесь, что только установите флажок Cache , чтобы избежать очистки важных данных просмотра. Затем нажмите Очистить сейчас , чтобы очистить кеш:

Очистить кеш браузера в Mozilla Firefox

И все! Кэш вашего браузера Firefox теперь пуст.

Как очистить кэш для Safari

Чтобы очистить кеш браузера для Safari, у вас есть два варианта.Если вы согласны с очисткой всей истории посещенных страниц (включая файлы cookie и посещенные страницы), вы можете воспользоваться более простым подходом и просто перейти к Safari → Очистить историю :

. Очистить историю в Safari

Опять же — этот метод использует подход выжженной земли. В дополнение к кешу вашего браузера, он также очистит вашу историю просмотров, файлы cookie и т. д. Чтобы только очистить кеш браузера Safari, вам нужно включить меню «Разработка », перейдя в «Настройки» → «Дополнительно» и отметив Показать меню разработки в строке меню поле:

Показать меню разработчика в Safari

Затем вы можете перейти к «Разработка» → «Очистить кэши» , чтобы очистить кеш браузера Safari:

Очистить кеш браузера в Safari

Как очистить кеш для Internet Explorer

Чтобы очистить кэш браузера для Internet Explorer, начните работу, щелкнув значок Gear в правом верхнем углу, чтобы получить доступ к меню Инструменты .Затем найдите Безопасность и выберите Удалить историю просмотров… из подменю:

Internet Explorer удалить историю просмотра

Вы также можете получить доступ к меню, используя ярлык: CTRL + SHIFT + DEL. Internet Explorer откроет всплывающее окно. Убедитесь, что для только выберите поле Временные файлы Интернета и файлы веб-сайтов , чтобы избежать очистки важной информации. Затем нажмите кнопку Удалить внизу:

Очистите кеш браузера в Internet Explorer

И кеш вашего браузера Internet Explorer очистится!

Как очистить кэш для Microsoft Edge

Чтобы очистить кеш браузера для Microsoft Edge, нажмите значок Three Dots  в правом верхнем углу окна браузера.

Настройки Microsoft Edge

Прокрутите вниз и нажмите Выберите, что очистить .

Выберите, что очищать в Microsoft Edge

. Убедитесь, что только , установите флажок Кэшированные данные и файлы , чтобы не удалять важную информацию. Вы также можете получить доступ к меню с помощью сочетания клавиш: CTRL + SHIFT + DEL. Затем нажмите кнопку Очистить внизу.

очистить кеш браузера в Microsoft Edge

Как очистить кеш для Opera

Чтобы очистить кэш браузера для Opera, щелкните значок Opera в левом верхнем углу, найдите параметр Дополнительные инструменты и выберите Очистить данные браузера в подменю:

Очистить данные браузера Opera

В большинстве случаев следует установить Удалить следующие элементы из: равно не менее за последние 4 недели. Затем обязательно установите флажок Кэшированные изображения и файлы и нажмите кнопку Очистить данные просмотра :

Очистить кеш браузера в Opera

Кэш вашего браузера Opera теперь пуст.


Экономьте время, деньги и максимизируйте производительность сайта с:

  • Мгновенная помощь от экспертов по хостингу WordPress, круглосуточно и без выходных.
  • Интеграция с Cloudflare Enterprise.
  • Глобальный охват аудитории с 29 центрами обработки данных по всему миру.
  • Оптимизация с помощью нашего встроенного мониторинга производительности приложений.

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

Как очистить кэш в любом браузере

История браузера — список всех посещенных вами страниц в Интернете и время, когда вы там были, — это стандарт современных вычислений.И это может привести к неприятностям; это практически клише. Подумайте о романтических «комедиях», где парень (это всегда парень) оказывается в затруднительном положении после того, как его девушка просматривает историю его браузера.

Для большинства из нас совместное использование ПК является нормальным явлением (к сожалению, создание нескольких учетных записей пользователей — нет), а передача смартфона кому-либо — обычное дело. Неважно, шифруете ли вы свою электронную почту, используете ли Tor и VPN во время просмотра, чтобы оставаться анонимным, или носите ли вы накладные усы за своим столом: если кто-то имеет доступ к вашим устройствам, они могут видеть, где вы были. .

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

Думаете, это нагнетание страха? Надеюсь, это так, для 99% из нас.Но учтите, что в 2016 году канадский суд обвинил сотрудника в уничтожении улик после того, как он очистил историю браузера на своем личном ноутбуке. (В конце концов, он победил.) В США Закон Сарбейнса-Оксли предназначен для предотвращения удаления доказательств корпорациями, однако он был применен по крайней мере к одному лицу. Предостережение: указанный человек также совершил много других глупостей.

Предположим, вы не преступник и просто хотите немного цифровой конфиденциальности. Что вы можете сделать, чтобы скрыть ваши прошлые визиты? Удалите их.Регулярно. Или, возможно, самый умный ход из всех: убедитесь, что он никогда не сохраняется. Это может сделать ваши путешествия по сети немного менее удобными, но это цена безопасности. Вот как удалить историю.


Браузеры для ПК

Google Chrome

Перейдите в меню из трех точек в правом верхнем углу Chrome, чтобы выбрать Дополнительные инструменты > Очистить данные браузера. Откроется диалоговое окно для удаления вашего браузера, а также истории загрузок (фактически загруженные файлы не будут удалены), файлов cookie, кэшированных изображений и файлов (которые помогают быстрее загружать страницы при повторном посещении), сохраненных паролей. , и больше.Вы можете удалить только информацию за последний час, день, неделю, месяц или всю информацию с «начала времен».

Chrome не дает возможности вместо собирать историю браузера. Хуже того, Google постоянно собирает информацию о вашей активности в Интернете и приложениях. Но вы можете удалять его регулярно. Перейдите на страницу myactivity.google.com и нажмите История приложений и веб-поиска . Снимите флажок Включить историю Chrome и действие и включите автоматическое удаление, чтобы Google удалял все, что старше трех, 18 или 36 месяцев (на ваш выбор).Также нажмите Управление активностью , чтобы удалить еще больше.


Opera

В главном меню Opera на панели навигации слева щелкните значок часов, чтобы войти в историю. Вы увидите кнопку  Очистить данные браузера  , которая предлагает практически те же настройки, что и Chrome. Это потому, что Opera построена на движке Chromium Project, который также лежит в основе Chrome. Тем не менее, Opera предлагает немного больше тем, кто хочет безопасно выходить в Интернет, с помощью встроенной опции VPN, любезно предоставленной SurfEasy, которая также находится в настройках конфиденциальности и безопасности.


Microsoft Edge

Microsoft Edge теперь также построен на Chromium, поэтому применяются многие из описанных выше шагов. Чтобы найти историю браузера, нажмите Ctrl+Shift+Del , введите « edge://settings/clearBrowserData » в адресной строке или перейдите в меню-гамбургер > Настройки > Настройки (снова) > Конфиденциальность, выполните поиск и услуги > Очистить данные браузера и нажмите Выберите, что нужно очистить .

Избавьтесь от истории посещенных страниц, файлов cookie и многого другого за одни и те же диапазоны дат — от последнего часа до всего времени с промежуточными интервалами.Если вы это сделаете, он также удалит его на любом устройстве, с которым вы синхронизировали Edge. Чтобы этого избежать, сначала выйдите из браузера.

Вернитесь на шаг назад в Настройки, и вы увидите ссылку с надписью Выберите, что очищать каждый раз, когда вы закрываете браузер . Переключите переключатель для истории браузера, чтобы удалять ее каждый раз. Как и Google, Microsoft хранит часть вашей истории в Интернете. Нажмите «Управление данными», чтобы перейти на страницу своей учетной записи Майкрософт, где вы можете удалить эту синхронизированную историю действий в браузере.


Microsoft Internet Explorer

Все еще используете Internet Explorer (IE)? Вы должны остановиться. Но если вы не можете, вы можете стереть историю в IE11 и IE10, перейдя к значку шестеренки в левом верхнем углу и выбрав Свойства обозревателя . На вкладке Общие установите флажок рядом с Удалить историю браузера при выходе или нажмите кнопку Удалить, чтобы мгновенно избавиться от истории, паролей, файлов cookie, кэшированных данных (так называемых временных файлов Интернета и файлов веб-сайтов) и многого другого. .

Если вы вместо этого нажмете Настройки , вы перейдете на вкладку «История», где вы можете убедиться, что ваша история собирается только за определенное количество дней и автоматически удаляет все, что старше.

У вас есть возможность удалить историю посещенных страниц с помощью меню «Избранное». Нажмите звездочку в правом верхнем углу и перейдите на вкладку «История». Там вы можете увидеть веб-сайты, которые вы посещали в определенные даты (сегодня, на прошлой неделе, 3 недели назад и т. д.). Щелкните правой кнопкой мыши, чтобы удалить все за определенный период времени, или щелкните, чтобы просмотреть и удалить определенные веб-сайты.Если вы используете старую версию IE, в Интернете есть инструкции по удалению истории.


Safari

В macOS правила Safari. Очистить историю посещений веб-сайта очень просто: нажмите История > Очистить историю . Во всплывающем окне выберите период времени, за который вы хотите стереть данные. Однако это намного больше, чем удаление истории браузера, — оно также удаляет ваши файлы cookie и кеш данных.

(ПКМаг)

Вместо этого вы можете нажать  История > Показать всю историю  и выполнить поиск отдельных сайтов, которые вы хотите удалить из своей истории.Удалите файлы cookie, выбрав Safari > Настройки > Конфиденциальность ; затем вы можете управлять данными веб-сайта с помощью кнопки.


Mozilla Firefox

В последней версии Firefox откройте меню-гамбургер и раздел Параметры > Конфиденциальность и безопасность . Прокрутите вниз, чтобы перейти к истории. Настройте Firefox так, чтобы он запоминал, никогда не запоминал, или получите некоторые пользовательские настройки, например, запоминать историю, но не файлы cookie. В этом разделе также есть кнопка «Очистить историю». Нажмите на нее, чтобы выбрать временной диапазон для очистки (один, два, четыре или 24 часа — или все) и данные для дампа (история, входы в систему, формы/поиск, файлы cookie и кеш).

Проверьте раздел Синхронизация , когда вы находитесь в Настройках — если вы вошли в систему с учетной записью Mozilla Firefox, ваша история (а также закладки, вкладки, пароли и настройки) может быть синхронизирована с другими вашими ПК и устройствами с помощью Firefox , даже на смартфонах.


Мобильные браузеры

Изображение: Гетти

Safari

На iPhone и iPad Safari является браузером по умолчанию. Чтобы не записывать историю браузера, вы можете оставаться в приватном режиме во время серфинга.Если у вас есть история для удаления, выберите «Настройки» > «Safari» > «Очистить историю и данные веб-сайта» . Выполнение удаляет историю, файлы cookie и другие данные. Кроме того, если телефон зарегистрирован в iCloud, он очищает историю в iCloud, а также на других устройствах, подключенных к этой учетной записи iCloud.

Если вы хотите удалить данные только для избранных сайтов, вернитесь в Настройки > Safari и прокрутите вниз до Дополнительно > Данные веб-сайта . После того, как он загрузится (это может занять некоторое время), вы увидите список всех веб-сайтов, которые вы посетили, и, вероятно, многих из них, которые вы не посещали, поскольку он также записывает сайты, использующие сторонние файлы cookie.Коснитесь Изменить > [символ минус]  рядом с каждым, чтобы удалить его, или просто проведите пальцем влево по каждому из них.


Chrome

Браузер Google Chrome является стандартным для всех телефонов Android и доступен для загрузки на iOS. В любом случае перейдите в меню из трех точек, выберите  История , и вы увидите список всех сайтов, которые вы посетили в режиме когнито (в отличие от инкогнито). Это включает в себя историю во всех браузерах Chrome, вошедших в одну и ту же учетную запись Google, поэтому здесь также отображается история вашего рабочего стола.

Рекомендовано нашими редакторами

В iOS у вас есть возможность нажать «Изменить» или «Очистить данные браузера» внизу. В последнем случае (это единственный вариант на телефонах и планшетах Android) вы попадаете в диалоговое окно (на фото), которое позволяет стереть всю историю просмотров, файлы cookie, кэшированные данные, сохраненные пароли и данные автозаполнения — вы выбираете что вы хотите удалить. Пользователи Android получают дополнительную возможность ограничить удаление до часа, дня, недели, месяца или легендарного «начала времени».»

Опять же, проверьте страницу Google Мои действия позже, чтобы увидеть, что может храниться в Интернете.

В iOS есть совершенно отдельное приложение Google для поиска (iOS, Android) с собственным встроенным браузером. Вы не можете удалить историю серфинга в этом приложении Google, хотя вы можете закрыть все вкладки, нажав значок «Вкладки» в правом нижнем углу, проведя пальцем по одному плавающему окну вправо, чтобы удалить, а затем выбрав «ОЧИСТИТЬ ВСЕ». История поиска этого приложения, конечно же, хранится в разделе «Мои действия».


Firefox

Браузер Firefox доступен для iOS или Android бесплатно на обеих платформах.То, как вы удаляете историю браузера в каждом из них, немного отличается.

В iOS коснитесь меню-гамбургера в правом нижнем углу и выберите  Настройки . Прокрутите вниз до раздела «Конфиденциальность» и выберите Управление данными . На следующем экране вы можете полностью отключить сбор истории браузера (или кэширование данных, файлы cookie и данные офлайн-сайта). Щелкните ссылку Clear Private Data внизу, чтобы очистить все вышеперечисленное. Обратите внимание, что в настройках также есть переключатель «Закрыть приватные вкладки», который закрывает их все, когда вы выходите из браузера.

На Android Firefox использует меню из трех точек в правом верхнем углу. Выберите История , чтобы просмотреть список, и нажмите ОЧИСТИТЬ ИСТОРИЮ БРАУЗЕРА внизу, чтобы удалить их все. Если щелкнуть меню и перейти к «Настройки» > «Конфиденциальность » и установить флажок «Очистить личные данные при выходе », вы получите возможность очищать личные данные по вашему выбору всякий раз, когда вы выходите из приложения браузера.


Opera

Приложение Opera, естественно, доступно для iOS и Android и доступно во многих вариантах, таких как Opera Mini и Opera Touch, в зависимости от платформы.

Чтобы очистить историю в Opera Mini на iPhone, щелкните меню O внизу и выберите «История», затем щелкните значок корзины, чтобы удалить ее. Или в меню O выберите «Настройки » > «Очистить », чтобы найти варианты удаления сохраненных паролей, истории посещенных страниц, файлов cookie и данных — или удалить их все сразу. В обычной Opera откройте страницу «Вкладки» и используйте меню с многоточием (…) , чтобы перейти к «Настройки» > «Очистить данные браузера» > «История просмотров» .

На Android в меню гамбургера выберите history и убейте его значком корзины на панели инструментов.Или перейдите в меню гамбургера, чтобы получить доступ к настройкам, прокрутите вниз до раздела «Конфиденциальность» и найдите «Очистить данные браузера» , который позволяет вам по отдельности удалять пароли, историю или файлы cookie.


Нравится то, что вы читаете?

Подпишитесь на информационный бюллетень «Советы и рекомендации» , чтобы получить советы экспертов, чтобы получить максимальную отдачу от вашей технологии.

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

Как очистить кэш браузера и файлы cookie

Зачем очищать кэш браузера и файлы cookie?

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

Ниже приведены пошаговые инструкции по очистке браузеров. кеш и куки.

ВАЖНО: Обязательно закройте/выйдите из браузера и перезапустите его после очистка кеша и куки.

Chrome

1. Щелкните меню Инструменты (три пунктирные линии в правом верхнем углу). угол).
2. Выберите История .
3. Выберите Очистить данные браузера с левой стороны. Установите время Диапазон установлен на Все время . Отметьте файлы cookie и другие данные сайта и Кэшированные изображения и файлы и выберите Очистить данные .
4. Если вы используете компьютер с Windows, закройте и снова откройте Chrome, чтобы сохранить изменения. Если на компьютере Apple перейдите в меню Chrome в верхней строке меню и выберите Выйдите из , чтобы изменения вступили в силу.

Firefox

1.Нажмите на панель инструментов .
2. Нажмите Настройки (на Mac она называется Настройки).
3. В меню слева выберите Конфиденциальность и безопасность .
4. В разделе «Файлы cookie и данные сайта» нажмите «Очистить данные…» . кнопка.
5. Выберите только две опции и нажмите Очистить сейчас .
6. Если вы используете компьютер с Windows, закройте и снова откройте Firefox, чтобы сохранить изменения. Если на компьютере Apple перейдите в меню Firefox в верхней строке меню и выберите Выйдите из , чтобы изменения вступили в силу.

Edge

1. Откройте меню Инструменты (три пунктирные линии в правом верхнем углу). углу) и откройте меню настроек .
2. Щелкните Конфиденциальность , поиск и услуги слева. меню.
3. В разделе Очистить данные просмотра нажмите Выберите, что нужно очистить .
4. Выберите Файлы cookie и другие данные сайта и Кэшированные изображения и файлы .
5. Щелкните Очистить сейчас .
6. Полностью закройте Microsoft Edge, чтобы изменения вступили в силу.

Safari для Mac

1. Нажмите Safari в верхней строке меню.
2. Нажмите Настройки .
3. Перейдите на вкладку Конфиденциальность .
4. Нажмите Управление данными веб-сайта…
5. Нажмите Удалить все .
6. Щелкните Удалить сейчас .
7. Перейдите в меню Safari в верхней строке меню.
8. Выберите Выйти , чтобы закрыть Safari и сохранить изменения.

Мобильные устройства

Safari для iOS

1. Перейдите в приложение «Настройки» на своем устройстве.
2. Прокрутите вниз до меню Safari .
3. Прокрутите вниз и выберите Очистить историю и данные веб-сайта .
4. Появится всплывающее окно, подтверждающее, что вы хотите очистить историю и данные. Выберите Очистить историю и данные .
5. Кнопка «Очистить историю и данные веб-сайта» станет серой при кэшировании и куки были успешно очищены.

Chrome для iOS

1. Откройте Google Chrome на устройстве iOS.
2. Нажмите на панель инструментов меню в правом нижнем углу.
3. Выберите Настройки .
4. Выберите Конфиденциальность .
5. Выберите Файлы cookie , Данные сайта , Кэшированные изображения и Файлы . Вверху установите Time Range на All Time .
6. Щелкните Очистить данные просмотра в нижней части экрана.
7. Затем подтвердите, нажав Очистить данные просмотра еще раз.


Предотвращение ненужных сетевых запросов с помощью кэша HTTP

— обновлено

Появляется в: Надежность сети много циклов между браузером и сервером.
  • Ваша страница не будет загружаться до тех пор, пока все ее важные ресурсы не будут полностью загружены.
  • Если человек получает доступ к вашему сайту с ограниченным тарифным планом мобильных данных, каждый ненужный сетевой запрос является пустой тратой его денег.
  • Как избежать ненужных сетевых запросов? HTTP-кэш браузера — это ваша первая линия защиты. Это не обязательно самый мощный или гибкий подход, и у вас есть ограниченный контроль над временем существования кэшированных ответов, но он эффективен, поддерживается во всех браузерах и не требует особых усилий.

    В этом руководстве показаны основы эффективной реализации кэширования HTTP.

    Совместимость с браузерами #

    На самом деле не существует единого API, называемого кэшем HTTP. Это общее название набора API-интерфейсов веб-платформы. Эти API поддерживаются во всех браузерах:

    Как работает HTTP-кэш #

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

    Поведение HTTP Cache управляется комбинацией заголовков запросов и заголовков ответов. В идеальном сценарии у вас будет контроль как над кодом вашего веб-приложения (который будет определять заголовки запросов), так и над конфигурацией вашего веб-сервера (который будет определять заголовки ответов).

    Прочтите статью MDN HTTP Caching, чтобы получить более подробный концептуальный обзор.

    Заголовки запросов: придерживайтесь значений по умолчанию (обычно) #

    Хотя существует ряд важных заголовков, которые должны быть включены в исходящие запросы вашего веб-приложения, браузер почти всегда заботится об их настройке от вашего имени при выполнении запросов. .Заголовки запросов, влияющие на проверку актуальности, такие как If-None-Match и If-Modified-Since , просто появляются на основе понимания браузером текущих значений в кэше HTTP.

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

    Разработчики, которым требуется больший контроль над HTTP-кэшем в своих веб-приложениях, имеют альтернативу — вы можете «раскрыть» уровень и вручную использовать Fetch API, передав ему Запросить объекты с определенным набором переопределений кэша .Однако это выходит за рамки данного руководства!

    Заголовки ответа: настройте веб-сервер #

    Наиболее важной частью настройки кэширования HTTP являются заголовки, которые ваш веб-сервер добавляет к каждому исходящему ответу. Следующие заголовки влияют на эффективность кэширования:

    • Cache-Control . Сервер может вернуть директиву Cache-Control , чтобы указать, как и как долго браузер и другие промежуточные кэши должны кэшировать отдельный ответ.
    • ETag . Когда браузер находит кешированный ответ с истекшим сроком действия, он может отправить небольшой токен (обычно это хэш содержимого файла) на сервер, чтобы проверить, изменился ли файл. Если сервер возвращает тот же токен, значит, файл тот же, и его не нужно повторно скачивать.
    • Последнее изменение . Этот заголовок служит той же цели, что и ETag , но использует стратегию, основанную на времени, чтобы определить, изменился ли ресурс, в отличие от стратегии ETag , основанной на содержимом.

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

    Чтобы избавить вас от поисков, вот инструкции по настройке нескольких популярных веб-серверов:

    Отсутствие заголовка ответа Cache-Control не отключает кэширование HTTP! Вместо этого браузеры фактически угадывают, какой тип кэширования наиболее целесообразен для данного типа контента.Скорее всего, вам нужен больший контроль, чем это предлагает, поэтому найдите время, чтобы настроить заголовки ответов.

    Какие значения заголовка ответа следует использовать? #

    Есть два важных сценария, которые вы должны учитывать при настройке заголовков ответа вашего веб-сервера.

    Долгоживущее кэширование для URL-адресов с версиями #

    Как URL-адреса с версиями могут помочь вашей стратегии кэширования

    URL-адреса с версиями являются хорошей практикой, поскольку они упрощают аннулирование кэшированных ответов.

    Предположим, ваш сервер указывает браузерам кэшировать файл CSS на 1 год ( Cache-Control: max-age=31536000 ), но ваш дизайнер только что сделал экстренное обновление, которое вам нужно развернуть немедленно.Как вы уведомляете браузеры об обновлении «устаревшей» кэшированной копии файла? Вы не можете, по крайней мере, без изменения URL-адреса ресурса. После того, как браузер кэширует ответ, кэшированная версия используется до тех пор, пока она не перестанет быть свежей, как это определено max-age или expires , или пока она не будет удалена из кэша по какой-либо другой причине, например, пользователь очищает кеш их браузера. В результате разные пользователи могут в конечном итоге использовать разные версии файла при построении страницы: пользователи, которые только что получили ресурс, используют новую версию, в то время как пользователи, кэшировавшие более раннюю (но все еще действительную) копию, используют более старую версию своего файла. отклик.Как получить лучшее из обоих миров: кэширование на стороне клиента и быстрые обновления? Вы меняете URL-адрес ресурса и заставляете пользователя загружать новый ответ при каждом изменении его содержимого. Как правило, вы делаете это, встраивая отпечаток файла или номер версии в его имя, например, style.x234dff.css .

    При ответе на запросы URL-адресов, которые содержат «отпечаток пальца» или информацию о версии и содержимое которых никогда не должно меняться, добавьте к своим ответам Cache-Control: max-age=31536000 .

    Установка этого значения сообщает браузеру, что когда ему нужно загрузить один и тот же URL-адрес в любое время в течение следующего года (31 536 000 секунд; максимальное поддерживаемое значение), он может немедленно использовать значение в кэше HTTP без необходимости создания сети. запрос к вашему веб-серверу вообще. Это здорово — вы сразу же добились надежности и скорости благодаря тому, что избегаете сети!

    Инструменты сборки, такие как webpack, могут автоматизировать процесс назначения хеш-отпечатков URL-адресам ваших ресурсов.

    Повторная проверка сервера для неверсионных URL-адресов #

    К сожалению, не все URL-адреса, которые вы загружаете, являются версионными. Возможно, вы не можете включить этап сборки перед развертыванием своего веб-приложения, поэтому вы не можете добавлять хэши к URL-адресам своих ресурсов. Каждому веб-приложению нужны HTML-файлы — эти файлы (почти!) никогда не будут содержать информацию о версиях, поскольку никто не станет использовать ваше веб-приложение, если им нужно помнить, что URL-адрес для посещения — https://example. com/index.34def12.HTML . Итак, что вы можете сделать для этих URL-адресов?

    Это один из сценариев, в котором вам нужно признать поражение. Кэширование HTTP само по себе недостаточно мощно, чтобы полностью избежать сети. (Не волнуйтесь — вы скоро узнаете о сервис-воркерах, которые обеспечат необходимую поддержку, чтобы повернуть битву в вашу пользу.) Но есть несколько шагов, которые вы можете предпринять, чтобы убедиться, что сетевые запросы и максимально эффективным.

    Следующие значения Cache-Control могут помочь вам точно настроить, где и как кэшируются неверсированные URL-адреса:

    • без кэша .Это указывает браузеру, что он должен проходить повторную проверку на сервере каждый раз, прежде чем использовать кешированную версию URL-адреса.
    • нет в магазине . Это указывает браузеру и другим промежуточным кэшам (например, CDN) никогда не сохранять никакую версию файла.
    • частный . Браузеры могут кэшировать файл, но промежуточные кеши не могут.
    • общественный . Ответ может быть сохранен любым кешем.

    Ознакомьтесь с приложением: блок-схема Cache-Control , чтобы визуализировать процесс принятия решения о том, какие значения Cache-Control использовать.Также обратите внимание, что Cache-Control может принимать список директив, разделенных запятыми. См. Приложение: примеры Cache-Control .

    Наряду с этим также может помочь установка одного из двух дополнительных заголовков ответа: либо ETag , либо Last-Modified . Как упоминалось в заголовках ответов, ETag и Last-Modified служат одной и той же цели: определяют, нужно ли браузеру повторно загружать кешированный файл, срок действия которого истек. ETag является рекомендуемым подходом, поскольку он более точен.

    Пример ETag Предположим, что с момента первоначальной выборки прошло 120 секунд, и браузер инициировал новый запрос для того же ресурса. Сначала браузер проверяет кэш HTTP и находит предыдущий ответ. К сожалению, браузер не может использовать предыдущий ответ, поскольку срок действия ответа истек. В этот момент браузер может отправить новый запрос и получить новый полный ответ. Однако это неэффективно, потому что если ресурс не изменился, то нет смысла загружать ту же информацию, которая уже есть в кеше! Это проблема, для решения которой предназначены токены проверки, указанные в заголовке ETag .Сервер генерирует и возвращает произвольный токен, который обычно является хэшем или другим отпечатком содержимого файла. Браузеру не нужно знать, как генерируется отпечаток пальца; ему нужно только отправить его на сервер при следующем запросе. Если отпечаток остался прежним, значит, ресурс не изменился и браузер может пропустить загрузку.

    Установив ETag или Last-Modified , вы сделаете запрос на повторную проверку более эффективным.В конечном итоге они вызывают заголовки запроса If-Modified-Since или If-None-Match , которые были упомянуты в заголовках запроса.

    Когда правильно настроенный веб-сервер видит эти заголовки входящих запросов, он может подтвердить, соответствует ли версия ресурса, которая уже есть в HTTP-кэше браузера, последней версии на веб-сервере. Если есть совпадение, сервер может ответить HTTP-ответом 304 Not Modified , что эквивалентно «Эй, продолжайте использовать то, что у вас уже есть!» При отправке ответа такого типа нужно передать очень мало данных, поэтому обычно это намного быстрее, чем необходимость отправлять обратно копию фактического запрашиваемого ресурса.

    Браузер запрашивает /file с сервера и включает заголовок If-None-Match , чтобы указать серверу возвращать полный файл только в том случае, если ETag файла на сервере не соответствует браузера. Значение If-None-Match . В этом случае 2 значения совпали, поэтому сервер возвращает ответ 304 Not Modified с инструкциями о том, как долго файл следует кэшировать ( Cache-Control: max-age=120 ).

    Сводка #

    Кэш HTTP — это эффективный способ повысить производительность загрузки, поскольку он уменьшает количество ненужных сетевых запросов.Он поддерживается во всех браузерах и не требует особых усилий для настройки.

    Следующие конфигурации Cache-Control являются хорошим началом:

    • Cache-Control: без кэша для ресурсов, которые должны повторно проверяться сервером перед каждым использованием.
    • Cache-Control: no-store для ресурсов, которые никогда не следует кэшировать.
    • Cache-Control: max-age=31536000 для версионных ресурсов.

    А заголовок ETag или Last-Modified может помочь более эффективно перепроверять просроченные ресурсы кэша.

    Попробуйте

    Попробуйте лабораторную работу HTTP Cache, чтобы получить практический опыт работы с Cache-Control и ETag в Express.

    Подробнее #

    Если вы хотите выйти за рамки основ использования заголовка Cache-Control , ознакомьтесь с рекомендациями Джейка Арчибальда по кэшированию и руководством по ошибкам максимального возраста.

    См. раздел Любите свой кеш, чтобы узнать, как оптимизировать использование кеша для повторных посетителей.

    Приложение: Дополнительные советы #

    Если у вас есть больше времени, вот дополнительные способы оптимизации использования кэша HTTP:

    • Используйте согласованные URL-адреса.Если вы предоставляете один и тот же контент по разным URL-адресам, этот контент будет извлекаться и сохраняться несколько раз.
    • Минимизация оттока. Если часть ресурса (например, файл CSS) часто обновляется, а остальная часть файла — нет (например, код библиотеки), подумайте о том, чтобы разделить часто обновляемый код в отдельный файл и использовать краткосрочную стратегию кэширования для часто обновляемого кода. обновление кода и длительная стратегия кэширования кода, который не часто меняется.
    • Ознакомьтесь с новой директивой stale-while-revalidate , если некоторая степень устаревания допустима в вашей политике Cache-Control .
    6 Приложение: Cache-Control блок-схема # Приложение: Кэш-контроль Примеры # Объяснение
    Объяснение
    Max-Age = 86400 Ответ может кэшироваться браузерами и промежуточными кэшами на срок до 1 дня (60 секунд x 60 минут x 24 часа).
    private, max-age=600 Ответ может кэшироваться браузером (но не промежуточными кэшами) на срок до 10 минут (60 секунд x 10 минут).
    public, max-age=31536000 Ответ может храниться любым кешем в течение 1 года.
    no-store Ответ не может быть кэширован и должен быть получен полностью при каждом запросе.
    Последнее обновление: — Улучшение статьи

    Посмотрите ее в действии

    Узнайте больше и примените это руководство на практике.

    Кэширование в браузере | Браузерное и прокси-кэширование | Руководство CDN

    Что такое кэширование браузера

    Кэширование браузера включает в себя загрузку браузером посетителя ресурсов вашего веб-сайта (например,g., файлы HTML, файлы JavaScript и изображения) на свой локальный диск. Это ускоряет загрузку страницы во время последующих посещений и снижает использование полосы пропускания.

    Процесс регулируется внутренней политикой кэширования браузера, которая указывает, какие ресурсы должны кэшироваться и на какой период времени. Как владелец веб-сайта, у вас есть определенный контроль над этой политикой через заголовки кеша HTTP, а именно заголовки Cache-Control и Etag.

    Cache-Control имеет несколько параметров, в том числе время жизни (TTL), которое можно использовать для определения того, как долго ресурс хранится в кеше браузера до истечения срока его действия.

    Заголовок Etag позволяет идентифицировать конкретную версию ресурса, например, Etag: "pub1259380237;gz" . Когда браузер получает заголовок Etag, он сверяется со значением Etag в кеше. Совпадение указывает на то, что ресурс может загружаться из локального кэша (браузера). В противном случае запрошенный ресурс необходимо повторно загрузить с сервера.

    Кэширование браузера и кэширование прокси-сервера

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

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

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

    Рекомендуется регулировать кэширование браузера и прокси-сервера.Кэш прокси может помочь в более сложных сценариях, таких как обработка динамических или часто обновляемых ресурсов; когда срок действия ресурса истек; или когда кеш браузера был очищен. Хотя предприятия могут управлять своими собственными прокси-серверами, большинству проще перенести кэширование и другие задачи доставки контента на CDN.

    Узнайте, как Imperva CDN может помочь вам повысить производительность веб-сайта.

    Как CDN упрощают кэширование

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

    CDN

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

    Как уже упоминалось, CDN также оптимизируют процесс доставки динамического контента, позволяя кэшировать некоторые динамически генерируемые объекты с помощью машинного обучения и других передовых методов автоматизации. Эти возможности упрощают оптимизацию бокового кэширования прокси-сервера и браузера (насколько это возможно) и ускоряют доставку контента пользователям.

    .

    Leave a Reply