PostgreSQL में पूल आकार और डेटाबेस कनेक्शन के बीच मधुर स्थान का निर्धारण कैसे करें

Question

हमें अपने डेटाबेस सर्वर पर पीक आवर्स के दौरान ट्रैफिक को संभालने में परेशानी हो रही है। हम हार्डवेयर में सुधार कर रहे हैं ( चीजों के उस पक्ष के बारे में यह प्रश्न देखें ) लेकिन हम पूलिंग कॉन्फ़िगरेशन और सर्वर ट्यूनिंग पर भी काम करना चाहते हैं।

आवेदन पर हम काम कर रहे हैं, जहां बैकएंड के होते हैं स्मार्टफोन, के लिए एक बारी आधारित मल्टीप्लेयर खेल है रेल के साथ गेंडा और PostgreSQL 9.1 डेटाबेस के रूप में। वर्तमान में हमारे पास ६०० ००० पंजीकृत उपयोगकर्ता हैं और चूंकि खेल राज्य डेटाबेस में संग्रहीत है, कई हजारों लिखते हैं प्रत्येक सेकंड के दो जोड़े बनाए जाते हैं। हमने PgBadger का उपयोग करके PostgreSQL से लॉग फ़ाइलों का विश्लेषण किया है और महत्वपूर्ण घंटों के दौरान हमें बहुत कुछ मिलता है

FATAL: remaining connection slots are reserved for non-replication superuser connections

इस समस्या का मुकाबला करने का भोला समाधान postgresql.conf में अधिकतम_कनेक्ट (जो वर्तमान में 100 है) को बढ़ाना होगा । मैंने http://wiki.postgresql.org/wiki/Number_Of_Database_Connections पढ़ा है जो बताता है कि ऐसा करना सही बात नहीं हो सकती है। पूर्वोक्त लेख में इसे max_connections और पूल आकार के बीच के मधुर स्थान को खोजने के लिए संदर्भित किया गया है ।

इस प्यारी जगह को खोजने के लिए क्या किया जा सकता है? क्या max_connections और पूल आकार के विभिन्न मूल्यों के लिए I / O प्रदर्शन को मापने के लिए कोई अच्छा उपकरण हैं ?

हमारा वर्तमान सेटअप 4 गेम सर्वर है, प्रत्येक में 16 गेंडा श्रमिक और 5 का एक पूल आकार है।

यहां उन गैर-डिफ़ॉल्ट पोस्टग्रेज-सेटिंग्स का उपयोग किया जा रहा है:

version                      | PostgreSQL 9.1.5 on x86_64-unknown-linux-gnu,compiled by gcc (Ubuntu/Linaro 4.6.3-1ubuntu5) 4.6.3, 64-bit
checkpoint_completion_target | 0.9
checkpoint_segments          | 60
checkpoint_timeout           | 6min
client_encoding              | UTF8
effective_cache_size         | 2GB
lc_collate                   | en_US.UTF-8
lc_ctype                     | en_US.UTF-8
log_destination              | csvlog
log_directory                | pg_log
log_filename                 | postgresql-%Y-%m-%d_%H%M%S.log
log_line_prefix              | %t
log_min_duration_statement   | 200ms
log_rotation_age             | 1d
log_rotation_size            | 10MB
logging_collector            | on
max_connections              | 100
max_stack_depth              | 2MB
server_encoding              | UTF8
shared_buffers               | 1GB
ssl                          | on
TimeZone                     | localtime
wal_buffers                  | 16MB
work_mem                     | 8MB

Comments

क्या आप वह व्यक्ति हैं जो पिछले कुछ हफ्तों में मेलिंग सूची में इस बारे में पूछ रहे थे? यदि हां, तो मैं उस चर्चा के लिए बैक-लिंक जोड़ूंगा। भी: आपका DB सर्वर हार्डवेयर और कॉन्फ़िगरेशन क्या है? wiki.postgresql.org/wiki/Slow_Query_Questions । गैर-डिफ़ॉल्ट सेटिंग शामिल करें: wiki.postgresql.org/wiki/Server_Configuration । क्या आपने wiki.postgresql.org/wiki/Tuning_Your_PostgreSQL_Sverver पढ़ा है ? क्या आप जहां संभव हो, बड़े लेनदेन में काम करते हैं? क्या आप कैशिंग लेयर का उपयोग करते हैं और यदि हां, तो क्या? आप उपयोग कर रहे हैं synchronous_commit = offया एक commit_delay?

— क्रेग रिंगर

