ਜ਼ੈਬਿਕਸ ਆਈਟਮ ਪ੍ਰੋਟੋਟਾਈਪ ਗਲਤੀਆਂ ਨੂੰ ਹੱਲ ਕਰਨਾ: ਪ੍ਰੌਕਸਮੌਕਸ ਵੀਈ ਮੈਮੋਰੀ ਵਰਤੋਂ ਨਿਗਰਾਨੀ

Proxmox VE ਨਿਗਰਾਨੀ ਲਈ ਜ਼ੈਬਿਕਸ ਪ੍ਰੋਟੋਟਾਈਪ ਗਲਤੀਆਂ ਨੂੰ ਸਮਝਣਾ

ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ ਜ਼ੈਬਿਕਸ ਸਿਸਟਮ ਨਿਗਰਾਨੀ ਲਈ, ਉਪਭੋਗਤਾ ਅਕਸਰ ਖਾਸ ਮੈਟ੍ਰਿਕਸ ਨੂੰ ਟਰੈਕ ਕਰਨ ਲਈ ਆਈਟਮ ਪ੍ਰੋਟੋਟਾਈਪ ਨੂੰ ਅਨੁਕੂਲਿਤ ਕਰਦੇ ਹਨ। ਦੇ ਨਾਲ ਇੱਕ ਆਮ ਏਕੀਕਰਣ ਹੈ Proxmox VE HTTP ਦੁਆਰਾ, ਜਿੱਥੇ ਪਹਿਲਾਂ ਤੋਂ ਪਰਿਭਾਸ਼ਿਤ ਟੈਂਪਲੇਟ ਸਰਵਰ ਦੀ ਸਿਹਤ ਦੀ ਨਿਗਰਾਨੀ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦੇ ਹਨ। ਹਾਲਾਂਕਿ, ਨਵੀਂ ਆਈਟਮ ਪ੍ਰੋਟੋਟਾਈਪ ਬਣਾਉਣ ਨਾਲ ਕਈ ਵਾਰ ਗਲਤੀਆਂ ਹੋ ਸਕਦੀਆਂ ਹਨ।

Zabbix 7.0.4 ਵਿੱਚ, ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਕਸਟਮ ਆਈਟਮ ਪ੍ਰੋਟੋਟਾਈਪ ਬਣਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਸਮੇਂ ਗਲਤੀਆਂ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪਿਆ ਹੈ। ਖਾਸ ਤੌਰ 'ਤੇ, ਲਈ ਮੈਮੋਰੀ ਵਰਤੋਂ ਪ੍ਰਤੀਸ਼ਤ ਦੀ ਗਣਨਾ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਸਮੇਂ ਇੱਕ ਮੁੱਦਾ ਪੈਦਾ ਹੁੰਦਾ ਹੈ Proxmox VE ਨੋਡਸ. ਇਹ ਨਿਰਾਸ਼ਾਜਨਕ ਹੋ ਸਕਦਾ ਹੈ, ਖਾਸ ਕਰਕੇ ਜਦੋਂ ਬਿਲਟ-ਇਨ ਟੈਂਪਲੇਟ ਇੱਕ ਸ਼ੁਰੂਆਤੀ ਬਿੰਦੂ ਦੀ ਪੇਸ਼ਕਸ਼ ਕਰਦੇ ਹਨ ਪਰ ਕਸਟਮ ਗਣਨਾਵਾਂ ਲਈ ਸਮਾਯੋਜਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।

ਇਹਨਾਂ ਤਰੁੱਟੀਆਂ ਦੇ ਕਾਰਨ ਨੂੰ ਸਮਝਣਾ ਕਾਰਗੁਜ਼ਾਰੀ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ ਕਿ ਮੈਟ੍ਰਿਕਸ ਸਹੀ ਡੇਟਾ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ। ਸਮੱਸਿਆ ਨਾ ਸਿਰਫ਼ ਮੈਮੋਰੀ ਨਿਗਰਾਨੀ 'ਤੇ ਅਸਰ ਪਾਉਂਦੀ ਹੈ ਬਲਕਿ ਹੋਰ ਨਾਜ਼ੁਕ ਖੇਤਰਾਂ ਜਿਵੇਂ ਕਿ ਫਾਈਲਸਿਸਟਮ ਵਰਤੋਂ, ਜੋ ਕਿ ਇਸ ਲਈ ਜ਼ਰੂਰੀ ਹੈ, ਨੂੰ ਵਧਾ ਸਕਦੀ ਹੈ। ਗ੍ਰਾਫਾਨਾ ਡੈਸ਼ਬੋਰਡ ਅਤੇ ਚੇਤਾਵਨੀ ਸਿਸਟਮ.

