Archiv des Monats: Januar 2026

Docker Hub Pull-Statistiken selbst auswerten

Veröffentlicht am von
Antworten

In diesem Artikel möchte ich beschreiben, wie man mit dem „zusammenstecken“ einiger Komponenten eine eigene grafische Auswertung über den Pull Verlauf von Docker Hub Images erstellen kann, die so aussehen könnte:

Der eigentliche Kniff ist nur, die Daten bei Docker Hub abzugreifen über die folgende URL:

https://hub.docker.com/v2/repositories/<namespace>/<name>

Architektur

Wie man in dem Schaubild sieht, wird ein Job zyklisch die Metriken von Docker Hub lesen und in einen MQTT Server pushen. Ein Dienst wird auf die entsprechenden Topics hören, ankommende Daten abgreifen und in einer Opensearch (oder Elasticsearch) Datenbank abspeichern. Ab da kann man diese bequem mit Grafana auslesen.

In meinem Tutorial werde ich Opensearch verwenden, aber die Verwendung von Elasticsearch ist analog möglich wird aber im nachfolgenden Tutorial nicht weiter erwähnt.

Warum so kompliziert? Nun ja, ich habe einen zentralen MQTT Server im Einsatz, der bei mir zu Hause dreh und angelpunkt für Datenaustausch darstellt, daher habe ich das entsprechend entkoppelt. Zudem gibt es anderen Diensten die Möglichkeit gleichzeitig die gesammelten Daten zu verarbeiten.

Umsetzung

Für die exemplartische Umsetzung verwende ich einen Linux Rechner mit vorinstalliertem Docker. Bitte achtet auf genügend Arbeitsspeicher, da die Opensearch Datenbank einiges benötigt. 4 GB sollten aber genügen.

Job

Um die Metriken abzugreifen, habe ich ein kleines Script geschrieben, welches mir die Metriken der Docker Hub Repositories abgreift und in einen MQTT Topic published. Das Script findet Ihr auch in meinem GitHub Repo: https://github.com/cybcon/docker.dockerhubstats2mqtt/blob/main/src/entrypoint.sh. Aus dem Repo heraus erstelle ich einen Docker Container, den Ihr hier findet: https://hub.docker.com/r/oitc/dockerhubstats2mqtt.Dieser ist einfach über Umgebungsvariablen zu konfigurieren.

Die Variable „REPOSITORIES“ enthält die Container Image Repositorie Namen auf die es einem ankommt bei der Visualisierung. Also von diesen werden die Daten gesammelt.Hierzu gibt man der Variable eine, mit Leerzeichen getrennte Liste mit der relevanten Repositories. Jeweils mit dem Docker Hub Namespace und dem eigentlichen Image Namen.

Docker-Compose Beispiel:

services:
  dockerhubstats2mqtt:
    restart: "no"
    user: 5241:5241
    image: oitc/dockerhubstats2mqtt:latest
    environment:
      MQTT_SERVER: test.mosquitto.org
      MQTT_PORT: 1883
      MQTT_TOPIC: com/docker/hub/repositories/metrics
      REPOSITORIES: oitc/dockerhubstats2mqtt oitc/mqtt2elasticsearch
      MQTT_RETAIN: true
      MQTT_TOPIC_REPO_EXTENSION: true

Beim starten des Containers wird das Skript die Daten sammeln und in den MQTT_TOPC publishen und sich dann wieder beenden. Das ganze triggere ich dann via Cron zyklisch, z.B. einmal am Tag:

0  1  *  *  * /usr/bin/docker compose -f /pathto/docker-compose.yml run --rm dockerhubstats2mqtt >/dev/null 2>&1

MQTT

Als MQTT Server nehm ich, zur einfachheit halber, in diesem Tutorial den Testserver von Eclipse Mosquitto. Dieser ist erreichbar auf test.mosquitto.org:1883.

In einem echten Szenario sollte man hier einen eigenen Server aufsetzen.

Service