तो आपके पास PostgreSQL सर्वर पर कुल 20 कनेक्शन हैं? 5 प्रति गेम सर्वर? 16 गेंडा श्रमिकों में प्रत्येक गेम सर्वर से 5 कॉन साझा किए जाने के साथ?

— क्रेग रिंगर

ओह, क्या आप धीमी क्वेरी लॉग कर रहे हैं? यदि हां, तो आपके हॉट-स्पॉट क्या हैं? सरल है INSERT? आपका स्कीमा कैसा है - क्या इसका विभाजन किया गया है? क्या है explain analyzeकुछ नमूना प्रश्नों की? आपकी चौकियों की संख्या कितनी है और उन्हें कितनी देर लगती है? (चेकपॉइंट लॉगिंग विकल्प देखें)। और गंभीरता से, आपका PostgreSQL संस्करण क्या है? (अपडेट: लगता है कि आप यहां अपना हार्डवेयर सूचीबद्ध करते हैं: dba.stackexchange.com/questions/28061/… )

— क्रेग रिंगर

वैसे भी, पूल आकार के लिए विशेष रूप से ट्यूनिंग, केवल वास्तविक उत्तर हैं लोड और डीबी सर्वर थ्रूपुट के मजबूत माप को सेट करना, फिर ऊपर और नीचे समायोजित करना शुरू करें जब तक कि आपको मिठाई स्पॉट न मिल जाए।

— क्रेग रिंगर

@ क्रैगरिंगर नहीं मैं वह व्यक्ति नहीं हूं। लेकिन पश्च के लिए धन्यवाद! मैंने ट्यूनिंग Your PostgreSQL सर्वर को पढ़ा है और कुछ उल्लिखित युक्तियों का पालन किया है। मैंने अब नॉट-डिफॉल्ट सेटिंग्स को शामिल किया है। अब हम बड़े लेन-देन और परीक्षण में देख रहे हैंsynchronous_commit = off

— lorgartzor

Answer 1

यहाँ संक्षिप्त उत्तर "निगरानी और प्रदर्शन मेट्रिक्स द्वारा निर्देशित परीक्षण और त्रुटि" है।

अंगूठे के कुछ सामान्य नियम हैं जिनकी मदद से आपको उस अस्पष्ट क्षेत्र को ढूंढना चाहिए जिसे आपको शुरू करना चाहिए, लेकिन वे बहुत सामान्य हैं। व्यापक दिशानिर्देश "सीपीयू की संख्या प्लस के स्वतंत्र डिस्क है" अक्सर उद्धृत किया जाता है, लेकिन यह केवल एक अविश्वसनीय मोटे बिंदु है।

आपको वास्तव में क्या करने की आवश्यकता है अपने आवेदन के लिए मजबूत प्रदर्शन मीट्रिक प्राप्त करें। आंकड़े दर्ज करना शुरू करें।

इसके लिए एकीकृत टूलिंग के रास्ते में बहुत कुछ नहीं है। नगीओस check_postgresस्क्रिप्ट, कैक्टि सिस्टम परफॉर्मेंस काउंटर लॉगिंग, पोस्टग्रेसीक्यूएस सांख्यिकी कलेक्टर आदि जैसी चीजें हैं ... लेकिन बहुत कुछ ऐसा नहीं है जो इसे एक साथ रखता है। अफसोस की बात है, आपको खुद ही ऐसा करना होगा। PostgreSQL पक्ष के लिए, PostgreSQL मैनुअल में निगरानी देखें । कुछ तीसरे पक्ष के विकल्प मौजूद हैं, जैसे एंटरप्राइज़डीबी के पोस्टग्रेज एंटरप्राइज मॉनिटर ।

यहां उल्लिखित एप्लिकेशन-स्तरीय मीट्रिक के लिए आप उन्हें साझा डेटा संरचनाओं में या बाहरी गैर-टिकाऊ DB में रिकॉर्ड करना चाहेंगे जैसे कि आप उन्हें रिकॉर्ड करते हैं या उनसे पहले अपने PostgreSQL DB में लिखते हैं। Pg पर सीधे लॉग इन करने की कोशिश करने से माप रिकॉर्ड करके बनाए गए ओवरहेड के साथ आपकी माप विकृत हो जाएगी और समस्या और भी बदतर हो जाएगी।

