Implementierung eines Auftragsverarbeitungssystems: Teileüberwachung und -warnung

1. Einführung und Ziele

Willkommen zum vierten Teil unserer Serie über die Implementierung eines anspruchsvollen Auftragsabwicklungssystems! In unseren vorherigen Beiträgen haben wir den Grundstein für unser Projekt gelegt, erweiterte zeitliche Arbeitsabläufe untersucht und uns mit erweiterten Datenbankoperationen befasst. Heute konzentrieren wir uns auf einen ebenso wichtigen Aspekt jedes produktionsbereiten Systems: Überwachung und Alarmierung.

Zusammenfassung früherer Beiträge

1. In Teil 1 haben wir unsere Projektstruktur eingerichtet und eine grundlegende CRUD-API implementiert.
2. In Teil 2 haben wir unseren Einsatz von Temporal erweitert, komplexe Arbeitsabläufe implementiert und fortgeschrittene Konzepte untersucht.
3. In Teil 3 haben wir uns auf fortgeschrittene Datenbankoperationen konzentriert, einschließlich Optimierung, Sharding und Sicherstellung der Konsistenz in verteilten Systemen.

Bedeutung von Überwachung und Warnung in der Microservices-Architektur

In einer Microservices-Architektur, insbesondere bei der Abwicklung komplexer Prozesse wie Auftragsverwaltung, sind effektive Überwachung und Alarmierung von entscheidender Bedeutung. Sie ermöglichen uns:

1. Verstehen Sie das Verhalten und die Leistung unseres Systems in Echtzeit
2. Probleme schnell identifizieren und diagnostizieren, bevor sie sich auf Benutzer auswirken
3. Treffen Sie datengesteuerte Entscheidungen zur Skalierung und Optimierung
4. Stellen Sie die Zuverlässigkeit und Verfügbarkeit unserer Dienste sicher

Überblick über Prometheus und sein Ökosystem

Prometheus ist ein Open-Source-Toolkit zur Systemüberwachung und -warnung. Aufgrund seiner leistungsstarken Funktionen und seines umfangreichen Ökosystems ist es zum Standard in der Cloud-nativen Welt geworden. Zu den Schlüsselkomponenten gehören:

1. Prometheus Server: Scrapt und speichert Zeitreihendaten
2. Client-Bibliotheken: Ermöglichen eine einfache Instrumentierung von Anwendungscode
3. Alertmanager: Verarbeitet Warnungen vom Prometheus-Server
4. Pushgateway: Ermöglicht kurzlebigen und Batch-Jobs die Offenlegung von Metriken
5. Exporteure: Erlauben Sie Drittanbietersystemen, Metriken für Prometheus verfügbar zu machen

Wir werden außerdem Grafana, eine beliebte Open-Source-Plattform für Überwachung und Beobachtbarkeit, verwenden, um Dashboards zu erstellen und unsere Prometheus-Daten zu visualisieren.

Ziele für diesen Teil der Serie

Am Ende dieses Beitrags werden Sie in der Lage sein:

1. Richten Sie Prometheus ein, um unser Auftragsverarbeitungssystem zu überwachen
2. Implementieren Sie benutzerdefinierte Metriken in unseren Go-Diensten
3. Erstellen Sie informative Dashboards mit Grafana
4. Richten Sie Warnregeln ein, um uns über potenzielle Probleme zu informieren
5. Überwachen Sie die Datenbankleistung und zeitliche Arbeitsabläufe effektiv

Lass uns eintauchen!

2. Theoretischer Hintergrund und Konzepte

Bevor wir mit der Implementierung beginnen, werfen wir einen Blick auf einige Schlüsselkonzepte, die für unsere Überwachungs- und Alarmierungseinrichtung von entscheidender Bedeutung sind.

Beobachtbarkeit in verteilten Systemen

Beobachtbarkeit bezieht sich auf die Fähigkeit, den internen Zustand eines Systems durch die Untersuchung seiner Ergebnisse zu verstehen. In verteilten Systemen wie unserem Auftragsverarbeitungssystem umfasst die Beobachtbarkeit typischerweise drei Hauptpfeiler:

1. Metriken: Numerische Darstellungen von Daten, die über Zeitintervalle gemessen wurden
2. Protokolle: Detaillierte Aufzeichnungen einzelner Ereignisse innerhalb des Systems
3. Spuren: Darstellungen kausaler Ereignisketten über Komponenten hinweg

In diesem Beitrag konzentrieren wir uns hauptsächlich auf Metriken, gehen jedoch darauf ein, wie diese in Protokolle und Traces integriert werden können.

Prometheus-Architektur

Prometheus folgt einer Pull-basierten Architektur:

1. Datenerfassung: Prometheus kratzt Metriken aus instrumentierten Jobs über HTTP
2. Datenspeicherung: Metriken werden in einer Zeitreihendatenbank im lokalen Speicher gespeichert
3. Abfragen: PromQL ermöglicht eine flexible Abfrage dieser Daten
4. Alarmierung: Prometheus kann Warnungen basierend auf Abfrageergebnissen auslösen
5. Visualisierung: Prometheus verfügt zwar über eine einfache Benutzeroberfläche, wird jedoch häufig mit Grafana für umfassendere Visualisierungen kombiniert

