Разное

Кэширование: Что такое кэширование и как управлять им в WordPress

27.03.1989

Содержание

Что представляет собой кэширование контента на Mac?

Что такое кэширование контента?

Кэширование контента — это служба macOS, которая помогает сократить расход интернет-трафика и ускорить установку программного обеспечения на компьютерах Mac, устройствах iOS, iPadOS и Apple TV.

Кэширование контента ускоряет загрузку программного обеспечения, распространяемого компанией Apple, а также данных, сохраняемых пользователями в iCloud, за счет хранения содержимого, которое уже было загружено на эти локальные компьютеры Mac, устройства iOS, iPadOS и Apple TV. Сохраненный контент хранится в кэше контента на Mac и доступен другим устройствам по локальной сети, без выхода в интернет.

См. статью на сайте поддержки Apple Типы содержимого, поддерживаемые функцией кэширования контента в macOS.

Кэширование контента можно использовать в сетях, содержащих среду NAT для кэша контента и всех устройств, и в сетях, состоящих из публичных IP-адресов. Устройства Apple с iOS 7 или новее и OS X 10. 8.2 или новее автоматически связываются с расположенным поблизости кэшем контента, не требуя для этого никакой настройки.

Важно! Настоятельно рекомендуется настроить кэширование контента на компьютере Mac, имеющем единственное подключение к сети — через проводное подключение Ethernet. Для кэширования контента допустимо использовать подключение Wi-Fi вместо Ethernet, но это может повлиять на производительность.

Как это работает?

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

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

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

На следующем рисунке показана одна частная подсеть с одним кэшем контента:

В моей сети несколько подсетей. Это что-то меняет?

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

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

Можно ли использовать несколько кэшей контента?

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

Где хранятся кэшированные файлы?

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

Рекомендации для повышения производительности

На кэширование контента в основном влияют следующие два фактора: конфигурация подключения и конфигурация оборудования.

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

Чтобы посмотреть, не является ли Ваш компьютер Mac узким местом, когда к кэшу контента одновременно обращается большое количество клиентов, проверьте использование процессора для процесса AssetCache в приложении «Мониторинг системы» (откройте Мониторинг системы, выберите «Вид» > «Все процессы», затем нажмите «ЦП»). Если загрузка процессора постоянно находится на максимуме или почти на максимуме, Вы можете добавить дополнительные кэши контента для распределения запросов между несколькими компьютерами.

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

Рекомендации в отношении кэширования контента

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

  • Разрешите все push-уведомления Apple.

  • Не используйте ручные настройки прокси.

  • Не используйте прокси для обработки запросов клиентов к кэшам контента.

  • Не выполняйте аутентификацию прокси для кэшей контента.

  • Укажите порт TCP для кэширования. (См. описание ключа «Порт» в разделе Расширенные настройки кэширования контента на Mac в руководстве Развертывание платформы Apple (на английском языке)).

  • Управляйте межсайтовым трафиком кэширования.

  • Блокируйте регистрацию поддельных кэшей.

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

См. такжеНастройка кэширования контента на MacРазвертывание платформы Apple: Введение в кэширование контента (на английском языке)Развертывание платформы Apple: Планирование и настройка кэширования контента (на английском языке)Развертывание платформы Apple: Использование нескольких кэшей контента для устройств Apple (на английском языке)

HTTP кеширование | Symfony

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

C HTTP-кешированием, вы можете кешировать страницы целиком (т.е. ответ), и затем, в обход приложения, отдавать кэшированные данные для каждого запроса. Конечно же, это не всегда возможно применить для очень динамичных сайтов, или всё же возможно? С помощью Edge Side Includes (ESI) вы можете использовать силу HTTP-кеширования только для фрагментов вашего сайта.

Система кеширования Symfony отличается от других, так как она полагается на простоту и мощь HTTP-кеширования, как это определено в спецификации RFC 7234 — Кеширование. Вместо того, чтобы изобретать кеширование заново, Symfony пользуется стандартом, который определяет базовые коммуникации в Web. Как только вы поймёте основополагающие модели HTTP валидации и истечения срока кэша, вы будете готовы к управлению системой кеширования Symfony.

Так как HTTP-кеширование используется не только Symfony, существует множество статей по данной теме. Если вы новичок в HTTP-кешировании, настоятельно рекомендуем вам прочитать статью Райана Томайко Вещи, которые делают кеши . Другим исчерпывающим источником является Учебное пособие по кешу от Марка Ноттингема.

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

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

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

Этот тип кeширования известен под именем «кeширующего HTTP шлюза». Существует много кeшеров такого типа, например: Varnish, Squid в режиме обратного прокси, а также обратный прокси Symfony.

Tip

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

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

Tip

Чтобы узнать детали о настройке Varnish, см. Як використовувати Varnish для прискорення мого сайту.

Чтобы включить прокси, для начала создайте кеширующее ядро:

Измените код вашего фронт контроллера, чтобы обернуть ядро по умолчанию в кеширующее ядро:

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

Caution

Если вы используете опцию framework.http_method_override для прочтения HTTP-метода из параметра

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

