Prometheus இல் கேச் த்ரோபுட் அளவீடுகளை மேம்படுத்துதல்

கேச் செயல்திறன் கண்காணிப்பு: சவால்கள் மற்றும் தீர்வுகள்

உங்கள் பயன்பாட்டில் ஒரு புதிய அம்சத்தைப் பயன்படுத்துவதை கற்பனை செய்து பாருங்கள், கேச் சேவை பயனீட்டாளர் அனுபவத்தைப் பாதிக்கும் என்பதை பின்னர் கண்டறியலாம். 📉 எந்த டெவலப்பரும் எதிர்கொள்ள விரும்பாத காட்சி இது. அளவீடுகள் அத்தகைய சிக்கல்களை அடையாளம் காண உதவ வேண்டும், ஆனால் சில நேரங்களில், அவை தெளிவை விட அதிக குழப்பத்தை உருவாக்கலாம்.

எடுத்துக்காட்டாக, கேச் சேவையைக் கையாளும் படித்தல்/எழுதுதல் என்ற எனது சமீபத்திய பணியில், காலப்போக்கில் செயல்திறனைக் கண்காணிக்கும் போது நான் சவால்களை எதிர்கொண்டேன். மொத்த குறியீடுகள் மற்றும் தாமதத்திற்கான கவுண்டர்கள் போன்ற அளவீடுகள் இருந்தபோதிலும், எனது PromQL வினவல்கள் மிகவும் கொந்தளிப்பான விளக்கப்படங்களை அளித்தன. அர்த்தமுள்ள முடிவுகளை எடுப்பது கிட்டத்தட்ட சாத்தியமற்றது.

இது எனக்கு ஆச்சரியத்தை ஏற்படுத்தியது—இது எனது அளவீடுகளின் தேர்வா, நான் தரவை ஒருங்கிணைக்கும் விதமா அல்லது முற்றிலும் வேறு ஏதாவதுதா? இதே போன்ற PromQL சிக்கல்களில் நீங்கள் எப்போதாவது போராடியிருந்தால் அல்லது உங்கள் அளவீடுகள் போதுமானதாக இல்லை எனில், செயல்திறன் தடைகளை சரிசெய்வது எவ்வளவு ஏமாற்றமளிக்கும் என்பதை நீங்கள் அறிவீர்கள்.

இந்த கட்டுரையில், இந்த சிக்கலைக் கண்டறிவதற்கான எனது அணுகுமுறையை நான் உங்களுக்குக் கூறுவேன். PromQL வினவல்களுக்கான நடைமுறை மாற்றங்களை நாங்கள் ஆராய்வோம் மற்றும் நம்பகமான கேச் த்ரோபுட் அளவீடுகளை உருவாக்குவது பற்றிய நுண்ணறிவுகளைப் பகிர்வோம். நீங்கள் அனுபவமுள்ள DevOps இன்ஜினியராக இருந்தாலும் அல்லது ப்ரோமிதியஸில் மூழ்கினாலும், இந்த உதவிக்குறிப்புகள் உங்கள் கண்காணிப்பு அமைப்பில் நிலைத்தன்மையைக் கொண்டுவர உதவும். 🚀

மேக்கிங் சென்ஸ் ஆஃப் மெட்ரிக்ஸ்: இந்த ஸ்கிரிப்ட்கள் எப்படி வேலை செய்கின்றன

