image-checker/main.go

package main

import (
	"context"
	"fmt"
	"log"
	"net/http"
	"regexp"
	"strings"
	"sync"

	"github.com/docker/docker/api/types/image"
	"github.com/docker/docker/client"
	"github.com/prometheus/client_golang/prometheus"
	"github.com/prometheus/client_golang/prometheus/promhttp"
	"github.com/regclient/regclient"
	"github.com/regclient/regclient/types/ref"
)

// Hilfsfunktion: registry/repo:tag für regclient
func toRegistryImage(imageTag string) (string, error) {
	r := regexp.MustCompile(`^(?:(?P<registry>[^/]+)/)?(?P<repo>[^:]+)(?::(?P<tag>.+))?$`)
	match := r.FindStringSubmatch(imageTag)
	if len(match) == 0 {
		return "", fmt.Errorf("Image-Tag nicht erkannt: %s", imageTag)
	}
	registry := match[r.SubexpIndex("registry")]
	repo := match[r.SubexpIndex("repo")]
	tag := match[r.SubexpIndex("tag")]
	if registry == "" {
		registry = "registry-1.docker.io"
	}
	if tag == "" {
		tag = "latest"
	}
	return fmt.Sprintf("%s/%s:%s", registry, repo, tag), nil
}

// Extrahiere nur den sha256:digest
func extractDigest(s string) string {
	for _, part := range strings.Split(s, "@") {
		if strings.HasPrefix(part, "sha256:") {
			return part
		}
	}
	return s
}

type imageUpdateCollector struct {
	metric *prometheus.Desc
}

func newImageUpdateCollector() *imageUpdateCollector {
	return &imageUpdateCollector{
		metric: prometheus.NewDesc(
			"docker_image_update_available",
			"Ob Update für das lokale Docker-Image für das Tag im Registry verfügbar ist (1=Update, 0=aktuell)",
			[]string{"image", "tag"},
			nil,
		),
	}
}

func (c *imageUpdateCollector) Describe(ch chan<- *prometheus.Desc) {
	ch <- c.metric
}

func (c *imageUpdateCollector) Collect(ch chan<- prometheus.Metric) {
	ctx := context.Background()
	cli, err := client.NewClientWithOpts(client.FromEnv)
	if err != nil {
		log.Printf("Fehler bei Docker-Client: %v", err)
		return
	}
	defer cli.Close()
	rc := regclient.New()

	images, err := cli.ImageList(ctx, image.ListOptions{All: true})
	if err != nil {
		log.Printf("Fehler bei ImageList: %v", err)
		return
	}

	var wg sync.WaitGroup
	for _, img := range images {
		for _, tag := range img.RepoTags {
			wg.Add(1)
			go func(tag string, img image.Summary) {
				defer wg.Done()
				imageRef, err := toRegistryImage(tag)
				if err != nil {
					log.Printf("ImageRef-Fehler bei %s: %v", tag, err)
					return
				}

				// Lokalen Digest holen
				var localDigest string
				if len(img.RepoDigests) > 0 {
					localDigest = extractDigest(img.RepoDigests[0])
				} else {
					localDigest = img.ID
				}

				// Remote Digest holen
				refObj, err := ref.New(imageRef)
				if err != nil {
					log.Printf("ImageRef (regclient) ungültig (%s): %v", tag, err)
					return
				}
				desc, err := rc.ManifestHead(ctx, refObj)
				if err != nil {
					log.Printf("Remote-Manifest nicht gefunden (%s): %v", tag, err)
					return
				}
				remoteDigest := desc.GetDigest().String()

				// Logging
				fmt.Printf("Image: %s\n  Local Digest:  %s\n  Remote Digest: %s\n", tag, localDigest, remoteDigest)
				var update float64 = 0
				if localDigest != remoteDigest {
					fmt.Println("  -> Update verfügbar!")
					update = 1
				} else {
					fmt.Println("  -> Kein Update verfügbar.")
				}

				labelImg, labelTag := tag, "latest"
				if cp := strings.Split(tag, ":"); len(cp) == 2 {
					labelImg, labelTag = cp[0], cp[1]
				}
				ch <- prometheus.MustNewConstMetric(
					c.metric, prometheus.GaugeValue,
					update, labelImg, labelTag,
				)
			}(tag, img)
		}
	}
	wg.Wait()
}

func main() {
	log.Println("Starte Docker-Image-Update Prometheus Exporter (Port 9788)...")
	exporter := newImageUpdateCollector()
	prometheus.MustRegister(exporter)
	http.Handle("/metrics", promhttp.Handler())
	log.Fatal(http.ListenAndServe(":9788", nil))
}