ਇਸ ਲੇਖ ਵਿੱਚ, ਅਸੀਂ ਇਹਨਾਂ ਜ਼ੈਬਿਕਸ ਗਲਤੀਆਂ ਦੇ ਮੂਲ ਕਾਰਨ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਹੱਲ ਕਰਨ ਦੇ ਤਰੀਕੇ ਦੀ ਪੜਚੋਲ ਕਰਾਂਗੇ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਅਸੀਂ Proxmox VE ਵਿੱਚ ਮੈਮੋਰੀ ਅਤੇ ਫਾਈਲਸਿਸਟਮ ਗਣਨਾਵਾਂ ਲਈ ਇੱਕ ਕਾਰਜਸ਼ੀਲ ਫਾਰਮੂਲਾ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਾਂਗੇ, ਜਿਸ ਨਾਲ Grafana ਅਤੇ ਸੁਧਰੇ ਹੋਏ ਅਲਰਟ ਕੌਂਫਿਗਰੇਸ਼ਨਾਂ ਦੇ ਨਾਲ ਸੁਚਾਰੂ ਏਕੀਕਰਣ ਦੀ ਆਗਿਆ ਮਿਲੇਗੀ।

Proxmox VE ਮੈਮੋਰੀ ਨਿਗਰਾਨੀ ਲਈ Zabbix API ਸਕ੍ਰਿਪਟ ਦੀ ਵਿਸਤ੍ਰਿਤ ਸੰਖੇਪ ਜਾਣਕਾਰੀ

ਪ੍ਰਦਾਨ ਕੀਤੀ ਗਈ ਸਕ੍ਰਿਪਟ ਵਿੱਚ, ਮੁੱਖ ਉਦੇਸ਼ ਵਿੱਚ ਮੈਮੋਰੀ ਵਰਤੋਂ ਦੀ ਨਿਗਰਾਨੀ ਕਰਨ ਲਈ ਇੱਕ ਨਵੀਂ ਆਈਟਮ ਪ੍ਰੋਟੋਟਾਈਪ ਬਣਾਉਣ ਲਈ ਜ਼ੈਬਿਕਸ API ਨਾਲ ਗੱਲਬਾਤ ਕਰਨਾ ਹੈ Proxmox VE. ਸਕ੍ਰਿਪਟ ਪ੍ਰੌਕਸਮੌਕਸ ਵਾਤਾਵਰਣ ਵਿੱਚ ਖਾਸ ਨੋਡਾਂ ਲਈ ਮੈਮੋਰੀ ਡੇਟਾ ਨੂੰ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਨ ਅਤੇ ਵਰਤੀ ਜਾ ਰਹੀ ਮੈਮੋਰੀ ਦੀ ਪ੍ਰਤੀਸ਼ਤਤਾ ਦੀ ਗਣਨਾ ਕਰਨ ਲਈ ਜ਼ੈਬਿਕਸ API ਦੀਆਂ ਸਮਰੱਥਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ। ਪ੍ਰਕਿਰਿਆ ਇੱਕ ਲੌਗਿਨ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਜ਼ੈਬਿਕਸ ਸਰਵਰ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਦੇ ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦੀ ਹੈ ਜੋ ਇੱਕ ਸੈਸ਼ਨ ID ਤਿਆਰ ਕਰਦਾ ਹੈ। ਇਹ ਸੈਸ਼ਨ ID ਮਹੱਤਵਪੂਰਨ ਹੈ, ਕਿਉਂਕਿ ਇਹ ਸਾਰੀਆਂ ਅਗਲੀਆਂ API ਕਾਲਾਂ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਕੰਮ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਉਪਭੋਗਤਾ ਪ੍ਰਮਾਣਿਤ ਹੈ।

