Изменения

{{Box|[[Файл:Warning icon.svg|32px|link=]] {{red|ВНИМАНИЕ!}} Для тех, кто в танке — fio-тест записи на диск ДЕСТРУКТИВНЫЙ. Не вздумайте запускать его на дисках/разделах, на которых есть нужные данные… например, журналы OSD (был прецедент).}}

* Перед тестированием отключите попробуйте отключить кэш записи диска: {{Cmd|hdparm -W 0 /dev/sdX}} (SATA-диски через SATA или HBA), {{Cmd|1=sdparm --set WCE=0 /dev/sdX}} (SAS-диски). Не совсем ясно, почему, но эта операция на серверных SSD может увеличить IOPS-ы на 2 порядка(а может НЕ увеличить, поэтому пробуйте оба варианта — и W0, и W1). Также см.ниже [[#Картина маслом «Тормозящий кэш»]].

* Задержка записи в журнал: {{Cmd|1=fio -ioengine=libaio -sync=1 -direct=1 -invalidate=1 -name=test -bs=4k -iodepth=1 -rw=write -runtime=60 -filename=/dev/sdX}} — также стоит повторить тот же тест с <tt>-fsync=1</tt> вместо <tt>-sync=1</tt> и принять худший результат, так как иногда бывает, что одним из методов sync игнорируется (зависит от контроллера).

«А почему так мало…» — см.нижесагу про конденсаторы. [[Файл:Warning icon.svg|32px|link=]] Когда разворачиваете Ceph OSD на SSD — очень разумно не отдавать её под Ceph целиком, а оставить небольшой раздел (10-20 гб) пустым для будущего использования под бенчмаркинг. Ибо SSD имеют свойство со временем (или при забивании данными под 80%) начинать тормозить. Очень удобно иметь возможность гонять fio на пустом никем не используемом разделе. ==== Лирическое отступление ==== Почему нужно тестировать именно так? Ведь в целом производительность диска зависит от многих параметров:* Размер блока* Режим — чтение, запись или смешанный режим чтение+запись в разных пропорциях* Параллелизм — размер очереди и число потоков, то есть, в целом число одновременно запрашиваемых у диска операций* Длительность теста* Исходное состояние — пуст, заполнен линейной записью, заполнен случайной записью, заполнен случайной записью на протяжении какого-то времени и т. п.* Распределение данных — например, 10% горячих данных и 90% холодных — или, например, определённое расположение горячих данных (в начале диска)* Другие смешанные режимы тестов, например, тестирование одновременно с разными размерами блоков Также и результаты можно интерпретировать с разной степенью детализации — вместо простого среднего числа операций или мегабайт в секунду можно также приводить графики, гистограммы, перцентили и так далее — это, естественно, даст больше информации о поведении тестируемого образца. Есть и философская сторона тестов — например, производители серверных SSD иногда заявляют о необходимости подготовки диска к тестам путём 2-х кратной полной случайной перезаписи, чтобы нагрузить слой трансляции адресов диска, а я считаю, что это на самом деле ставит SSD в неправдоподобно плохие по сравнению с реальной нагрузкой условия; есть сторонники рисования графиков формата «задержка в зависимости от числа операций в секунду», что я считаю немного странным, но тоже возможным подходом — в нём, по сути, строится график F1(q) в зависимости от F2(q) и график обычно получается достаточно замысловатый — но для каких-то применений, может быть, и тоже разумный. В общем, бенчмаркингом заниматься можно бесконечно, и уж несколько дней, чтобы предоставить полную информацию, точно уйдёт. Этим обычно и занимаются ресурсы типа 3dnews в своих обзорах SSD. А мы не хотим сидеть несколько дней. Мы хотим обозначить набор тестов, которые можно провести быстро и сразу составить примерное представление о производительности. Посему общая идея — выделить несколько наиболее «крайних» режимов, протестировать диск в них и представить, что остальная часть «амплитудно-скоростной характеристики» диска является некоторой гладкой функцией в пределах изменения параметров между крайними точками. Тем более, что каждому из крайних режимов соответствует и реальное применение в своей категории приложений:# Использующих в основном линейный или крупноблочный доступ. Для таких приложений наиболее важная характеристика — производительность линейного доступа в мегабайтах в секунду. Отсюда режим тестирования линейным доступом 4 МБ блоком со средней очередью — 16-32 операции. Результаты — только в МБ/с.# Использующих случайный доступ мелким блоком и при этом способных к распараллеливанию. Отсюда — режимы тестирования случайным доступом 4 КБ блоком (стандартный блок для большинства ФС и, плюс-минус, СУБД) с большой очередью — 128 операций или, если диск не удаётся нагрузить одним потоком CPU с глубиной очереди 128 — тогда в несколько (2-4-8 или больше) потоков по 128 операций. Результаты — только в iops. Задержку (latency) указывать не нужно, так как в данном тесте её можно произвольно увеличить, просто подняв размер очереди — задержка жёстко связана с iops формулой latency=queue/iops.# Использующих случайный доступ мелким блоком и при этом НЕспособных к распараллеливанию. Таких приложений больше, чем вы могли подумать — например, в части записи сюда относятся все транзакционные СУБД. Отсюда вытекают режимы тестирования случайным доступом 4 КБ блоком с очередью 1 и, для записи, с fsync после каждой операции, чтобы диск/СХД не могли нас обмануть и положить запись во внутренний кэш. Результаты — iops или latency, по желанию — но выберите что-то одно, так как числа, опять же, жёстко связанные.

Как тестировать Ceph после сборки:.

* rados bench лучше не использовать — он создаёт для тестирования очень мало объектов (в 1 поток всего 2, в 128 — несколько сотен). Из-за этого, например, на заполненном HDD результаты будут сильно оптимистичнее, так как снимается необходимость постоянного поиска метаданных в RocksDB.* fio в RBD: {{Cmd|1=fio -ioengine=rbd -direct=1 -invalidate=1 -nameRBD =test -bs=4k -iodepth=128 -rw=randwrite -pool=rpool_hdd -runtime=60 -rbdname=testimg}}** лучше запускать с другого узла — результат будет в 1.5 раза лучше, видимо, из-за отсутствия переключения контекстов между ceph OSD и fio. можно запускать два теста параллельно, bluestore любит параллелизм — суммарный результат вполне может оказаться ещё в 2 раза лучше.** для мазохистов — параметр iodepth=128 поменять на iodepth=1. цифра будет раз в 20 хуже и она будет отражать то, сколько примерно TPS сможет выполнить ваша OLTP СУБД изнутри Ceph.* Встроенной утилитой {{Cmd|rbd bench --io-size 4096 --io-threads 64 --io-total 10G --io-pattern rand --io-type write rpool_hdd/testimg}}* Можно тестировать и fio изнутри виртуалки, rbd драйвер нормально создаёт параллельную нагрузку — проверено.* Производительность может отличаться на заполненном и незаполненном RBD-образе. Но отличия небольшие, думать, что там будет разница в несколько раз — не нужно.* При тестировании случайной записи в ceph в один поток (fsync/fdatasync/sync/iodepth=1/rados bench -t 1) вы фактически всё время тестируете ОДИН диск. То есть, всё время тестируются разные диски, но в каждый отдельный момент времени запрос идёт '''только к одной placement group''' (тройке-четвёрке-пятёрке дисков).* Соответственно, вы '''не увидите''' 100 % утилизации дисков на хостах при тестировании в один поток, однопоточная нагрузка '''не может''' полностью загрузить кластер.

Как тестировать производительность отдельных OSDfio -ioengine=rbd. Нужно сделать следующее:* Создать # fio -ioengine=rbd -direct=1 -name=test -bs=4M -iodepth=16 -rw=write -pool =rpool_hdd -runtime=60 -rbdname=testimg# fio -ioengine=rbd -direct=1 -name=test -bs=4k -iodepth=1 -rw=randwrite -pool=rpool_hdd -runtime=60 -rbdname=testimg# fio -ioengine=rbd -direct=1 -name=test -bs=4k -iodepth=128 -rw=randwrite -pool=rpool_hdd -runtime=60 -rbdname=testimg# ...и потом то же самое для read/randread. Смысл в том, чтобы протестировать а) задержку в идеальных условиях б) линейную пропускную способность в) случайные iops-ы. Перед тестами чтения образ сначала нужно заполнить линейной записью, так как чтение из пустого образа очень быстрое :) Запускать нужно оттуда, где будут реальные пользователи RBD. В целом, с другого узла результаты обычно лучше. Также всё то же самое можно повторить изнутри виртуалки или через krbd:# fio -ioengine=libaio -direct=1 -name=test -bs=4M -iodepth=16 -rw=write -runtime=60 -filename=/dev/rbdX# fio -ioengine=libaio -direct=1 -sync=1 -name=test -bs=4k -iodepth=1 -rw=randwrite -runtime=60 -filename=/dev/rbdX# fio -ioengine=libaio -direct=1 -name=test -bs=4k -iodepth=128 -rw=randwrite -runtime=60 -filename=/dev/rbdX Заметьте, что при тестировании задержки через libaio добавилась опция -sync=1. Это не случайно, а соответствует режиму работы СУБД (транзакционная запись в 1 поток). В ioengine=rbd понятие sync отсутствует, там всё всегда «sync». ==== Отдельные OSD ==== ceph-gobench: https://github.com/rumanzo/ceph-gobench/ Либо https://github.com/vitalif/ceph-bench, что примерно то же самое. Родоначальник идеи — @socketpair Марк Коренберг ([https://github.com/socketpair/ceph-bench оригинал]). Бенчилка тестирует ''отдельные OSD'', что очень помогает понять, кто же из них тупит-то. Перед запуском надо создать пул без репликации {{Cmd|ceph osd pool create r1pool bench 128 replicated; ceph osd pool set r1pool bench size 1; ceph osd pool set r1pool bench min_size 1}} и с числом PG, достаточным, чтобы при случайном выборе туда попали все OSD(ну или прибить их вручную к каждому OSD upmap-ами).* Воспользоваться бенчилкой Марка ==== CephFS ==== «Нормальных» инструментов для тестирования ФС, сцуко, нет!!! «Нормальный» инструмент — это такой инструмент, который вёл бы себя, как файловый сервер: случайно открывал, создавал/писал/читал и закрывал маленькие файлы среди большого общего количества, разбитые по набору каталогов Всё, что есть, какое-то кривожопое: bonnie++, например, зачем-то тестирует запись по 1 байту. iometer, fs_mark не обновлялись лет по 10, но и паттерн файл сервера не умеют. Лучшее, что умеют — это тест создания файлов. Пришлось написать свой ioengine для fio: https://github.com/socketpairvitalif/cephlibfio_fileserver :) ==== S3 (rgw) ==== Предпочтительный вариант: [https://github.com/vitalif/hsbench hsbench] — ссылка дана на исправленную версию (!). Максимально простой, консольное Golang приложение. Оригинальная версия пока что имеет 2 неприятных бага: во-bench первых, вместо чтения объектов целиком читает только первые 64 КБ, во- команда видавторых, производит последовательное, а не случайное, чтение. Что, например, с minio приводит к слишком оптимистичным результатам тестов. В моей данные баги исправлены. [https: {{Cmd|python main//github.py com/intel-cloud/cosbench cosbench] — очень толстый, Java с Web-keyring интерфейсом, XML-настройки. [https:/etc/cephgithub.com/ceph.clientminio/warp minio warp] — тестов чуть больше, чем в hsbench, но зато тестирует только 1 бакет и при каждом тесте загружает данные заново.admin.keyring r1pool osd}} ==== Что использовать не надо ==== * Внимание: результату с bluestore dd и HDD верить можно только наполовинуhdparm для бенчмаркинга не использовать вообще никогда!!!* rados bench использовать тоже не надо, так как бенчилка перезаписывает один и тот же блок он создаёт для тестирования очень мало объектов (в 1 поток всего 2, в 128 — несколько сотен). «Случайная» запись в такое число объектов не очень-то и случайная.* rbd bench лучше тоже не создаёт достаточно нагрузки использовать. В принципе, он адекватен, но fio всё равно лучше.* Не надо удивляться, если Ceph не может загрузить диски на HDD100 % при случайной записи. Он тормоз :) ==== Про RBD и параллелизм ==== [[File:Warning icon.svg|32px|link=]] Тестировать запись несколькими параллельными процессами (fio numjobs > 1) в один RBD-образ бесполезно. Из-за особенностей реализации RBD, так как множество запросов сливается в 1частности, из-за object-map, при параллельной записи из нескольких источников производительность СИЛЬНО проседает (в 2-10 раз). Чтобы проверить «честно» — бенчилку Можно отключить object-map, но это будет некорректный тест, т.к. в реальной эксплуатации в 99% случаев он нужен, так что с отключенным object-map вы лишь получите неправильный (слишком хороший) результат. Если вы не можете загрузить кластер одним процессом fio, то нужно исправитьсоздать несколько отдельных RBD-образов и запустить несколько процессов fio параллельно, чтобы она записывала каждый на своём RBD-образе. === Тестирование сети === sockperf. На одной ноде запускаем сервер: <tt>sockperf sr -i IP --tcp</tt>. На другой клиент в случайные позиции нескольких объектоврежиме ping-pong: <tt>sockperf pp -i SERVER_IP --tcp -m 4096</tt>. ВНИМАНИЕ: В выводе фигурирует '''половина''' задержки (задержка в одну сторону). Таким образом, для получения RTT её стоит умножить на 2. Нормальный средний RTT - в районе 30-50 микросекунд (0.05ms).* Полученный результат<s>Также qperf. На одной ноде просто <tt>qperf</tt>. На второй <tt>qperf -vvs -m 4096 SERVER_IP tcp_lat</tt>.</s> qperf написан криво: 1) всегда использует для tcp_lat размер сообщения 1 байт!!! 2) не использует TCP_NODELAY. Так что его юзать, только если возьмёте его с моим патчем отсюда: [[Мой Debian репозиторий]]. [[Файл:Warning icon.svg|32px|link=]] Внимание: в частностиUbuntu на сетевую задержку негативно влияет AppArmor, может помочь выявить отдельную тупящую OSDего лучше отключить. Картина примерно такая (Intel X520-DA2): * centos 3.10: rtt min/avg/max/mdev = 0.039/0.053/0.132/0.012 ms* ubuntu 4.x + apparmor: rtt min/avg/max/mdev = 0.068/0.163/0.230/0.029 ms* ubuntu 4.x: rtt min/avg/max/mdev = 0.037/0.071/0.157/0.018 ms

[[Файл:Warning icon.svg|32px|link=]] Плохая новость!

Важная особенность Ceph — ''вся запись, даже та, для которой никто этого явно не просит, ведётся транзакционно''. То есть, никакая операция записи не завершается, пока она не записана в журналы всех OSD и не сделан fsync() диска. Так сделано, чтобы предотвращать [[#RAID WRITE HOLE]]-подобные ситуации рассинхронизации данных между репликами при отключении питания, потере сети и т.п…

Нас спасёт такое чудо инженерной мысли, как '''SSD с конденсаторами''' (точнее, обычно или с суперконденсаторами — ионисторами). Которые на M.2 SSD, кстати, прекрасно видны невооружённым глазом(только тут это не ионисторы :)):

И ещё один вариант — Intel Optane. Это тоже SSD, но они основаны не на Flash памяти (не NAND и не NOR), а вообще на другой технологии, называющейся 3D XPointPhase-Change-Memory «3D XPoint». Хз, как она работает, но По спецификации заявляются 550000 iops при полном отсутствии необходимости в стирании блоков, кэше и конденсаторах. Но аесли даже задержка такого диска и равна 0.005мс (она действительно равна) в применении к Ceph — нужно проверять — не факт, что то задержка Ceph вообще сможет выжать из них их iopsвсё равно 0.5-ы б) вариант дорогой1мс, раза в 3 дороже типичной SSD соответственно, с Ceph оптаны использовать чуть менее, чем бессмысленно — за большие деньги (1500$ за 960 гб, 500$ за 240 гб)вы получите не сильно лучший результат.

== BlueStore Bluestore vs FileStore Filestore ==

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

После долгого ковыряния Что лучше в проблеме разъясняю: нет, BlueStore не тормозит «в целом». В частности:Bluestore?

* BlueStore в 2 раза быстрее FileStore Ликвидирована двойная запись при линейной записи . Линейная запись быстрее в честных 2 раза практически в любых конфигурациях.* Отложенная запись, эффективная для HDD (можно считатьи, что всегдачастично, для очень плохих SSD). iops случайной записи в HDD-only конфигурациях почти в 2 раза больше, так как чем в нём крупные блоки пишутся 1 раз — сразу на устройствоFilestore. Правда, а речь об iops на HDD не 2 (идёт в журнал и потом принципе, поэтому вся разница — 33 или 66 iops на устройство)1 HDD.* BlueStore примерно равен FileStore по производительности случайной записи Возможность использования EC под CephFS и latency RBD благодаря реализованной частичной перезаписи объектов в AllEC-Flash кластерахпулах. Пиковая производительность при этом обычно немного выше* Эффективные снапшоты (благодаря «виртуальным клонам»): после снятия снапшота iops практически не падают, однопоточная — немного нижев отличие от Filestore, в котором они падают до считанных сотен даже на NVMe, так как при перезаписи даже 4 КБ после снятия снапшота в Filestore копируется целый 4 МБ объект. Жор CPU тоже немного меньше*: [[Файл:Warning icon. Всё svg|32px|link=]] Увы, это варьируетсяотносится только к '''rbd snapshot''', но по крайней мере блюстор здесь не хужек '''rbd clone'''. Клоны неэффективны в Bluestore точно так же, как и в Filestore. Запись 4 КБ в клон точно так же выливается в копирование 4 МБ.* Это не так критично, но в Bluestore есть поддержка сжатия и контрольных сумм данных.

ОДНАКО! BlueStore без дополнительных ухищрений действительно ХУЖЕ FileStore в популярной конфигурации HDD + журнал на SSDА что хуже? В целом, претензии сводятся к производительности:

* Условно, собрав небольшой кластер Гораздо хуже производительность случайной записи на BlueStoreSSD+HDD, SSD-раздел не работает как буфер для быстрой записи. Bluestore не пишет быстрее, чем может в 1 поток на среднем сам HDD+. То есть, с SSD вы получите ~100 -журналом и Filestore будет 1000—2000 иопс на записьслучайной записи, а в FileStore ~500 с Bluestore (и без SSD вообще будет 30-50 иопсbcache) — 200—300. 1000—2000, конечно, упадёт до 100 или даже ниже, когда у Filestore забьётся журнал и его придётся сбрасывать — но тем не менее, «буфер» для сглаживания пиков Filestore предоставляет. А Bluestore — нет.* Почему? Потому: И проблема не только в том, что BlueStore очень часто делает параметры по умолчанию — deferred_batch_ops и max_deferred_txc — задают частый сброс данных из очереди отложенной записи операций на HDD медленный диск (каждые 32 раз в 64 операции). Проблема ещё в том, deferred_batch_opsчто в Bluestore отсутствуют механизмы фоновой очистки «журнала» (очереди отложенной записи) . Поэтому, когда очередь забивается, производительность просто падает до HDD-шной до перезапуска OSD. Ну и при сбросе тормозит все последующие операциисама очередь находится в RocksDB, поэтому сильно поднимать её размер, по идее, неполезно.* В итоге случайная запись ждёт окончания До 1.5-2 раз хуже latency случайной записи не только на SSD/NVMe (All-Flash), а также и ибо накладных расходов на HDDкаждую операцию записи у Bluestore больше.* Ждёт оно так не каждую операциюЖор памяти больше. Да, поэтому iops-ы лучшеу Filestore много занимал pagecache, чем просто на HDDно Bluestore меньше 2 ГБ памяти не жрёт вообще никогда. Но всё-таки ждёт, поэтому iopsПричиной тому — RocksDB (одни только memtable-ы хуже, чем в FileStoreс дефолтными настройками съедают 1 ГБ памяти) и собственный кэш метаданных и данных (Bluestore не может использовать pagecache).* Фрагментация приводит к снижению скорости чтения.

Как Также BlueStore делает огромное количество fsync-ов (что очень смешно — даже больше, чем запросов записи), из-за чего не терпит десктопных SSD под журналом. Но FileStore работает похоже, и кардинальных различий производительности это не вносит. Как полечитьвысокие задержки на SSD+HDD?

* Либо использовать HDD с SSD Cache, Media Cache или аналогом (перманентным кэшем случайной записи на пластинах). Например, в старых дисках HGST это включается при отключении волатильного кэша командой `hdparm -W 0 /dev/sdXX`. В новых, похоже, включено всё время.

Также BlueStore делает огромное === Тест на 1 NVMe === Threadripper 2920X, NVMe Intel P4500, localhost. 1 OSD без репликации, 8 PG, чтобы не упираться в блокировки, 1 маленький RBD образ 10 Гб. Журнал Filestore 1 GB, чтобы в тестах успевал начинаться сброс. Bluestore 4k — это min_alloc_size и prefer_deferred_size = 4096 (4k запись идёт через redirect-write), Bluestore 16k — 16384 (4k запись идёт через deferred). <tab sep="bar" head="topleft" class="wikitable">| Filestore | Bluestore 16k | Bluestore 4k |bs=4M iodepth=16 rw=write | 950 MB/s | 1700 MB/s | 1700 MB/s |bs=4M iodepth=16 rw=read | 1250 MB/s | 1300 MB/s | 1300 MB/s | После полной линейной перезаписи + drop_cachesbs=4M iodepth=16 rw=read | 1250 MB/s | 450 MB/s | 320 MB/s | После 33 % случайной перезаписи блоком min_alloc_sizebs=4k iodepth=1 rw=randwrite | 3900 iops | 3200 iops | 2500 iops |bs=4k iodepth=128 rw=randwrite | 19100 iops | 19500 iops | 25500 iops |bs=4k iodepth=1 rw=randwrite | 180 iops | 2800 iops | 2500 iops | Сразу после снятия snapshot-а RBDbs=4k iodepth=128 rw=randwrite | 180 iops | 8800 iops | 15600 iops | Сразу после снятия snapshot-а RBDbs=4k iodepth=1 rw=randread | 3900 iops | 4500 iops | 4500 iops | После drop_caches / перезапуска OSDbs=4k iodepth=1 rw=randread | 6300 iops | 4500 iops | 4500 iops | Прогретый кэшbs=4k iodepth=128 rw=randread | 33000 iops | 32000 iops | 33000 iops |RAM | 270 MB | 2 GB + | | Filestore также использует произвольный объём page cacheCPU randwrite Q=128 | 600 % | 550 % | |</tab> === Про размер block.db === '''Внимание:''' актуально до Ceph 14. Начиная с Ceph 15, благодаря добавленным «allocation hints» RocksDB, Bluestore стал нормально утилизировать раздел block.db. Для истории — это коммит 5f72c376deb64562e5e88be2f22339135ac7372b, там добавили опцию bluestore_volume_selection_policy. Дальше стоит читать, только если у вас всё ещё проблемы со spillover-ами. Спилловер — это когда вы собрали Bluestore на SSD+HDD, выделив SSD под базу (block.db), но при этом эта самая база постоянно частично утекает на HDD. При этом она, вроде бы, даже влезает в SSD с запасом — но всё равно утекает. Начиная с Ceph 14 Nautilus о спилловерах предупреждает <tt>ceph -s</tt>. Когда случается спилловер в SSD+HDD конфигурациях, работа кластера замедляется — в большей или меньшей степени, в зависимости от размеров RocksDB и паттерна нагрузки, так как когда метаданных не очень много, они влезают в кэш OSD — либо onode cache, либо rocksdb cache, либо, если включено bluefs buffered io — то ещё и в системный page cache. Если кэш-промахов достаточно много, или если OSD упирается в compaction RocksDB, могут даже появляться slow ops-ы. Так в чём же дело и как это победить? А дело в том, что с выбором раздела для очередного файла БД (RocksDB организована в виде набора файлов) «есть нюанс», точнее, даже два. '''Нюанс № 1:''' RocksDB кладёт файл на быстрый диск только когда считает, что на быстром диске хватит места под все файлы этого же уровня (для тех, кто ещё не в курсе — RocksDB это [https://github.com/facebook/rocksdb/wiki/Leveled-Compaction LSM база]). Дефолтные настройки цефа:* 1 Гб WAL = 4x256 Мб* max_bytes_for_level_base и max_bytes_for_level_multiplier не изменены, поэтому равны 256 Мб и 10 соответственно* соответственно, L1 = 256 Мб* L2 = 2560 Мб* L3 = 25600 Мб и т. д. …Соответственно! Rocksdb положит L2 на block.db, только если раздел имеет размер хотя бы 2560+256+1000 Мб — округлим вверх до '''4 ГБ'''. А L3 она положит на block.db, только если block.db размером хотя бы 25600+2560+256+1000 МБ = около '''30 ГБ'''. А L4, соответственно, если ещё +256 ГБ, то есть итого '''286 ГБ'''. Иными словами, имеют смысл только размеры раздела block.db 4 ГБ, 30 ГБ, 286 ГБ. Все промежуточные значения бессмысленны — место сверх предыдущего граничного значения использоваться не будет. Например, если БД занимает 10 ГБ, а раздел SSD — 20 ГБ, то фактически на SSD ляжет только WAL (1 ГБ), L1 и L2 (256 МБ + 2.56 ГБ). L3, составляющий бОльшую часть базы, уедет на HDD и будет тормозить работу. При этом 4 ГБ — слишком мало, 286 ГБ — слишком много. Так что, по сути, правильно делать block.db размером 30 ГБ для OSD любого размера. Ещё раз повторюсь: это актуально до Ceph 14, с Ceph 15 уже не актуально. Кстати, из этого же следует то, что официальная рекомендация — выделять под block.db то ли 2 %, то ли 4 % от размера устройства данных — полный отстой. Но что делать, если у вас разделы другого размера? Например, 80 ГБ, и вы по каким-то причинам не хотите делать bcache, но хотите использовать эти 80 ГБ по максимуму. В этом случае можно поменять базовый размер уровня RocksDB (max_bytes_for_level_base). multiplier менять не будем, оставим по умолчанию 10 — его значение влияет на итоговое количество fsyncуровней RocksDB, а это уже более тонкая материя. Теоретически, меньшее число уровней снижает read и space amplification, но замедляет compaction и из-ов за этого может сильно повысить итоговый write amplification. Также есть тема с уменьшением размера отдельных memtable и кратным увеличением общего их числа, то есть, например, установки 32*32 МБ вместо дефолтных 4*256 МБ и min_write_buffer_to_merge=8, но эффект от этого тоже не совсем понятен (возможно, немного экономится CPU при compaction-е), так что это тоже пока лучше не трогать. Так как каждый уровень отличается от предыдущего в 10 раз, общий размер раздела БД должен быть равен k*X, где k — коэффициенты из ряда: 1, 11, 111, 1111 и т. п. (по числу уровней RocksDB). Значит, мы можем взять размер нашего block.db, вычесть из него 1 ГБ WAL (лучше даже вычесть с запасом 2 ГБ) и делить его последовательно на каждую из цифр до тех пор, пока не получим значение, близкое к 256 МБ … 1 ГБ. Это значение округлить вниз, принять за базовый размер уровня RocksDB и прописать в конфиг как max_bytes_for_level_base. База компактится по 256 МБ за раз, так что меньше 256 МБ размер первого уровня ставить точно смысла нет. Например, для 80 ГБ раздела это будет 719 МБ, только не забываем считать всё в двоичных мегабайтах — MiB. Остаётся прописать это значение в конфигурацию (bluestore_rocksdb_options = …,max_bytes_for_level_base=719MB), перезапустить OSD и сделать ручной compaction (можно дважды). '''Нюанс № 2:''' При ручном compaction-е RocksDB переписывает уровни целиком. Если при этом на SSD нет запаса места в размере этого уровня, то уровень, опять-таки, утечёт на HDD и так там и останется, ибо перемещать после compaction-а его обратно она не умеет. Теоретически, если после этого сделать compaction ещё раз, то уровень должен вернуться на SSD (поэтому выше дана рекомендация делать ручной compaction дважды). Однако по сведениям из чата якобы бывает так, что один-два файла *.sst на SSD не возвращается. Чтобы это побороть на 100 %, можно предусмотреть на SSD-разделе ещё и запас в размере первого + последнего уровня БД. В этом случае коэффициенты вместо 1-11-111-1111 превращаются в 2-22-212-2112 и т. п. == RGW vs Minio == Вопрос частый, так как Ceph и Minio — две наиболее распространённые реализации S3. Сравнение, как всегда, не совсем честное, так как в Minio «бесконечного масштабирования» и произвольных схем избыточности нет. Есть только erasure коды, которые оперируют группами дисков, кратными по количеству 4 или 16 дискам. Расширения кластера в Minio раньше не было вообще, потом в каком-то смысле появилось через создание дополнительных зон. Таких же гарантий целостности, как в Ceph, в Minio тоже нет. Minio работает поверх обычных ФС, даже не делая fsync данных. На практике ext4, правда, делает sync автоматически раз в 5 секунд, да и Minio пишет с O_DIRECT, так что не совсем всё плохо — но тем не менее, потенциально небольшие потери при отключении питания возможны. Особенно классный перл был в баге https://github.com/minio/minio/issues/3478: <blockquote>Minio in this case is working as intended, minio cannot be expanded or shrinkable in this manner. Minio is different by design. It is designed to solve all the needs of a single tenant. Spinning minio per tenant is the job of external orchestration layer. Any addition and removal means one has to rebalance the nodes. When Minio does it internally, it behaves like blackbox. It also adds significant complexity to Minio. Minio is designed to be deployed once and forgotten. We dont even want users to be replacing failed drives and nodes. Erasure code has enough redundancy built it. By the time half the nodes or drives are gone, it is time to refresh all the hardware. If the user still requires rebalancing, one can always start a new minio server on the same system on a different port and simply migrate the data over. It is essentially what minio would do internally. Doing it externally means more control and visibility. Minio is meant to be deployed in static units per tenant.</blockquote> Короче, всё работает как надо, в минио нет возможности расширения, если у вас будут ломаться диски — не меняйте, просто дождитесь, пока из строя выйдет половина дисков и пересоздайте кластер. На самом деле всё не так печально, можно заменить диск и запустить heal, но, конечно, без той же прозрачности, что в Ceph — оно будет просто сканировать все объекты и проверять отсутствующие. Если дисков много, это очень смешно — накладно. Ещё Minio хранит объекты в виде обычных файлов, даже большене шардируя каталоги (соответствующие бакетам) по подкаталогам, чем запросов записиплюс на каждый объект ещё создаёт директорию с парой файлов метаданных. Ну а директории в ФС по миллиону файлов — это, естественно, удовольствие ниже среднего. Хотя просто для раздачи оно, благодаря всяким dir_index-ам, работает. Для представления о производительности проведём простой тест Ceph (bluestore)vs Minio (ext4) на 1 HDD. Да, я знаю, что это тупо и нужно ещё хотя бы посравнивать их на SSD. Но всё-таки результаты довольно показательны. Да и объектное хранилище чаще холодное/прохладное и строится на HDD, а не на SSD. Тест делался через [https://github.com/vitalif/hsbench hsbench]. Заключался в заливке примерно 1.1 миллиона объектов в 1 бакет, потом сброса кэшей и перезапуска Ceph/Minio, и потом — их раздачи в случайном порядке, а также проверки скорости выполнения операций листингов. Результаты:* Заливка в 32 потока: Minio — 305 объектов в секунду, RGW — 135 объектов в секунду. RGW indexless — 288 объектов в секунду.* Раздача в 32 потока: Minio — 45 объектов в секунду, RGW — 78 объектов в секунду* Листинги в 32 потока: Minio — после сброса кэша 35 сек, после прогрева — 2.9 сек с разбросом от 0.5 до 16 сек. RGW — стабильно — 0.4 сек Да, заливка в Minio быстрее. Но, во-первых, меньшая скорость заливки — это цена, во-первых, консистентности (fsync), а во-вторых, bucket index-а и bucket index log-а, которые позволяют RGW, например, делать геосинхронизацию (multisite), чего в Minio нет. Кроме того, индексы в RGW можно положить на отдельные SSD (как обычно все и делают), а если же вам совсем не нужны листинги, синхронизация и прочее, в Ceph бакеты можно сделать безиндексными (indexless), и тогда оверхед bucket index-а вообще исчезает, как и возможные проблемы с его шардированием. == Снапшоты == В реализации снапшотов в Ceph есть целый ворох проблем из-за количества параллельных реализаций и общего накопленного архитектурного бардака: * На уровне RADOS снапшоты свои и их уже 2 вида: снапшоты пулов и снапшоты объектов.* На уровне RBD тоже свои снапшоты, причём они отличаются от RADOS-снапшотов, хоть внутри и реализованы частично через них. RBD снапшоты, можно сказать, не юзабельны ни для чего , кроме быстрого снятия бэкапов, за которым тут же следует удаление снапшота. Откат к RBD снапшотам очень медленный и реализован не терпит десктопных SSD под журналомпросто ужасно, а отвратительно — копированием содержимого снапшота поверх образа, ''даже неизменённых частей''. Кроме того, при откате цепочка последующих снапшотов уничтожается. Кроме того, есть прикол с жором места — см. на 2 пункта ниже.* В Bluestore снапшоты эффективны — после снятия снапшота случайная запись практически не замедляется, в отличие от Filestore, где принцип работы снапшотов схож со старым LVM и при записи даже 4 КБ после снятия снапшота соответствующий 4 МБ объект копируется целиком.* Но FileStore работает похожепри этом эта оптимизация снапшотов — «виртуальные клоны» — реализована именно на уровне Bluestore, ни клиент, ни OSD о ней ничего не знают и кардинальных различий производительности поэтому она… ломается при ребалансе. Выглядит это так: ты добавляешь в кластер диск, он заполняется, а доступного места больше не вноситстановится. Почему? Потому что изначально, при записи, Bluestore получил запрос «клонировать 4 МБ объект в новую версию» и сделал это внутри себя, реально не копируя данные, а потом перезаписал 4 КБ. А при ребалансе эта связь порвалась и объект стал занимать все 4 МБ… Fail.* Также на уровне RBD есть клоны, которые, с одной стороны, более юзабельны — реализованы они через ссылку на родительский образ, соответственно, откат к такому «снапшоту» быстрый — достаточно просто создать новый клон. С другой стороны, для клонов не работает эта самая блюсторовская оптимизация, поэтому они опять-таки копируют объекты целиком при любой записи… что выливается в 40 иопс на запись (QD=1) в свежий клон даже в NVMe кластере.* В CephFS ещё одна реализация снапшотов, и там отката нет вообще. В общем, наговнокодили — мама не горюй… == EC == EC ещё больше снижает iops-ы, так как добавляется цикл Read-Modify-Write. [[#RAID WRITE HOLE]] в цефе закрыт, поэтому при записи все OSD сначала делают вторые копии объекта (по-видимому, виртуальные, через тот же механизм virtual clone bluestore), а потом удаляют старые. В моём примере на NVMe-шках — write iops с репликацией Q=1 примерно 1500, а с EC — примерно 500. Q=128 — примерно 25000 с репликацией и 10000 с EC. === Про вероятность потери данных ===

Ну и ещё FileStore отстаёт от BlueStore по функциональностиСмотрите мой калькулятор вероятности потери данных в кластере:* Снапшоты там работают со скоростью LVM, то есть, при записи 4 кб после снятия снапшота копируется весь 4 Мб объектhttps://yourcmc. То есть, после снятия снапшота RBD ВМ тормозят.* Плюс отсутствуют некоторые другие фичи BlueStore: нет частичной перезаписи в ECru/afr-пулах (соответственно, EC нельзя использовать под CephFS и RBD), нет сжатия (хотя оно и не особо нужно), нет контрольных сумм (а вот они полезны, в частности, из-за их отсутствия нельзя использовать size=2).calc/

* Если не выкинули RAID — отключайте все кэши контроллера, чтобы уменьшить влияние прослойки и не страдать при разряде батарейки / перемещении диска в другой сервер... и молитесь :). Наверное, в теории можно выжить и с включенным кэшем, но это стрельба себе в ногу.* Даже если у вас HBA — имейте в виду, что некоторые HBA (в частности, Adaptec) могут всё равно не сбросить кэш корректно и устроить вам Cloudmouse при отключении питания. Но по крайней мере точно известно, что LSI ведут себя нормально.* Хороший пост про RAID-кэши в списке рассылки: http://lists.ceph.com/pipermail/ceph-users-ceph.com/2019-July/036237.html - если вкратце - человек, админивший 6000 OSD, пишет, что никогда больше не свяжется с RAID0-режимами.

* При подключении через SATA или HBA контроллер не забывайте для '''серверных''' SATA дисков сделать {{cmd|hdparm -W 0 /dev/sdX}}, для SAS — {{cmd|1=sdparm --set WCE=0 /dev/sdX}}.

** <tt>cpupower idle-set -D 10</tt> — отключает C-States (либо опции ядра processor.max_cstate=1 intel_idle.max_cstate=0)** <tt>cpupower frequency-set -g performance</tt> или (старое) <tt>for i in {$(seq 0..$((`nproc`-1))}); do cpufreq-set -c $i -g performance; done</tt> (вместо 63 подставьте своё число ядер минус 1) — отключает снижение частоты через множитель

* Оценка производительности кластера просто по спецификациям входящих в него SSD не совсем верна дисков — абсолютно неправильна. Речь о Bluestore. Под iops понимаются iops случайного чтения/записи блоками по 4 кб. 1 HDD (точнееобычный, 7200 rpm, скорее совсем не верна)SMR, причём в обе стороныбез ssd-кэша) — это:*~100-120 iops при QD=128* Bluestore~66 iops при QD=1* ~40 MB/s линейного чтения/записи* При недостатке памяти показатели будут хуже, видимотак как будут cache miss по метаданным 1 быстрый SSD или NVMe SSD (с конденсаторами, за счёт параллелизма, выдаёт чуть больше write iops >= 25000):* ~1000 iops-ов даже на SSD без конденсаторовзапись при QD=1, чем просто те же ssd могут выдать с fsync — я лично смог добиться в зависимости от тестового пула частоты CPU и настроек может быть от 300 до, в самом идеальном случае, ~2500 iops.* Максимум до ~10000-20000 iops на 3запись при QD=128 на 1 OSD.* На чтение показатели примерно в 2-х Intel SSDSC2KW256G8 8000 2.5 раза лучше: QD=1 ~2000 iops (случайная записьмаксимум до ~4000), хотя сами ssd с fsync выдают примерно 5500QD=128 ~20000, максимум до 50000.** И обратноЕстественно, даже если SSD мегабыстраяпоказатель QD=128 не может быть больше, цеф — это огромный оверхед, он жрёт проц и никаких 220000 iops из одной чем показатель самого диска :). Но так как хорошие SSD в параллельном режиме обычно быстрые — этого не выжметзамечаешь. См. ниже [[#Пример теста от Micron]] — там в суперкрутом сетапе у них вышло всего 8750 * Создав несколько OSD на одном диске, можно умножить число QD=128 iops в пересчёте на 1 NVMe число OSD (но это у них без SPDK/DPDKпока диск позволяет). Естественно, ценой аналогичного увеличения жора CPU.* Можно считать, что лимит iops-ов в пересчёте на одну SSDСкорость линейного чтения/NVMe находится на уровне ~10000-15000записи примерно равна скорости линейного чтения/записи самого диска.* Большой Кардинальной разницы по iops между хорошей SATA SSD и даже NVMe в цефе — , если у обоих есть конденсаторы — нет. Это не отменяет того, что NVMe лучше, но на случайном доступе это заметить трудно.* Если SATA На актуальных SSD плохая — разница естьчтение QD=1 часто бывает медленнее записи QD=1, так как писать можно в быстрый кэш, а читать можно только из реальной памяти. Разница бывает примерно такая:) плохим можно считать всёна чтение при QD=1 8000 iops, что даёт меньше 20000 а на запись 40000 iops в один поток с sync.* <s>Лайфхак для ускорения однопоточной нагрузкиИтоговые показатели: mdadm RAID 0 * Линейное чтение из RBD-образов внутри самой виртуалки<кластера = Число OSD * MB/s> — проверено, не работает.одного OSD* Лайфхак для очень быстрых дисков: несколько Линейная запись в реплицированный пул = Число OSD / Репликация * MB/s одного OSD на одном диске — работает, но ценой сильного увеличения жора CPU.* Гипотетический монстр производительности Линейная запись в вакууме: мощные процы, Intel NVMe, сеть 25EC-пул = Число OSD / (K+ ГбитM) * K * MB/с или Infiniband, <s>SPDK/DPDK</s> (SPDK работаетодного OSD* С iops всё сложнее, но не даёт прироста, DPDK не работает вообще)так как репликация вносит нелинейный эффект в масштабирование.Но, условно говоря:** iops QD=1 — усредняются по всем OSD, а iops QD=128 — суммируются** При этом на 1 RBD клиента можно получить лишь до ~30000 iops на чтение и ~15000 iops на запись* Естественно, если что-то упирается в сеть — соответствующая цифра обрезается показателем сети

Дано=== O_SYNC vs fsync vs hdparm -W 0 === У SATA и SCSI дисков есть два способа сброса кэша: 3 компа команда FLUSH CACHE и флаг FUA (Force Unit Access) на команде записи. Первый — это явный сброс кэша, второй — это указание записать операцию на диск, минуя кэш. Точнее, у SCSI оно есть, а с 3x 7200rpm SATA HDD (ситуация точно не ясна: в одном 4x HDDспецификации NCQ бит FUA есть, но по факту FUA большинством дисков вроде как не суть важноподдерживается и, соответственно, эмулируется ядром/контроллером (если контроллер не кривой). По всей видимости, fsync() отправляет диску команду FLUSH CACHE, а открытие файла с O_SYNC устанавливает бит FUA на все команды записи. Есть ли разница? Обычно нет. Но на некоторых контроллерах и/или с некоторыми настройками различия по неустановленным причинам встречаются. И тогда fio -sync=1 и fio -fsync=1 начинают давать разные результаты — возможно, даже на порядки разные результаты. Кроме того, у дисков есть команда отключения кэша. Когда он отключен, запросы сброса (fsync) Linux диску не отправляет. Казалось бы, такой режим тоже должен быть эквивалентен выполнению fsync и/или O_SYNC после каждой команды. Но и это не всегда так! На SSD с конденсаторами (то есть серверных моделях с Advanced Power Loss Protection) при отключении кэша iops-ы случайной записи часто вырастают на порядок (например, с 5000 до 40000). Но не всегда, так как это, опять-таки, зависит от контроллера. Почему? По-видимому, потому, что команда FLUSH CACHE трактуется диском как «сбрось все кэши» (включая энергонезависимый), а отключение кэша — как «отключи энергозависимый кэш» (а энергонезависимый можешь оставить включенным). Соответственно, запись со сбросом кэша становится медленнее, чем просто отключённый кэш. А что с NVMe? В NVMe разнообразие чуть меньше — возможность отключить кэш в спецификации не предусмотрена вообще, но точно так же есть команды FLUSH CACHE и бит FUA. При этом по личным наблюдениям FUA часто игнорируется то ли диском, то ли Linux-ом, и <tt>fio -sync=1</tt> выдаёт с NVMe такие же результаты, как и без sync вообще. <tt>-fsync=1</tt> при этом ведёт себя как надо и приземляет производительность туда, где ей самое место (на десктопных NVMe — до тех же 1000—2000 iops). P.S: Bluestore использует fsync. Filestore использует O_SYNC. === Серверные SSD === Disabling cache is not a joke! <tt>fio -ioengine=libaio -name=test -filename=/dev/sdb -(sync|fsync)=1 -direct=1 -bs=(4k|4M) -iodepth=(1|32|128) -rw=(write|randwrite)</tt> '''Micron 5100 Eco 960GB''' <div style="float: left"><div>'''Запись'''</div><tab sep="bar" head="top" class="wikitable">sync или fsync | bs | iodepth | rw | hdparm -W 1 | hdparm -W 0sync | 4k | 1 | write | 612 iops | 22200 iopssync | 4k | 1 | randwrite | 612 iops | 22200 iopssync | 4k | 32 | randwrite | 6430 iops | 59100 iopssync | 4k | 128 | randwrite | 6503 iops | 59100 iopssync | 4M | 32 | write | 469 MB/s | 485 MB/sfsync | 4k | 1 | write | 659 iops | 25100 iopsfsync | 4k | 1 | randwrite | 671 iops | 25100 iopsfsync | 4k | 32 | randwrite | 695 iops | 59100 iopsfsync | 4k | 128 | randwrite | 701 iops | 59100 iopsfsync | 4M | 32 | write | 384 MB/s | 486 MB/s</tab></div><div style="float: left; margin-left: 10px"><div>'''Чтение'''</div><tab sep="bar" head="top" class="wikitable">bs | iodepth | rw | результат4k | 1 | randread | 6000 iops4k | 4 | randread | 15900 iops4k | 8 | randread | 18500 iops4k | 16 | randread | 24800 iops4k | 32 | randread | 37400 iops4M | 1 | read | 460 MB/s4M | 16 | read | 514 MB/s</tab></div><div style="clear:both"></div> Результаты по чтению не отличаются на hdparm -W 0 и 1. '''Seagate Nytro 1351 XA3840LE10063''' Диск заполнен почти полностью, на 90-100 %. <div style="float: left"><div>'''Запись'''</div><tab sep="bar" head="top" class="wikitable">sync или fsync | bs | iodepth | rw | hdparm -W 1 | hdparm -W 0sync | 4k | 1 | randwrite | 18700 iops | 18700 iopssync | 4k | 4 | randwrite | 49400 iops | 54700 iopssync | 4k | 32 | randwrite | 51800 iops | 65700 iopssync | 4M | 32 | write | 516 MB/s | 516 MB/sfsync=1 | 4k | 1 | randwrite | {{red|288 iops}} | 18100 iopsfsync=1 | 4k | 4 | randwrite | {{red|288 iops}} | 52800 iopsfsync=4 | 4k | 4 | randwrite | 1124 iops | 53500 iopsfsync=1 | 4k | 32 | randwrite | {{red|288 iops}} | 65700 iopsfsync=32 | 4k | 32 | randwrite | 7802 iops | 65700 iopsfsync=1 | 4M | 32 | write | 336 MB/s | 516 MB/s</tab></div><div style="float: left; margin-left: 10px"><div>'''Чтение'''</div><tab sep="bar" head="top" class="wikitable">bs | iodepth | rw | результат4k | 1 | randread | 8600 iops4k | 4 | randread | 21900 iops4k | 8 | randread | 30500 iops4k | 16 | randread | 39200 iops4k | 32 | randread | 50000 iops4M | 1 | read | 508 MB/s4M | 16 | read | 536 MB/s</tab></div><div style="clear:both"></div> Если не хотите 288 иопс — отключайте кэш. === Ceph HDD+SSD === Дано: 3 компа с 4x 7200rpm SATA HDD, с 1 SSD (десктопным) под систему и ceph-mon и с 1 SSD (старым, но серверным, 25000 iops) под журналы. Не самая быстрая 10-гигабитная сеть — флуд пингом средний RTT (задержка) 0.098ms. Развёрнут Ceph + OpenNebula с KVM. Диски под Ceph отформатированы в Bluestore утилитой ceph-volume (то есть используется LVM). Диски виртуалок лежат в обычном реплицированном ceph pool с size=3.

<s>{{Note}} Мораль: отключайте кэш записи всем устройствам</s>дискам!

'''РазгадкаЧастичная разгадка:''' в  # <s>В жёстких дисках HGST есть Media Cache — Cache</s> (энергонезависимый кэш случайной записи прямо на пластинах) — во-первых, там не HGST, во-вторых, в HGST медиакэш включён всегда и не зависит от hdparm -W 0. Включается # В жёстких дисках Seagate Enterprise Capacity ST8000NM0055 (коих из общего числа 3) есть встроенный SSD-кэш. И вот он , видимо, действительно включается только при отключении обычного энергозависимого кэшаhdparm -W 0. А блюстор при сбросе отложенной записи на диск # Блюстор блокирует последующие операциизапись в журнал записью на HDD. Но сбрасывает он их всего лишь по 32 штуки, это очень мало, поэтому блокирует последующие операции он постоянноКогда включен спец. Следовательно, когда включается медиакэшкэш, HDD начинает рандомно писать сильно быстрее, и вот эти вот блокировки при сбросе уходят. Действует медиакэшкэш, естественно, временно — когда он кончится, производительность случайной записи опять упадёт. Однако плюс в том, что в Ceph-е этого, скорее всего, не произойдёт, так как скорость случайной записи ограничивается, собственно, самим Ceph-ом и распределяется по всем дискам кластера :). Другие производители эту технику# Однако, кстатидля обычных дисков без SSD-кэша отключение кэша тоже даёт выигрыш… есть гипотеза, уже что из-за того же тормоза с bluefs (проверю). Более свежие тесты бенчилкой ceph-gobench на том же самом стенде. Версия Ceph Mimic 13.2.2, Bluestore, журналы на SSD. osd.1 и osd.3 без выноса журналов на SSD оба показывали 75-80 iops вне зависимости от отключения кэша. В таблице показаны однопоточные IOPS с глубиной очереди Q=1 без репликации. <tab sep="bar" class="wikitable" head="topleft">Номер OSD | Патч + кэш | Кэш выкл | Кэш вкл | Модель диска | Номер моделиosd.0 | 365 | 308 | 226 | Seagate Constellation ES.2 | ST32000645NSosd.1 | 322 | 325 | 234 | Hitachi Ultrastar 7K3000 | HUA723020ALA640osd.2 | 1278 | 1392 | 230 | Seagate Enterprise Capacity | ST8000NM0055osd.4 | 198 | 244 | 140 | Hitachi Ultrastar A7K2000 | HUA722020ALA330osd.5 | 251 | 185 | 154 | Hitachi Ultrastar A7K2000 | HUA722020ALA330osd.7 | 1351 | 1129 | 253 | Seagate Enterprise Capacity | ST8000NM0055osd.9 | 399 | 315 | 184 | Hitachi Ultrastar 7K3000 | HUA723020ALA640osd.13 | 226 | 212 | 142 | Hitachi Ultrastar A7K2000 | HUA722020ALA330osd.3 | 393 | 386 | 241 | Hitachi Ultrastar 7K3000 | HUA723020ALA640osd.8 | 340 | 323 | 156 | Hitachi Ultrastar A7K2000 | HUA722020ALA330osd.10 | 1461 | 1319 | 273 | Seagate Enterprise Capacity | ST8000NM0055osd.14 | 302 | 229 | 135 | Hitachi Ultrastar A7K2000 | HUA722020ALA330</tab> ==== Примечания ==== Toshiba MG07ACA14TE тоже перенялизамечены в подобном поведении, см. обсуждение в списке рассылки: https://www.spinics.net/lists/ceph-users/msg60753.html

{{Note}} По итогам дополнительных изысканий хейтспич несколько подправленТретья редакция hatespeech’а.

Речь о Вкратце ситуация такова: После того, как хранилище Ceph переписали с упоротой архитектуры с хранением объектов в ФС XFS и дополнительным журналом, в которой, по идее, был дикий оверхед — быстрее (в смысле random write iops) оно практически не стало. Ведь вроде старались-старались'''Логичный ответ на вопрос «какого х#ра» такой: то ли XFS на самом деле написана очень хорошо, уходили от двойной записи и «журналирования журнала» в filestore…то ли Bluestore на самом деле написан очень плохо.''' Сразу скажу: оба ответа верны. :-)

ОкейОтчаиваемся и по советам знатоков прикручиваем туда SSD под wal+db. И думаем: ну, дальше нам говорят — эээтеперь у нас быстрая SSD с конденсаторами под журналом, нелатенси записи 50 микросекунд, значит должно быть много иопсов — ну, в устоявшемся режиме хотя бы 300 (9 * 100 / 3). 120 random iops с Тестируем. В 1 HDD — поток получаем ну… 60 иопс. Во много — где-то 200. Опять плохо. Смысл в том, что собственной реализации журнала у блюстора нет, есть очередь отложенной записи, живущая прямо в RocksDB. RocksDB — это без syncLSM keyvalue база, случайная запись с sync — примерно 50по сути база-60 iopsжурнал. ОкейВ принципе, говорим мыэто достаточно разумно, но вотак как всё равно нужно журналировать изменения метаданных, которые там держит блюстор. Когда очередь отложенной записи засунута туда же, изменение можно коммитить одной транзакцией (соответственно, одним fsync-первых у нас ом). И в этой схеме есть одно большое отличие от filestore — оно заключается в том, что в filestore журнал работал как буфер для временного повышения нагрузки на запись. Пока в журнале было место, случайная запись была очень быстрой, а журналы обычно делали размеров в несколько гигабайт. В bluestore же глубина очереди 128«очередь отложенной записи» очень маленькая и сбрасывается через каждые 64 запроса. То есть, значитbluestore не пишет быстрее, параллелизмчем в среднем может медленное устройство (HDD). Плюс к этому на практике (при просмотре strace) оказывается, значитчто fsync-ов на каждую операцию записи делается не 1, операции должны пролезать между syncа 2. Второй fsync — это лишняя транзакция записи в журнал BlueFS, сводящаяся к обновлению размера лог-ами файла RocksDB. Это нафиг не нужно, так как в опциях RocksDB в цефе по умолчанию стоит wal_recovery_mode=kTolerateCorruptedTailRecords и быть быстрее — а воrecycle_log_number=4, но это так, потому что без этого у них из-вторыхза другого бага корраптятся данные при падении OSD. Что на самом деле исправляется легко, 50*9я им даже отправил фикс — https:/1/tracker.5ceph.com/3 — это всё равно 100issues/38559 https://github. Ну хоть 100 иопсcom/ceph/ceph/pull/26909 -то должно у нас быть и они даже вроде как обещают его влить. С фиксом на запись? А у нас 30HDD ускорение случайной записи при глубине очереди 1 — двукратное (с 33 % до 66 % возможностей самого HDD, обычно как раз с 33 до 66 иопс). При глубине очереди 128 — почти нулевое.

Дальше ОК, ладно. В конце концов мы отчаиваемся решаем — гулять так гулять и по советам знатоков прикручиваем туда собираем кластер на серверных SSD под wal+db(или вообще NVMe). И думаем: Думаем — ну, теперь-то у нас запись идёт на SSD, SSD хорошая, с конденсаторами. Теперь суммарно у нас должно быть не меньше 300 иопс (N * скорость шпинделя / фактор репликации), да и ?!… Бенчим в 1 поток должно быть столько же. Тестируем. В 1 поток получаем ну… 60 300 иопс. Во много — где-то 200. Опять медленно.Охреневаем окончательно и идём гуглить эту статью :)

Вариант решения № 1: Здесь смысл в том, что в голове у наших HDD обнаруживается media cacheвсех сидит мысль «а, мы его включаемну да, оно медленное, потому что слишком много пишет на диск — диск же относительно медленный, а софт быстрый». А вот хрен. :) оказывается, Ceph довольно сложно разогнать до latency < 1 ms, получаем нормальную производительность и успокаиваемся виной тому не диски, а сам Ceph. То есть да, Ceph при записи мелкими блоками порождает WA (хотя осадочек-то осталсяWrite Amplification)3. Вариант № 2: медиакэша у наших дисков нет и мы продолжаем ломать голову «почему ж так медленно-то».5 на каждой OSD — это легко посчитать через тот же strace. Но на хороших SSD это практически не занимает времени, одна операция 4кб записи занимает условно 20 микросекунд. Проблема именно в С++ коде Ceph.

Так вот. Журнала у блюстора собственного нетПричём даже не до конца понятно, что конкретно там тормозит — такое ощущение, вместо него RocksDBчто всё целиком. Это как бы keyvalue базаВыявить какие-то «горячие точки» при профилировании трудно, но она же LSM, она же так и работает — типа до лимита пишет в памятьпросто при записи выполняется много всякой C+журнал+ной мелочи, потом когда упирается в лимит — делает compaction которая суммарно отъедает достаточно много времени. Одно горячее место — вычисление цифровых подписей пакетов (включено по уровнямумолчанию, можно отключить), другое — сериализация/десериализация (код обрабатывает каждое поле пакета, чуть ли не каждый байт, отдельным вызовом функции). По сути как бы БДДальше идут уже malloc-журнал. Вот они её как журнал и юзают. В той же RocksDB метаданные, и их дохрена, ибо виртуальные клоны и всякое такоекоторых тоже происходят тонны. Плюс чексуммыПричём всё это происходит в несколько потоков. Плюс два варианта записи — прямой На это ещё навёрнута какая-то странная смесь буферизованного и отложенныйпрямого I/O.

Теоретически в этом ничего плохого нет. НаоборотRocksDB не виновата — её я пробовал бенчить, хорошо тоона быстрая, что и метаданные, и данные записываются ~8000 транзакций в секунду на NVMe в 1 транзакциейпоток она даёт и даже масштабируется до ~120000 tps в 256 потоков. А Ceph OSD даже с максимальным параллелизмом на той же NVMe даёт только 10-20 тысяч iops.

Однако на практике Сеть тоже не виновата — её я пробовал бенчить с помощью nbd (при просмотре stracenetwork block device) оказывается. При прямом доступе диск выдаёт 50000 iops, что при записи 4к-блоками OSD демонстрируют фактор Write Amplification от 3 до 5 плюс делают огромное количество commit-овпробросе диска с одного сервера на другой через nbd — 8000 iops. Запись делается двумя системными вызовами — pwritev и io_submit. Commit — тоже двумяТо есть, sync_file_range и fdatasyncдобавленная latency сети — примерно 0.1ms. Это не много.

Например, по итогам простого теста И даже Bluestore не совсем виноват. На NVMe Bluestore с SSDнекоторыми тюнами всё-настройками получается, что эта тварь на 6193 запроса записи делает 18585 записей (суммарно записывая 21674 4к-блока) и 24776 коммитов (больше, чем запросов записи)! Итого Write Amplification = 3таки осиливает завершить запись примерно за 0.3мс. И в то же время код самого Ceph сжирает ещё 0.54мс.

Тот же тест По сути, нужно было бы добиться ситуации, в которой Ceph бы отъедал 0.1ms и Bluestore ещё 0.1ms. Сеть съест ещё 0.1ms и тогда на HDD: на 1183 операции 3020 запросов хорошей NVMe получится latency ~ 0.33ms, что в 1 поток соответствует 3000 операциям записи суммарным объёмом 4926 * 4 кб и 3664 syncв секунду. До локальной SSD это всё равно не дотянуло бы, но, тем не менее, было бы уже очень-аочень неплохо. Итого WA Тогда, скажем, можно будет бороться за CPU: поставив самолётные CPU по 20000$ каждый, настроив ядро и снизив время Ceph+Bluestore ещё в 2 раза, вы получите уже 0.23ms = 4~4350 iops.16 (4926/1183)А допилив поддержку Infiniband, а sync-ов опять большеможет, чем запросов записиполучите и все 6000 iops. Пока же код не оптимизирован… всё это — мёртвому припарки.

Причины найдено две:* Блюстор всё время «едет Авторы сейчас пытаются пилить новую реализацию OSD на ручнике» из-за совершенно идиотской проблемы, которую я не далее чем вчера зарепортил сюда https://tracker.ceph.com/issues/38559 - при каждой записи в журнал RocksDB происходит дополнительная «ненужная» транзакция записи в журнал BlueFS, сводящаяся к обновлению размера лог-файла RocksDB. Теоретически это не нужноасинхронном фреймворке Seastar (Crimson OSD), так как RocksDB настроена с wal_recovery_mode=kTolerateCorruptedTailRecords и recycle_log_number=4. Но практически — видимо, где-то что у нас есть баг и это нужнотеоретические шансы увидеть Ceph, так как иначе при падении OSD его rocksdb ломается.** На HDD ускорение случайной записи при отключении этого поведения достигает 1.5-2 который будет в несколько разбыстрее.* Для серверных SSD число коммитов не важноХотя, но важен WA — чем больше WAконечно, тем больше работы приходится выполнять. А откуда WA?** Во-первых, тот же коммит BlueFS добавляет 4кб на каждую операцию.** Во-вторых, min_alloc_size на SSD по умолчанию — 16кб. Всё, что меньше, заполняется нулями — нулевые блоки добавляются к WA.** …а также min_alloc_size приводит к тому, что на SSD на самом деле тоже работает отложенная запись. Всё, что меньше min_alloc_size, сначала пишется там вопрос далеко не только в RocksDB, как многопоточности и на HDD. Отложенная запись порождает примерно 3x WA: блок+метаданные первый раз (размер блока WAL — 4кб) + блок второй раз.** Сами блокировках — по себе метаданные толстоваты. Extent-ы хранятся не отдельными ключамиидее, а списками размерами по умолчанию до 1200 байт. Правда, с учётом дефолтных min_alloc_size и max_blob_size на SSD (64K), на самом деле они меньшемного съедает именно программная логика. Но это порождает обратную проблему — по идее, 4 Мб на SSD запишутся так как 64*64Кб + 64 записи в RocksDBеё они фактически тоже частично переписывают с нуля — она тоже может улучшиться.

* Однако, похоже, в силу неоптимальной реализации самого сетевого кода Ceph ни от DPDK, ни от RDMA ожидать ускорения не приходится — потому приходится. Задержка Ceph в 10-100 раз выше сетевой задержки, так что один , уменьшая сетевую задержку, добиться практически нечего. Один чувак недавно даже проводил эксперимент — отрезал код AsyncMessenger-а от всего остального цефа и попробовал побенчить пробовал бенчить его отдельно: https://www.spinics.net/lists/ceph-devel/msg43555.html - html — и получил всего лишь ~80000 iops.* В перспективе SPDK будет на хрен не нужен, так как в ядро приняли штуку под названием io_uring: https://lore.kernel.org/linux-block/20190116175003.17880-1-axboe@kernel.dk/ - с ней обычный код прокачивает через Optane-ы практически столько же iops, сколько и SPDK, при заметно меньшем объёме геморроя на поддержку работы с SPDK/DPDK == RAID WRITE HOLE == В RAID-е есть один интересный момент: при отказе диска и одновременном отключении питания RAID 5 может кораптить данные. Суть такая: допустим, есть три диска в рейд5. Есть какая-то пара блоков данных A и B. Соответственно на дисках хранятся: A, B, A xor B. Теперь представим, что мы пишем в блок B данные B2. Для этого нам надо обновить данные на двух дисках: B -> B2, A+B -> A+B2. Теперь представим, что один из них успел записать, а второй не успел. Тут вырубилось питание и одновременно сдох диск A (или диск сдох от умирания питания, или контроллер повис и ядро в панику упало...). Что мы имеем на дисках? ?, B2, A+B либо ?, B, A+B2. Теперь при попытке восстановить A мы получим A+B+B2 => опа! Покорраптились данные, которые даже не записывались! Из-за этого raid всегда делает полный resync после нештатного вырубания питания. И, собственно, такая же потеря данных возможна при отказе диска до завершения resync. mdadm RAID5 в таких ситуациях (когда одновременно потерян диск и массив помечен как грязный) просто отказывается стартовать. И именно чтоб этого избежать, в цефе сделано полное журналирование всех данных на уровне отдельных дисков (т.е. OSD). Потому что других способов борьбы с этой проблемой НЕТ, а при работе по сети отказы гораздо более вероятны, чем при работе RAID-массива на локальных дисках. Даже write intent bitmap может только сказать вам, потеряли вы какие-то данные или нет, но не может помочь их восстановить, если они потеряны. Так что Ceph надёжнее RAID-а. :) медленнее (на SSD). Но надёжнее и не требует resync-а.

Особенность NAND флеш-памяти (NAND/NOR) заключается в том, что пишется она мелкими блоками (обычно 512 байт), а стирается большими . Актуальное соотношение для Micron 3D NAND — страница (2-4 мегабайтаpage) 16 КБ, блок стирания (block) — и при этом 16 или 24 МБ (1024 или 1536 страниц, MLC/TLC соответственно). Случайное чтение страницы быстрое. Запись тоже, но писать можно только в предварительно стёртую область. Чтение блока при этом быстрое, запись тоже быстрая; область — а стирание же медленное, да ещё и число стираний каждого erase unit-а блока ограничено — после нескольких тысяч (типичное значение для MLC) блок физически выходит из строя. В более дешёвых и плотных (MLC, TLC, QLC — 2-4 бита на ячейку) чипах лимит стираний меньше, в более дорогих и менее плотных (SLC, один бит на ячейку) — больше. Соответственно, при «тупом» подходе — если при записи каждого блока его просто стирать и перезаписывать — случайная запись во флеш-память, во-первых, будет очень медленной, а во-вторых, она будет быстро выводить её из строя.

Но почему тогда SSD быстрые? А потому, что внутри SSD на самом деле есть очень мощный и умный контроллер (1-2 гигагерца, типично 4 ядра или больше, примерно как процессоры мобильников), и на нём выполняется нечто, называемое Flash Translation Layer — прошивка, которая переназначает каждый мелкий логический сектор в произвольное место диска. FTL всё время поддерживает некоторое количество свободных стёртых блоков и направляет каждую мелкую случайную запись в новое место диска, в заранее стёртую область. Поэтому запись быстрая. Одновременно FTL делает дефрагментацию свободного места и Wear Leveling (распределение износа), направляя запись и перемещая данные так, чтобы все блоки диска стирались примерно одинаковое количество раз. Кроме того, во всех SSD некоторый % реального места зарезервирован под Wear Leveling и не виден пользователю («overprovision»), а в хороших серверных SSD этот процент весьма большой — например, в Micron 5100 Max это +60 % ёмкости(в Micron 5100 Eco — всего лишь +7.5 %, 1.92 ТБ SSD содержит 10 чипов NAND по 1.5 терабита и 2 по 768 гигабит).

А почему тогда USB-флешки такие медленные? Случайная запись на флешку 512-байтными (или 4 Кб) блоками обычно идёт со скоростью 2-3 iops. А флеш-память там ровно примерно та же, что в SSD — ну, может, более дешёвые вариациии мелкие чипы с меньшими размерами страницы и блока (часто 4 КБ страница и 4 МБ блок), но разница принцип тот же и разница в скорости не на порядки. Ответ кроется в том, что на флешках тоже есть FTL (и даже Wear Leveling), но по сравнению с SSD-шным он маленький и тупой. У него слабый процессор и мало памяти. Из-за малого объёма RAM контроллеру флешки, в отличие от контроллера SSD, негде хранить полную таблицу сопоставления виртуальных и реальных секторов — поэтому отображаются не сектора, а крупные блоки где-то по мегабайту или больше, а и при записи есть лимит на количество «открытых» блоков. Как это происходит:

Пример самолётного сетапа от Micron с процами по полляма (2x Xeon GoldPlatinum 8168), 1002x100-гбит сетью (точнее 2x2x100, так как 2 карты по 2 порта) и 10x топовыми NVMe (с конденсаторами, ага) в каждом узле, 4 узла, репликация 2x: https://www.micron.com/resource-details/30c00464-e089-479c-8469-5ecb02cfe06f

Всего 350000 367011 iops на запись в пике на весь кластер, при 100 % загрузке CPU. Казалось бы, довольно много, но если поделить 350000367000/40 osd — получится 8750 9175 иопс на 1 osd. С учётом репликации на диски нагрузка двойная, выходит, 17500 18350 иопс. Ок, журналы тоже удваивают нагрузку, итого — 35000 36700 iops на запись смог выжать ceph из одной NVMe… которая сама по спеке может 260000 иопс в одиночку. Вот такой вот overhead.

UPDПримечание: ПоправкаPDF-ка по ссылке обновлена, новый результат с теми же тюнами, что ниже, составил 479882 iops на запись и 2277453 iops на чтение. Старая [[:Media:Micron_9200_ceph_3.0_reference_architecture.pdf|тут]]. Что и подтверждает, что разница между Micron 9200 и 9300 для Ceph незаметна. === Апдейт === https://www.micron.com/-/media/client/global/documents/products/other-documents/micron_9300_and_red_hat_ceph_reference_architecture.pdf NVMe обновились до Micron 9300 (максимальной ёмкости 12.8 ТБ). iops-ов такие диски дают даже не 260 тыс., а 310 тыс. Всё остальное осталось прежним. Итого 100 клиентами на запись сняли 477029 iops. Однако надо понимать, что каждому клиенту при этом досталось лишь 4770 iops. 10 клиентами сняли 294000 iops — то есть на 1 клиента 29400 иопс, что всё-таки поприличней. Почему стало лучше? Предположительно, благодаря тюнингу. По сравнению с прошлым тестом они:* отключили чексуммы мессенджера (ms_crc_data=false) и чексуммы блюстора (bluestore_csum_type=none)* затюнили rocksdb: <stt>в чём микрон неправ — они не использовали SPDK bluestore_rocksdb_options = compression=kNoCompression,max_write_buffer_number=64,min_write_buffer_number_to_merge=32,recycle_log_file_num=64,compaction_style=kCompactionStyleLevel,<br />write_buffer_size=4MB,target_file_size_base=4MB,max_background_compactions=64,level0_file_num_compaction_trigger=64,level0_slowdown_writes_trigger=128,<br />level0_stop_writes_trigger=256,max_bytes_for_level_base=6GB,compaction_threads=32,flusher_threads=8,compaction_readahead_size=2MB</tt>** 64x32x4 MB memtable (number x merge x size) вместо стандартных 4x1x256 MB. Скорее всего, это и DPDKсыграло основную роль. Есть большая вероятностьЭффект не совсем очевиден, но, вероятно, это снижает нагрузку на CPU, потому что поиск в их случае выигрыш мог быть 64 маленьких memtable быстрее, чем поиск в несколько 1 (или 4) больших.** сильно изменён max_bytes_for_level_base — с 256 мб он поднят до 6 гб!** добавлены потоки compaction-а.* выдали 14 гб RAM каждому OSD* osd_max_pg_log_entries=osd_min_pg_log_entries=osd_pg_log_dups_tracked=osd_pg_log_trim_min = 10 (хз, по-моему, ничего не даёт) Также надо отметить, что:* cephx у них уже был отключён. В этот раззачем-то добавили и отключение подписей — видимо, читали мою статью.<Но это нафиг не надо, при отключенном cephx подписи можно уже не отключать.* debug objecter = 0/s> Нет0 и вообще отключенные дебаги у них тоже уже были* с prefer_deferred_size и min_alloc_size они, это бессмысленновидимо, не игрались* обновлённые диски не играют никакой роли гарантированно.260000 или 310000 iops — для цефа никакой разницы нет. === Бонус: висян (vSAN) === [https://media-www.micron.com/-/media/client/global/documents/products/other-documents/micron_vsan_6,-d-,7_on_x86_smc_reference_architecture.pdf Micron Accelerated All-Flash SATA vSAN 6.7 Solution] Конфигурация серверов: * 384 GB RAM 2667 MHz* 2X Micron 5100 MAX 960 GB (randread: 93k iops, randwrite: 74k iops)* 8X Micron 5200 ECO 3.84TB (randread: 95k iops, randwrite: 17k iops)* 2x Xeon Gold 6142 (16c 2.6GHz)* Mellanox ConnectX-4 Lx* Connected to 2x Mellanox SN2410 25GbE switches «Соответствует конфигурации VMWare AF-6, по заявлениям дающей от 50K iops чтения на каждый сервер» * 2 реплики (аналог size=2 в цефе)* 4 сервера* 4 ВМ на каждом сервере* 8 диска на каждую ВМ* 4 потока на каждый дискСуммарный параллелизм ввода/вывода: 512 100%/70%/50%/30%/0% write* «Baseline» (данные умещаются в кэш): 121k/178k/249k/314k/486k iops* «Capacity» (не умещаются): 51k/66k/90k/134k/363k* Задержка равна 1000*512/IOPS миллисекунд во всех тестах (1000мс * параллелизм / iops)* '''Нет тестов задержки с низким параллелизмом'''* '''Нет тестов линейного чтения/записи''' Заключение:* ~3800 iops на запись в пересчёте на каждый диск данных* ~1600 iops на запись в пересчёте на диск, если данные не влезают в кэш* ~15000 iops на чтение в пересчёте на каждый диск данных* ~11400 iops на чтение в пересчёте на диск, если данные не влезают в кэш* Итого: при параллельной нагрузке в данном тесте vSAN смотрится хуже, чем Ceph* С другой стороны, vSAN гиперконвергентный, а Ceph, в идеале, нет — или тормозит сильнее, чем мог бы

* Micron серий 5100/5200, 9300. Возможно также 5300, 7300

Написанное в статье актуально для версий Ceph, доступных на момент последней правки (см. «История» вверху страницы). Конкретно — для 12 -15 luminous-octopus. Различия между версиями минимальны, 13 mimic, да и 14 nautilus тоже — всё пока что актуально. Если вдруг в будущем что-то пофиксят и всё вдруг станет чудесно быстрым — сам побегу обновляться первым и поправлю статью :). == См. также == * https://www.ixsystems.com/community/resources/list-of-known-smr-drives.141/ - список SMR дисков (вероятно, не полный)* http://vasilisc.com/bluestore-ceph-2017 - кое-что про bluestore, местами не совсем верно, но тем не менее* https://amarao-san.livejournal.com/3437997.html - «IOPS не существует» — сказ о latency*: ''Прим.вред — iops существуют, но с обязательным указанием режима тестирования и параллелизма''* https://yourcmc.ru/afr-calc/ - мой калькулятор вероятности потери данных в кластере Ceph в зависимости от размера кластера и схемы отказоустойчивости == Советы лучших собаководов == Офлайн балансер: <pre>ceph osd getmap -o om; osdmaptool om --upmap upmap.sh --upmap-deviation 0; bash upmap.sh; rm -f upmap.sh om</pre>