OSMC 2020 | GET ON STAGE!

Hey folks, listen up!

OSMC’s call for papers is about to close. So prepare yourselves for the big monitoring stage and submit your paper.
We are looking for the latest trends, how-tos, case studies, best practices, future developments and anything that can help practitioners in their daily work. You can read more about CfP 2020 here.

The conference is aimed at professionals from the open source monitoring scene. The Open Source Monitoring Conference OSMC is about networking and meeting the international community. The lecture program provides up-to-date expert knowledge, and the workshops offer deep insights into various specialist areas. At the Hackathon, you build together with like-minded people on the project you always wanted to tackle.

So be there when the international open source scene meets in November at the monitoring hotspot Nuremberg! The conference will take place for the 15th time from November 16 to 19. You can find the ticket details here.

What are you waiting for? See you!

Pamela Drescher
Pamela Drescher
Head of Marketing

Pamela hat im Dezember 2015 das Marketing bei NETWAYS übernommen. Sie ist für die Corporate Identity unserer Veranstaltungen sowie von NETWAYS insgesamt verantwortlich. Die enge Zusammenarbeit mit Events ergibt sich aus dem Umstand heraus, dass sie vor ein paar Jahren mit Markus zusammen die Eventsabteilung geleitet hat und diese äußerst vorzügliche Zusammenarbeit nun auch die Bereiche Events und Marketing noch enger verknüpft. Privat ist sie Anführerin einer vier Mitglieder starken Katzenhorde, was ihr den absolut...

Vom Bordstein zur Skyline von Robert Waffen | OSMC 2019

This entry is part 2 of 2 in the series OSMC 2019 | Recap

 

Auf der Open Source Monitoring Conference (OSMC) 2019 in Nürnberg hat uns Robert Waffen mit seinem Vortrag “Vom Bordstein zur Skyline” in den Bann gezogen. Für den Fall, dass jemand nicht die Möglichkeit hatte, an seinem Vortrag teilzunehmen, haben wir hier etwas vorbereitet: Seht euch das Video von Roberts “Kriegsgeschichte” – wie er selbst es nennt – an und lest weiter unten eine Zusammenfassung.

Die OSMC ist das jährliche Treffen internationaler Monitoring-Experten, auf dem zukünftige Trends und Strategien festgelegt werden. Seit 2006 findet die Veranstaltung jedes Jahr im Herbst in Nürnberg, Deutschland, statt. Führende Spezialisten präsentieren die ganze Bandbreite des Open Source Monitorings und stehen bereit, um Fragen zu beantworten, und seien diese noch so schwierig. Lernt neue Techniken kennen, tauscht Wissen aus und diskutiert mit Top-Entwicklern.

Ausführliche Workshops am Tag vor der Konferenz und ein Hackathon bieten weitere Möglichkeiten, eure Fähigkeiten zu erweitern und euer Wissen im Bereich IT-Monitoring und -Management zu vertiefen.

Die nächste OSMC findet vom 16. bis 19. November 2020 in Nürnberg statt.
Weitere Informationen und Tickets unter osmc.de.


Vom Bordstein zur Skyline

Der Talk von Robert Waffen “Vom Bordstein zur Skyline” handelt von den Monitoring-Entwicklungsstufen des Unternehmens Publicis Pixelpark.

Wie war der bisherige Stand im Monitoring?

Bei Robert Waffen in der Firma war schon Xymon oder – noch früher – Zabbix im Einsatz, was nicht richtig gepflegt wurde. Und wenn, dann nur zum Teil. Das dadurch entstandene Wissen wurde abgewandelt und daraufhin auf zwei Elk-Instanzen umgestellt. Als Metriken wurden nur Default-Metriken verwendet, also das, was das System standardmäßig bereitstellt. Dazu gehörten Metriken in 5-Minuten-Intervallen.

Das ganze Monitoring war weder automatisiert noch teilautomatisiert. Konfigurationen oder Interfaces konnte man einchecken, wenn man sich durchklickte.

 

Xymon

Xymon hat natürlich wie jedes andere Monitoring-System Checks, wodurch Auswertungen gemacht werden, wie zum Beispiel Shell. Dabei wurde meistens sehr viel Output produziert. Und zwar nicht wie beispielsweise in Icinga eine Zeile, sondern ganze Prozesslisten. Das ganze Interface war nicht dynamisch und wurde in HTML vorgerendert, was wiederum eigene Vor- und Nachteile hatte. Bei HD-Grafen, die auch gerne ein bisschen größer werden, mussten diese gelöscht werden. Das eigentliche Problem war, dass es sehr hohe Check-Intervalle gab und keine Anbindung an Grafana oder sonstiges möglich war, da Xymon aus den 1990er-Jahren kommt. Zudem ein Thema, das immer wieder zu Problemen führte: Es gab keine richtige Verschlüsselung.

 