பைத்தானில் எழுதப்பட்ட முதல் ஸ்கிரிப்ட், ப்ரோமிதியஸ் கிளையன்ட் லைப்ரரியைப் பயன்படுத்தி கேச் த்ரோபுட்டை அளவிட வடிவமைக்கப்பட்டுள்ளது. இந்த ஸ்கிரிப்ட் இரண்டு அளவீடுகளை வரையறுக்கிறது: ஒன்று வாசிப்பு செயல்பாடுகளுக்கும் மற்றொன்று எழுதும் செயல்பாடுகளுக்கும். இந்த அளவீடுகள் வகையிலானவை சுருக்கம், எடுக்கப்பட்ட மொத்த நேரத்தையும் நிகழ்வுகளின் எண்ணிக்கையையும் கண்காணிக்க உதவுகிறது. ஒவ்வொரு செயல்பாடும் ஒரு சீரற்ற தாமதத்துடன் உருவகப்படுத்தப்படுகிறது, கேச் செயல்பாடுகள் மாறி தாமதங்களைக் கொண்டிருக்கும் நிஜ உலகக் காட்சிகளைப் பிரதிபலிக்கிறது. ஸ்கிரிப்ட் இந்த அளவீடுகளை வெளிப்படுத்த போர்ட் 8000 இல் உள்ளூர் HTTP சேவையகத்தைத் தொடங்குகிறது, இது ப்ரோமிதியஸ் தரவை ஸ்கிராப் செய்ய உதவுகிறது. நேரடி பயன்பாடுகளைக் கண்காணிப்பதற்கும் புதிய வரிசைப்படுத்தல்கள் தற்காலிக சேமிப்பை எவ்வாறு பாதிக்கின்றன என்பதைப் புரிந்துகொள்வதற்கும் இந்த அமைப்பு சிறந்தது. 🚀

இரண்டாவது ஸ்கிரிப்ட் ஜாவாஸ்கிரிப்ட் மற்றும் Chart.js ப்ரோமிதியஸ் தரவை மாறும் வகையில் காட்சிப்படுத்த. Fetch API ஐப் பயன்படுத்தி பைதான் சேவையகத்திலிருந்து அளவீடுகளைப் பெறுவதன் மூலம் இது தொடங்குகிறது. மூல உரைத் தரவு ஒரு கட்டமைக்கப்பட்ட வடிவத்தில் பாகுபடுத்தப்படுகிறது, வாசிப்பு மற்றும் எழுதுதல் செயல்திறன் போன்ற குறிப்பிட்ட அளவீடுகளைப் பிரித்தெடுக்கிறது. இந்தத் தரவு பின்னர் Chart.js ஐப் பயன்படுத்தி ஒரு வரி வரைபடத்தில் கொடுக்கப்படுகிறது. விளக்கப்படத்தை அவ்வப்போது புதுப்பிப்பதன் மூலம், டெவலப்பர்கள் கேச் செயல்திறனில் நிகழ்நேரப் போக்குகளை அவதானிக்க முடியும். எடுத்துக்காட்டாக, ஒரு அம்சத்தைப் பயன்படுத்திய பிறகு தாமதத்தின் அதிகரிப்பு ஏற்பட்டால், இந்த காட்சிப்படுத்தல் அதை உடனடியாக கவனிக்க வைக்கிறது. 📈

யூனிட் டெஸ்டிங் என்பது தீர்வின் மற்றொரு முக்கிய அம்சமாகும், பைதான் ஸ்கிரிப்ட்டில் இதைப் பயன்படுத்தி நிரூபிக்கப்பட்டுள்ளது. அலகு சோதனை கட்டமைப்பு. இது உருவாக்கப்படும் அளவீடுகளின் நம்பகத்தன்மையை உறுதி செய்கிறது. எடுத்துக்காட்டாக, செயல்பாடுகளைச் செய்யும்போது அளவீடுகள் சரியாகப் புதுப்பிக்கப்படுகிறதா என்பதைச் சோதனைகள் சரிபார்க்கின்றன. வாசிப்பு மற்றும் எழுதுதல் செயல்திறன் அளவீடுகள் இரண்டையும் சரிபார்ப்பதன் மூலம், டெவலப்பர்கள் செயல்திறன் பகுப்பாய்விற்காக வெளிப்படும் தரவை நம்பிக்கையுடன் நம்பலாம். இந்த சோதனைகள் பிழைகளை முன்கூட்டியே கண்டறிய உதவுகின்றன, கண்காணிப்பு அமைப்பு உற்பத்திக்கு பயன்படுத்தப்படுவதற்கு முன்பு எதிர்பார்த்தபடி செயல்படுவதை உறுதி செய்கிறது.

