प्रोमेथियस सर्वर से मेट्रिक्स लोड करें

TensorFlow.org पर देखें Google Colab में चलाएं GitHub पर स्रोत देखें नोटबुक डाउनलोड करें

अवलोकन

एक से इस ट्यूटोरियल भार CoreDNS मैट्रिक्स प्रोमेथियस एक में सर्वर tf.data.Dataset , तो का उपयोग करता tf.keras प्रशिक्षण और अनुमान के लिए।

CoreDNS सेवा खोज पर ध्यान देने के साथ एक DNS सर्वर है, और व्यापक रूप से की एक भाग के रूप में तैनात किया जाता है Kubernetes क्लस्टर। इस कारण से यह अक्सर devops संचालन द्वारा बारीकी से निगरानी कर रहा है।

यह ट्यूटोरियल एक उदाहरण है जिसका उपयोग मशीन लर्निंग के माध्यम से अपने संचालन में स्वचालन की तलाश करने वाले देवोप्स द्वारा किया जा सकता है।

सेटअप और उपयोग

आवश्यक टेंसरफ़्लो-आईओ पैकेज स्थापित करें, और रनटाइम को पुनरारंभ करें

import os

try:
  %tensorflow_version 2.x
except Exception:
  pass

TensorFlow 2.x selected.

pip install tensorflow-io

from datetime import datetime

import tensorflow as tf
import tensorflow_io as tfio

CoreDNS और Prometheus को स्थापित और सेटअप करें

डेमो उद्देश्यों के लिए, बंदरगाह के साथ एक CoreDNS सर्वर स्थानीय रूप से 9053 खुला DNS क्वेरी और बंदरगाह प्राप्त करने के लिए 9153 scraping के लिए मैट्रिक्स का पर्दाफाश करने के (defult) खुला। निम्नलिखित CoreDNS के लिए एक बुनियादी Corefile विन्यास है और के लिए उपलब्ध है डाउनलोड :

.:9053 {
  prometheus
  whoami
}

स्थापना के बारे में अधिक जानकारी के लिए CoreDNS के पर पाया जा सकता है प्रलेखन ।

curl -s -OL https://github.com/coredns/coredns/releases/download/v1.6.7/coredns_1.6.7_linux_amd64.tgz
tar -xzf coredns_1.6.7_linux_amd64.tgz

curl -s -OL https://raw.githubusercontent.com/tensorflow/io/master/docs/tutorials/prometheus/Corefile

cat Corefile

.:9053 {
  prometheus
  whoami
}

# Run `./coredns` as a background process.
# IPython doesn't recognize `&` in inline bash cells.
get_ipython().system_raw('./coredns &')

अगले कदम के लिए सेटअप प्रोमेथियस सर्वर से है और बंदरगाह पर संपर्क में हैं कि खरोंच CoreDNS मैट्रिक्स से प्रोमेथियस का उपयोग 9153 से। prometheus.yml विन्यास के लिए फ़ाइल के लिए भी उपलब्ध है डाउनलोड :

curl -s -OL https://github.com/prometheus/prometheus/releases/download/v2.15.2/prometheus-2.15.2.linux-amd64.tar.gz
tar -xzf prometheus-2.15.2.linux-amd64.tar.gz --strip-components=1

curl -s -OL https://raw.githubusercontent.com/tensorflow/io/master/docs/tutorials/prometheus/prometheus.yml

cat prometheus.yml

global:
  scrape_interval:     1s
  evaluation_interval: 1s
alerting:
  alertmanagers:

  - static_configs:
    - targets:
rule_files:
scrape_configs:
- job_name: 'prometheus'
  static_configs:
  - targets: ['localhost:9090']
- job_name: "coredns"
  static_configs:
  - targets: ['localhost:9153']

# Run `./prometheus` as a background process.
# IPython doesn't recognize `&` in inline bash cells.
get_ipython().system_raw('./prometheus &')

आदेश कुछ गतिविधि दिखाने के लिए, dig आदेश CoreDNS सर्वर है कि सेटअप किया गया है के खिलाफ कुछ DNS क्वेरी उत्पन्न करने के लिए इस्तेमाल किया जा सकता:

sudo apt-get install -y -qq dnsutils

dig @127.0.0.1 -p 9053 demo1.example.org

; <<>> DiG 9.11.3-1ubuntu1.11-Ubuntu <<>> @127.0.0.1 -p 9053 demo1.example.org
; (1 server found)
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 53868
;; flags: qr aa rd; QUERY: 1, ANSWER: 0, AUTHORITY: 0, ADDITIONAL: 3
;; WARNING: recursion requested but not available

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 4096
; COOKIE: 855234f1adcb7a28 (echoed)
;; QUESTION SECTION:
;demo1.example.org.     IN  A

;; ADDITIONAL SECTION:
demo1.example.org.  0   IN  A   127.0.0.1
_udp.demo1.example.org. 0   IN  SRV 0 0 45361 .