Tip

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

Объект CacheKernel имеет разумную конфигурацию по умолчанию, но вы можете хорошо настроить его с помощью набора опций, переопределив метод getOptions():

Чтобы увидеть весь список опций и их значения, см. Документацию HttpCache::__construct().

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

Как только вы добавить кеш обратного прокси (например, как обратный прокси Symfony или Varnish), вы готовы кешировать ваши ответы. Чтобы сделать это, вам нужно сообщить вашему кешу, какие

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

HTTP определяет четыре заголовка ответакеша, которые вы можете активировать:

  • Cache-Control
  • Expires
  • ETag
  • Last-Modified

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

  1. Кеширование Expiration (окончания срока действия) Используется, чтобы кешировать весь ваш ответ на определенное количество времени (например, 24 часа). Просто, однако девалидация кеша более сложная.
  2. Кешировани Validation (валидации) Более сложная модель: используется, чтобы кешировать ваш ответ, но позволяет вам динамически инвалидировать его, как только ваш контент изменяется.

Самый простой способ кешировать ответ — это кешировать его на определенное количество времени:

Благодаря этому новому коду, ваш HTTP-ответ будет иметь следующий заголовок:

Он сообщает вашему обратному прокси HTTP кешировать этот ответ на 3600 секунд. Если кто-либо запросит этот URL опять раньше, чем через 3600 секунд, ваше приложение вообще не

не будеть задействовано. Если вы используете обратный прокси Symfony, посмотрите на заголовок X-Symfony-Cache, для отладки информации о попаданиях и промахах кеша.

Tip

URI запроса используется в качестве ключа кеша (разве что вы варьируете).

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

Tip

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

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

В конце-концов, для более детальной информации об окончании срока действия кеша, см. Окочание действия HTTP-кеша.

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

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

Чтобы узнать больше, см. Валидация HTTP-кеша.

HTTP кэширование работает лишь для «безопасных» HTTP методов (таких как GET и HEAD). Это означает 2 вещи:

  • Не пытайтесь кешировать запросы PUT или DELETE. Это не сработает, и по хорошей причине. Эти методы не должны быть использованы при изменении состояния вашего приложения (например, удалении поста блога). Их кеширование будет предотвращать некоторые запросы от попадания и изменения вашего приложения.
  • Вам никогда не стоит изменять состояние вашего приложение (например, обновлять пост блога), во время ответа на запрос GET или HEAD. Если эти запросы будут кешированы, будущие запросы могут никогда не попасть на ваш сервер.

Класс Response содержит также множество других методов, относящихся к кешу. Вот самые полезные из них:

В дополнение к этому, все основные HTTP заголовки, относящиеся к кешу, могут быть установлены при помощи одного метода setCache():

Аннуляция кеша не является частью HTTP-спецификации.

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

Чтобы узнать больше, см. Аннуляция кеша.

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

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

  • Інвалідація кешу
  • Варьирование ответа для HTTP-кеша
  • Работа с включениями крайней стороны
  • Окочание действия HTTP-кеша
  • Кеширование страниц, содержащих CSRF-защищённые формы
  • Работа с серверными включениями (SSI)
  • Валидация HTTP-кеша
  • Як використовувати Varnish для прискорення мого сайту

Модуль «Кэширование» — CMS NetCat

Предисловие

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

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

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

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

Примеры из жизни

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

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

Принцип работы кэша

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

Файлы кэша расположены в папках на сервере, связанных с определёнными сущностями (сайт, раздел и компонент в разделе). Имя файла строится на основе адреса запрашиваемой страницы. Стоит иметь ввиду, что страница с адресом /news/news_5.html и страница /news/news_5.html?curPos=2 для системы — два разных набора данных для кэширования, которые будут храниться в разных файлах, но в одной папке на сервере.

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

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

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

Рассмотрим теперь непосредственно использование кэширования в рамках системы NetСat.

Руководство по кэшированию

— HTTP-сервер Apache версии 2.4

Доступные языки:  en  | фр  | tr 

Этот документ дополняет mod_cache , mod_cache_disk , mod_file_cache и справочная документация htcacheclean. В нем описывается, как использовать функции кэширования HTTP-сервера Apache для ускорения веб- и прокси, избегая распространенных проблем и неправильных конфигураций.

  • Введение
  • HTTP-кэширование RFC2616 с тремя состояниями
  • Примеры настройки кэша
  • Общее кэширование общих объектов ключа/значения с двумя состояниями
  • Специализированное кэширование файлов
  • Вопросы безопасности

См. также

  • Комментарии

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

