Przejdź do głównej zawartości
AggregaAggrega
Wybierz język: Polski
Ta strona została przetłumaczona maszynowo. Przeczytaj oryginał w języku angielskim.

Prometheus — jeden serwer, dwa cele zbierania metryk

Ten przykład kompiluje mały, rzeczywisty stos — serwer metryk Prometheus zbierający metryki z dwóch serwerów pulpitów Grafana — z jednego Aggregate napisanego przez programistę do dwóch środowisk docelowych:

  • Docker Compose do lokalnego programowania oraz
  • Kubernetes za pomocą syntezy encji Workload na oficjalnym obrazie prom/prometheus.

Ten sam plik aggregate.yaml steruje oboma. Dla każdego celu zmienia się tylko warstwa encji Recipe wybrana przez encję Manifest.

Grafana udostępnia własne metryki w formacie tekstowym Prometheus pod ścieżką /metrics na swoim porcie webowym i robi to domyślnie, więc każda instancja Grafany jest rzeczywistym celem zbierania metryk. Obie są tym samym typem encji Component podłączonym dwukrotnie, więc wszystko, co różni oba zadania zbierania metryk, wynika z tego, co zapisano w każdym połączeniu, oraz z tego, gdzie każda instancja Grafany deklaruje udostępnianie swoich metryk.

Pliki

PlikRola
aggregate.yamlIntencja dewelopera: dwie instancje Grafany, team-dashboards i ops-dashboards (obie core/observability/grafana), oraz serwer metrics (core/observability/prometheus), który deklaruje użycie scrape_target każdej z nich.
manifest-compose.yamlMapuje typ Prometheus na Recipe dla Compose (compose/prometheus), a typ Grafana na Recipe Grafany dla Compose (compose/grafana).
manifest-helm-synth.yamlMapuje typ Prometheus na syntetyzowany Recipe helm (helm/prometheus), a typ Grafana na syntetyzowany Recipe helm Grafany (helm/grafana). Żaden z nich nie pobiera chartu.
release-compose.yaml / release-helm-synth.yamlRekordy operatora dla obu celów.

Podłączanie dwóch celów do jednego gniazda

scrape_target to jedno gniazdo przenoszące dwa połączenia, a każde połączenie staje się jednym zadaniem scrapowania:

metrics:
type: core/observability/prometheus
uses:
scrape_target:
team-dashboards:
target: team-dashboards
ops-dashboards:
target: ops-dashboards
values:
job_name: ops-grafana
scrape_interval: 30s

Połączenie team-dashboards nie definiuje żadnych values, więc jego zadanie przyjmuje to, co deklaruje gniazdo. Połączenie ops-dashboards ustawia dwa klucze, a każdy ustawiony przez nie klucz kształtuje wyłącznie to zadanie — zadanie team-dashboards pozostaje przez nie nienaruszone.

Cel określa, gdzie udostępnia metryki

Połączenie określa, jak często Prometheus odpytuje cel i pod jaką nazwą zadania; nigdy nie określa, gdzie. To fakt należący do samego celu i to cel go publikuje: każda encja Recipe dla Grafany publikuje metrics_endpoint, pełny adres swoich metryk — schemat, host, port i ścieżkę, na przykład http://team-dashboards:3000/metrics w Compose. Prometheus buduje zadanie odpytywania z tego adresu: z jego schematu, ścieżki oraz hosta i portu jako celu zadania.

Cel, który nie udostępnia metryk, nie publikuje więc adresu, a podłączenie go do scrape_target zatrzymuje kompilację ze wskazaniem tego celu, zamiast skompilować zadanie, które niczego by nie odpytywało. Produkt, którego metryki są wyłączone, dopóki nie włączy ich jakaś wartość — wiele produktów w katalogu przyjmuje metrics_enabled — publikuje swój adres, gdy metryki są włączone. W Kubernetes cel może zamiast tego publikować to, po czym Prometheus wykrywa jego metryki: Service lub selektor podów, gdy żaden pojedynczy adres nie dociera do wszystkich; realizacja Compose nie ma klastra, w którym mogłaby wykrywać, i zatrzymuje się na takim celu.

Gniazdo przyjmuje zarówno serwery i serwery stanowe, jak i procesy robocze, więc bazę danych, magazyn logów czy operatora podłącza się w ten sam sposób; to, czy można je odpytywać, zależy od tego, co publikują.