;; Query time: 0 msec
;; SERVER: 127.0.0.1#9053(127.0.0.1)
;; WHEN: Tue Mar 03 22:35:20 UTC 2020
;; MSG SIZE  rcvd: 132

dig @127.0.0.1 -p 9053 demo2.example.org

; <<>> DiG 9.11.3-1ubuntu1.11-Ubuntu <<>> @127.0.0.1 -p 9053 demo2.example.org
; (1 server found)
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 53163
;; flags: qr aa rd; QUERY: 1, ANSWER: 0, AUTHORITY: 0, ADDITIONAL: 3
;; WARNING: recursion requested but not available

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 4096
; COOKIE: f18b2ba23e13446d (echoed)
;; QUESTION SECTION:
;demo2.example.org.     IN  A

;; ADDITIONAL SECTION:
demo2.example.org.  0   IN  A   127.0.0.1
_udp.demo2.example.org. 0   IN  SRV 0 0 42194 .

;; Query time: 0 msec
;; SERVER: 127.0.0.1#9053(127.0.0.1)
;; WHEN: Tue Mar 03 22:35:21 UTC 2020
;; MSG SIZE  rcvd: 132

अब एक CoreDNS सर्वर जिसका मेट्रिक्स एक प्रोमेथियस सर्वर द्वारा स्क्रैप किया गया है और TensorFlow द्वारा उपभोग के लिए तैयार है।

CoreDNS मेट्रिक्स के लिए डेटासेट बनाएं और इसे TensorFlow में उपयोग करें

CoreDNS मैट्रिक्स कि PostgreSQL सर्वर से उपलब्ध है के लिए एक डेटासेट बनाएँ, के साथ किया जा सकता है tfio.experimental.IODataset.from_prometheus । कम से कम दो तर्कों की जरूरत है। query मीट्रिक चुनने के लिए प्रोमेथियस सर्वर से पारित कर दिया है और length डेटासेट में अवधि लोड करने के लिए आप चाहते हैं।

आप के साथ शुरू कर सकते हैं "coredns_dns_request_count_total" और "5" नीचे डेटासेट बनाने के लिए (सेकंड)। चूंकि ट्यूटोरियल दो DNS क्वेरी में पहले भेजा गया था, यह उम्मीद है कि के लिए मैट्रिक्स "coredns_dns_request_count_total" हो जाएगा "2.0" समय श्रृंखला के अंत में:

dataset = tfio.experimental.IODataset.from_prometheus(
      "coredns_dns_request_count_total", 5, endpoint="http://localhost:9090")


print("Dataset Spec:\n{}\n".format(dataset.element_spec))