HTTP-кэширование RFC2616 с тремя состояниями
mod_cache и его модули провайдера mod_cache_disk обеспечить интеллектуальное кэширование с учетом HTTP. Сам контент хранится в кеше, а mod_cache стремится учитывать все различные HTTP заголовки и параметры, управляющие кешируемостью контента как описано в Раздел 13 RFC2616. мод_кэш предназначен как для простых, так и для сложных конфигураций кэширования, где вы имеете дело с прокси-контентом, динамическим локальным контентом или необходимо ускорить доступ к локальным файлам на потенциально медленный диск.
Кэширование общих объектов с двумя состояниями ключа и значения
API общего кэша объектов (socache) и его модули провайдера обеспечивают Кэш общих объектов на основе ключей/значений на уровне сервера. Эти модули предназначены для кэширования данных низкого уровня, таких как сеансы SSL и учетные данные аутентификации. Бэкенды позволяют хранить данные на уровне сервера в общей памяти или на уровне центра обработки данных в кеше, например как memcache или distcache.
Специализированное кэширование файлов
mod_file_cache предлагает возможность предварительной загрузки файлы в память при запуске сервера и может улучшить доступ раз и сохранять дескрипторы файлов для файлов, к которым часто обращаются, так как нет необходимости обращаться к диску при каждом запросе.

Чтобы получить максимальную отдачу от этого документа, вы должны быть знакомы с основы HTTP и прочли Руководства пользователя по Сопоставление URL-адресов с файловой системой и Переговоры по содержанию.

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

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

Запись в кэше HTTP существует в одном из трех состояний:

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

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

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

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

Полную информацию о том, как работает кэширование HTTP, можно найти в Раздел 13 RFC2616.

Взаимодействие с Сервером

Модуль mod_cache подключается к серверу через два возможные места в зависимости от значения Директива CacheQuickHandler :

Фаза быстрого обработчика

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

В этом сценарии кэш ведет себя так, как если бы он был «прикручен болтами». on» на перед сервером.

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

Запросы с заголовком «Авторизация» (например, HTTP Basic Аутентификация) не кэшируются и не обслуживаются из кеша когда mod_cache работает на этом этапе.

Нормальная фаза обработчика

Эта фаза происходит поздно в обработке запроса, в конце концов этапы запроса завершены.

В этом сценарии кэш ведет себя так, как если бы он был «прикручен болтами». on» на задней панели сервера.

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

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

Если содержимое, найденное в кэше, устарело, 9Модуль 0005 mod_cache преобразует запрос в условный запрос . Если исходный сервер отвечает обычный ответ, обычный ответ кэшируется, заменяя содержимое уже кэшировано. Если исходный сервер отвечает 304 Not Modified ответ, содержимое снова помечается как свежее, а кэшированное содержимое обслуживается фильтром вместо его сохранения.

Улучшение попаданий в кэш

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

Срок службы свежести

Правильно сформированный контент, предназначенный для кэширования, должен объявлять явное время жизни свежести с Кэш-Контроль поля заголовка max-age или s-maxage , или путем включения заголовка Expires .

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

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

Если ответ не включает заголовок Expires , но содержит включить заголовок Last-Modified , mod_cache может сделать вывод о продолжительности жизни на основе эвристики, которая может быть контролируется с помощью директивы CacheLastModifiedFactor .

Для локального контента или для удаленного контента, который не определяет свой собственный Expires заголовок, mod_expires может использоваться для точно настройте срок службы свежести, добавив max-age и Истекает .

Максимальный срок хранения можно также контролировать с помощью CacheMaxExpire .

Краткое руководство по условным запросам

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

Когда ETag 9Заголовок 0006 существует в исходном кэше ответ, mod_cache добавит Заголовок If-None-Match запроса к исходному серверу. Когда заголовок Last-Modified существует в исходном кешированный ответ, mod_cache добавит Заголовок If-Modified-Since к запросу к источнику сервер. Выполнение любого из этих действий делает запрос условное .

Когда исходный сервер получает условный запрос, Исходный сервер должен проверить, является ли ETag или Last-Modified параметр изменился в соответствии с запросом. Если нет, то origin должен ответить кратким ответом «304 Not Modified». Этот сигналы кэшу о том, что устаревшее содержимое все еще свежее, должны используется для последующих запросов до истечения срока действия нового содержимого достигается снова.

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

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

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

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

Что можно кэшировать?

Полное определение того, какие ответы могут кэшироваться HTTP кеш определяется в RFC2616 Раздел 13.4 Кэширование ответов, и может быть резюмирован как следующим образом:

  1. Кэширование должно быть включено для этого URL. См. директивы CacheEnable и CacheDisable .
  2. Если ответ имеет код состояния HTTP, отличный от 200, 203, 300, 301 или 410 он также должен указывать заголовок «Expires» или «Cache-Control».
  3. Запрос должен быть запросом HTTP GET.
  4. Если ответ содержит заголовок «Авторизация:», он должен также содержат опцию «s-maxage», «must-revalidate» или «public» в заголовке «Cache-Control:», иначе он не будет кэшироваться.
  5. Если URL-адрес содержал строку запроса (например, из HTML-формы GET метод) он не будет кэшироваться, если в ответе не указан явное истечение срока действия путем включения заголовка «Expires:» или максимального возраста или директива s-maxage заголовка «Cache-Control:» согласно RFC2616. разделы 13.9и 13.2.1.
  6. Если ответ имеет статус 200 (ОК), ответ должен также включите по крайней мере один из «Etag», «Last-Modified» или заголовки «Expires» или директивы max-age или s-maxage заголовок "Cache-Control:", если только Кэшигноререноластмод директива использовалась, чтобы требовать иного.
  7. Если ответ включает опцию "private" в "Cache-Control:" заголовок, он не будет сохранен, если CacheStorePrivate был привык требовать иного.
  8. Аналогичным образом, если ответ включает в себя параметр «без хранения» в заголовок "Cache-Control:", он не будет сохранен, если только CacheStoreNoStore был использовал.
  9. Ответ не будет сохранен, если он содержит заголовок «Vary:». содержащий совпадение всех "*".