ਸਫਲਤਾਪੂਰਵਕ ਲੌਗਇਨ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਸਕ੍ਰਿਪਟ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ item.get Proxmox ਨੋਡਸ ਤੋਂ ਮੈਮੋਰੀ ਵਰਤੋਂ ਡੇਟਾ ਨੂੰ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ API ਵਿਧੀ। ਇਹ ਕਮਾਂਡ ਖਾਸ ਤੌਰ 'ਤੇ "memused" ਅਤੇ "memtotal" ਵਰਗੇ ਮੈਮੋਰੀ ਮੈਟ੍ਰਿਕਸ ਦੀ ਪੁੱਛਗਿੱਛ ਲਈ ਤਿਆਰ ਕੀਤੀ ਗਈ ਹੈ। ਇਹਨਾਂ ਮੁੱਲਾਂ ਨੂੰ ਐਕਸਟਰੈਕਟ ਕਰਕੇ, ਸਕ੍ਰਿਪਟ ਇੱਕ ਸਧਾਰਨ ਡਿਵੀਜ਼ਨ ਫਾਰਮੂਲਾ ਲਾਗੂ ਕਰਕੇ ਵਰਤੀ ਗਈ ਮੈਮੋਰੀ ਦੀ ਪ੍ਰਤੀਸ਼ਤਤਾ ਦੀ ਗਣਨਾ ਕਰ ਸਕਦੀ ਹੈ। ਇਹ ਵਿਧੀ ਨਾ ਸਿਰਫ਼ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਮੈਮੋਰੀ ਨਿਗਰਾਨੀ ਲਈ ਇੱਕ ਆਈਟਮ ਪ੍ਰੋਟੋਟਾਈਪ ਬਣਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ ਬਲਕਿ ਇਸ ਤਰਕ ਨੂੰ ਹੋਰ ਖੇਤਰਾਂ ਜਿਵੇਂ ਕਿ ਫਾਈਲਸਿਸਟਮ ਵਰਤੋਂ, ਚੇਤਾਵਨੀਆਂ ਪੈਦਾ ਕਰਨ ਲਈ ਗ੍ਰਾਫਾਨਾ ਵਰਗੇ ਸਿਸਟਮਾਂ ਵਿੱਚ ਮਦਦ ਕਰਨ ਲਈ ਲਚਕਤਾ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ।

ਸਕ੍ਰਿਪਟ ਦੇ ਮੁੱਖ ਪਹਿਲੂਆਂ ਵਿੱਚੋਂ ਇੱਕ ਪਾਈਥਨ ਦੀ ਵਰਤੋਂ ਹੈ ਬੇਨਤੀਆਂ ਲਾਇਬ੍ਰੇਰੀ, ਜੋ ਸਕ੍ਰਿਪਟ ਅਤੇ ਜ਼ੈਬਿਕਸ API ਵਿਚਕਾਰ ਸੰਚਾਰ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦੀ ਹੈ। ਬੇਨਤੀਆਂ ਦੀ ਲਾਇਬ੍ਰੇਰੀ API ਨੂੰ HTTP POST ਬੇਨਤੀਆਂ ਕਰਦੀ ਹੈ, ਪ੍ਰਮਾਣੀਕਰਨ ਅਤੇ ਡਾਟਾ ਪ੍ਰਾਪਤੀ ਵਰਗੇ ਕੰਮਾਂ ਲਈ JSON ਡੇਟਾ ਭੇਜਦੀ ਹੈ। ਇੱਕ ਹੋਰ ਮਹੱਤਵਪੂਰਨ ਪਹਿਲੂ JSON ਜਵਾਬਾਂ ਦਾ ਪਾਈਥਨ-ਪੜ੍ਹਨ ਯੋਗ ਫਾਰਮੈਟਾਂ ਵਿੱਚ ਰੂਪਾਂਤਰਨ ਹੈ। ਦੁਆਰਾ ਇਹ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ json.dumps() ਫੰਕਸ਼ਨ, ਜੋ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਜ਼ੈਬਿਕਸ ਨੂੰ ਭੇਜਿਆ ਗਿਆ ਡੇਟਾ ਸਹੀ ਢੰਗ ਨਾਲ ਫਾਰਮੈਟ ਕੀਤਾ ਗਿਆ ਹੈ। ਇੱਕ ਵਾਰ ਮੈਮੋਰੀ ਵਰਤੋਂ ਡੇਟਾ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਪਾਈਥਨ ਦਾ ਫਲੋਟ() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਗਣਨਾ ਵਿੱਚ ਸੰਖਿਆਤਮਕ ਸ਼ੁੱਧਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