Zabbix

Bei Zabbix hingegen macht das GUI alles. Es gibt zwar ein Puppet-Modul, welches einen Server aufbauen kann, aber das Modul kann den Server nicht konfigurieren, was problematisch ist. Weiter war ein Update auf die neueste Version nicht möglich, weil interne Probleme auftraten. Das heißt, man ist bei einer älteren Version hängen geblieben.

Probleme wurden prinzipiell zwar immer angezeigt, aber nicht welcher Art. In einem Monitoring wurde der Alarm aktiviert. Daraufhin musste man in einem anderen System nachsehen und eventuell dort das Problem ausfindig machen. Man musste in mehreren Interfaces nachsehen, was sehr umständlich war.

Der Aufbau der GUI in Zabbix war auch nicht logisch, wenn man es mit anderen Monitoring-Systemen vergleicht. Es zeigte nur an, wenn ein Problem auftrat. Das Host-Objekt an sich gibt es in Zabbix gar nicht, an dem man sieht, dass der Host up ist und der Host folgende Daten hat… Das wird nicht angezeigt, man muss erst nach diesen Informationen suchen.

 

ELK

Zudem gibt es zwei verschiedene ELK-Stacks. Ein Stack ist schon etwas älter und beinhaltet sensible Daten eines langjährigen Kunden, die auch separat gehalten werden sollen. Daneben gibt es einen neueren Stack der Version 6 mit entsprechender Umgebung. Die Stacks sind alle manuell aufgesetzt und eine nachträgliche Automatisierung scheint nicht möglich, da sonst Indexe oder ganze Konfigurationen verworfen werden oder ähnliches. Deswegen wird hier ein Neuaufbau geplant.

 

Graylog

Als Alternative zum ELK gibt es auch noch Graylog. Das wird für neuere Kunden eingesetzt und funktioniert ganz gut.

 

Wie ist der aktueller Stand im Monitoring?

Aktuell sieht das Monitoring bei Robert so aus: Zabbix und Xymon dienen als Hauptmonitoring. Hier wurde ein Grafana mit diversen Quellen hinzugebaut, wie InfluxDB, Prometheus, Graphite oder ElasticSearch. Daneben existiert ein Proof of Concept für Icinga 2 und ELK 7.

 

Prometheus

Wir haben von null angefangen und ein Prometheus aufgesetzt. Wenn man sich damit beschäftigt, meint man erst, oh, ja, Kubernetes, da ist alles schön und toll. Da deployed man sein YAMLs und es ist alles schön und sicher – bis man von Systemen außerhalb von Kubernetes auf Metriken zugreifen möchte. Mit einem Reverse Proxy davorgebaut, mit einem Apache und HTTPS, und einem IP Require, so dass nur der Prometheus-Server den Node Exporter abfragen darf.

 

Icinga 2

Bei Icinga 2 hat man einen Pock aufgesetzt, der vollautomatisch aus dem Puppet generiert wird. Das heißt, wenn man den Host wegreißt und neu startet, werden alle Hosts, Konfigurationen, Checks wie vorher angezeigt.

So weiß man, woher der Check kommt. In Vergleich mit Zabbix und Xymon weiß man weißt nicht, woher die Checks kommen und warum etwas anspringt. Viele sagen, man brauche Automatisierung erst dann, wenn man mehrere Server hat. Aber es geht auch darum, nachvollziehbar zu arbeiten, um Konfigurationen einsehen zu können.

 

Wie soll Monitoring in Zukunft aussehen?

Host-Inventarisierung: Wir haben viele Hosts, die keine Puppet-Module haben, Puppet ausgeschaltet ist oder eine alte Puppet-Version installiert ist. Wir müssen diese updaten und installieren und das ist teilweise schwierig wegen Solaris.

Benachrichtigungsplan erstellen: Man muss man sich ein Konzept überlegen, über was wann benachrichtigt werden soll. Zum Beispiel wenn ein Server nur tagsüber wichtig ist, braucht man keine Notifications in der Nacht. Dies ist zum Beispiel bei Testmaschinen der Fall, wenn es in der Testumgebung Probleme gibt. Wenn es sich allerdings um eine Produktionsumgebung handelt, möchte man rund um die Uhr benachrichtigt werden.

 

Saeid Hassan-Abadi
Saeid Hassan-Abadi
Junior Consultant

Saeid hat im September 2019 seine Ausbildung zum Fachinformatiker im Bereich Systemintegration gestartet. Der gebürtige Perser hat in seinem Heimatland Iran Wirtschaftsindustrie-Ingenieurwesen studiert. Er arbeitet leidenschaftlich gerne am Computer und eignet sich gerne neues Wissen an. Seine Hobbys sind Musik hören, Sport treiben und mit seinen Freunden Zeit verbringen.