Um Daten aus einem MQTT Topic auszulesen und in eine Opensearch Datenbank zu speichern, habe ich auch schon vor einiger Zeit ein kleines Python Skript geschrieben, dass genau das macht. Ihr findet das Skript in meinem GitHub Repo: https://github.com/cybcon/docker.mqtt2elasticsearch/blob/main/src/app/bin/mqtt2elasticsearch.py. Auch aus diesem Repo heraus erstelle ich einen Docker Container den Ihr hier findet: https://hub.docker.com/r/oitc/mqtt2elasticsearch.

Das Skipt selbst wird gesteuert durch 2 Konfigurationsdateien. Die „mqtt2elasticsearch.json“ enthält dabei die Verbindungsdaten zu den jeweiligen Servern. Also dem MQTT Server von dem es die Daten bekommt und die Opensearch Datebank, in den es die Daten schrieben soll. Die andere Datei „mqtt2elasticsearch-mappings.json“ dagegen enthält die eigentliche Mapping von MQTT Daten zu Opensearch Index. Einstieg ist immer der MQTT Topic auf den das Tool hören soll und darin wird das Ziel spezifiziert, wohin die Daten geschrieben werden sollen und wie dies dann im Detail aussieht. Dieser „elasticBody“ Bereich ist aber optional. Er ist dafür da, der Datenbank die Entscheidung abzunehmen was es denn für Felder gibt und was für Daten darin enthalten sein werden. Wenn man das weglässt. entscheidet die Datenbak das selbst anhand der Daten.

Die Konfigurationsdatei für die Verbindungsinformationen sieht z.B. so aus (mqtt2elasticsearch.json):

{
"DEBUG": true,
"removeIndex": false,
"opensearch": {
  "hosts": [
     {
       "host": "opensearch-node1",
       "port": 9200
     }
  ],
  "tls": true,
  "verify_certs": false,
  "username": "admin",
  "password": "FooBarBaz-123"
  },
"mqtt": {
  "server": "test.mosquitto.org",
  "port": 1883,
  "tls": false,
  "protocol_version": 3
  }
}

Die Konfigurationsdatei für das Mapping von MQTT Topic und die Opensearch Datenbank sieht z.B. so aus (mqtt2elasticsearch-mappings.json):

{
  "com/docker/hub/repositories/metrics/#": {
    "elasticIndex": "dockerhub-repositories-metrics-{Y}-{m}",
    "elasticBody": {
      "settings": {
        "index": {
          "number_of_shards": 5,
          "number_of_replicas": 0
        }
      },
      "mappings": {
        "properties": {
          "timestamp": { "type": "date" },
          "user": { "type": "keyword" },
          "name": { "type": "keyword" },
          "repository_type": { "type": "keyword" },
          "status": { "type": "integer" },
          "status_description": { "type": "keyword" },
          "description": { "type": "text" },
          "is_private": { "type": "boolean" },
          "is_automated": { "type": "boolean" },
          "star_count": { "type": "integer" },
          "pull_count": { "type": "integer" },
          "last_updated": { "type": "date" },
          "last_modified": { "type": "date" },
          "date_registered": { "type": "date" },
          "collaborator_count": { "type": "integer" },
          "affiliation": { "type": "keyword" },
          "hub_user": { "type": "keyword" },
          "has_starred": { "type": "boolean" },
          "permissions": { "type": "object" },
          "media_types": { "type": "text" },
          "content_types": { "type": "text" },
          "categories": { "type": "object" },
          "immutable_tags": { "type": "boolean" },
          "immutable_tags_rules": { "type": "keyword" },
          "storage_size": { "type": "integer" }
        }
      }
    }
  }
}

Diese beiden Konfigurationsdateien legt man dann im Dateisystem ab und mounted diese als Volume in den Container.

Docker-Compose Beispiel:


services:
  mqtt2elasticsearch:
    restart: unless-stopped
    image: oitc/mqtt2elasticsearch:latest
    container_name: mqtt2elasticsearch
    volumes:
      - /path/to/mqtt2elasticsearch/etc:/app/etc:ro
    depends_on:
      - opensearch-node1

Opensearch / Elasticsearch

Ich glaube, die Opensearch Datenbank zu betreiben ist das kompizierteste an allem, da die ein wenig „Liebe“ benötigt und genügend Ressourcen (RAM). 😀

Docker-Compose Beispiel:

services:
  opensearch-node1:
    restart: unless-stopped
    image: opensearchproject/opensearch:3.4.0
    container_name: opensearch-node1
    environment:
      node.name: opensearch-node1
      discovery.type: single-node
      discovery.seed_hosts: opensearch-node1
      OPENSEARCH_INITIAL_ADMIN_PASSWORD: FooBarBaz-123
      bootstrap.memory_lock: true  # along with the memlock settings below, disables swapping
      OPENSEARCH_JAVA_OPTS: -Xms512m -Xmx512m # minimum and maximum Java heap size, recommend setting both to 50% of system RAM
    ulimits:
      memlock:
        soft: -1
        hard: -1
      nofile:
        soft: 65536
        hard: 65536

Grafana

Nachdem nun alle Vorbereitungen erledigt sind, widmen wir uns der eigentlichen graifschen Auswertung. Hierfür verwende ich Grafana. Das Tool wird häufig auch im Unternehmensumfeld eingesetzt und kann zwischenzeitlich mit vielen Datenquellen interagieren.

Docker Compose Beispiel:

services:
  grafana:
    container_name: grafana
    image: grafana/grafana:12.3-ubuntu
    restart: unless-stopped
    ports:
      - 3000:3000

Nach dem Starten von Grafana, kann man sich mit dem Browser auf http://<server>:3000 verbinden und mit dem Benutzername admin und dem Passwort admin anmelden.

Zunächst brauchen richten wir die Datenquelle ein, also unsere Opensearch Datenbank. Hierfür gibt es im Grafana die Möglichkeit ein passendes Datenbank Plugin zu installieren. wir navigieren im Grafan im Menü zu „Connections“ > „Add new connection“. suchen dort nach „Opensearch“, wählen das Plugin aus und installieren dieses über den „Install“ Button.

Nach der Installation des Plugins können wir die Datenbankverbindung selbst anlegen. Hierzu klicken wir entweder auf den Button „Add a new datasource“ nach der Plugin Installation oder Navigieren im Menü zu „Connections“ > „Data sources“ und wählen dort „Add data source“ und wählen hier „Opensearch“. Hier machen wir folgende Konfigurationen:

Namedockerhub-repositories-metrics
HTTP: URLhttps://opensearch-node1:9200
Auth: Basic autheinschalten
Auth: With Credentialseinschalten
Auth: Skip TLS Verifyeinschalten
Auth: Basic Auth Details: Useradmin
Auth: Basic Auth Details: PasswordFooBarBaz-123
OpenSearch details: Index namedockerhub-repositories-metrics-*
OpenSearch details: Time field nametimestamp (ohne das @ Zeichen)
OpenSearch details: VersionAuf „Get Version and Save“ klicken sollte die Version entsprechend finden. (hier OpenSearch 3.4.0)
Grafana Konfiguration für Opensearch Datenquelle

Nach Eingabe der Daten, sollte über Klick auf „Save & test“ alles gün sein.

Danach richten wir das Dashboard ein. Hierzu navigieren wir im Grafana im Menü nach „Dashboards“ und Klicken hier auf „Create dashboard“. Nun haben wir die Wahl, ob wir komplett frisch anfangen wollen oder ob wir ein fertiges Dashboard importieren möchten. Das passende Dashboard habe ich bei Grafan hochgeladen und kann über ID: 24696 einfach importiert werden. Hier auch der Link zum Dashboard: https://grafana.com/grafana/dashboards/24696-docker-image-pulls/. Daher klicken wir im Bereich „Import a dashboard“ auf den Button „mport dashboard“.