Что не следует кэшировать?

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

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

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

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

Переменное/согласованное содержимое

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

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

Если, например, получен ответ с заголовком изменения, таким как;

Варьировать: согласовать, принять-язык, принять-кодировку

mod_cache будет передавать кэшированное содержимое только реквестеры с заголовками accept-language и accept-charset совпадающие с исходным запросом.

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

Кэширование на диск

Модуль mod_cache зависит от определенного внутреннего хранилища реализации для управления кешем и для кэширования на диск mod_cache_disk предоставляется для поддержки этого. 22 возможных хэша. Например, URL-адрес может быть хеширован до xyTGxSMO2b68mBCykqkp1w . Этот хэш используется в качестве префикса для именования файлов, специфичных для этого URL-адреса в пределах кэш, однако сначала он разбит на каталоги в соответствии с CacheDirLevels и CacheDirLength директивы.

Кэшдирлевелс указывает, сколько должно быть уровней подкаталога, и CacheDirLength указывает, сколько символов должно быть в каждом каталоге. С пример настроек, приведенный выше, хэш будет преобразован в префикс имени файла как /var/кэш/apache/x/y/TGxSMO2b68mBCykqkp1w .

Общая цель этого метода — уменьшить количество подкаталоги или файлы, которые могут находиться в определенном каталоге, поскольку большинство файловых систем замедляются по мере увеличения этого числа. С установка "1" для CacheDirLength на любом конкретном уровне может быть не более 64 подкаталогов. При значении 2 может быть 64 * 64 подкаталога и так далее. Если у вас нет веских причин не делать этого, используйте настройку «1». на Длина кэша Рекомендовано.

Настройка Кэшдирлевелс зависит от того, сколько файлов вы планируете хранить в кеше. С настройкой «2», используемой в приведенном выше примере, большой Всего может быть создано 4096 подкаталогов. С Кешируется 1 миллион файлов, получается примерно 245 кешированных файлов. URL-адреса для каждого каталога.

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

В случае согласования содержания через заголовок "Vary" Каталог «.vary» будет создан для рассматриваемого URL-адреса. Этот каталог будет иметь несколько файлов «. data», соответствующих по-разному согласованный контент.

Обслуживание дискового кэша

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

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

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

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


Рисунок 1 : Типичный увеличение кеша/чистая последовательность.

Потому что mod_cache_disk сам не обращает внимания сколько места используется, вы должны убедиться, что htcacheclean настроен на оставьте достаточно «комнаты для выращивания» после очистки.

Кэширование в memcached

Использование модуля mod_cache_socache , mod_cache может кэшировать данные из различных реализаций (также известных как «поставщики»). С использованием модуль mod_socache_memcache , например, можно указать, что memcached должен использоваться как внутренний механизм хранения.

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

 CacheEnable socache /
CacheSocache memcache:memcd. example.com:11211

Дополнительные серверы memcached могут быть указаны добавление их в конец CacheSocache memcache: строка через запятую:

 CacheEnable socache /
CacheSocache memcache:mem1.example.com:11211,mem2.example.com:11212

Этот формат также используется с другими различными mod_cache_socache провайдеры. Например:

 CacheEnable socache /
CacheSocache shmcb:/path/to/datafile(512000) 
 CacheEnable socache /
CacheSocache dbm:/path/to/datafile

HTTP-сервер Apache предлагает кэш общих объектов низкого уровня для кэширование информации, такой как сеансы SSL или учетные данные аутентификации, внутри интерфейса socache.

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

mod_socache_dbm
Кэш общих объектов на основе DBM.
mod_socache_dc
Кэш общих объектов на основе Distcache.
mod_socache_memcache
Кэш общих объектов на основе Memcache.
mod_socache_shmcb
Кэш общих объектов на основе общей памяти.

Кэширование учетных данных аутентификации

Модуль mod_authn_socache позволяет получить результат аутентификация кэшируется, что снижает нагрузку на серверную часть аутентификации.

Кэширование сеансов SSL

Модуль mod_ssl использует сокаш интерфейс для предоставления кэша сеанса и кэша сшивания.

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

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

Кэширование файловых дескрипторов

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

CacheFile

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

Директива CacheFile инструктирует httpd открывать файл при его запуске и повторно использовать этот дескриптор файла для всех последующих обращений к этому файлу.

 CacheFile /usr/local/apache2/htdocs/index.html

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

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

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

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

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

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