Current State of Icinga by Bernd Erk | OSMC 2019

This entry is part of 2 in the series OSMC 2019 | Recap

 

 

At the Open Source Monitoring Conference (OSMC) 2019 in Nuremberg, Bernd Erk presented the „Current State of Icinga”. You have missed him speaking? We have got something for you: Watch the video of Bernd‘s presentation and read a summary (below).

The OSMC is the annual meeting of international monitoring experts, where future trends and objectives are set. Since 2006 the event takes place every autumn in Nuremberg, Germany. Leading specialists present the full scope of Open Source monitoring and are ready to answer your hardest questions. Learn new techniques, exchange knowledge and discuss with top developers.

In-depth workshops the day prior to the conference and a Hackathon provide further possibilities to extend your skills and deepen your knowledge in IT monitoring and management.

The next OSMC takes place November 16 – 19, 2020 in Nuremberg.

More information and tickets at osmc.de.


Current State of Icinga

In the talk „Current State of Icinga“ Bernd Erk shortly introduces himself and the team behind Icinga. Bernd’s presentation gives at first a quick overview over Icinga, followed by a really funny presentation with Emojis (Long story short: Icinga makes you happy!). After that Bernd explains the blog, the ongoing user survey, IcingaConf, Icinga Camp and Icinga partners all around the world. He also presents the reason why we don’t know most of the Icinga users: As it is an open-source product, anyone can download it and use it for free.

In the main part Bernd gives a product update for Icinga and everything connected to it. Thereupon he reports about what happened during summer 2019 regarding development. After that he goes deeper into the new features and innovations of Icinga version 2.11, which is the current major version as of November 2019. In the second part of the main presentation he illustrates Icinga Web 2 and the new features of the current version 2.7 (November 2019) and its accessibility features. vSphere version 1.1 is the third main theme and Bernd touches on its new features and improvements. The topic after vSphere is Icinga Director and its current version 1.7 (November 2019). Bernd discloses the new features of the Director and what it is capable of. He completes his talk with aspects of Icinga Business Process Monitoring in its newest version 2.2 (November 2019). Here the main components are the Drag & Drop feature, Export & Import and Usability. With regard to this Bernd presents the mentioned features and innovations in a short live demo.

After the live demo Bernd introduces Icinga for Windows. A short video of the installation of Icinga on Windows is shown. Christian Stein, a long-standing member of the Icinga team, is the main developer of this outstanding Icinga innovation. After having presented Windows monitoring, the focus moved on to Icinga for AWS (Amazon Web Services) version 1.0 (November 2019) and its possibilities. Thereafter Bernd goes in deep with the Icinga module for JIRA in version 1.0 (November 2019) and how it works.

Icinga DB is the last topic covered. For that a few last year’s slides were repeated, followed by a funny video about why it took so long. After this hilarious video a live demo of all the new features and innovations is given.

Bernd concludes his talk with a summary:

  • Icinga Director 1.7.2 is out now
  • Icinga Module for vSphere 1.1.0 is out now
  • Icinga Module for JIRA 1.0.1 is out now
  • Icinga 2.12 RC will be ready later

And that is basically Bernd’s entire talk, though highly compressed. If you are interested in the full talk with all its details and funny moments I recommend watching the whole video. It is worth every second, entertaining and highly informative.

Nathaniel Donahue
Nathaniel Donahue
Junior Consultant

Nathaniel hat 2019 die Wirtschaftsschule abgeschlossen. Wegen seinem Interesse am IT-Bereich entschied er sich dafür eine Ausbildung zum Fachinformatiker im Bereich Systemintegration zu machen und fing im September 2019 bei NETWAYS Professional Services an. Auch in seiner Freizeit sitzt er gerne am Computer, allerdings meistens zum Spielen, oder er unternimmt etwas mit seinen Freunden.

Versteckte Director-Features: Update-Only Sync-Regeln

Heute möchte ich ein neues kleines Feature im Icinga-Director vorstellen: die Möglichkeit, mit Sync-Regeln keine vollständigen Objekte zu verwalten, sondern nur bestimmte Eigenschaften von bestehenden Objekten zu steuern. Das klingt erst mal banal, also wozu das Ganze?

Bereits seit der ersten Director-Version ist es möglich, mehrere Import-Quellen in einer Sync-Regel miteinander zu kombinieren. Allerdings ist das in der Praxis nicht immer ganz so einfach. Spätestens wenn die zweite Quelle nur Zusatzinfos liefern soll, dabei aber mehr Hosts als die erste enthält – dann wird es kompliziert. Viele Import-Quellen lassen sich filtern, da kommt man schon weiter. Und seit einiger Zeit gibt es auch wenn die Quelle das nicht kann die Möglichkeit, via Property-Modifier Zeilen filterbasiert zuzulassen oder abzuweisen.

