ClickHouse + Graphite: ഡിസ്ക് സ്പേസ് ഉപഭോഗം എങ്ങനെ ഗണ്യമായി കുറയ്ക്കാം

ആശംസകൾ, ഹാബർ.

ആരെങ്കിലും സിസ്റ്റത്തെ ചൂഷണം ചെയ്താൽ ഗ്രാഫൈറ്റ്-വെബ് കൂടാതെ ഒരു സ്റ്റോറേജ് പ്രകടന പ്രശ്‌നം നേരിട്ടു വിരസത (IO, ഡിസ്ക് സ്പേസ് ഉപയോഗിച്ചു), തുടർന്ന് ക്ലിക്ക്ഹൗസ് പകരക്കാരനായി കാസ്‌റ്റ് ചെയ്യപ്പെടാനുള്ള സാധ്യത ഒന്നായി മാറും. ഈ പ്രസ്താവന സൂചിപ്പിക്കുന്നത് ഒരു മൂന്നാം കക്ഷി നടപ്പിലാക്കൽ ഒരു ഡെമൺ സ്വീകരിക്കുന്ന മെട്രിക്കുകളായി ഇതിനകം തന്നെ ഉപയോഗിച്ചിട്ടുണ്ട് എന്നാണ്. കാർബൺറൈറ്റർ അഥവാ ഗോ-കാർബൺ.

ClickHouse വിവരിച്ച പ്രശ്നങ്ങൾ നന്നായി പരിഹരിക്കുന്നു. ഉദാഹരണത്തിന്, വിസ്പറിൽ നിന്ന് 2TiB ഡാറ്റ ട്രാൻസ്ഫർ ചെയ്ത ശേഷം, അവ 300GiB-ലേക്ക് യോജിക്കുന്നു. താരതമ്യത്തെക്കുറിച്ച് ഞാൻ വിശദമായി സംസാരിക്കില്ല; ഈ വിഷയത്തിൽ ധാരാളം ലേഖനങ്ങളുണ്ട്. കൂടാതെ, അടുത്തിടെ വരെ, ഞങ്ങളുടെ ClickHouse സംഭരണത്തിൽ എല്ലാം തികഞ്ഞിരുന്നില്ല.

ഉപയോഗിച്ച സ്ഥലവുമായി ബന്ധപ്പെട്ട പ്രശ്നങ്ങൾ

ഒറ്റനോട്ടത്തിൽ, എല്ലാം നന്നായി പ്രവർത്തിക്കണം. പിന്തുടരുന്നു പ്രമാണീകരണം, മെട്രിക്സ് സ്റ്റോറേജ് സ്കീമിനായി ഒരു കോൺഫിഗറേഷൻ സൃഷ്ടിക്കുക (കൂടുതൽ retention), തുടർന്ന് ഗ്രാഫൈറ്റ്-വെബിനായി തിരഞ്ഞെടുത്ത ബാക്കെൻഡിന്റെ ശുപാർശ അനുസരിച്ച് ഒരു പട്ടിക സൃഷ്ടിക്കുക: കാർബൺ-ക്ലിക്ക്ഹൗസ്+ഗ്രാഫൈറ്റ്-ക്ലിക്ക്ഹൗസ് അഥവാ ഗ്രാഫൌസ്, ഏത് സ്റ്റാക്ക് ഉപയോഗിക്കുന്നു എന്നതിനെ ആശ്രയിച്ചിരിക്കുന്നു. പിന്നെ... ടൈം ബോംബ് പൊട്ടുന്നു.

ഏതാണ് എന്ന് മനസിലാക്കാൻ, * കുടുംബത്തിന്റെ എഞ്ചിനുകളുടെ പട്ടികകളിൽ ഉൾപ്പെടുത്തലുകൾ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്നും ഡാറ്റയുടെ തുടർന്നുള്ള ജീവിത പാതയെക്കുറിച്ചും നിങ്ങൾ അറിയേണ്ടതുണ്ട്.മെർജ് ട്രീ ക്ലിക്ക്ഹൗസ് (ചാർട്ടുകൾ എടുത്തത് അവതരണങ്ങൾ അലക്സി സാറ്റെലിപിൻ):

• ചേർത്തു блок ഡാറ്റ. ഞങ്ങളുടെ കാര്യത്തിൽ, എത്തിയ മെട്രിക്സ് ആയിരുന്നു.
  
• അത്തരം ഓരോ ബ്ലോക്കും ഡിസ്കിൽ എഴുതുന്നതിന് മുമ്പ് കീ അനുസരിച്ച് അടുക്കുന്നു. ORDER BYപട്ടിക സൃഷ്ടിക്കുമ്പോൾ വ്യക്തമാക്കിയിരിക്കുന്നു.
• അടുക്കിയ ശേഷം, кусок (part) ഡാറ്റ ഡിസ്കിൽ എഴുതിയിരിക്കുന്നു.
  