Кэширование операционной системы

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

 colm@coroebus:~$ time cat testfile > /dev/null
реальное 0м0.065с
пользователь 0м0.000с
система 0m0.001s
colm@coroebus:~$ тестовый файл time cat > /dev/null
реальное 0м0.003с
пользователь 0м0.003с
система 0m0.000s

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

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

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

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

Кэширование MMapFile

mod_file_cache обеспечивает Директива MMapFile , которая позволяет вам использовать httpd для отображения содержимого статического файла в память по адресу время начала (используя системный вызов mmap). httpd будет использовать оперативную память содержимого для всех последующих обращений к этому файлу.

 MMapFile /usr/local/apache2/htdocs/index. html

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

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

Авторизация и контроль доступа

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

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

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

Когда CacheQuickHandler директива установлена ​​на Off , полный набор обработки запросов фазы выполняются, а модель безопасности остается неизменной.

Локальные эксплойты

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

Если пользователь Apache скомпрометирован, например, из-за уязвимости в процесс CGI, возможно, что кеш может быть нацелен. Когда используя mod_cache_disk , относительно легко вставить или изменить кэшированный объект.

Представляет несколько повышенный риск по сравнению с другими виды атаки можно производить как пользователь Apache. Если ты используя mod_cache_disk , вы должны помнить об этом - убедитесь, что вы обновляете httpd, когда объявляются обновления безопасности и запускайте процессы CGI от имени пользователя, отличного от Apache, используя suEXEC, если это возможно.

Отравление кеша

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

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

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

Отказ в обслуживании / очистка кеша

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

В других случаях может возникнуть необходимость изменить URL определенного ресурс при каждом запросе, обычно добавляя строку «cachebuster» в URL-адрес. Если это содержимое объявлено кэшируемым сервером для значительное время жизни, эти записи могут вытеснить законные записи в кэше. Пока mod_cache обеспечивает CacheIgnoreURLSessionIdentifiers директивы, эта директива должна использоваться с осторожностью, чтобы гарантировать, что нисходящие прокси-серверы или кеши браузера не подвергаются такому же отказу сервисного вопроса.

Решения для кэширования в памяти | Быстрое распределенное кэширование

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

  • Обзор
  • Функции
  • Ресурсы

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

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

Скорость

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

Гибкость

Hazelcast предлагает множество вариантов разработки, развертывания и эксплуатации. Клиенты могут воспользоваться преимуществами мощного и простого в использовании стандартного API JCache через клиент-серверную или кластерную архитектуру. Наша платформа также легко интегрируется с популярными платформами и библиотеками, такими как Spring, Memcached и Hibernate.

Управляемость

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

Безопасность

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

Скорость и масштабируемость

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

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

Hazelcast предлагает расширенные функции с практически мгновенным откликом

Центр управления / управление кэшем

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

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

Репликация WAN
Позволяет синхронизировать несколько кластеров Hazelcast, реплицируя их состояние в средах глобальной сети, таких как Интернет. Hazelcast поддерживает режимы Active-Passive и Active-Active для наиболее распространенных сценариев WAN-репликации.

Кэш Горячий перезапуск Сохранение
Опция высокой производительности, включенная в Hazelcast Enterprise в дополнение к базовым параметрам надежности (сквозная запись и отложенная запись). Эта функция хранения Hot Restart Store обеспечивает быстрый перезапуск кластера, сохраняя состояния членов кластера на диске в формате, специально разработанном для производительности перезапуска и для совместной работы с твердотельными накопителями.

Комплект безопасности
Богатый набор функций безопасности на основе JAAS, которые аутентифицируют членов кластера и клиентов для выполнения проверок авторизации клиентских операций. Socket Interceptor, Security Interceptor, Encryption, SSL, Credentials и ClusterLoginModule, Cluster Member Security и Native Client Security являются основными компонентами пакета безопасности.

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

Корпоративные развертывания PaaS
Сертифицированные собственные образы позволяют Hazelcast Enterprise работать в ведущих корпоративных средах облачных контейнеров PaaS, включая Pivotal Cloud Foundry и Red Hat OpenShift Container Platform.

Шаблоны доступа к кэшу

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

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

Кэш сквозного чтения

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

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

Кэш со сквозной записью

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

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

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

Кэш отложенной записи

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

Ближний кэш

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

Ближний кеш дает пользователям Hazelcast огромное преимущество перед решениями NoSQL, такими как Redis, Cassandra, MongoDB и т. д., которые не имеют возможности ближнего кэширования. При сравнении тестов Hazelcast уже на 56% быстрее, чем Redis, без использования ближнего кэша. Включение ближнего кэша делает Hazelcast в 5 раз быстрее, чем Redis. Если используются функции ближнего кэша Hazelcast в развертываниях клиент-сервер, время отклика в микросекундах может быть достигнуто с помощью правильной сериализации.

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

Связанные ресурсы