Der übliche Trick an der Stelle ist dann aber häufig das Anlegen von entsprechenden Datenlisten im Director. Diese befüllt man über dedizierte Sync-Regeln mit Leben und kann sie dann via Map-Modifier am primären Host-Import nutzen. Das funktioniert einwandfrei, ist aber ein wenig umständlich.

Director Sync-Rule - Update-Only

Director Sync-Rule – Update-Only

Beides ist mittlerweile nicht mehr erforderlich. Im aktuellen Master-Branch und in der kommenden Version 1.8 gibt es die Möglichkeit, sogenannte “Update-only” Sync-Regeln anzulegen. Dabei kann man einem beliebigen Objekt-Typ (meist Hosts) eine Reihe von zusätzlichen Eigenschaften aus einer anderen Quelle verpassen, ohne aber zu riskieren dass diese Zweitquelle jetzt ungewollt Hosts hinzufügt oder gar entfernt.

Einfach, aber nützlich. Und das war’s auch schon für heute, wünsche euch ein schönes Wochenende!

Thomas Gelf
Thomas Gelf
Principal Consultant

Der gebürtige Südtiroler Tom arbeitet als Principal Consultant für Systems Management bei NETWAYS und ist in der Regel immer auf Achse: Entweder vor Ort bei Kunden, als Trainer in unseren Schulungen oder privat beim Skifahren in seiner Heimatstadt Bozen. Neben Icinga und Nagios beschäftigt sich Tom vor allem mit Puppet.

Monitoring Kubernetes mit Prometheus

This entry is part 5 of 7 in the series Kubernetes - so startest Du durch!

Monitoring – für viele eine gewisse Hass-Liebe. Die einen mögen es, die anderen verteufeln es. Ich gehöre zu denen, die es meist eher verteufeln, dann aber meckern, wenn man gewisse Metriken und Informationen nicht einsehen kann. Unabhängig der persönlichen Neigungen zu diesem Thema ist der Konsens aller jedoch sicher: Monitoring ist wichtig und ein Setup ist auch nur so gut wie sein dazugehöriges Monitoring.

Wer seine Anwendungen auf Basis von Kubernetes entwickeln und betreiben will, stellt sich zwangsläufig früher oder später die Frage, wie man diese Anwendungen und den Kubernetes Cluster überwachen kann. Eine Variante ist der Einsatz der Monitoringlösung Prometheus; genauer gesagt durch die Verwendung des Kubernetes Prometheus Operators. Eine beispielhafte und funktionale Lösung wird in diesem Blogpost gezeigt.

Kubernetes Operator

Kubernetes Operators sind kurz erklärt Erweiterungen, mit denen sich eigene Ressourcentypen erstellen lassen. Neben den Standard-Kubernetes-Ressourcen wie Pods, DaemonSets, Services usw. kann man mit Hilfe eines Operators auch eigene Ressourcen nutzen. In unserem Beispiel kommen neu hinzu: Prometheus, ServiceMonitor und weitere. Operators sind dann von großem Nutzen, wenn man für seine Anwendung spezielle manuelle Tasks ausführen muss, um sie ordentlich betreiben zu können. Das könnten beispielsweise Datenbank-Schema-Updates bei Versionsupdates sein, spezielle Backupjobs oder das Steuern von Ereignissen in verteilten Systemen. In der Regel laufen Operators – wie gewöhnliche Anwendungen auch – als Container innerhalb des Clusters.

Wie funktioniert es?

Die Grundidee ist, dass mit dem Prometheus Operator ein oder viele Prometheus-Instanzen gestartet werden, die wiederum durch den ServiceMonitor dynamisch konfiguriert werden. Das heißt, es kann an einem gewöhnlichen Kubernetes Service mit einem ServiceMonitor angedockt werden, der wiederum ebenfalls die Endpoints auslesen kann und die zugehörige Prometheus-Instanz entsprechend konfiguriert. Verändern sich der Service respektive die Endpoints, zum Beispiel in der Anzahl oder die Endpoints haben neue IPs, erkennt das der ServiceMonitor und konfiguriert die Prometheus-Instanz jedes Mal neu. Zusätzlich kann über Configmaps auch eine manuelle Konfiguration vorgenommen werden.

Voraussetzungen

Voraussetzung ist ein funktionierendes Kubernetes Cluster. Für das folgende Beispiel verwende ich einen NWS Managed Kubernetes Cluster in der Version 1.16.2.

Installation Prometheus Operator