Metriktypen in Prometheus

Prometheus bietet vier Kernmetriktypen:

1. Zähler: Eine kumulative Metrik, die nur steigt (z. B. Anzahl der verarbeiteten Anfragen)
2. Messwert: Eine Metrik, die nach oben und unten gehen kann (z. B. aktuelle Speichernutzung)
3. Histogramm: Erfasst Beobachtungen und zählt sie in konfigurierbaren Zeiträumen (z. B. Anforderungsdauer)
4. Zusammenfassung: Ähnlich wie ein Histogramm, berechnet jedoch konfigurierbare Quantile über ein gleitendes Zeitfenster

Einführung in PromQL

PromQL (Prometheus Query Language) ist eine leistungsstarke funktionale Sprache zum Abfragen von Prometheus-Daten. Es ermöglicht Ihnen, Zeitreihendaten in Echtzeit auszuwählen und zu aggregieren. Zu den Hauptmerkmalen gehören:

• Sofortige Vektorselektoren
• Bereichsvektorselektoren
• Offset-Modifikator
• Aggregationsoperatoren
• Binäre Operatoren

Wir werden Beispiele für PromQL-Abfragen sehen, während wir unsere Dashboards und Warnungen erstellen.

Überblick über Grafana

Grafana ist eine plattformübergreifende Open-Source-Webanwendung für Analyse und interaktive Visualisierung. Es stellt Diagramme, Grafiken und Warnungen für das Web bereit, wenn es mit unterstützten Datenquellen verbunden ist, zu denen auch Prometheus gehört. Zu den Hauptmerkmalen gehören:

• Flexible Dashboard-Erstellung
• Große Auswahl an Visualisierungsmöglichkeiten
• Alarmfunktionen
• Benutzerauthentifizierung und -autorisierung
• Plugin-System zur Erweiterbarkeit

Da wir nun diese Konzepte behandelt haben, beginnen wir mit der Implementierung unseres Überwachungs- und Warnsystems.

3. Einrichten von Prometheus für unser Auftragsverarbeitungssystem

Beginnen wir mit der Einrichtung von Prometheus zur Überwachung unseres Auftragsabwicklungssystems.

Prometheus installieren und konfigurieren

Zuerst fügen wir Prometheus zu unserer docker-compose.yml-Datei hinzu:

services:
  # ... other services ...

  prometheus:
    image: prom/prometheus:v2.30.3
    volumes:
      - ./prometheus:/etc/prometheus
      - prometheus_data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--web.console.libraries=/usr/share/prometheus/console_libraries'
      - '--web.console.templates=/usr/share/prometheus/consoles'
    ports:
      - 9090:9090

volumes:
  # ... other volumes ...
  prometheus_data: {}

Als nächstes erstellen Sie eine prometheus.yml-Datei im Verzeichnis ./prometheus:

global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']

  - job_name: 'order_processing_api'
    static_configs:
      - targets: ['order_processing_api:8080']

  - job_name: 'postgres'
    static_configs:
      - targets: ['postgres_exporter:9187']

Diese Konfiguration weist Prometheus an, Metriken von sich selbst, unserer Auftragsverarbeitungs-API und einem Postgres-Exporter (den wir später einrichten werden) zu extrahieren.

Implementierung von Prometheus Exporters für unsere Go-Dienste

Um Metriken aus unseren Go-Diensten bereitzustellen, verwenden wir die Prometheus-Clientbibliothek. Fügen Sie es zunächst Ihrem go.mod hinzu:

go get github.com/prometheus/client_golang

Jetzt ändern wir unsere Haupt-Go-Datei, um Metriken verfügbar zu machen:

package main

import (
    "net/http"

    "github.com/gin-gonic/gin"
    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promhttp"
)

var (
    httpRequestsTotal = prometheus.NewCounterVec(
        prometheus.CounterOpts{
            Name: "http_requests_total",
            Help: "Total number of HTTP requests",
        },
        []string{"method", "endpoint", "status"},
    )

    httpRequestDuration = prometheus.NewHistogramVec(
        prometheus.HistogramOpts{
            Name: "http_request_duration_seconds",
            Help: "Duration of HTTP requests in seconds",
            Buckets: prometheus.DefBuckets,
        },
        []string{"method", "endpoint"},
    )
)

func init() {
    prometheus.MustRegister(httpRequestsTotal)
    prometheus.MustRegister(httpRequestDuration)
}

func main() {
    r := gin.Default()

    // Middleware to record metrics
    r.Use(func(c *gin.Context) {
        timer := prometheus.NewTimer(httpRequestDuration.WithLabelValues(c.Request.Method, c.FullPath()))
        c.Next()
        timer.ObserveDuration()
        httpRequestsTotal.WithLabelValues(c.Request.Method, c.FullPath(), string(c.Writer.Status())).Inc()
    })

    // Expose metrics endpoint
    r.GET("/metrics", gin.WrapH(promhttp.Handler()))

    // ... rest of your routes ...

    r.Run(":8080")
}