ਅੰਤ ਵਿੱਚ, ਸਕ੍ਰਿਪਟ ਨੂੰ ਮਾਡਿਊਲਰਿਟੀ ਅਤੇ ਗਲਤੀ ਨਾਲ ਨਜਿੱਠਣ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖ ਕੇ ਬਣਾਇਆ ਗਿਆ ਹੈ। ਇਹ ਵੱਖ-ਵੱਖ ਕਿਸਮਾਂ ਦੇ ਡੇਟਾ ਨਿਗਰਾਨੀ ਲਈ ਮੁੜ ਵਰਤੋਂ ਅਤੇ ਅਨੁਕੂਲ ਬਣਾਉਣਾ ਆਸਾਨ ਬਣਾਉਂਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਡਿਸਕ ਸਪੇਸ ਜਾਂ CPU ਵਰਤੋਂ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਨਾਲ ਦਿੱਤਾ ਗਿਆ ਯੂਨਿਟ ਟੈਸਟ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਮੈਮੋਰੀ ਪ੍ਰਤੀਸ਼ਤ ਦੀ ਗਣਨਾ ਕਰਨ ਲਈ ਤਰਕ ਭਰੋਸੇਯੋਗ ਹੈ। ਦ ਯੂਨਿਟ ਟੈਸਟ ਫਰੇਮਵਰਕ ਦੀ ਵਰਤੋਂ ਆਉਟਪੁੱਟ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨ, ਵੱਖ-ਵੱਖ ਮੈਮੋਰੀ ਮੁੱਲਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਕਿ ਗਣਨਾ ਉਮੀਦ ਕੀਤੇ ਨਤੀਜਿਆਂ ਨਾਲ ਮੇਲ ਖਾਂਦੀ ਹੈ। ਇੱਕ ਸਥਿਰ ਨਿਗਰਾਨੀ ਪ੍ਰਣਾਲੀ ਨੂੰ ਬਣਾਈ ਰੱਖਣ ਲਈ ਟੈਸਟਿੰਗ 'ਤੇ ਇਹ ਜ਼ੋਰ ਮਹੱਤਵਪੂਰਨ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ ਜਦੋਂ ਗ੍ਰਾਫਾਨਾ ਵਰਗੇ ਸਾਧਨਾਂ ਨਾਲ ਏਕੀਕ੍ਰਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜੋ ਵਿਜ਼ੂਅਲਾਈਜ਼ੇਸ਼ਨਾਂ ਅਤੇ ਚੇਤਾਵਨੀ ਸੰਰਚਨਾਵਾਂ ਲਈ ਸਹੀ ਡੇਟਾ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹਨ।

import requests
import json
from requests.auth import HTTPBasicAuth
# Zabbix API and authentication details
ZABBIX_URL = 'https://your-zabbix-url/api_jsonrpc.php'
USERNAME = 'your_username'
PASSWORD = 'your_password'
# Function to login and retrieve session ID
def zabbix_login():
    headers = {'Content-Type': 'application/json'}
    payload = {
        "jsonrpc": "2.0",
        "method": "user.login",
        "params": {"user": USERNAME, "password": PASSWORD},
        "id": 1
    }
    response = requests.post(ZABBIX_URL, headers=headers, data=json.dumps(payload))
    return response.json()['result']

def get_memory_usage(session_id, host_id):
    headers = {'Content-Type': 'application/json'}
    payload = {
        "jsonrpc": "2.0",
        "method": "item.get",
        "params": {
            "output": ["itemid", "lastvalue"],
            "hostids": host_id,
            "search": {"key_": "proxmox.node.memused"},
        },
        "auth": session_id,
        "id": 2
    }
    response = requests.post(ZABBIX_URL, headers=headers, data=json.dumps(payload))
    mem_used = float(response.json()['result'][0]['lastvalue'])
    payload["search"] = {"key_": "proxmox.node.memtotal"}
    response = requests.post(ZABBIX_URL, headers=headers, data=json.dumps(payload))
    mem_total = float(response.json()['result'][0]['lastvalue'])
    mem_percent = (mem_used / mem_total) * 100
    return mem_percent