Zuerst wird der Prometheus-Operator bereitgestellt. Es werden ein Deployment, eine benötigte ClusterRole mit zugehörigem ClusterRoleBinding und einem ServiceAccount definiert.

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  labels:
    app.kubernetes.io/component: controller
    app.kubernetes.io/name: prometheus-operator
    app.kubernetes.io/version: v0.38.0
  name: prometheus-operator
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: prometheus-operator
subjects:
- kind: ServiceAccount
  name: prometheus-operator
  namespace: default
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  labels:
    app.kubernetes.io/component: controller
    app.kubernetes.io/name: prometheus-operator
    app.kubernetes.io/version: v0.38.0
  name: prometheus-operator
rules:
- apiGroups:
  - apiextensions.k8s.io
  resources:
  - customresourcedefinitions
  verbs:
  - create
- apiGroups:
  - apiextensions.k8s.io
  resourceNames:
  - alertmanagers.monitoring.coreos.com
  - podmonitors.monitoring.coreos.com
  - prometheuses.monitoring.coreos.com
  - prometheusrules.monitoring.coreos.com
  - servicemonitors.monitoring.coreos.com
  - thanosrulers.monitoring.coreos.com
  resources:
  - customresourcedefinitions
  verbs:
  - get
  - update
- apiGroups:
  - monitoring.coreos.com
  resources:
  - alertmanagers
  - alertmanagers/finalizers
  - prometheuses
  - prometheuses/finalizers
  - thanosrulers
  - thanosrulers/finalizers
  - servicemonitors
  - podmonitors
  - prometheusrules
  verbs:
  - '*'
- apiGroups:
  - apps
  resources:
  - statefulsets
  verbs:
  - '*'
- apiGroups:
  - ""
  resources:
  - configmaps
  - secrets
  verbs:
  - '*'
- apiGroups:
  - ""
  resources:
  - pods
  verbs:
  - list
  - delete
- apiGroups:
  - ""
  resources:
  - services
  - services/finalizers
  - endpoints
  verbs:
  - get
  - create
  - update
  - delete
- apiGroups:
  - ""
  resources:
  - nodes
  verbs:
  - list
  - watch
- apiGroups:
  - ""
  resources:
  - namespaces
  verbs:
  - get
  - list
  - watch
---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app.kubernetes.io/component: controller
    app.kubernetes.io/name: prometheus-operator
    app.kubernetes.io/version: v0.38.0
  name: prometheus-operator
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      app.kubernetes.io/component: controller
      app.kubernetes.io/name: prometheus-operator
  template:
    metadata:
      labels:
        app.kubernetes.io/component: controller
        app.kubernetes.io/name: prometheus-operator
        app.kubernetes.io/version: v0.38.0
    spec:
      containers:
      - args:
        - --kubelet-service=kube-system/kubelet
        - --logtostderr=true
        - --config-reloader-image=jimmidyson/configmap-reload:v0.3.0
        - --prometheus-config-reloader=quay.io/coreos/prometheus-config-reloader:v0.38.0
        image: quay.io/coreos/prometheus-operator:v0.38.0
        name: prometheus-operator
        ports:
        - containerPort: 8080
          name: http
        resources:
          limits:
            cpu: 200m
            memory: 200Mi
          requests:
            cpu: 100m
            memory: 100Mi
        securityContext:
          allowPrivilegeEscalation: false
      nodeSelector:
        beta.kubernetes.io/os: linux
      securityContext:
        runAsNonRoot: true
        runAsUser: 65534
      serviceAccountName: prometheus-operator
---
apiVersion: v1
kind: ServiceAccount
metadata:
  labels:
    app.kubernetes.io/component: controller
    app.kubernetes.io/name: prometheus-operator
    app.kubernetes.io/version: v0.38.0
  name: prometheus-operator
  namespace: default
---
apiVersion: v1
kind: Service
metadata:
  labels:
    app.kubernetes.io/component: controller
    app.kubernetes.io/name: prometheus-operator
    app.kubernetes.io/version: v0.38.0
  name: prometheus-operator
  namespace: default
spec:
  clusterIP: None
  ports:
  - name: http
    port: 8080
    targetPort: http
  selector:
    app.kubernetes.io/component: controller
    app.kubernetes.io/name: prometheus-operator
$ kubectl apply -f 00-prometheus-operator.yaml
clusterrolebinding.rbac.authorization.k8s.io/prometheus-operator created
clusterrole.rbac.authorization.k8s.io/prometheus-operator created
deployment.apps/prometheus-operator created
serviceaccount/prometheus-operator created
service/prometheus-operator created

Role Based Access Control

Zusätzlich werden entsprechende Role Based Access Control (RBAC) Policies benötigt. Die Prometheus-Instanzen (StatefulSets), gestartet durch den Prometheus-Operator, starten Container unter dem gleichnamigen ServiceAccount “Prometheus”. Dieser Account benötigt lesenden Zugriff auf die Kubernetes API, um später die Informationen über Services und Endpoints auslesen zu können.

Clusterrole