Dieser Code richtet zwei Metriken ein:

1. http_requests_total: Ein Zähler, der die Gesamtzahl der HTTP-Anfragen verfolgt
2. http_request_duration_seconds: Ein Histogramm, das die Dauer von HTTP-Anfragen verfolgt

Einrichten der Serviceerkennung für dynamische Umgebungen

Für dynamischere Umgebungen unterstützt Prometheus verschiedene Service-Erkennungsmechanismen. Wenn Sie beispielsweise Kubernetes verwenden, können Sie die Kubernetes SD-Konfiguration verwenden:

scrape_configs:
  - job_name: 'kubernetes-pods'
    kubernetes_sd_configs:
      - role: pod
    relabel_configs:
      - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_scrape]
        action: keep
        regex: true
      - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_path]
        action: replace
        target_label: __metrics_path__
        regex: (.+)

Diese Konfiguration erkennt und extrahiert automatisch Metriken aus Pods mit den entsprechenden Anmerkungen.

Konfigurieren der Aufbewahrung und Speicherung für Prometheus-Daten

Prometheus speichert Daten in einer Zeitreihendatenbank im lokalen Dateisystem. Sie können Aufbewahrungszeit und Speichergröße in der Prometheus-Konfiguration konfigurieren:

global:
  scrape_interval: 15s
  evaluation_interval: 15s

storage:
  tsdb:
    retention.time: 15d
    retention.size: 50GB

# ... rest of the configuration ...

Diese Konfiguration legt einen Aufbewahrungszeitraum von 15 Tagen und eine maximale Speichergröße von 50 GB fest.

Im nächsten Abschnitt befassen wir uns mit der Definition und Implementierung benutzerdefinierter Metriken für unser Auftragsabwicklungssystem.

4. Definieren und Implementieren benutzerdefinierter Metriken

Nachdem wir Prometheus nun eingerichtet und grundlegende HTTP-Metriken implementiert haben, definieren und implementieren wir benutzerdefinierte Metriken, die speziell für unser Auftragsverarbeitungssystem gelten.

Entwerfen eines Metrikschemas für unser Auftragsverarbeitungssystem

Beim Entwerfen von Metriken ist es wichtig, darüber nachzudenken, welche Erkenntnisse wir aus unserem System gewinnen möchten. Für unser Bestellabwicklungssystem möchten wir möglicherweise Folgendes verfolgen:

1. Auftragserstellungsrate
2. Auftragsbearbeitungszeit
3. Bestellstatusverteilung
4. Erfolgs-/Fehlerquote bei der Zahlungsabwicklung
5. Inventaraktualisierungsvorgänge
6. Versandvereinbarungszeit

Lassen Sie uns diese Metriken implementieren:

package metrics

import (
    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promauto"
)

var (
    OrdersCreated = promauto.NewCounter(prometheus.CounterOpts{
        Name: "orders_created_total",
        Help: "The total number of created orders",
    })

    OrderProcessingTime = promauto.NewHistogram(prometheus.HistogramOpts{
        Name: "order_processing_seconds",
        Help: "Time taken to process an order",
        Buckets: prometheus.LinearBuckets(0, 30, 10), // 0-300 seconds, 30-second buckets
    })

    OrderStatusGauge = promauto.NewGaugeVec(prometheus.GaugeOpts{
        Name: "orders_by_status",
        Help: "Number of orders by status",
    }, []string{"status"})

    PaymentProcessed = promauto.NewCounterVec(prometheus.CounterOpts{
        Name: "payments_processed_total",
        Help: "The total number of processed payments",
    }, []string{"status"})

    InventoryUpdates = promauto.NewCounter(prometheus.CounterOpts{
        Name: "inventory_updates_total",
        Help: "The total number of inventory updates",
    })

    ShippingArrangementTime = promauto.NewHistogram(prometheus.HistogramOpts{
        Name: "shipping_arrangement_seconds",
        Help: "Time taken to arrange shipping",
        Buckets: prometheus.LinearBuckets(0, 60, 5), // 0-300 seconds, 60-second buckets
    })
)

Implementierung anwendungsspezifischer Metriken in unseren Go-Services

Da wir nun unsere Metriken definiert haben, implementieren wir sie in unseren Service:

package main

import (
    "time"

    "github.com/yourusername/order-processing-system/metrics"
)

func createOrder(order Order) error {
    startTime := time.Now()

    // Order creation logic...

    metrics.OrdersCreated.Inc()
    metrics.OrderProcessingTime.Observe(time.Since(startTime).Seconds())
    metrics.OrderStatusGauge.WithLabelValues("pending").Inc()

    return nil
}

func processPayment(payment Payment) error {
    // Payment processing logic...

    if paymentSuccessful {
        metrics.PaymentProcessed.WithLabelValues("success").Inc()
    } else {
        metrics.PaymentProcessed.WithLabelValues("failure").Inc()
    }

    return nil
}