सबसे सरल विकल्प शायद प्रत्येक ऐप सर्वर में एक सिंगलटन है जिसे आप एप्लिकेशन आँकड़े रिकॉर्ड करने के लिए उपयोग करते हैं। आप शायद लगातार अपडेट होने वाले मिन, मैक्स, एन, टोटल और माध्य को बनाए रखना चाहते हैं; इस तरह से आपको प्रत्येक स्टेट पॉइंट को स्टोर करने की जरूरत नहीं है, सिर्फ एग्रीगेट। यह सिंगलटन अपने एग्रीगेट आँकड़े को Pg को हर x मिनट में लिख सकता है, एक कम पर्याप्त दर जो कि प्रदर्शन प्रभाव न्यूनतम होगा।

के साथ शुरू:

• अनुरोध विलंबता क्या है? दूसरे शब्दों में, क्लाइंट से रिक्वेस्ट आने तक ऐप को क्लाइंट से कितना समय लगता है। व्यक्तिगत रिकॉर्ड के बजाय एक समय अवधि में इसे रिकॉर्ड करें। इसे अनुरोध प्रकार द्वारा समूहित करें; पृष्ठ द्वारा कहो।

• एप्लिकेशन को निष्पादित करने वाले प्रत्येक क्वेरी या क्वेरी प्रकार के लिए डेटाबेस एक्सेस विलंब क्या है? जब तक यह किया जाता है, तब तक जानकारी / भंडारण जानकारी के लिए DB से पूछने में कितना समय लगता है और अगले कार्य के लिए आगे बढ़ सकता है? फिर से, इन आंकड़ों को एप्लिकेशन में एग्रीगेट करें और केवल डीबी को एग्रीगेट जानकारी लिखें।

• आपका थ्रूपुट कैसा है? किसी भी x मिनट में, आपके द्वारा निष्पादित किए जाने वाले प्रत्येक प्रमुख वर्ग के कितने प्रश्न DB द्वारा सेवित किए जाते हैं?

• एक्स मिनट की उसी समय सीमा के लिए, कितने क्लाइंट अनुरोध थे?

• हर कुछ सेकंड में नमूना लेना और DB में एक ही x मिनट की खिड़कियों पर एकत्र करना, कितने DB कनेक्शन थे? उनमें से कितने निष्क्रिय थे? कितने सक्रिय थे? आवेषण में? अद्यतन? चयन? हटाए गए? उस अवधि में कितने लेनदेन हुए? आँकड़े कलेक्टर प्रलेखन देखें

• एक ही समय अंतराल पर फिर से नमूना लेना और एकत्र करना, मेजबान सिस्टम के प्रदर्शन मैट्रिक्स की तरह क्या थे? कितने पढ़े और कितने लिखे डिस्क IOs / सेकंड? मेगाबाइट्स प्रति सेकंड डिस्क पढ़ता है और लिखता है? CPU उपयोग? औसत भार? RAM का उपयोग?

अब आप डेटा को सहसंबंधित करके, उसे रेखांकन आदि करके अपने ऐप के प्रदर्शन के बारे में सीखना शुरू कर सकते हैं। आप पैटर्न देखना शुरू कर देंगे, अड़चनें खोजने लगेंगे।

आप सीख सकते हैं कि आपका सिस्टम मेगाबाइट्स प्रति सेकंड में काफी कम डिस्क I / O के बावजूद उच्च लेनदेन दरों पर बोतल-गर्दन है INSERTऔर UPDATEएस। यह एक संकेत होगा कि आपको एक बैटरी समर्थित राइट-बैक कैशिंग RAID नियंत्रक या कुछ उच्च-गुणवत्ता वाले बिजली-संरक्षित एसएसडी के साथ अपने डिस्क फ्लश प्रदर्शन को बेहतर बनाने की आवश्यकता है। यदि आप सिंक synchronous_commit = offक्रैश commit_delayलोड को कुछ लेने के लिए सर्वर क्रैश, और / या a पर कुछ लेनदेन खोना ठीक है, तो आप इसका उपयोग भी कर सकते हैं ।

जब आप अपने लेन-देन को प्रति सेकंड समवर्ती कनेक्शनों की संख्या के अनुसार ग्राफ करते हैं और अलग-अलग अनुरोध दर के लिए आवेदन को देख रहे हैं, तो आप एक बेहतर विचार प्राप्त कर पाएंगे कि आपका थ्रूपुट स्वीट स्पॉट कहां है।