import unittest
class TestMemoryCalculation(unittest.TestCase):
    def test_memory_percentage(self):
        mem_used = 2048
        mem_total = 4096
        expected_percentage = 50.0
        actual_percentage = (mem_used / mem_total) * 100
        self.assertEqual(expected_percentage, actual_percentage)
if __name__ == '__main__':
    unittest.main()

ਵਿਸਤ੍ਰਿਤ ਪ੍ਰੌਕਸਮੌਕਸ ਨਿਗਰਾਨੀ ਲਈ ਜ਼ੈਬਿਕਸ ਪ੍ਰੋਟੋਟਾਈਪਾਂ ਨੂੰ ਅਨੁਕੂਲਿਤ ਕਰਨਾ

ਵਿਚ ਨਵੀਂ ਆਈਟਮ ਪ੍ਰੋਟੋਟਾਈਪ ਬਣਾਉਂਦੇ ਸਮੇਂ ਇਕ ਹੋਰ ਨਾਜ਼ੁਕ ਪਹਿਲੂ ਜ਼ੈਬਿਕਸ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰ ਰਿਹਾ ਹੈ ਕਿ ਗਣਨਾ ਕੀਤਾ ਡੇਟਾ ਸਹੀ ਰਹੇ ਅਤੇ ਵੱਡੇ ਪੈਮਾਨੇ ਦੀ ਨਿਗਰਾਨੀ ਲਈ ਅਨੁਕੂਲਿਤ ਰਹੇ। ਮੁੱਖ ਚੁਣੌਤੀ ਨਿਗਰਾਨੀ ਵਾਤਾਵਰਣਾਂ ਦੀ ਗਤੀਸ਼ੀਲ ਪ੍ਰਕਿਰਤੀ ਨੂੰ ਸੰਭਾਲਣਾ ਹੈ Proxmox VE, ਜਿੱਥੇ ਸਰੋਤ ਵੰਡ ਅਤੇ ਵਰਤੋਂ ਵੱਖ-ਵੱਖ ਨੋਡਾਂ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਤੌਰ 'ਤੇ ਵੱਖ-ਵੱਖ ਹੋ ਸਕਦੇ ਹਨ। ਇਸ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ, ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਨਿਰੀਖਣ ਆਈਟਮਾਂ ਦੀ ਖੋਜ ਅਤੇ ਸਿਰਜਣਾ ਨੂੰ ਸਵੈਚਲਿਤ ਕਰਨ ਲਈ ਘੱਟ-ਪੱਧਰੀ ਖੋਜ (LLD) ਦੀ ਵਰਤੋਂ ਕਰਨ 'ਤੇ ਵਿਚਾਰ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ। ਇਹ ਜ਼ੈਬਿਕਸ ਨੂੰ ਮੈਨੂਅਲ ਕੌਂਫਿਗਰੇਸ਼ਨਾਂ ਦੀ ਲੋੜ ਨੂੰ ਘੱਟ ਕਰਦੇ ਹੋਏ, ਸਾਰੇ ਨੋਡਾਂ ਅਤੇ ਉਹਨਾਂ ਦੀ ਮੈਮੋਰੀ ਵਰਤੋਂ ਨੂੰ ਆਪਣੇ ਆਪ ਲੱਭਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਸਹੀ ਸਥਾਪਨਾ ਟਰਿੱਗਰ ਕਿਰਿਆਸ਼ੀਲ ਸਿਸਟਮ ਪ੍ਰਬੰਧਨ ਲਈ ਮੈਮੋਰੀ ਵਰਤੋਂ ਥ੍ਰੈਸ਼ਹੋਲਡ ਦੇ ਆਧਾਰ 'ਤੇ ਚੇਤਾਵਨੀ ਦੇਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ। ਟਰਿਗਰਸ ਨੂੰ ਚੇਤਾਵਨੀ ਦੇਣ ਲਈ ਅਨੁਕੂਲਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਜਦੋਂ ਮੈਮੋਰੀ ਦੀ ਵਰਤੋਂ ਇੱਕ ਨਿਸ਼ਚਿਤ ਪ੍ਰਤੀਸ਼ਤ ਤੱਕ ਪਹੁੰਚ ਜਾਂਦੀ ਹੈ, ਪ੍ਰਬੰਧਕਾਂ ਨੂੰ ਸਰੋਤ ਥਕਾਵਟ ਨੂੰ ਰੋਕਣ ਵਿੱਚ ਮਦਦ ਕਰਦੇ ਹਨ। ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ ਮੈਮੋਰੀ ਦੀ ਵਰਤੋਂ 80% ਤੋਂ ਵੱਧ ਜਾਂਦੀ ਹੈ ਤਾਂ ਚੇਤਾਵਨੀਆਂ ਨੂੰ ਟਰਿੱਗਰ ਕਰਨ ਲਈ ਸੈਟ ਅਪ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਪ੍ਰਸ਼ਾਸਕ ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰ ਸਕਦੇ ਹਨ। ਇਹ ਟਰਿਗਰਸ, ਵਿਜ਼ੂਅਲਾਈਜ਼ੇਸ਼ਨ ਲਈ ਗ੍ਰਾਫਾਨਾ ਦੇ ਨਾਲ ਮਿਲ ਕੇ, ਇੱਕ ਵਿਆਪਕ ਨਿਗਰਾਨੀ ਹੱਲ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ ਜੋ ਅਸਲ ਸਮੇਂ ਵਿੱਚ ਸਰੋਤਾਂ ਦੀ ਵਰਤੋਂ 'ਤੇ ਨਜ਼ਰ ਰੱਖਦਾ ਹੈ।