func updateInventory(item Item) error {
    // Inventory update logic...

    metrics.InventoryUpdates.Inc()

    return nil
}

func arrangeShipping(order Order) error {
    startTime := time.Now()

    // Shipping arrangement logic...

    metrics.ShippingArrangementTime.Observe(time.Since(startTime).Seconds())

    return nil
}

Best Practices für die Benennung und Kennzeichnung von Metriken

Berücksichtigen Sie beim Benennen und Kennzeichnen von Metriken die folgenden Best Practices:

1. Use a consistent naming scheme (e.g., __)
2. Use clear, descriptive names
3. Include units in the metric name (e.g., _seconds, _bytes)
4. Use labels to differentiate instances of a metric, but be cautious of high cardinality
5. Keep the number of labels manageable

Instrumenting Key Components: API Endpoints, Database Operations, Temporal Workflows

For API endpoints, we’ve already implemented basic instrumentation. For database operations, we can add metrics like this:

func (s *Store) GetOrder(ctx context.Context, id int64) (Order, error) {
    startTime := time.Now()
    defer func() {
        metrics.DBOperationDuration.WithLabelValues("GetOrder").Observe(time.Since(startTime).Seconds())
    }()

    // Existing GetOrder logic...
}

For Temporal workflows, we can add metrics in our activity implementations:

func ProcessOrderActivity(ctx context.Context, order Order) error {
    startTime := time.Now()
    defer func() {
        metrics.WorkflowActivityDuration.WithLabelValues("ProcessOrder").Observe(time.Since(startTime).Seconds())
    }()

    // Existing ProcessOrder logic...
}

5. Creating Dashboards with Grafana

Now that we have our metrics set up, let’s visualize them using Grafana.

Installing and Configuring Grafana

First, let’s add Grafana to our docker-compose.yml:

services:
  # ... other services ...

  grafana:
    image: grafana/grafana:8.2.2
    ports:
      - 3000:3000
    volumes:
      - grafana_data:/var/lib/grafana

volumes:
  # ... other volumes ...
  grafana_data: {}

Connecting Grafana to Our Prometheus Data Source

1. Access Grafana at http://localhost:3000 (default credentials are admin/admin)
2. Go to Configuration > Data Sources
3. Click “Add data source” and select Prometheus
4. Set the URL to http://prometheus:9090 (this is the Docker service name)
5. Click “Save & Test”

Designing Effective Dashboards for Our Order Processing System

Let’s create a dashboard for our order processing system:

1. Click “Create” > “Dashboard”
2. Add a new panel

For our first panel, let’s create a graph of order creation rate:

1. In the query editor, enter: rate(orders_created_total[5m])
2. Set the panel title to “Order Creation Rate”
3. Under Settings, set the unit to “orders/second”

Let’s add another panel for order processing time:

1. Add a new panel
2. Query: histogram_quantile(0.95, rate(order_processing_seconds_bucket[5m]))
3. Title: “95th Percentile Order Processing Time”
4. Unit: “seconds”

For order status distribution:

1. Add a new panel
2. Query: orders_by_status
3. Visualization: Pie Chart
4. Title: “Order Status Distribution”

Continue adding panels for other metrics we’ve defined.

Implementing Variable Templating for Flexible Dashboards

Grafana allows us to create variables that can be used across the dashboard. Let’s create a variable for time range:

1. Go to Dashboard Settings > Variables
2. Click “Add variable”
3. Name: time_range
4. Type: Interval
5. Values: 5m,15m,30m,1h,6h,12h,24h,7d

Now we can use this in our queries like this: rate(orders_created_total[$time_range])

Best Practices for Dashboard Design and Organization

1. Group related panels together
2. Use consistent color schemes
3. Include a description for each panel
4. Use appropriate visualizations for each metric type
5. Consider creating separate dashboards for different aspects of the system (e.g., Orders, Inventory, Shipping)

In the next section, we’ll set up alerting rules to notify us of potential issues in our system.

6. Implementing Alerting Rules

Now that we have our metrics and dashboards set up, let’s implement alerting to proactively notify us of potential issues in our system.

Designing an Alerting Strategy for Our System

When designing alerts, consider the following principles:

1. Alert on symptoms, not causes
2. Ensure alerts are actionable
3. Avoid alert fatigue by only alerting on critical issues
4. Use different severity levels for different types of issues

For our order processing system, we might want to alert on:

1. High error rate in order processing
2. Slow order processing time
3. Unusual spike or drop in order creation rate
4. Low inventory levels
5. High rate of payment failures

Implementing Prometheus Alerting Rules

Let’s create an alerts.yml file in our Prometheus configuration directory:

groups:
- name: order_processing_alerts
  rules:
  - alert: HighOrderProcessingErrorRate
    expr: rate(order_processing_errors_total[5m]) / rate(orders_created_total[5m]) > 0.05
    for: 5m
    labels:
      severity: critical
    annotations:
      summary: High order processing error rate
      description: "Error rate is over the last 5 minutes"

  - alert: SlowOrderProcessing
    expr: histogram_quantile(0.95, rate(order_processing_seconds_bucket[5m])) > 300
    for: 10m
    labels:
      severity: warning
    annotations:
      summary: Slow order processing
      description: "95th percentile of order processing time is over the last 5 minutes"

  - alert: UnusualOrderRate
    expr: abs(rate(orders_created_total[1h]) - rate(orders_created_total[1h] offset 1d)) > (rate(orders_created_total[1h] offset 1d) * 0.3)
    for: 30m
    labels:
      severity: warning
    annotations:
      summary: Unusual order creation rate
      description: "Order creation rate has changed by more than 30% compared to the same time yesterday"

  - alert: LowInventory
    expr: inventory_level  0.1
    for: 15m
    labels:
      severity: critical
    annotations:
      summary: High payment failure rate
      description: "Payment failure rate is over the last 15 minutes"

Update your prometheus.yml to include this alerts file:

rule_files:
  - "alerts.yml"

Setting Up Alertmanager for Alert Routing and Grouping

Now, let’s set up Alertmanager to handle our alerts. Add Alertmanager to your docker-compose.yml:

services:
  # ... other services ...

  alertmanager:
    image: prom/alertmanager:v0.23.0
    ports:
      - 9093:9093
    volumes:
      - ./alertmanager:/etc/alertmanager
    command:
      - '--config.file=/etc/alertmanager/alertmanager.yml'

Create an alertmanager.yml in the ./alertmanager directory:

route:
  group_by: ['alertname']
  group_wait: 30s
  group_interval: 5m
  repeat_interval: 1h
  receiver: 'email-notifications'

receivers:
- name: 'email-notifications'
  email_configs:
  - to: 'team@example.com'
    from: 'alertmanager@example.com'
    smarthost: 'smtp.example.com:587'
    auth_username: 'alertmanager@example.com'
    auth_identity: 'alertmanager@example.com'
    auth_password: 'password'

Update your prometheus.yml to point to Alertmanager:

alerting:
  alertmanagers:
    - static_configs:
        - targets:
          - alertmanager:9093

Configuring Notification Channels

In the Alertmanager configuration above, we’ve set up email notifications. You can also configure other channels like Slack, PagerDuty, or custom webhooks.

Implementing Alert Severity Levels and Escalation Policies

In our alerts, we’ve used severity labels. We can use these in Alertmanager to implement different routing or notification strategies based on severity:

route:
  group_by: ['alertname']
  group_wait: 30s
  group_interval: 5m
  repeat_interval: 1h
  receiver: 'email-notifications'
  routes:
  - match:
      severity: critical
    receiver: 'pagerduty-critical'
  - match:
      severity: warning
    receiver: 'slack-warnings'

receivers:
- name: 'email-notifications'
  email_configs:
  - to: 'team@example.com'
- name: 'pagerduty-critical'
  pagerduty_configs:
  - service_key: '<your-pagerduty-service-key>'
- name: 'slack-warnings'
  slack_configs:
  - api_url: '<your-slack-webhook-url>'
    channel: '#alerts'

</your-slack-webhook-url></your-pagerduty-service-key>

7. Monitoring Database Performance

Monitoring database performance is crucial for maintaining a responsive and reliable system. Let’s set up monitoring for our PostgreSQL database.

Implementing the Postgres Exporter for Prometheus

First, add the Postgres exporter to your docker-compose.yml:

services:
  # ... other services ...

  postgres_exporter:
    image: wrouesnel/postgres_exporter:latest
    environment:
      DATA_SOURCE_NAME: "postgresql://user:password@postgres:5432/dbname?sslmode=disable"
    ports:
      - 9187:9187

Make sure to replace user, password, and dbname with your actual PostgreSQL credentials.

Key Metrics to Monitor for Postgres Performance

Some important PostgreSQL metrics to monitor include:

1. Number of active connections
2. Database size
3. Query execution time
4. Cache hit ratio
5. Replication lag (if using replication)
6. Transaction rate
7. Tuple operations (inserts, updates, deletes)

Creating a Database Performance Dashboard in Grafana

Let’s create a new dashboard for database performance:

1. Create a new dashboard in Grafana
2. Add a panel for active connections:
   • Query: pg_stat_activity_count{datname="your_database_name"}
   • Title: “Active Connections”
3. Add a panel for database size:
   • Query: pg_database_size_bytes{datname="your_database_name"}
   • Title: “Database Size”
   • Unit: bytes(IEC)
4. Add a panel for query execution time:
   • Query: rate(pg_stat_database_xact_commit{datname="your_database_name"}[5m]) + rate(pg_stat_database_xact_rollback{datname="your_database_name"}[5m])
   • Title: “Transactions per Second”
5. Add a panel for cache hit ratio:
   • Query: pg_stat_database_blks_hit{datname="your_database_name"} / (pg_stat_database_blks_hit{datname="your_database_name"} + pg_stat_database_blks_read{datname="your_database_name"})
   • Title: “Cache Hit Ratio”

Setting Up Alerts for Database Issues