print("CoreDNS Time Series:")
for (time, value) in dataset:
  # time is milli second, convert to data time:
  time = datetime.fromtimestamp(time // 1000)
  print("{}: {}".format(time, value['coredns']['localhost:9153']['coredns_dns_request_count_total']))

Dataset Spec:
(TensorSpec(shape=(), dtype=tf.int64, name=None), {'coredns': {'localhost:9153': {'coredns_dns_request_count_total': TensorSpec(shape=(), dtype=tf.float64, name=None)} } })

CoreDNS Time Series:
2020-03-03 22:35:17: 2.0
2020-03-03 22:35:18: 2.0
2020-03-03 22:35:19: 2.0
2020-03-03 22:35:20: 2.0
2020-03-03 22:35:21: 2.0

आगे डेटासेट की विशिष्टता को देखते हुए:

(
  TensorSpec(shape=(), dtype=tf.int64, name=None),
  {
    'coredns': {
      'localhost:9153': {
        'coredns_dns_request_count_total': TensorSpec(shape=(), dtype=tf.float64, name=None)
      }
    }
  }
)

यह स्पष्ट है कि डाटासेट एक के होते हैं (time, values) टपल जहां values क्षेत्र एक अजगर dict में विस्तार किया है:

"job_name": {
  "instance_name": {
    "metric_name": value,
  },
}

उपरोक्त उदाहरण में, 'coredns' , नौकरी का नाम है 'localhost:9153' उदाहरण के नाम है, और 'coredns_dns_request_count_total' मीट्रिक नाम है। ध्यान दें कि प्रयुक्त प्रोमेथियस क्वेरी के आधार पर, यह संभव है कि एकाधिक कार्य/उदाहरण/मैट्रिक्स लौटाए जा सकें। यही कारण है कि डेटासेट की संरचना में अजगर dict का उपयोग किया गया है।

किसी अन्य क्वेरी लो "go_memstats_gc_sys_bytes" एक उदाहरण के रूप। चूंकि दोनों CoreDNS और प्रोमेथियस Golang में लिखे गए हैं, "go_memstats_gc_sys_bytes" मीट्रिक दोनों के लिए उपलब्ध है "coredns" नौकरी और "prometheus" काम:

dataset = tfio.experimental.IODataset.from_prometheus(
    "go_memstats_gc_sys_bytes", 5, endpoint="http://localhost:9090")

print("Time Series CoreDNS/Prometheus Comparision:")
for (time, value) in dataset:
  # time is milli second, convert to data time:
  time = datetime.fromtimestamp(time // 1000)
  print("{}: {}/{}".format(
      time,
      value['coredns']['localhost:9153']['go_memstats_gc_sys_bytes'],
      value['prometheus']['localhost:9090']['go_memstats_gc_sys_bytes']))

Time Series CoreDNS/Prometheus Comparision:
2020-03-03 22:35:17: 2385920.0/2775040.0
2020-03-03 22:35:18: 2385920.0/2775040.0
2020-03-03 22:35:19: 2385920.0/2775040.0
2020-03-03 22:35:20: 2385920.0/2775040.0
2020-03-03 22:35:21: 2385920.0/2775040.0

बनाया Dataset के लिए पारित होने के लिए तैयार है tf.keras सीधे या तो प्रशिक्षण या अनुमान प्रयोजनों के लिए अब।

मॉडल प्रशिक्षण के लिए डेटासेट का उपयोग करें

मैट्रिक्स डेटासेट बनाया के साथ, यह सीधे करने के लिए डेटासेट पारित करने के लिए संभव है tf.keras मॉडल प्रशिक्षण या अनुमान के लिए।

डेमो उद्देश्यों के लिए, यह ट्यूटोरियल केवल 1 फीचर और इनपुट के रूप में 2 चरणों के साथ एक बहुत ही सरल LSTM मॉडल का उपयोग करेगा:

n_steps, n_features = 2, 1
simple_lstm_model = tf.keras.models.Sequential([
    tf.keras.layers.LSTM(8, input_shape=(n_steps, n_features)),
    tf.keras.layers.Dense(1)
])

simple_lstm_model.compile(optimizer='adam', loss='mae')

उपयोग किया जाने वाला डेटासेट 10 नमूनों के साथ CoreDNS के लिए 'go_memstats_sys_bytes' का मान है। हालांकि, की एक रपट खिड़की के बाद window=n_steps और shift=1 बनते हैं, अतिरिक्त नमूने की जरूरत है (किसी भी दो consecute तत्वों के लिए, पहले के रूप में लिया जाता है x और दूसरी के रूप में लिया जाता है y प्रशिक्षण के लिए)। कुल है 10 + n_steps - 1 + 1 = 12 सेकंड।

डेटा मान भी करने के लिए माप लिया जाता है [0, 1] ।

n_samples = 10

dataset = tfio.experimental.IODataset.from_prometheus(
    "go_memstats_sys_bytes", n_samples + n_steps - 1 + 1, endpoint="http://localhost:9090")

# take go_memstats_gc_sys_bytes from coredns job 
dataset = dataset.map(lambda _, v: v['coredns']['localhost:9153']['go_memstats_sys_bytes'])

# find the max value and scale the value to [0, 1]
v_max = dataset.reduce(tf.constant(0.0, tf.float64), tf.math.maximum)
dataset = dataset.map(lambda v: (v / v_max))

# expand the dimension by 1 to fit n_features=1
dataset = dataset.map(lambda v: tf.expand_dims(v, -1))

# take a sliding window
dataset = dataset.window(n_steps, shift=1, drop_remainder=True)
dataset = dataset.flat_map(lambda d: d.batch(n_steps))


# the first value is x and the next value is y, only take 10 samples
x = dataset.take(n_samples)
y = dataset.skip(1).take(n_samples)

dataset = tf.data.Dataset.zip((x, y))

# pass the final dataset to model.fit for training
simple_lstm_model.fit(dataset.batch(1).repeat(10),  epochs=5, steps_per_epoch=10)

Train for 10 steps
Epoch 1/5
10/10 [==============================] - 2s 150ms/step - loss: 0.8484
Epoch 2/5
10/10 [==============================] - 0s 10ms/step - loss: 0.7808
Epoch 3/5
10/10 [==============================] - 0s 10ms/step - loss: 0.7102
Epoch 4/5
10/10 [==============================] - 0s 11ms/step - loss: 0.6359
Epoch 5/5
10/10 [==============================] - 0s 11ms/step - loss: 0.5572
<tensorflow.python.keras.callbacks.History at 0x7f1758f3da90>

ऊपर दिया गया प्रशिक्षित मॉडल वास्तव में बहुत उपयोगी नहीं है, क्योंकि इस ट्यूटोरियल में स्थापित किए गए CoreDNS सर्वर पर कोई कार्यभार नहीं है। हालाँकि, यह एक कार्यशील पाइपलाइन है जिसका उपयोग वास्तविक उत्पादन सर्वर से मीट्रिक लोड करने के लिए किया जा सकता है। तब मॉडल को देवोप्स ऑटोमेशन की वास्तविक दुनिया की समस्या को हल करने के लिए बेहतर बनाया जा सकता था।