Кэширование в GitLab CI/CD | Гитлаб

  • Чем кеш отличается от артефактов
    • Кэш
    • Артефакты
  • Надлежащая практика кэширования
  • Использовать несколько кэшей
  • Использовать резервный ключ кэша
  • Отключить кэширование для определенных заданий
  • Наследовать глобальную конфигурацию, но переопределять определенные настройки для каждого задания
  • Общие варианты использования кешей
    • Совместное использование кешей между заданиями в одной ветви
    • Совместное использование кешей между заданиями в разных ветвях
    • Кэшировать зависимости Node. js
      • Вычислить ключ кэша из файла блокировки
    • Кэш зависимостей PHP
    • Кэш зависимостей Python
    • Кэш зависимостей Ruby
    • Кэш зависимостей Go
  • Наличие кэша
    • Где хранятся кеши
      • Имена ключей кэша
        • Использовать один и тот же кэш для всех ветвей
  • Очистка кэша
    • Очистить кэш, изменив cache:key
    • Очистить кэш вручную
  • Устранение неполадок
    • Несоответствие кэша
      • Пример несоответствия кэша 1
      • Пример несоответствия кэша 2

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

Чтобы узнать, как определить кеш в файле .gitlab-ci.yml , см. ссылку кэша .

Чем кеш отличается от артефактов

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

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

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

Кэш

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

Артефакты

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

Надлежащая практика кэширования

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

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

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

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

Использовать несколько кэшей

История версий

  • Представлено в GitLab 13.10.
  • Флаг функции удален в GitLab 13.12.

У вас может быть максимум четыре кэша:

 тестовое задание:
  этап: сборка
  кеш:
    - ключ:
        файлы:
          - Gemfile.lock
      пути:
        - продавец/рубин
    - ключ:
        файлы:
          - пряжа.замок
      пути:
        - .пряжа-кэш/
  сценарий:
    - комплект конфигурации пакета --local path 'vendor/ruby'
    - пакетная установка
    - установка пряжи --cache-folder . yarn-cache
    - эхо Запустить тесты...

Если несколько кэшей объединены с резервным ключом кэша, резервный кеш извлекается каждый раз, когда кеш не найден.

Использовать резервный ключ кэша

Представлено в GitLab Runner 13.4.

Вы можете использовать предопределенную переменную $CI_COMMIT_REF_SLUG чтобы указать ваш кеш : ключ . Например, если ваш $CI_COMMIT_REF_SLUG — это test , вы можете настроить задание на загрузку кеша с тегом test .

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

В следующем примере, если $CI_COMMIT_REF_SLUG не найден, задание использует определенный ключ по переменной CACHE_FALLBACK_KEY :

 переменных:
  CACHE_FALLBACK_KEY: запасной ключ
задание1:
  сценарий:
    - эхо
  кеш:
    ключ: "$CI_COMMIT_REF_SLUG"
    пути:
      - двоичные файлы/

Отключение кеша для определенных заданий

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

Чтобы полностью отключить его для задания, используйте пустой хэш:

 задание:
  кеш: []

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

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

 кэш: &global_cache
  ключ: $CI_COMMIT_REF_SLUG
  пути:
    - node_modules/
    - общественный/
    - продавец/
  политика: тяни-толкай
работа:
  кеш:
    # наследовать все настройки глобального кеша
    <<: *глобальный_кэш
    # переопределить политику
    политика: тянуть

Дополнительные сведения см. в разделе Кэш : политика .

Общие варианты использования кэшей

Обычно вы используете кеши, чтобы избежать загрузки контента, например зависимостей или библиотеки каждый раз, когда вы запускаете задание. пакеты Node.js, Пакеты PHP, драгоценные камни Ruby, библиотеки Python и другие могут кэшироваться.

Примеры см. в шаблонах GitLab CI/CD.

Совместное использование кэшей между заданиями в одной ветке

Чтобы задания в каждой ветви использовали один и тот же кеш, определите кеш с помощью 9Ключ 0005: $CI_COMMIT_REF_SLUG :

 кэш:
  ключ: $CI_COMMIT_REF_SLUG

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

Чтобы включить кэширование для отдельных заданий и ветвей:

 кэш:
  ключ: "$CI_JOB_NAME-$CI_COMMIT_REF_SLUG"

Чтобы включить кэширование для отдельных стадий и ветвей:

 кеш:
  ключ: "$CI_JOB_STAGE-$CI_COMMIT_REF_SLUG"

Совместное использование кешей для заданий в разных ветвях

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

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

Чтобы разделить кеш между филиалами, но иметь уникальный кеш для каждого задания:

 кеш:
  ключ: $CI_JOB_NAME

Кэш зависимостей Node.

js

Если ваш проект использует npm для установки Node.js зависимости, следующий пример определяет кэширует глобально, чтобы все задания наследовали его. По умолчанию npm хранит данные кеша в домашней папке ( ~/.npm ). Однако вы не может кэшировать вещи за пределами каталога проекта. Вместо этого скажите npm использовать ./.npm и кэшировать его для каждой ветки:

 #
# https://gitlab.com/gitlab-org/gitlab/-/tree/master/lib/gitlab/ci/templates/Nodejs.gitlab-ci.yml
#
изображение: узел: последний
# Кэшировать модули между заданиями
кеш:
  ключ: $CI_COMMIT_REF_SLUG
  пути:
    - .нпм/