apiVersion: rbac.authorization.k8s.io/v1beta1
kind: ClusterRole
metadata:
  name: prometheus
rules:
- apiGroups: [""]
  resources:
  - nodes
  - services
  - endpoints
  - pods
  verbs: ["get", "list", "watch"]
- apiGroups: [""]
  resources:
  - configmaps
  verbs: ["get"]
- nonResourceURLs: ["/metrics"]
  verbs: ["get"]
$ kubectl apply -f 01-clusterrole.yaml
clusterrole.rbac.authorization.k8s.io/prometheus created

 

ClusterRoleBinding

apiVersion: rbac.authorization.k8s.io/v1beta1
kind: ClusterRoleBinding
metadata:
  name: prometheus
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: prometheus
subjects:
- kind: ServiceAccount
  name: prometheus
  namespace: default
$ kubectl apply -f 01-clusterrolebinding.yaml
clusterrolebinding.rbac.authorization.k8s.io/prometheus created

 

ServiceAccount

apiVersion: v1
kind: ServiceAccount
metadata:
  name: prometheus
$ kubectl apply -f 01-serviceaccount.yaml
serviceaccount/prometheus created

Monitoring von Kubernetes Cluster Nodes

Es gibt diverse Metriken, die aus einem Kubernetes Cluster ausgelesen werden können. In diesem Beispiel wird zunächst nur auf die Systemwerte der Kubernetes Nodes eingegangen. Für die Überwachung der Kubernetes Cluster Nodes bietet sich die ebenfalls vom Prometheus-Projekt bereitgestellte Software “Node Exporter” an. Diese liest sämtliche Metriken über CPU, Memory sowie I/O aus und stellt diese Werte unter /metrics zum Abruf bereit. Prometheus selbst “crawlet” diese Metriken später in regelmäßigen Abständen. Ein DaemonSet steuert, dass jeweils ein Container/Pod auf einem Kubernetes Node gestartet wird. Mit Hilfe des Services werden alle Endpoints unter einer Cluster IP zusammengefasst.

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: node-exporter
spec:
  selector:
    matchLabels:
      app: node-exporter
  template:
    metadata:
      labels:
        app: node-exporter
      name: node-exporter
    spec:
      hostNetwork: true
      hostPID: true
      containers:
      - image: quay.io/prometheus/node-exporter:v0.18.1
        name: node-exporter
        ports:
        - containerPort: 9100
          hostPort: 9100
          name: scrape
        resources:
          requests:
            memory: 30Mi
            cpu: 100m
          limits:
            memory: 50Mi
            cpu: 200m
        volumeMounts:
        - name: proc
          readOnly:  true
          mountPath: /host/proc
        - name: sys
          readOnly: true
          mountPath: /host/sys
      volumes:
      - name: proc
        hostPath:
          path: /proc
      - name: sys
        hostPath:
          path: /sys
---
apiVersion: v1
kind: Service
metadata:
  labels:
    app: node-exporter
  annotations:
    prometheus.io/scrape: 'true'
  name: node-exporter
spec:
  ports:
  - name: metrics
    port: 9100
    protocol: TCP
  selector:
    app: node-exporter
$ kubectl apply -f 02-exporters.yaml
daemonset.apps/node-exporter created
service/node-exporter created

Service Monitor

Mit der sogenannten Third Party Ressource “ServiceMonitor”, bereitgestellt durch den Prometheus Operator, ist es möglich, den zuvor gestarteten Service, in unserem Fall node-exporter, für die zukünftige Überwachung aufzunehmen. Die TPR selbst erhält ein Label team: frontend, das wiederum später als Selector für die Prometheus-Instanz genutzt wird.

apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
  name: node-exporter
  labels:
    team: frontend
spec:
  selector:
    matchLabels:
      app: node-exporter
  endpoints:
  - port: metrics
$ kubectl apply -f 03-service-monitor-node-exporter.yaml
servicemonitor.monitoring.coreos.com/node-exporter created

Prometheus-Instanz

Es wird eine Prometheus-Instanz definiert, die nun alle Services anhand der Labels sammelt und von deren Endpoints die Metriken bezieht.

apiVersion: monitoring.coreos.com/v1
kind: Prometheus
metadata:
  name: prometheus
spec:
  serviceAccountName: prometheus
  serviceMonitorSelector:
    matchLabels:
      team: frontend
  resources:
    requests:
      memory: 400Mi
  enableAdminAPI: false
$ kubectl apply -f 04-prometheus-service-monitor-selector.yaml
prometheus.monitoring.coreos.com/prometheus created

Prometheus Service

Die gestartete Prometheus-Instanz wird mit einem Service-Objekt exponiert. Nach einer kurzen Wartezeit ist ein Cloud-Loadbalancer gestartet, der aus dem Internet erreichbar ist und Anfragen zu unserer Prometheus-Instanz durchreicht.