நடைமுறை அடிப்படையில், இந்த ஸ்கிரிப்ட்கள் கேச் செயல்திறன் செயல்திறனை அளவிட, காட்சிப்படுத்த மற்றும் சரிபார்க்க ஒரு விரிவான வழியை வழங்குகிறது. நீங்கள் அதிக அளவு வாசிப்பு/எழுதுதல் செயல்பாடுகளைக் கொண்ட மின்வணிக தளத்தை இயக்குகிறீர்கள் என்று கற்பனை செய்து பாருங்கள். செயல்திறனில் திடீர் வீழ்ச்சியானது கேச்சிங் லேயரில் உள்ள சிக்கலைக் குறிக்கலாம், இது பயனர் அனுபவத்தை பாதிக்கும். இந்த ஸ்கிரிப்ட்களைப் பயன்படுத்தி, இதுபோன்ற சிக்கல்களைக் கண்டறிந்து விரைவாகத் தீர்க்க நம்பகமான கண்காணிப்பு அமைப்பை நீங்கள் அமைக்கலாம். நீங்கள் உள்ளூர் சூழலில் அளவீடுகளை உருவகப்படுத்தினாலும் அல்லது உற்பத்தியில் அவற்றைப் பயன்படுத்தினாலும், அதிக செயல்திறன் கொண்ட பயன்பாடுகளைப் பராமரிக்க இந்தக் கருவிகள் அவசியம். 💡

# Import necessary libraries
from prometheus_client import Summary, start_http_server
import random
import time

# Define Prometheus metrics for tracking throughput
cache_write_throughput = Summary('cache_write_throughput', 'Write throughput in cache')
cache_read_throughput = Summary('cache_read_throughput', 'Read throughput in cache')

# Simulate cache read/write operations
def cache_operations():
    while True:
        # Simulate a write operation
        with cache_write_throughput.time():
            time.sleep(random.uniform(0.1, 0.3))  # Simulated latency

        # Simulate a read operation
        with cache_read_throughput.time():
            time.sleep(random.uniform(0.05, 0.15))  # Simulated latency

# Start the Prometheus metrics server
if __name__ == "__main__":
    start_http_server(8000)  # Expose metrics at localhost:8000
    print("Prometheus metrics server running on port 8000")
    cache_operations()

// Include the Chart.js library in your HTML
// Fetch Prometheus metrics using Fetch API
async function fetchMetrics() {
    const response = await fetch('http://localhost:8000/metrics');
    const data = await response.text();
    return parseMetrics(data);
}

// Parse Prometheus metrics into a usable format
function parseMetrics(metrics) {
    const lines = metrics.split('\\n');
    const parsedData = {};
    lines.forEach(line => {
        if (line.startsWith('cache_write_throughput') || line.startsWith('cache_read_throughput')) {
            const [key, value] = line.split(' ');
            parsedData[key] = parseFloat(value);
        }
    });
    return parsedData;
}

// Update Chart.js graph with new data
function updateChart(chart, metrics) {
    chart.data.datasets[0].data.push(metrics.cache_write_throughput);
    chart.data.datasets[1].data.push(metrics.cache_read_throughput);
    chart.update();
}

import unittest
from prometheus_client import Summary

# Define dummy metrics for testing
class TestPrometheusMetrics(unittest.TestCase):
    def setUp(self):
        self.write_metric = Summary('cache_write_test', 'Write throughput test')
        self.read_metric = Summary('cache_read_test', 'Read throughput test')

    def test_write_throughput(self):
        with self.write_metric.time():
            time.sleep(0.1)
        self.assertGreater(self.write_metric._sum.get(), 0)

    def test_read_throughput(self):
        with self.read_metric.time():
            time.sleep(0.05)
        self.assertGreater(self.read_metric._sum.get(), 0)

if __name__ == "__main__":
    unittest.main()

ப்ரோமிதியஸ் அளவீடுகளில் நிலையற்ற தன்மையைப் புரிந்துகொள்வது