до_скрипта:
  - npm ci --cache .npm --prefer-offline
тест_асинхронный:
  сценарий:
    - узел ./specs/start.js ./specs/async.spec.js
Вычислить ключ кэша из файла блокировки

Вы можете использовать cache:key:files для вычисления кеша key из файла блокировки, такого как package-lock.json или yarn. lock , и повторно использовать его во многих заданиях.

 # Кэшировать модули с помощью файла блокировки
кеш:
  ключ:
    файлы:
      - пакет-lock.json
  пути:
    - .нпм/

Если вы используете Yarn, вы можете использовать yarn-offline-mirror для кэширования заархивированных архивов node_modules . Кэш генерируется быстрее, т.к. нужно сжать меньше файлов:

 задание:
  сценарий:
    - echo 'yarn-offline-mirror ".yarn-cache/"' >> .yarnrc
    - echo 'yarn-offline-mirror-pruning true' >> .yarnrc
    - установка пряжи --frozen-lockfile --no-progress
  кеш:
    ключ:
      файлы:
        - пряжа.замок
    пути:
      - .пряжа-кэш/

Кэш зависимостей PHP

Если ваш проект использует Composer для установки зависимостей PHP, следующий пример определяет cache глобально, чтобы все задания наследуют его. Модули библиотек PHP установлены в продавец/ и кэшируются для каждой ветки:

 #
# https://gitlab. com/gitlab-org/gitlab/-/tree/master/lib/gitlab/ci/templates/PHP.gitlab-ci.yml
#
изображение: php:7.2
# Кешировать библиотеки между заданиями
кеш:
  ключ: $CI_COMMIT_REF_SLUG
  пути:
    - продавец/
до_скрипта:
  # Устанавливаем и запускаем Composer
  - curl --show-error --silent "https://getcomposer.org/installer" | php
  - установить php composer.phar
тест:
  сценарий:
    -vendor/bin/phpunit --configuration phpunit.xml --coverage-text --colors=never

Кэшировать зависимости Python

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

 #
# https://gitlab.com/gitlab-org/gitlab/-/tree/master/lib/gitlab/ci/templates/Python.gitlab-ci.yml
#
изображение: питон: последний
# Измените каталог кеша pip так, чтобы он находился внутри каталога проекта, так как мы можем
# кэшировать только локальные элементы. 
переменные:
  PIP_CACHE_DIR: "$CI_PROJECT_DIR/.cache/pip"
# Кэш Pip не хранит пакеты python
# https://pip.pypa.io/en/stable/reference/pip_install/#caching
кеш:
  пути:
    - .кэш/пип
до_скрипта:
  - python -V # Распечатать версию Python для отладки
  - пип установить виртуалэнв
  - виртуальный венв
  - источник venv/bin/активировать
тест:
  сценарий:
    - тест python setup.py
    - пип установить flake8
    - чешуйка8 .

Кэш зависимостей Ruby

Если ваш проект использует Bundler для установки gem, следующий пример определяет cache глобально, так что все рабочие места наследуют его. Гемы устанавливаются в vendor/ruby/ и кэшируются для каждой ветки:

 #
# https://gitlab.com/gitlab-org/gitlab/-/tree/master/lib/gitlab/ci/templates/Ruby.gitlab-ci.yml
#
изображение: рубин: 2,6
# Кэшировать гем между сборками
кеш:
  ключ: $CI_COMMIT_REF_SLUG
  пути:
    - продавец/рубин
до_скрипта:
  - ruby ​​-v # Распечатать версию ruby ​​для отладки
  - набор конфигурации пакета --local path 'vendor/ruby' # Место для установки указанных драгоценных камней
  - bundle install -j $(nproc) # Установить зависимости в . /vendor/ruby
rspec:
  сценарий:
    - спецификация rspec

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

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

 кеш:
  ключ:
    файлы:
      - Gemfile.lock
    префикс: $CI_JOB_NAME
  пути:
    - продавец/рубин
test_job:
  этап: тест
  до_скрипта:
    - комплект конфигурации пакета --local path 'vendor/ruby'
    - пакетная установка -- без производства
  сценарий:
    - пакет exec rspec
развертывание_работа:
  этап: производство
  до_скрипта:
    - набор конфигурации пакета --local path 'vendor/ruby' # Место для установки указанных драгоценных камней
    - пакетная установка -- без теста
  сценарий:
    - развертывание исполняемого пакета

Кэш Go зависимостей

Если в вашем проекте для установки используются модули Go Go, в следующем примере определяется кэш в шаблоне go-cache , который любая работа может расширяться. Модули Go устанавливаются в ${GOPATH}/pkg/mod/ и кэшируются для всех проектов go :

 .go-cache:
  переменные:
    GOPATH: $CI_PROJECT_DIR/.go
  до_скрипта:
    - mkdir -p .go
  кеш:
    пути:
      - .go/упаковка/мод/