• സെർവർ പശ്ചാത്തലത്തിൽ നിരീക്ഷിക്കുന്നതിനാൽ അത്തരം നിരവധി ഭാഗങ്ങൾ ഉണ്ടാകാതിരിക്കുകയും പശ്ചാത്തലം സമാരംഭിക്കുകയും ചെയ്യുന്നു слияния (merge, ഇനി മുതൽ ലയിപ്പിക്കുക).
  
  
• ഡാറ്റയിലേക്ക് സജീവമായി ഒഴുകുന്നത് നിർത്തിയ ഉടൻ തന്നെ സെർവർ സ്വന്തമായി ലയനം പ്രവർത്തിക്കുന്നത് നിർത്തുന്നു партицию (partition), എന്നാൽ നിങ്ങൾക്ക് കമാൻഡ് ഉപയോഗിച്ച് സ്വമേധയാ പ്രക്രിയ ആരംഭിക്കാൻ കഴിയും OPTIMIZE.
• പാർട്ടീഷനിൽ ഒരു കഷണം മാത്രമേ അവശേഷിക്കുന്നുള്ളൂ എങ്കിൽ, സാധാരണ കമാൻഡ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് ലയനം പ്രവർത്തിപ്പിക്കാൻ കഴിയില്ല; നിങ്ങൾ ഉപയോഗിക്കണം OPTIMIZE ... FINAL

അതിനാൽ, ആദ്യ അളവുകൾ വരുന്നു. അവർ കുറച്ച് സ്ഥലം എടുക്കുകയും ചെയ്യുന്നു. തുടർന്നുള്ള സംഭവങ്ങൾ പല ഘടകങ്ങളെ ആശ്രയിച്ച് അല്പം വ്യത്യാസപ്പെടാം:

• പാർട്ടീഷനിംഗ് കീ വളരെ ചെറുതോ (ഒരു ദിവസം) അല്ലെങ്കിൽ വളരെ വലുതോ (നിരവധി മാസങ്ങൾ) ആകാം.
• സജീവമായ പാർട്ടീഷനിലെ (മെട്രിക്‌സ് രേഖപ്പെടുത്തിയിരിക്കുന്നിടത്ത്) നിരവധി സുപ്രധാന ഡാറ്റ അഗ്രഗേഷൻ ത്രെഷോൾഡുകൾ നിലനിർത്തൽ കോൺഫിഗറിനു യോജിച്ചേക്കാം.
• ധാരാളം ഡാറ്റ ഉണ്ടെങ്കിൽ, ബാക്ക്ഗ്രൗണ്ട് ലയനം മൂലം ഇതിനകം തന്നെ വളരെ വലുതായേക്കാവുന്ന ആദ്യ ഭാഗങ്ങൾ (നിങ്ങൾ ഒപ്റ്റിമൽ അല്ലാത്ത പാർട്ടീഷനിംഗ് കീ തിരഞ്ഞെടുക്കുകയാണെങ്കിൽ), പുതിയ ചെറിയ കഷണങ്ങളുമായി സ്വയം ലയിക്കില്ല.

അത് എപ്പോഴും ഒരേ പോലെ അവസാനിക്കുന്നു. ClickHouse-ൽ മെട്രിക്കുകൾ ഉൾക്കൊള്ളുന്ന ഇടം ഇനിപ്പറയുന്നവയാണെങ്കിൽ മാത്രമേ വർദ്ധിക്കുകയുള്ളൂ:

• പ്രയോഗിക്കരുത് OPTIMIZE ... FINAL സ്വമേധയാ അല്ലെങ്കിൽ
• എല്ലാ പാർട്ടീഷനുകളിലേക്കും തുടർച്ചയായി ഡാറ്റ ചേർക്കരുത്, അതുവഴി എത്രയും വേഗം അല്ലെങ്കിൽ പിന്നീട് ഒരു പശ്ചാത്തല ലയനം ആരംഭിക്കും