apiVersion: v1
kind: Service
metadata:
  name: prometheus
spec:
  type: LoadBalancer
  ports:
  - name: web
    port: 9090
    protocol: TCP
    targetPort: web
  selector:
    prometheus: prometheus
$ kubectl apply -f 05-prometheus-service.yaml
service/prometheus created
$ kubectl get services
NAME         TYPE           CLUSTER-IP       EXTERNAL-IP   PORT(S)          AGE
prometheus   LoadBalancer   10.254.146.112    pending      9090:30214/TCP   58s

Sobald die externe IP-Adresse verfügbar ist, kann diese über http://x.x.x.x:9090/targets aufgerufen werden und man sieht alle seine Kubernetes Nodes, deren Metriken ab sofort regelmäßig abgerufen werden. Kommen später weitere Nodes hinzu, so werden diese automatisch mit aufgenommen bzw. wieder entfernt.

Visualisierung mit Grafana

Die gesammelten Metriken, lassen sich leicht und ansprechend mit Grafana visualisieren. Grafana ist ein Analyse-Tool, das diverse Datenbackends unterstützt.

apiVersion: v1
kind: Service
metadata:
  name: grafana
spec:
#  type: LoadBalancer
  ports:
  - port: 3000
    targetPort: 3000
  selector:
    app: grafana
---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: grafana
  name: grafana
spec:
  selector:
    matchLabels:
      app: grafana
  replicas: 1
  revisionHistoryLimit: 2
  template:
    metadata:
      labels:
        app: grafana
    spec:
      containers:
      - image: grafana/grafana:latest
        name: grafana
        imagePullPolicy: Always
        ports:
        - containerPort: 3000
        env:
          - name: GF_AUTH_BASIC_ENABLED
            value: "false"
          - name: GF_AUTH_ANONYMOUS_ENABLED
            value: "true"
          - name: GF_AUTH_ANONYMOUS_ORG_ROLE
            value: Admin
          - name: GF_SERVER_ROOT_URL
            value: /api/v1/namespaces/default/services/grafana/proxy/
$ kubectl apply -f grafana.yaml
service/grafana created
deployment.apps/grafana created
$ kubectl proxy
Starting to serve on 127.0.0.1:8001

Sobald die Proxy-Verbindung durch kubectl verfügbar ist, kann die gestartete Grafana-Instanz via http://localhost:8001/api/v1/namespaces/default/services/grafana/proxy/ im Browser aufgerufen werden. Damit die in Prometheus vorliegenden Metriken jetzt auch visuell ansprechend dargestellt werden können, sind nur noch wenige weitere Schritte notwendig. Zuerst wird eine neue Data-Source vom Typ Prometheus angelegt. Dank des kuberneteseigenen und -internen DNS lautet die URL http://prometheus.default.svc:9090. Das Schema ist servicename.namespace.svc. Alternativ kann natürlich auch die Cluster-IP verwendet werden.

Für die gesammelten Metriken des node-exporters gibt es bereits ein sehr vollständiges Grafana-Dashboard, das sich über die Import-Funktion importieren lässt. Die ID des Dashboards ist 1860.

Nach dem erfolgreichem Import des Dashboards können jetzt die Metriken begutachtet werden.

Monitoring weiterer Anwendungen

Neben diesen eher technischen Statistiken sind auch weitere Metriken der eigenen Anwendungen möglich, beispielsweise HTTP Requests, SQL Queries, Business-Logik und vieles mehr. Hier werden einem durch das sehr flexible Datenformat kaum Grenzen gesetzt. Um seine eigenen Metriken zu sammeln, gibt es wie immer mehrere Lösungsansätze. Einer davon ist, seine Anwendung mit einem /metrics Endpunkt auszustatten. Manche Frameworks wie z.B. Ruby on Rails haben bereits brauchbare Erweiterungen. Ein weiterer Ansatz sind sogenannte Sidecars. Ein Sidecar ist ein zusätzlicher Container, der neben dem eigentlichen Anwendungscontainer mitläuft. Beide zusammen ergeben einen Pod, der sich Namespace, Netzwerk etc. teilt. In dem Sidecar läuft dann Code, der die Anwendung prüft und die Ergebnisse als parsebare Werte für Prometheus zur Verfügung stellt. Im Wesentlichen können beide Ansätze, wie im oben gezeigten Beispiel, mit dem Prometheus Operator verknüpft werden.

Sebastian Saemann
Sebastian Saemann
Head of Managed Services

Sebastian kam von einem großen deutschen Hostingprovider zu NETWAYS, weil ihm dort zu langweilig war. Bei uns kann er sich nun besser verwirklichen, denn er leitet das Managed Services Team. Wenn er nicht gerade Cloud-Komponenten patched, versucht er mit seinem Motorrad einen neuen Rundenrekord aufzustellen.