Let’s add some database-specific alerts to our alerts.yml:

  - alert: HighDatabaseConnections
    expr: pg_stat_activity_count > 100
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: High number of database connections
      description: "There are active database connections"

  - alert: LowCacheHitRatio
    expr: pg_stat_database_blks_hit / (pg_stat_database_blks_hit + pg_stat_database_blks_read) 



<h2>
  
  
  8. Monitoring Temporal Workflows
</h2>

<p>Monitoring Temporal workflows is essential for ensuring the reliability and performance of our order processing system.</p>

<h3>
  
  
  Implementing Temporal Metrics in Our Go Services
</h3>

<p>Temporal provides a metrics client that we can use to expose metrics to Prometheus. Let’s update our Temporal worker to include metrics:<br>
</p>

<pre class="brush:php;toolbar:false">import (
    "go.temporal.io/sdk/client"
    "go.temporal.io/sdk/worker"
    "go.temporal.io/sdk/contrib/prometheus"
)

func main() {
    // ... other setup ...

    // Create Prometheus metrics handler
    metricsHandler := prometheus.NewPrometheusMetricsHandler()

    // Create Temporal client with metrics
    c, err := client.NewClient(client.Options{
        MetricsHandler: metricsHandler,
    })
    if err != nil {
        log.Fatalln("Unable to create Temporal client", err)
    }
    defer c.Close()

    // Create worker with metrics
    w := worker.New(c, "order-processing-task-queue", worker.Options{
        MetricsHandler: metricsHandler,
    })

    // ... register workflows and activities ...

    // Run the worker
    err = w.Run(worker.InterruptCh())
    if err != nil {
        log.Fatalln("Unable to start worker", err)
    }
}

Key Metrics to Monitor for Temporal Workflows

Important Temporal metrics to monitor include:

1. Workflow start rate
2. Workflow completion rate
3. Workflow execution time
4. Activity success/failure rate
5. Activity execution time
6. Task queue latency

Creating a Temporal Workflow Dashboard in Grafana

Let’s create a dashboard for Temporal workflows:

1. Create a new dashboard in Grafana
2. Add a panel for workflow start rate:
   • Query: rate(temporal_workflow_start_total[5m])
   • Title: “Workflow Start Rate”
3. Add a panel for workflow completion rate:
   • Query: rate(temporal_workflow_completed_total[5m])
   • Title: “Workflow Completion Rate”
4. Add a panel for workflow execution time:
   • Query: histogram_quantile(0.95, rate(temporal_workflow_execution_time_bucket[5m]))
   • Title: “95th Percentile Workflow Execution Time”
   • Unit: seconds
5. Add a panel for activity success rate:
   • Query: rate(temporal_activity_success_total[5m]) / (rate(temporal_activity_success_total[5m]) + rate(temporal_activity_fail_total[5m]))
   • Title: “Activity Success Rate”

Setting Up Alerts for Workflow Issues

Let’s add some Temporal-specific alerts to our alerts.yml:

  - alert: HighWorkflowFailureRate
    expr: rate(temporal_workflow_failed_total[15m]) / rate(temporal_workflow_completed_total[15m]) > 0.05
    for: 15m
    labels:
      severity: critical
    annotations:
      summary: High workflow failure rate
      description: "Workflow failure rate is over the last 15 minutes"

  - alert: LongRunningWorkflow
    expr: histogram_quantile(0.95, rate(temporal_workflow_execution_time_bucket[1h])) > 3600
    for: 30m
    labels:
      severity: warning
    annotations:
      summary: Long-running workflows detected
      description: "95th percentile of workflow execution time is over 1 hour"

These alerts will help you detect issues with your Temporal workflows, such as high failure rates or unexpectedly long-running workflows.

In the next sections, we’ll cover some advanced Prometheus techniques and discuss testing and validation of our monitoring setup.

9. Advanced Prometheus Techniques

As our monitoring system grows more complex, we can leverage some advanced Prometheus techniques to improve its efficiency and capabilities.

Using Recording Rules for Complex Queries and Aggregations

Recording rules allow you to precompute frequently needed or computationally expensive expressions and save their result as a new set of time series. This can significantly speed up the evaluation of dashboards and alerts.

Let’s add some recording rules to our Prometheus configuration. Create a rules.yml file:

groups:
- name: example_recording_rules
  interval: 5m
  rules:
  - record: job:order_processing_rate:5m
    expr: rate(orders_created_total[5m])

  - record: job:order_processing_error_rate:5m
    expr: rate(order_processing_errors_total[5m]) / rate(orders_created_total[5m])

  - record: job:payment_success_rate:5m
    expr: rate(payments_processed_total{status="success"}[5m]) / rate(payments_processed_total[5m])

Add this file to your Prometheus configuration:

rule_files:
  - "alerts.yml"
  - "rules.yml"

Now you can use these precomputed metrics in your dashboards and alerts, which can be especially helpful for complex queries that you use frequently.

Implementing Push Gateway for Batch Jobs and Short-Lived Processes

The Pushgateway allows you to push metrics from jobs that can’t be scraped, such as batch jobs or serverless functions. Let’s add a Pushgateway to our docker-compose.yml:

services:
  # ... other services ...

  pushgateway:
    image: prom/pushgateway
    ports:
      - 9091:9091

Now, you can push metrics to the Pushgateway from your batch jobs or short-lived processes. Here’s an example using the Go client:

import (
    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/push"
)

func runBatchJob() {
    // Define a counter for the batch job
    batchJobCounter := prometheus.NewCounter(prometheus.CounterOpts{
        Name: "batch_job_processed_total",
        Help: "Total number of items processed by the batch job",
    })

    // Run your batch job and update the counter
    // ...

    // Push the metric to the Pushgateway
    pusher := push.New("http://pushgateway:9091", "batch_job")
    pusher.Collector(batchJobCounter)
    if err := pusher.Push(); err != nil {
        log.Printf("Could not push to Pushgateway: %v", err)
    }
}

Don’t forget to add the Pushgateway as a target in your Prometheus configuration:

scrape_configs:
  # ... other configs ...

  - job_name: 'pushgateway'
    static_configs:
      - targets: ['pushgateway:9091']

Federated Prometheus Setups for Large-Scale Systems

For large-scale systems, you might need to set up Prometheus federation, where one Prometheus server scrapes data from other Prometheus servers. This allows you to aggregate metrics from multiple Prometheus instances.

Here’s an example configuration for a federated Prometheus setup:

scrape_configs:
  - job_name: 'federate'
    scrape_interval: 15s
    honor_labels: true
    metrics_path: '/federate'
    params:
      'match[]':
        - '{job="order_processing_api"}'
        - '{job="postgres_exporter"}'
    static_configs:
      - targets:
        - 'prometheus-1:9090'
        - 'prometheus-2:9090'

This configuration allows a higher-level Prometheus server to scrape specific metrics from other Prometheus servers.

Using Exemplars for Tracing Integration

Exemplars allow you to link metrics to trace data, providing a way to drill down from a high-level metric to a specific trace. This is particularly useful when integrating Prometheus with distributed tracing systems like Jaeger or Zipkin.

To use exemplars, you need to enable them in your Prometheus configuration:

global:
  scrape_interval: 15s
  evaluation_interval: 15s
  exemplar_storage:
    enable: true

Then, when instrumenting your code, you can add exemplars to your metrics:

import (
    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promauto"
)

var (
    orderProcessingDuration = promauto.NewHistogramVec(
        prometheus.HistogramOpts{
            Name: "order_processing_duration_seconds",
            Help: "Duration of order processing in seconds",
            Buckets: prometheus.DefBuckets,
        },
        []string{"status"},
    )
)

func processOrder(order Order) {
    start := time.Now()
    // Process the order...
    duration := time.Since(start)

    orderProcessingDuration.WithLabelValues(order.Status).Observe(duration.Seconds(),
        prometheus.Labels{
            "traceID": getCurrentTraceID(),
        },
    )
}

This allows you to link from a spike in order processing duration directly to the trace of a slow order, greatly aiding in debugging and performance analysis.

10. Testing and Validation

Ensuring the reliability of your monitoring system is crucial. Let’s explore some strategies for testing and validating our Prometheus setup.

Unit Testing Metric Instrumentation

When unit testing your Go code, you can use the prometheus/testutil package to verify that your metrics are being updated correctly:

import (
    "testing"

    "github.com/prometheus/client_golang/prometheus/testutil"
)

func TestOrderProcessing(t *testing.T) {
    // Process an order
    processOrder(Order{ID: 1, Status: "completed"})

    // Check if the metric was updated
    expected := `
        # HELP order_processing_duration_seconds Duration of order processing in seconds
        # TYPE order_processing_duration_seconds histogram
        order_processing_duration_seconds_bucket{status="completed",le="0.005"} 1
        order_processing_duration_seconds_bucket{status="completed",le="0.01"} 1
        # ... other buckets ...
        order_processing_duration_seconds_sum{status="completed"} 0.001
        order_processing_duration_seconds_count{status="completed"} 1
    `
    if err := testutil.CollectAndCompare(orderProcessingDuration, strings.NewReader(expected)); err != nil {
        t.Errorf("unexpected collecting result:\n%s", err)
    }
}

Integration Testing for Prometheus Scraping

To test that Prometheus is correctly scraping your metrics, you can set up an integration test that starts your application, waits for Prometheus to scrape it, and then queries Prometheus to verify the metrics:

func TestPrometheusIntegration(t *testing.T) {
    // Start your application
    go startApp()

    // Wait for Prometheus to scrape (adjust the sleep time as needed)
    time.Sleep(30 * time.Second)

    // Query Prometheus
    client, err := api.NewClient(api.Config{
        Address: "http://localhost:9090",
    })
    if err != nil {
        t.Fatalf("Error creating client: %v", err)
    }

    v1api := v1.NewAPI(client)
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()
    result, warnings, err := v1api.Query(ctx, "order_processing_duration_seconds_count", time.Now())
    if err != nil {
        t.Fatalf("Error querying Prometheus: %v", err)
    }
    if len(warnings) > 0 {
        t.Logf("Warnings: %v", warnings)
    }

    // Check the result
    if result.(model.Vector).Len() == 0 {
        t.Errorf("Expected non-empty result")
    }
}