രണ്ടാമത്തെ രീതി നടപ്പിലാക്കാൻ ഏറ്റവും എളുപ്പമാണെന്ന് തോന്നുന്നു, അതിനാൽ ഇത് തെറ്റാണ്, ആദ്യം പരീക്ഷിച്ചു.
കഴിഞ്ഞ 4 വർഷമായി എല്ലാ ദിവസവും ഡമ്മി മെട്രിക്‌സ് അയയ്ക്കുകയും ഓരോ മണിക്കൂറിലും ക്രോൺ റൺ ചെയ്യുകയും ചെയ്യുന്ന വളരെ ലളിതമായ ഒരു പൈത്തൺ സ്‌ക്രിപ്റ്റ് ഞാൻ എഴുതി.
ClickHouse DBMS-ന്റെ മുഴുവൻ പ്രവർത്തനവും ഈ സിസ്റ്റം എത്രയും വേഗം അല്ലെങ്കിൽ പിന്നീട് എല്ലാ പശ്ചാത്തല പ്രവർത്തനങ്ങളും ചെയ്യുമെന്ന വസ്തുതയെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്, എന്നാൽ എപ്പോഴാണെന്ന് അറിയില്ല, പഴയ കൂറ്റൻ ഭാഗങ്ങൾ ലയിക്കാൻ തുടങ്ങുന്ന നിമിഷത്തിനായി കാത്തിരിക്കാൻ എനിക്ക് കഴിഞ്ഞില്ല. പുതിയ ചെറിയവ. നിർബന്ധിത ഒപ്റ്റിമൈസേഷനുകൾ ഓട്ടോമേറ്റ് ചെയ്യുന്നതിനുള്ള ഒരു വഴി ഞങ്ങൾ നോക്കേണ്ടതുണ്ടെന്ന് വ്യക്തമായി.

ClickHouse സിസ്റ്റം ടേബിളുകളിലെ വിവരങ്ങൾ

പട്ടികയുടെ ഘടന നോക്കാം സിസ്റ്റം.ഭാഗങ്ങൾ. ClickHouse സെർവറിലെ എല്ലാ ടേബിളുകളുടേയും ഓരോ ഭാഗത്തെയും കുറിച്ചുള്ള സമഗ്രമായ വിവരമാണിത്. മറ്റ് കാര്യങ്ങൾക്കൊപ്പം, ഇനിപ്പറയുന്ന നിരകൾ അടങ്ങിയിരിക്കുന്നു:

• db പേര് (database);
• പട്ടികയുടെ പേര് (table);
• പാർട്ടീഷൻ പേരും ഐഡിയും (partition & partition_id);
• കഷണം സൃഷ്ടിച്ചപ്പോൾ (modification_time);
• ഒരു കഷണത്തിലെ ഏറ്റവും കുറഞ്ഞതും കൂടിയതുമായ തീയതി (വിഭജനം ദിവസം കൊണ്ടാണ് ചെയ്യുന്നത്) (min_date & max_date);

ഒരു മേശയും ഉണ്ട് system.graphite_retentions, ഇനിപ്പറയുന്ന രസകരമായ ഫീൽഡുകൾക്കൊപ്പം:

• db പേര് (Tables.database);
• പട്ടികയുടെ പേര് (Tables.table);
• അടുത്ത അഗ്രഗേഷൻ പ്രയോഗിക്കേണ്ട മെട്രിക് പ്രായം (age);

അങ്ങനെ:

1. ഞങ്ങൾക്ക് ചങ്കുകളുടെ ഒരു പട്ടികയും അഗ്രഗേഷൻ നിയമങ്ങളുടെ ഒരു പട്ടികയും ഉണ്ട്.
2. ഞങ്ങൾ അവയുടെ കവലകൾ സംയോജിപ്പിച്ച് എല്ലാ ടേബിളുകളും *GraphiteMergeTree നേടുന്നു.
3. ഞങ്ങൾ എല്ലാ പാർട്ടീഷനുകളും തിരയുന്നു:
   • ഒന്നിലധികം കഷണങ്ങൾ
   • അല്ലെങ്കിൽ അടുത്ത അഗ്രഗേഷൻ റൂൾ പ്രയോഗിക്കാനുള്ള സമയം വന്നിരിക്കുന്നു, കൂടാതെ modification_time ഈ നിമിഷത്തേക്കാൾ പഴയത്.

നടപ്പാക്കൽ

ഈ അഭ്യർത്ഥന

SELECT
    concat(p.database, '.', p.table) AS table,
    p.partition_id AS partition_id,
    p.partition AS partition,
    -- Самое "старое" правило, которое может быть применено для
    -- партиции, но не в будущем, см (*)
    max(g.age) AS age,
    -- Количество кусков в партиции
    countDistinct(p.name) AS parts,
    -- За самую старшую метрику в партиции принимается 00:00:00 следующего дня
    toDateTime(max(p.max_date + 1)) AS max_time,
    -- Когда партиция должна быть оптимизированна
    max_time + age AS rollup_time,
    -- Когда самый старый кусок в партиции был обновлён
    min(p.modification_time) AS modified_at
FROM system.parts AS p
INNER JOIN
(
    -- Все правила для всех таблиц *GraphiteMergeTree
    SELECT
        Tables.database AS database,
        Tables.table AS table,
        age
    FROM system.graphite_retentions
    ARRAY JOIN Tables
    GROUP BY
        database,
        table,
        age
) AS g ON
    (p.table = g.table)
    AND (p.database = g.database)