Evolution of a Microservice-Infrastructure by Jan Martens | OSDC 2019

This entry is part 2 of 6 in the series OSDC 2019 | Recap

 

At the Open Source Data Center Conference (OSDC) 2019 in Berlin, Jan Martens invited to audience to travel with him in his talk „Evolution of a Microservice-Infrastructure”. You have missed him speaking? We got something for you: See the video of Jan‘s presentation and read a summary (below).

The former OSDC will be held for the first time in 2020 under the new name stackconf. With the changes in modern IT in recent years, the focus of the conference has increasingly shifted from a mainly static infrastructure approach to a broader spectrum that includes agile methods, continuous integration, container, hybrid and cloud solutions. This development is taken into account by changing the name of the conference and opening the topic area for further innovations.

Due to concerns around the coronavirus (COVID-19), the decision was made to hold stackconf 2020 as an online conference. The online event will now take place from June 16 to 18, 2020. Join us, live online! Save your ticket now at: stackconf.eu/ticket/


 

Evolution of a Microservice-Infrastructure

Jan Martens signed up with a talk titled “Evolution of a Microservice Infrastructure” and why should I summarize his talk if he had done that himself perfectly: “This talk is about our journey from Ngnix & Docker Swarm to Traefik & Nomad.”

But before we start getting more in depth with this talk, there is one more thing to know about it. This is more or less a sequel to “From Monolith to Microservices” by Paul Puschmann a colleague of Jan Martens, but it’s not absolutely necessary to watch them in order or both.

 

So there will be a bunch of questions answered by Jan during the talk, regarding their environment, like: “How do we do deployments? How do we do request routing? What problems did we encounter, during our infrastructural growth and how did we address them?”

After giving some quick insight in the scale he has to deal with, that being 345.000 employees and 15.000 shops, he goes on with the history of their infrastructure.

Jan works at REWE Digital, which is responsible for the infrastructure around services, like delivery of groceries. They started off with the takeover of an existing monolithic infrastructure, not very attractive huh? They confronted themselves with the question: “How can we scale this delivery service?” and the solution they came up with was a micro service environment. Important to point out here, would be the use of Docker/Swarm for the deployment of micro services.

Let’s skip ahead a bit and take a look at the state of 2018 REWE Digital. Well there operating custom Docker-Environment consists of: Docker, Consul, Elastic Stack, ngnix, dnsmasq and debian

Jan goes into explaining his infrastructure more and more and how the different applications work with each other, but let’s just say: Everything was fine and peaceful until the size of the environment grew to a certain point. And at that point problems with nginx were starting to surface, like requests which never reached their destination or keepalive connections, which dropped after a short time. The reason? Consul-template would reload all ngnix instances at the same time. The solution? Well they looked for a different reverse proxy, which is able to reload configuration dynamically and best case that new reverse proxy is even able to be configured dynamically.

The three being deemed fitting for that job were envoy, Fabio and traefik, but I have already spoiled their decision, its treafik. The points Jan mentioned, which had them decide on traefik were that it is dynamically configurable and is able to reload configuration live. That’s obviously not all, lots of metrics, a web ui, which was deemed nice by Jan and a single go binary, might have made the difference.

Jan drops a few words on how migration is done and then invests some time in talking about the benefits of traefik, well the most important benefit for us to know is, that the issues that existed with ngnix are gone now.

Well now that the environment was changed, there were also changes coming for swarm, acting on its own. The problems Jan addresses are a poor container spread, no self-healing, and more. You should be able to see where this is going. Well the candidates besides Docker Swarm are Rancher, Kubernetes and Nomad. Well, this one was spoiled by me as well.

The reasons to use nomad in this infrastructure might be pretty obvious, but I will list them anyway. Firstly, seamless consul integration, well both are by HashiCorp, who would have guessed. Nomad is able to selfheal and comes in a single go binary, just like traefik. Jan also claims it has a nice web UI, we have to take his word on that one.

Jan goes into the benefits of using Nomad, just like he went into the benefits of ngnix and shows how their work processes have changed with the change of their environment.

This post doesn’t give enough credit to how much information Jan has shared during his talk. Maybe roughly twenty percent of his talk are covered here. You should definitely check it out the full video to catch all the deeper more insightful topics about the infrastructure and how the applications work with each other.

Alexander Stoll
Alexander Stoll
Junior Consultant

Alexander ist ein Organisationstalent und außerdem seit Kurzem Azubi im Professional Services. Wenn er nicht bei NETWAYS ist, sieht sein Tagesablauf so aus: Montag, Dienstag, Mittwoch Sport - Donnerstag Pen and Paper und ein Wochenende ohne Pläne. Den Sportteil lässt er gern auch mal ausfallen.