Bu sayfa, Cloud Translation API ile çevrilmiştir.
Switch to English

Prometheus sunucusundan ölçümleri yükle

TensorFlow.org'da görüntüleyin Google Colab'de çalıştırın Kaynağı GitHub'da görüntüleyin Defteri indirin

Genel Bakış

Bu öğretici, bir Prometheus sunucusundan birtf.data.Dataset CoreDNS metriklerini yükler, ardından eğitim ve çıkarım için tf.keras kullanır.

CoreDNS , hizmet keşfine odaklanan bir DNS sunucusudur ve Kubernetes kümesinin bir parçası olarak yaygın şekilde dağıtılır. Bu nedenle genellikle devops operasyonları tarafından yakından izlenir.

Bu eğitim, makine öğrenimi aracılığıyla işlemlerinde otomasyon arayan girişimciler tarafından kullanılabilecek bir örnektir.

Kurulum ve kullanım

Gerekli tensorflow-io paketini kurun ve çalışma zamanını yeniden başlatın

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 ve Prometheus'u kurun ve kurun

Demo amacıyla, DNS sorgularını almak için 9053 bağlantı noktasının açık olduğu ve veri toplama için ölçümleri açığa çıkarmak için 9153 numaralı bağlantı noktasının (varsayılan) açık olduğu bir CoreDNS sunucusu. Aşağıdakiler CoreDNS için temel bir Corefile konfigürasyonudur ve indirilebilir :

.:9053 {
  prometheus
  whoami
}

Kurulumla ilgili daha fazla ayrıntı CoreDNS'nin belgelerinde bulunabilir .

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 &')

Bir sonraki adım, Prometheus sunucusunu kurmak ve Prometheus'u yukarıdan 9153 numaralı bağlantı noktasında gösterilen CoreDNS ölçümlerini kazımak için kullanmaktır. Yapılandırma için prometheus.yml dosyası da indirilebilir :

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 &')

Bazı etkinlikleri göstermek için, dig komutu, kurulan CoreDNS sunucusuna karşı birkaç DNS sorgusu oluşturmak için kullanılabilir:

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


Artık metrikleri bir Prometheus sunucusu tarafından alınan ve TensorFlow tarafından kullanılmaya hazır bir CoreDNS sunucusu.

CoreDNS ölçümleri için Veri Kümesi oluşturun ve bunu TensorFlow'da kullanın

PostgreSQL sunucusundan temin edilebilen CoreDNS ölçümleri için bir Veri Kümesi oluşturun, tfio.experimental.IODataset.from_prometheus iletfio.experimental.IODataset.from_prometheus . Asgari düzeyde iki argüman gereklidir. query metrikleri seçmek için Prometheus sunucusuna iletilir ve length , Veri Kümesine yüklemek istediğiniz süredir.

Aşağıdaki Veri "coredns_dns_request_count_total" oluşturmak için "coredns_dns_request_count_total" ve "5" (saniye) ile başlayabilirsiniz. "coredns_dns_request_count_total" daha önce iki DNS sorgusu gönderilmiş olduğundan, "coredns_dns_request_count_total" için ölçümlerin zaman serisinin sonunda "2.0" olması beklenmektedir:

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

Veri Kümesinin teknik özelliklerine daha fazla bakalım:

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

Veri kümesinin bir (time, values) demetinden oluştuğu açıktır ve burada values alanı aşağıdakilere genişletilmiş bir python diktedir:

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

Yukarıdaki örnekte, 'coredns' iş adı, 'localhost:9153' örnek adı ve 'coredns_dns_request_count_total' metrik adıdır. Kullanılan Prometheus sorgusuna bağlı olarak, birden çok iş / örnek / ölçümün döndürülebileceğini unutmayın. Veri Kümesinin yapısında python dict'in kullanılmasının nedeni de budur.

Örnek olarak başka bir "go_memstats_gc_sys_bytes" sorgusunu ele alalım. Hem CoreDNS hem de Prometheus Golang'da yazıldığından, "go_memstats_gc_sys_bytes" metriği hem "coredns" işi hem de "prometheus" işi için kullanılabilir:

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

Oluşturulan Dataset , eğitim veya çıkarım amacıyla doğrudan tf.keras aktarılmaya hazırdır.

Model eğitimi için Veri Kümesini kullanın

Oluşturulan metrikler Veri Kümesi ile, Veri tf.keras doğrudan model eğitimi veya çıkarım için tf.keras geçirmek mümkündür.

Demo amaçlı olarak, bu öğretici giriş olarak 1 özellik ve 2 adımlı çok basit bir LSTM modelini kullanacaktır:

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')

Kullanılacak veri kümesi, 10 örnekli CoreDNS için 'go_memstats_sys_bytes' değeridir. Bununla birlikte, window=n_steps ve shift=1 şeklinde kayan bir pencere oluşturulduğundan, ek örneklere ihtiyaç vardır (herhangi iki ardışık eleman için, birincisi x ve ikincisi eğitim için y olarak alınır). Toplam 10 + n_steps - 1 + 1 = 12 saniyedir.

Veri değeri de [0, 1] ölçeklenir.

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>

Yukarıdaki eğitimli model, bu eğitimde kurulan CoreDNS sunucusunun herhangi bir iş yükü içermediğinden gerçekte pek kullanışlı değildir. Ancak bu, gerçek üretim sunucularından ölçümleri yüklemek için kullanılabilecek çalışan bir kanaldır. Model daha sonra gerçek dünyadaki devops otomasyonu sorununu çözmek için geliştirilebilir.