Auf dem nächsten Screen können wir die Dashboard ID (24696) eingeben und per Klick auf „Load“ das Dashboard laden.

Auf dem daraufhin folgenden Screen müssen wir nur noch unsere vorher angelegte Datenquelle (dockerhub-repositories-metrics) auswählen und auf „Import“ klicken.

Dann sollte einem das Dashboard mit den Daten angezeigt werden. Sollten hier noch keine Daten auftauchen, kann man:

  1. das Tool dockerhubstats2mqtt einmal manuell aufrufen
  2. Den Zeitraum des Dashboards vom Default (30 Tage) auf zum Beispiel „Last 15 minutes“ einstellen.

Die gesamte Docker Compose Konfiguration

Da dies im Verlauf ein wenig zerstückelt war, hier nochmals die gesamt Docker Compose Konfiguration. Bitte beachtet, dass Ihr die beiden Konfigurationsdateien vom mqtt2ealsticsearch passend platzieren müsst und den Pfad bei „volumes“ dann richtig angeben müsst.

services:
  dockerhubstats2mqtt:
    restart: "no"
    user: 5241:5241
    image: oitc/dockerhubstats2mqtt:latest
    environment:
      MQTT_SERVER: test.mosquitto.org
      MQTT_PORT: 1883
      MQTT_TOPIC: com/docker/hub/repositories/metrics
      REPOSITORIES: oitc/dockerhubstats2mqtt oitc/mqtt2elasticsearch
      MQTT_RETAIN: true
      MQTT_TOPIC_REPO_EXTENSION: true

  mqtt2elasticsearch:
    restart: unless-stopped
    image: oitc/mqtt2elasticsearch:latest
    container_name: mqtt2elasticsearch
    volumes:
      - /path/to/mqtt2elasticsearch/etc:/app/etc:ro
    depends_on:
      - opensearch-node1

  opensearch-node1:
    restart: unless-stopped
    image: opensearchproject/opensearch:3.4.0
    container_name: opensearch-node1
    environment:
      node.name: opensearch-node1
      discovery.type: single-node
      discovery.seed_hosts: opensearch-node1
      OPENSEARCH_INITIAL_ADMIN_PASSWORD: FooBarBaz-123
      bootstrap.memory_lock: true  # along with the memlock settings below, disables swapping
      OPENSEARCH_JAVA_OPTS: -Xms512m -Xmx512m # minimum and maximum Java heap size, recommend setting both to 50% of system RAM
    ulimits:
      memlock:
        soft: -1
        hard: -1
      nofile:
        soft: 65536
        hard: 65536

  grafana:
    container_name: grafana
    image: grafana/grafana:12.3-ubuntu
    restart: unless-stopped
    ports:
      - 3000:3000

Hinweise

datenpersitenz

Dieses kleine Tutorial verwendet keinerlei Persistenz. D.b. wenn Ihr die Docker Container wegwerft oder erneuert, dann sind die gesammelten historischen Daten auch weg.

  • Bei Grafana sind die Daten im Container Image an der Stelle „/var/lib/grafana„.
  • Bei Opensearch sind die Daten im Container Image an der Stelle „/usr/share/opensearch/data„

Passwörter und Zugänge

Das sind ganz einfache Beispiel, bitte verwendet richtige Passwörter. Im Unternehmenskontext sollte man auch nicht mit dem „admin“ user arbeiten sondern dedizierte Accounts anlegen die eben auch nur die Rechte haben, die benötigt werden.

TLS Zertifikate

Die Verbindungen sind alle unverschlüsselt bis auf die Verbindung zur Opensearch Datenbank. Und Opensearch verwendet ein selbst generiertes Zertifikat. In einer „echten“ Umgebung im Unternehmenskontext verwenden die Tools auch „echte“ Zertifikate um den Netzwerkverkehr abzusichern. Hier wird auch die TLS Validierung nicht deaktiviert.

Links