ਅੰਤ ਵਿੱਚ, ਕਾਰਜਕੁਸ਼ਲਤਾ ਓਪਟੀਮਾਈਜੇਸ਼ਨ ਦੀ ਵਰਤੋਂ ਵੀ ਸ਼ਾਮਲ ਹੈ ਕੁੱਲ ਫੰਕਸ਼ਨ ਮਲਟੀਪਲ ਨੋਡਸ ਤੋਂ ਮੈਮੋਰੀ ਡੇਟਾ ਨੂੰ ਸੰਖੇਪ ਕਰਨ ਲਈ ਜ਼ੈਬਿਕਸ ਵਿੱਚ। ਇਹ ਖਾਸ ਤੌਰ 'ਤੇ ਵਾਤਾਵਰਨ ਵਿੱਚ ਲਾਭਦਾਇਕ ਹੋ ਸਕਦਾ ਹੈ ਜਿੱਥੇ ਕਈ ਪ੍ਰੌਕਸਮੌਕਸ ਨੋਡ ਇੱਕੋ ਸਰੋਤ ਸਾਂਝੇ ਕਰਦੇ ਹਨ। ਡੇਟਾ ਨੂੰ ਇਕੱਠਾ ਕਰਨਾ ਸਿਸਟਮ ਦੀ ਸਿਹਤ ਦੇ ਵਧੇਰੇ ਸੰਪੂਰਨ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਘੱਟ ਕਾਰਗੁਜ਼ਾਰੀ ਵਾਲੇ ਨੋਡਾਂ ਦਾ ਪਤਾ ਲਗਾਉਣਾ ਆਸਾਨ ਹੋ ਜਾਂਦਾ ਹੈ। ਜਦੋਂ Grafana ਵਰਗੇ ਥਰਡ-ਪਾਰਟੀ ਟੂਲਸ ਨਾਲ ਏਕੀਕ੍ਰਿਤ ਕਰਨ ਦੀ ਜ਼ੈਬਿਕਸ ਦੀ ਯੋਗਤਾ ਨਾਲ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ ਹੱਲ ਗੁੰਝਲਦਾਰ ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਦੀ ਕੁਸ਼ਲਤਾ ਨਾਲ ਨਿਗਰਾਨੀ ਕਰਨ ਲਈ ਇੱਕ ਮਜ਼ਬੂਤ ​​ਫਰੇਮਵਰਕ ਬਣਾਉਂਦੇ ਹਨ।