Load Testing and Observing Metrics Under Stress

It’s important to verify that your monitoring system performs well under load. You can use tools like hey or vegeta to generate load on your system while observing your metrics:

hey -n 10000 -c 100 http://localhost:8080/orders

While the load test is running, observe your Grafana dashboards and check that your metrics are updating as expected and that Prometheus is able to keep up with the increased load.

Validating Alerting Rules and Notification Channels

To test your alerting rules, you can temporarily adjust the thresholds to trigger alerts, or use Prometheus’s API to manually fire alerts:

curl -H "Content-Type: application/json" -d '{
  "alerts": [
    {
      "labels": {
        "alertname": "HighOrderProcessingErrorRate",
        "severity": "critical"
      },
      "annotations": {
        "summary": "High order processing error rate"
      }
    }
  ]
}' http://localhost:9093/api/v1/alerts

This will send a test alert to your Alertmanager, allowing you to verify that your notification channels are working correctly.

11. Challenges and Considerations

As you implement and scale your monitoring system, keep these challenges and considerations in mind:

Managing Cardinality in High-Dimensional Data

High cardinality can lead to performance issues in Prometheus. Be cautious when adding labels to metrics, especially labels with many possible values (like user IDs or IP addresses). Instead, consider using histogram metrics or reducing the cardinality by grouping similar values.

Scaling Prometheus for Large-Scale Systems

For large-scale systems, consider:

• Using the Pushgateway for batch jobs
• Implementing federation for large-scale setups
• Using remote storage solutions for long-term storage of metrics

Ensuring Monitoring System Reliability and Availability

Your monitoring system is critical infrastructure. Consider:

• Implementierung hoher Verfügbarkeit für Prometheus und Alertmanager
• Überwachung Ihres Überwachungssystems (Meta-Überwachung)
• Sichern Sie regelmäßig Ihre Prometheus-Daten

Sicherheitsüberlegungen für Metriken und Warnungen

Stellen Sie sicher, dass:

• Der Zugang zu Prometheus und Grafana ist ordnungsgemäß gesichert
• Sensible Informationen werden nicht in Metriken oder Warnungen offengelegt
• TLS wird für die gesamte Kommunikation in Ihrem Überwachungsstapel verwendet

Umgang mit vorübergehenden Problemen und flatternden Alarmen

Um Alarmgeräusche zu reduzieren:

• Verwenden Sie geeignete Zeitfenster in Ihren Alarmregeln
• Alarmgruppierung im Alertmanager implementieren
• Erwägen Sie die Verwendung der Alarmunterdrückung für verwandte Alarme

12. Nächste Schritte und Vorschau auf Teil 5

In diesem Beitrag haben wir die umfassende Überwachung und Alarmierung unseres Auftragsverarbeitungssystems mithilfe von Prometheus und Grafana behandelt. Wir haben benutzerdefinierte Metriken eingerichtet, informative Dashboards erstellt, Warnungen implementiert und erweiterte Techniken und Überlegungen untersucht.

Im nächsten Teil unserer Serie konzentrieren wir uns auf die verteilte Ablaufverfolgung und Protokollierung. Wir behandeln Folgendes:

1. Implementierung der verteilten Ablaufverfolgung mit OpenTelemetry
2. Zentralisierte Protokollierung mit dem ELK-Stack einrichten
3. Korrelation von Protokollen, Traces und Metriken für effektives Debugging
4. Implementierung der Protokollaggregation und -analyse
5. Best Practices für die Anmeldung in einer Microservices-Architektur

Bleiben Sie auf dem Laufenden, während wir unser Auftragsabwicklungssystem weiter verbessern und uns als Nächstes darauf konzentrieren, tiefere Einblicke in das Verhalten und die Leistung unseres verteilten Systems zu gewinnen!

---

Brauchen Sie Hilfe?

Stehen Sie vor herausfordernden Problemen oder benötigen Sie eine externe Perspektive auf eine neue Idee oder ein neues Projekt? Ich kann helfen! Ganz gleich, ob Sie einen Technologie-Proof of Concept erstellen möchten, bevor Sie eine größere Investition tätigen, oder ob Sie Beratung bei schwierigen Themen benötigen, ich bin hier, um Ihnen zu helfen.

Angebotene Dienstleistungen:

• Problemlösung:Komplexe Probleme mit innovativen Lösungen angehen.
• Beratung: Bereitstellung fachkundiger Beratung und neuer Standpunkte zu Ihren Projekten.
• Proof of Concept: Entwicklung vorläufiger Modelle zum Testen und Validieren Ihrer Ideen.

Wenn Sie an einer Zusammenarbeit mit mir interessiert sind, wenden Sie sich bitte per E-Mail an hungaikevin@gmail.com.

Lassen Sie uns Ihre Herausforderungen in Chancen verwandeln!

Das obige ist der detaillierte Inhalt vonImplementierung eines Auftragsverarbeitungssystems: Teileüberwachung und -warnung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!