WHERE
    -- Только активные куски
    p.active
    -- (*) И только строки, где правила аггрегации уже должны быть применены
    AND ((toDateTime(p.max_date + 1) + g.age) < now())
GROUP BY
    table,
    partition
HAVING
    -- Только партиции, которые младше момента оптимизации
    (modified_at < rollup_time)
    -- Или с несколькими кусками
    OR (parts > 1)
ORDER BY
    table ASC,
    partition ASC,
    age ASC

ഓരോ *GraphiteMergeTree ടേബിൾ പാർട്ടീഷനുകളും നൽകുന്നു, അവയുടെ ലയനം ഡിസ്ക് സ്പേസ് ശൂന്യമാക്കും. ഒരു അഭ്യർത്ഥനയുമായി അവയിലൂടെ കടന്നുപോകുക മാത്രമാണ് ഇനി ചെയ്യേണ്ടത് OPTIMIZE ... FINAL. സജീവമായ റെക്കോർഡിംഗ് ഉള്ള പാർട്ടീഷനുകൾ സ്പർശിക്കേണ്ടതില്ല എന്ന വസ്തുതയും അന്തിമ നടപ്പാക്കൽ കണക്കിലെടുക്കുന്നു.

ഇതുതന്നെയാണ് പദ്ധതിയും ചെയ്യുന്നത് ഗ്രാഫൈറ്റ്-ch-ഒപ്റ്റിമൈസർ. Yandex.Market-ൽ നിന്നുള്ള മുൻ സഹപ്രവർത്തകർ ഇത് ഉൽപ്പാദനത്തിൽ പരീക്ഷിച്ചു, ജോലിയുടെ ഫലം ചുവടെ കാണാൻ കഴിയും.

ClickHouse ഉള്ള ഒരു സെർവറിൽ നിങ്ങൾ പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ, അത് ഡെമൺ മോഡിൽ പ്രവർത്തിക്കാൻ തുടങ്ങും. ഒരു മണിക്കൂറിൽ ഒരിക്കൽ ഒരു അഭ്യർത്ഥന നടപ്പിലാക്കും, ഒപ്റ്റിമൈസ് ചെയ്യാൻ കഴിയുന്ന മൂന്ന് ദിവസത്തിലധികം പഴയ പുതിയ പാർട്ടീഷനുകൾ പ്രത്യക്ഷപ്പെട്ടിട്ടുണ്ടോ എന്ന് പരിശോധിക്കുക.

ഞങ്ങളുടെ ഉടനടി പദ്ധതികൾ കുറഞ്ഞത് ഡെബ് പാക്കേജുകളെങ്കിലും നൽകാനാണ്, സാധ്യമെങ്കിൽ ആർപിഎമ്മും.

പകരം ഒരു നിഗമനത്തിൽ എന്ന

കഴിഞ്ഞ 9+ മാസങ്ങളായി ഞാൻ എന്റെ കമ്പനിക്കുള്ളിലാണ് ഇന്നോഗെയിംസ് ക്ലിക്ക് ഹൗസിന്റെയും ഗ്രാഫൈറ്റ്-വെബിന്റെയും കവലയിൽ ധാരാളം സമയം ചിലവഴിച്ചു. ഇതൊരു നല്ല അനുഭവമായിരുന്നു, ഇത് വിസ്‌പറിൽ നിന്ന് ഒരു മെട്രിക്‌സ് സ്‌റ്റോറേജായി ClickHouse-ലേക്ക് പെട്ടെന്നുള്ള പരിവർത്തനത്തിന് കാരണമായി. ഈ സ്റ്റാക്കിന്റെ വിവിധ ഭാഗങ്ങളിൽ ഞങ്ങൾ എന്തൊക്കെ മെച്ചപ്പെടുത്തലുകൾ വരുത്തി, ഭാവിയിൽ എന്തുചെയ്യും എന്നതിനെക്കുറിച്ചുള്ള ഒരു പരമ്പരയുടെ തുടക്കമാണ് ഈ ലേഖനം എന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു.

അഭ്യർത്ഥന വികസിപ്പിക്കുന്നതിനായി നിരവധി ലിറ്റർ ബിയറും അഡ്മിൻ ദിവസങ്ങളും ചെലവഴിച്ചു v0ഡെവിൾ, അതിനായി ഞാൻ അദ്ദേഹത്തോട് എന്റെ നന്ദി പ്രകടിപ്പിക്കാൻ ആഗ്രഹിക്കുന്നു. കൂടാതെ ഈ ലേഖനം അവലോകനം ചെയ്യുന്നതിനും.

ഗിത്തബിലെ പ്രോജക്റ്റ് പേജ്

അവലംബം: www.habr.com