Co demonstruje

  • Jedna powierzchnia tworzenia, wiele celów. Pojedyncza encja Aggregate jest źródłem prawdy o tym, czym jest stos. Każda encja Manifest mówi, jak go zrealizować.
  • Jedno gniazdo, wiele połączeń. Prometheus zbiera metryki z tylu celów, ile encja Aggregate podłącza do scrape_target. Encja Recipe emituje jedno zadanie zbierania na połączenie, więc liczba zadań wynika z topologii, a nie z encji Recipe.
  • Konfiguracja na poziomie połączenia. job_name i scrape_interval są zadeklarowane w valueSchema gniazda, co czyni je właściwościami połączenia, a nie serwera. Jeden Prometheus zbierający metryki z kilku celów nie może wyrazić kilku częstotliwości w jednej wartości obejmującej całą encję Component.
  • Zadeklarowane wartości domyślne uzupełniają klucze pominięte przez połączenie. scrape_interval ma wartość domyślną w valueSchema gniazda. Połączenie, które go pomija — tutaj team-dashboards — otrzymuje ją, a połączenie, które go ustawia — ops-dashboards — nadpisuje tylko to, co ustawiło.
  • Podłączanie zbierania metryk przez String Pipe. metrics_endpoint każdej encji Recipe Grafany jest przekazywany do Prometheusa i renderowany w zadaniu tej Grafany: jego schemat, ścieżka i wpis targets. Kompilator przekazuje ciąg znaków bez interpretowania go: każda encja Recipe decyduje, jaki adres publikuje jej cel, a kompilator przekazuje go bez zmian.
  • Konfiguracja idiomatyczna dla encji Provider. Na obu celach serwer zapisuje przy uruchomieniu minimalny plik prometheus.yml, którego zadania zbierania wskazują podłączone instancje Grafany, a następnie uruchamia (exec) Prometheusa z tą konfiguracją. W Compose działa to jako usługa; w Kubernetes ten sam kontener jest renderowany do StatefulSet.
  • Trwały stan. Prometheus przechowuje próbki na woluminie danych, dzięki czemu przetrwają restarty — lokalnie na nazwanym woluminie Compose, a w Kubernetes na PersistentVolumeClaim dla każdej repliki o rozmiarze z infra.storage. Każda Grafana przechowuje użytkowników i pulpity na własnym woluminie.
  • Powtarzalne obrazy. Każda encja Recipe w tym przykładzie przypina tag obrazu z infra.engine_version, więc renderowane obciążenia odwołują się do stałych obrazów.
  • Oszczędny, jednozadaniowy kształt. W Kubernetes komponent Prometheusa jest renderowany jako StatefulSet, usługi ClusterIP i Headless oraz żądanie woluminu danych — nic więcej. Każda Grafana jest renderowana jako własny Deployment, Service i żądanie woluminu danych.

Generowanie przykładu

Ten przykład można zbudować za pomocą poniższych poleceń albo zlecić jego zbudowanie asystentowi AI.

Należy zapisać przykład w nowym folderze nazwanym tak jak on:

Terminal window
aggrega scaffold --example prometheus-scrape

Następnie wypisuje polecenia do uruchomienia w dalszej kolejności. Pierwsze przechodzi do nowego folderu:

Terminal window
cd prometheus-scrape

Kompilacja

Ta przestrzeń robocza nie zawiera pliku .aggrega-config.yaml, więc encje biblioteki standardowej są rozwiązywane z rejestru hub, hub.aggrega.ai, i flaga katalogu nie jest potrzebna:

Terminal window
# Local development (Docker Compose)
aggrega build --release release-compose.yaml --auto-pull
# Kubernetes (Workload synthesis on prom/prometheus)
aggrega build --release release-helm-synth.yaml --auto-pull

Wygenerowane artefakty trafiają do dist/. --auto-pull rozwiązuje zależności każdej encji Release do jej pliku blokady podczas kompilacji; jednorazowe wywołanie aggrega pull --release release-compose.yaml na początku robi to samo i pozwala uruchamiać późniejsze kompilacje bez tej flagi. Syntetyzowany cel nie wymaga pobierania zewnętrznego chartu — obie encje Recipes renderują oficjalne obrazy bezpośrednio do zasobów Kubernetes.

Z asystentem AI

Asystent AI skonfigurowany z narzędziami Aggrega może zrobić to samo: wystarczy wkleić mu ten prompt.

Używaj wyłącznie narzędzi Aggrega i nie twórz samodzielnie żadnego folderu. Jeśli folder Workspace nie zawiera jeszcze folderu `prometheus-scrape`, wywołaj raz narzędzie `scaffold` z `example` ustawionym na `prometheus-scrape` i bez `dir`: zapisuje ono przykład w nowym folderze `prometheus-scrape`. Następnie wywołaj narzędzie `build` raz dla każdej encji Release, w tej kolejności — `release-compose.yaml` i `release-helm-synth.yaml` — za każdym razem z `workspace_root` ustawionym na `prometheus-scrape`, `release` ustawionym na ten plik, `auto_pull` ustawionym na true i `write` ustawionym na true. Powiedz mi, jakie pliki zapisała każda kompilacja; znajdują się w `prometheus-scrape/dist/`.

Jak wygląda skompilowana konfiguracja zbierania metryk

W Compose serwer zapisuje plik prometheus.yml zawierający jedno zadanie na każdą podłączoną instancję Grafany, z których każde adresuje metrics_endpoint publikowany przez tę Grafanę — jej nazwę usługi compose i port:

scrape_configs:
- job_name: ops-grafana
scrape_interval: 30s
scheme: http
metrics_path: "/metrics"
static_configs:
- targets:
- "ops-dashboards:3001"
- job_name: team-dashboards
scrape_interval: 15s
scheme: http
metrics_path: "/metrics"
static_configs:
- targets:
- "team-dashboards:3000"

W Kubernetes te same dwa zadania zapisuje polecenie startowe syntetyzowanego obiektu StatefulSet, a każde z nich adresuje obiekt Service danej Grafany, który dostawca helm nazywa od komponentu i jego klucza usługi default:

scrape_configs:
- job_name: ops-grafana
scrape_interval: 30s
scheme: http
metrics_path: "/metrics"
static_configs:
- targets:
- "ops-dashboards-default:3001"
- job_name: team-dashboards
scrape_interval: 15s
scheme: http
metrics_path: "/metrics"
static_configs:
- targets:
- "team-dashboards-default:3000"

Oba cele kompilują te same dwa zadania z tych samych dwóch krawędzi encji Aggregate: każdy metrics_endpoint Grafany przechodzi przez własne połączenie scrape_target, a kompilator przekazuje ten ciąg do zadania bez jego interpretowania. Cele różnią się adresem, który publikuje każda Grafana — w jednym jest to nazwa usługi compose, w drugim nazwa obiektu Service — oraz obciążeniem, do którego zapisywana jest konfiguracja — w jednym usługą Compose, w drugim obiektem StatefulSet. Tutaj obie Grafany znajdują się w tym samym zakresie co Prometheus; w Kubernetes Grafana, którą encja Release umieszcza w innej przestrzeni nazw, jest adresowana nazwą swojego obiektu Service kwalifikowaną tą przestrzenią nazw.

Porównując zadanie team-dashboards z zadaniem ops-grafana, można zobaczyć, skąd pochodzi każda wartość. Zadanie ops-grafana zawiera ops-grafana i 30s, ponieważ jego połączenie definiuje obie wartości. Zadanie team-dashboards ma team-dashboards jako job_name, ponieważ encja Aggregate go nie deklaruje, a encja Recipe sięga wtedy po alias połączenia — nazwę, którą ta encja Aggregate nadała połączeniu — a wartość 15s wynika z tego, że jest to wartość domyślna, którą gniazdo scrape_target encji Component deklaruje dla klucza pominiętego w tym połączeniu. Schemat, metrics_path i cel obu zadań pochodzą z adresu, który publikuje każda Grafana, czyli z miejsca, w którym Grafana udostępnia swoje metryki, dlatego żadne połączenie nic o nich nie mówi. Ustawienie klucza w połączeniu nadpisuje go dla tego zadania i nie zmienia drugiego.

Wszystko to dzieje się po stronie konsumenta. Konfiguracja poszczególnych połączeń pojawia się tylko w kontekście renderowania węzła, który zdefiniował połączenie, nigdy w kontekście celu, więc podłączenie lub dostrojenie połączenia do Grafany nigdy nie zaburza tego, co renderuje sama Grafana — jej obiekty Deployment i Service mają w obu przypadkach te same bajty.

Grafana udostępnia swoje metryki każdemu wywołującemu, więc żadne połączenie nie zawiera poświadczenia. W przypadku celu, którego metryki go wymagają, połączenie przenosi je w slocie credential, a Prometheus przedstawia je jako token bearer odczytywany z pliku; cel publikujący metrics_credential_required o wartości true zatrzymuje kompilację, dopóki jego połączenie go nie zawiera.

Uruchomienie (Compose)

Terminal window
aggrega build --release release-compose.yaml --auto-pull
docker compose -f dist/app/compose/docker-compose.yaml up -d

Encja Release przydziela każdej instancji Grafana własny port — team-dashboards na 3000, a ops-dashboards na 3001 — dzięki czemu obie działają lokalnie obok siebie. Każda instancja Grafana nasłuchuje na porcie, który przydziela jej encja Release, a każdy port trafia w adresie publikowanym przez tę instancję Grafana do celu jej własnego zadania scrape.

Należy otworzyć http://127.0.0.1:9090 — przeglądarkę wyrażeń Prometheusa, którą encja Recipe dla Compose publikuje wyłącznie na adresie pętli zwrotnej hosta. W sekcji Status → Targets oba zadania są wymienione pod nazwami nadanymi im przez skompilowaną konfigurację, ops-grafana i team-dashboards, a każde z nich adresuje /metrics swojej instancji Grafana. Zapytanie o grafana_build_info, wskaźnik, który każda instancja Grafana ustawia na 1 i oznacza etykietą ze swoją wersją, zwraca po jednej serii na zadanie. Środowisko można usunąć poleceniem docker compose -f dist/app/compose/docker-compose.yaml down.