கண்காணிப்பு அமைப்புகளின் ஒரு முக்கியமான அம்சம் அளவீட்டுத் தரவின் நிலையற்ற தன்மையை நிர்வகிப்பது. ப்ரோமிதியஸில் உள்ள வாசிப்பு/எழுது செயல்திறன் போன்ற அளவீடுகளை பகுப்பாய்வு செய்யும் போது, ​​அதிக கொந்தளிப்பான விளக்கப்படங்கள் போக்குகளை மறைத்து, செயல்திறன் சிதைவுகளைக் கண்டறிவதை கடினமாக்கும். அதிகப்படியான சிறுமணி நேர வரம்புகளைப் பயன்படுத்துவதிலிருந்தோ அல்லது ஒருங்கிணைக்க தவறான அளவீடுகளைத் தேர்ந்தெடுப்பதிலிருந்தோ அடிக்கடி நிலையற்ற தன்மை எழுகிறது. 1 நிமிட சாளரங்களை மட்டுமே நம்புவதற்குப் பதிலாக, 5 நிமிட இடைவெளி போன்ற பெரிய சாளரங்களில் விகிதங்கள் பயன்படுத்துவதே சிறந்த அணுகுமுறை. இது அர்த்தமுள்ள மாற்றங்களைக் கைப்பற்றும் போது ஏற்ற இறக்கங்களை மென்மையாக்குகிறது. 📊

இந்தச் சிக்கலைத் தீர்ப்பதற்கான மற்றொரு வழி, உங்கள் அளவீடுகளில் பரிமாண லேபிள்களைச் சேர்ப்பதாகும். எடுத்துக்காட்டாக, உங்கள் கேச் அளவீடுகளை `பிராந்தியம்` அல்லது `சேவை` போன்ற லேபிள்களுடன் குறியிடுவது செயல்திறனைப் பற்றிய ஆழமான நுண்ணறிவை அனுமதிக்கிறது. சிக்கலைத் தீர்க்கும்போது இது மிகவும் பயனுள்ளதாக இருக்கும். ஒரு குறிப்பிட்ட பகுதிக்கான `கேச்_ரைட்_த்ரூபுட்` இல் திடீரென ஸ்பைக் இருப்பதைக் கற்பனை செய்து பாருங்கள்; இத்தகைய கிரானுலாரிட்டி பிரச்சனையின் மூலத்தைக் கண்டறிய உதவும். இருப்பினும், நீங்கள் கார்டினலிட்டி-ஐக் கவனத்தில் கொள்ள வேண்டும்—அதிக லேபிள்கள் உங்கள் ப்ரோமிதியஸ் சர்வரை ஓவர்லோட் செய்யலாம்.

காட்சிப்படுத்தலை மேம்படுத்த, கவுண்டர்களுக்குப் பதிலாக ஹிஸ்டோகிராம் அளவீடுகளைப் பயன்படுத்தவும். ஹிஸ்டோகிராம்கள் அளவு அடிப்படையிலான நுண்ணறிவுகளை வழங்குகின்றன (எ.கா., 95வது சதவீதம்) மேலும் அவை ஸ்பைக்குகளுக்கு குறைவாகவே பாதிக்கப்படுகின்றன. உதாரணமாக, `கேச்_ரைட்_லேட்டன்சி`க்கான ஹிஸ்டோகிராம், பெரும்பாலான பயனர்கள் அனுபவிக்கும் வழக்கமான லேட்டன்சியைப் புரிந்து கொள்ள உதவும். விலகல்களுக்கான விழிப்பூட்டல் விதிகளுடன் ஹிஸ்டோகிராம்களை இணைப்பதன் மூலம், எந்தவொரு செயல்திறன் சிதைவும் உடனடியாகக் கொடியிடப்படுவதை உறுதிசெய்யலாம். இந்த முழுமையான அணுகுமுறை நிலையான, செயல்படக்கூடிய கண்காணிப்பை உறுதி செய்கிறது. 🚀