यदि आपके पास तेज़ फ्लशिंग स्टोरेज (BBU RAID या तेज़ टिकाऊ SSDs) नहीं है, तो आप सक्रिय रूप से लिखने वाले कनेक्शनों की एक छोटी संख्या से अधिक नहीं चाहेंगे, हो सकता है कि अधिकांश 2x पर आपके पास डिस्क की संख्या, शायद RAID व्यवस्था के आधार पर कम हो , डिस्क प्रदर्शन, आदि इस मामले में यह परीक्षण और त्रुटि के लायक भी नहीं है; बस फास्ट डिस्क फ्लश के साथ अपने स्टोरेज सबसिस्टम को अपग्रेड करें ।

pg_test_fsyncएक उपकरण के लिए देखें जो आपको यह निर्धारित करने में मदद करेगा कि क्या यह आपके लिए समस्या हो सकती है। अधिकांश PostgreSQL पैकेज इस उपकरण को कंट्रीब के हिस्से के रूप में स्थापित करते हैं, इसलिए आपको इसे संकलित करने की आवश्यकता नहीं है। यदि आपको कुछ हज़ार से कम ops / सेकंड मिलते हैं, तो pg_test_fsyncआपको तुरंत अपने स्टोरेज सिस्टम को अपग्रेड करने की आवश्यकता है। मेरे SSD- लैस लैपटॉप को 5000-7000 मिलते हैं। 7200rpm SATA डिस्क और राइट-थ्रू (नॉन-राइट-कैशिंग) के 4-डिस्क RAID 10 सरणी के साथ काम पर मेरा वर्कस्टेशन लगभग 80 ऑप्स / सेकंड में f_datasync, नीचे 20 ऑप्स / सेकंड के लिए मिलता है fsync(); यह सैकड़ों गुना धीमा है । तुलना करें: ssd बनाम वर्कस्टेशन वाला लैपटॉप राइट-थ्रू (नॉन-राइट-कैशिंग) RAID 10 के साथ। यह लैपटॉप का एसएसडी सस्ता है और मुझे पॉवर-लॉस पर इसके राइट कैश को फ्लश करने के लिए जरूरी नहीं है; मैं अच्छा बैकअप रखता हूं और डेटा के लिए इसका उपयोग नहीं करता हूं जिसकी मुझे परवाह है। अच्छी गुणवत्ता वाले SSD केवल बेहतर नहीं होने पर भी बेहतर प्रदर्शन करते हैं और लिखते हैं।

आपके आवेदन के मामले में, मैं आपको दृढ़तापूर्वक सलाह देता हूं कि आप इस पर गौर करें:

• तेज फ्लश के साथ एक अच्छा भंडारण उपतंत्र। मैं इस पर अधिक जोर नहीं दे सकता हूं। अच्छी गुणवत्ता वाली बिजली-विफल-सुरक्षित SSDs और / या शक्ति-संरक्षित राइट-बैक कैश के साथ एक RAID नियंत्रक।
• UNLOGGEDडेटा के लिए तालिकाओं का उपयोग करना आप खो सकते हैं। समय-समय पर इसे लॉग इन तालिकाओं में संयोजित करें। उदाहरण के लिए, अनलोड टेबल में गेम्स-इन-प्रोग्रेस रखें और स्कोर को साधारण टिकाऊ टेबल पर लिखें।
• commit_delayकम उपयोग करना (फास्ट-फ्लशिंग स्टोरेज के साथ कम उपयोगी - संकेत)
• synchronous_commitलेन-देन के लिए आप बंद कर सकते हैं खोने के लिए (तेजी से फ्लशिंग भंडारण के साथ कम उपयोगी - संकेत संकेत)
• विभाजन तालिकाएं, विशेष रूप से तालिकाओं जहां डेटा "बाहर उम्र" और साफ किया जाता है। एक विभाजन तालिका से हटाने के बजाय, एक विभाजन को छोड़ दें।
• आंशिक सूचकांक
• आपके द्वारा बनाए गए अनुक्रमित की संख्या को कम करना। हर इंडेक्स में एक लेखन लागत होती है।
• बड़े लेन-देन में बैचिंग का काम
• मुख्य डीबी से रीड लोड लेने के लिए रीड-ओनली हॉट स्टैंडबाय प्रतिकृतियों का उपयोग करना
• एक कैशिंग लेयर का उपयोग करना, जैसे कि डेटा के लिए मेम्केड या रेडिस जो कम बार बदलता है या बासी हो सकता है। आप PostgreSQL तालिकाओं पर ट्रिगर का उपयोग करके कैश अमान्यता का उपयोग कर सकते हैं LISTENऔर कर सकते हैं NOTIFY।

यदि संदेह में: http://www.postgresql.org/support/professional_support/