тест:
  изображение: голанг: 1.13
  расширяет: .go-кэш
  сценарий:
    - пройти тест ./... -v -short

Наличие кэша

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

После определения кэша в .gitlab-ci.yml , доступность кеша зависит от:

  • Тип исполнителя бегуна.
  • Используются ли разные бегуны для передачи кэша между заданиями.

Где хранятся тайники

Все кэши, определенные для задания, архивируются в одном cache.zip файл. Конфигурация бегуна определяет, где хранится файл. По умолчанию кеш хранится на машине, где установлен GitLab Runner. Расположение также зависит от типа исполнителя.

Runner executor Default path of the cache
Shell Locally, under the gitlab-runner user's home directory: /home/gitlab-runner/cache// <проект>/<кэш-ключ>/cache.zip .
Docker Локально, в томах Docker: /var/lib/docker/volumes//_data////cache.zip .
Docker Machine (автомасштабируемые бегуны) То же, что и Docker executor.

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

Имена ключей кэша

Представлено в GitLab 15.0.

К ключу кэша добавляется суффикс, за исключением резервного ключа кэша.

В качестве примера предположим, что cache. key имеет значение $CI_COMMIT_REF_SLUG и что у нас есть две ветви main и функция , то следующая таблица представляет результирующие ключи кэша:

Имя ветки Ключ кэша
Main Основной защищенный
Функция Функция-NON_PROTED
Использование для All Cach

Представлено в GitLab 15.0.

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

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

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

  1. На верхней панели выберите Главное меню > Проекты и найдите свой проект.
  2. На левой боковой панели выберите Настройки > CI/CD .
  3. Развернуть Трубопроводы общего назначения .
  4. Снимите флажок Использовать отдельные кэши для защищенных веток .
  5. Выберите Сохранить изменения .

В этом примере показаны два задания на двух последовательных этапах:

 этапов:
  - строить
  - тест
до_скрипта:
  - эхо "Привет"
задание А:
  этап: сборка
  сценарий:
    - продавец mkdir/
    - эхо "сборка" > поставщик/hello.txt
  кеш:
    ключ: build-cache
    пути:
      - продавец/
  после_скрипта:
    - эхо "Мир"
задание Б:
  этап: тест
  сценарий:
    - продавец кота/hello.txt
  кеш:
    ключ: build-cache
    пути:
      - продавец/

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

  1. Конвейер запускается.
  2. Задание A выполняется.
  3. выполняется before_script .
  4. скрипт выполняется.
  5. выполняется after_script .
  6. cache запускается, а каталог vendor/ заархивирован в cache.zip . Затем этот файл сохраняется в каталоге на основе настройка бегуна и кэш : ключ .
  7. задание B выполняется.
  8. Кэш извлечен (если найден).
  9. выполняется before_script .
  10. скрипт выполняется.
  11. Отделка трубопроводов.

Используя один бегун на одной машине, вы не столкнетесь с проблемой Задание B может выполняться на бегуне, отличном от задания A . Эта установка гарантирует кеш можно повторно использовать между этапами. Работает только если выполнение идет с этапа build к стадии test на том же бегуне/машине. В противном случае кэш может быть недоступен.

В процессе кэширования также необходимо учитывать несколько моментов:

  • Если какое-то другое задание с другой конфигурацией кэша сохранило свои cache в том же zip-файле, он перезаписывается. Если общий кеш на основе S3 используется, файл дополнительно загружается на S3 в объект на основе кеша ключ. Таким образом, два задания с разными путями, но одним и тем же ключом кеша перезаписывают их кеш.
  • При извлечении кеша из cache.zip все в zip файле извлекается в рабочий каталог задания (обычно это репозиторий, снесен), и бегун не возражает, если в архиве задание A перезаписывает вещи в архиве задание Б .

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

Очистка кеша

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

Есть два способа начать с новой копии кэша.

Очистите кеш, изменив

cache:key

Измените значение кэша : ключ в файле .gitlab-ci.yml . При следующем запуске конвейера кэш сохраняется в другом месте.

Очистить кеш вручную

Вы можете очистить кеш в пользовательском интерфейсе GitLab:

  1. На верхней панели выберите Главное меню > Проекты и найдите свой проект.
  2. На левой боковой панели выберите CI/CD > Конвейеры .
  3. В правом верхнем углу выберите Очистить кеши бегунов .

При следующей фиксации ваши задания CI/CD используют новый кеш.

примечание

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

Устранение неполадок

Несоответствие кэша

Если у вас есть несоответствие кэша, выполните следующие действия для устранения неполадок.

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

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

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

 этапов:
  - строить
  - тест
задание А:
  этап: сборка
  скрипт: сделать сборку
  кеш:
    ключ: тот же ключ
    пути:
      - общественный/
задание Б:
  этап: тест
  скрипт: сделать тест
  кеш:
    ключ: тот же ключ
    пути:
      - продавец/
  1. Задание A выполняется.
  2. public/ кэшируется как cache.zip.
  3. задание B выполняется.
  4. Предыдущий кэш, если он был, разархивирован.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *