#AdminCases, czyli gotowa solucja: Permanentna inwigilacja trwa nadal czyli zbieranie logów z Grafana Loki w kontenerach

Grafana Loki, Promtail oraz Grafana z wykorzystaniem Docker i Docker Compose

Ave ;)

Znowu przyszedł czas żeby na blogu Asseco zostało przedstawionych trochę zagadnień związanych z administracją - przecież nie samym programowaniem żyje gatunek potocznie zwany Homo sapiens informaticus. Długo nie było mi dane rozpocząć pisania kolejnego artykułu (z uwagi na ogrom zajęć i czas, którego wciąż brakuje) jednak zebrawszy się w sobie stwierdziłem, że dotrzymam słowa danego w tym, który preparowałem poprzednio czyli #AdminCases, czyli gotowa solucja: Permanentna inwigilacja musi trwać czyli jak zebrać logi w jednym miejscu za pomocą rsylog oraz Grafana Loki i dopiszę dalszą część rozwijając temat o konteneryzację i Grafanę ergo wspomniana w artykule “Następna raza” właśnie następuje.

No dobra, komu Let’s temu go.

Zacznijmy od tego, że jak i w przypadku poprzedniego elaboratu skupię się na pokazaniu rozwiązania w możliwie przyswajalny sposób, zwracając uwagę na to gdzie można się potknąć i stanąć w korku swojego jestestwa czyli dostać blokady z powodów różnych poświęcając czas na poszukiwaniach rozwiązań z wujkiem Google-m czy innym Chat-em z GPT. Jak to mówią, że prawdziwi twardziele nie robią backupów tak i my nie będziemy się pytać sztucznych inteligencji czy innych algorytmów tylko użyjemy swojej szarej substancji z pofałdowania kory żeby z każdej niedoli się wykaraskać. Będzie też dużo obrazków żeby unaocznić to wszystko co mamy do zobaczenia celem potwierdzenia, że nie piszę aż takich głupot jakich można się po mnie podziewać ;)

Tym razem - oprócz zgromadzenia logów w jednym centralnym miejscu co dodaje nam poczucie - jak to ostatnio mówią - że jesteśmy zaopiekowani to drugim pozytywem niezaprzeczalnie jest to, że nie trzeba latać po całej swojej infrastrukturze żeby coś znaleźć. Na dodatek dorzucimy możliwość wizualizacji via www czyli odchodzimy od jakże pięknego ale jednak surowego świata ascetów w świat rozpusty i przepychu czy innych udogodnień ;)

W przypadku tej solucji uproszczę architekturę naszego rozwiązanie żeby wszystko było maksymalnie przejrzyste, a w jakimś momencie (lub momentach) wspomnę o bardziej skomplikowanych rozwiązaniach, które są lub mogą być wykorzystywane w przypadku infrastruktury z wykorzystaniem Grafana Loki. Dodatkowo zamiast standardowo instalować poszczególne komponenty na naszych serwerach do budowy rozwiązania skorzystamy z kontenerów zatem w ruch pójdą Docker i Docker Compose. Aby każdy, kto będzie chciał się pobawić i zobaczyć jak to działa w ramach gratisu od siebie dorzucę konfigurację do produktu Hashicorp Vagrant tak aby jednym strzałem zbudować sobie infrastrukturę składającą się z 4 serwerów wirtualnych posadowionych na VirtualBox jako providerze. Ja osobiście raczej korzystam z libvirt jako providera ale wiem, że większość osobników jednak woli rozwiązanie od Oracle. Link do tejże będzie w podsumowaniu na koniec artykułu.

Skoro już wspomniałem o infrastrukturze, a jeszcze nie jesteśmy przy clue tematu czyli pokazaniu samego rozwiązania to może opowiem pokrótce na czym będzie to unaocznione czy też pokazane jakie komponenty są niezbędne do tego aby móc przejść przez tą mękę bez problemów. Dodam, że wszystkie niezbędne pakiety, które należy zainstalować są zaimplementowane we wspomnianej konfiguracji Vagrant i jest to zrobione na różnych systemach operacyjnych więc można zawsze rzucić okiem w celu podpatrzenia, a jestem pewien, że żaden belfer za to po łapach nie da.

Mamy 4 serwery wirtualne:

• loki - 192.168.56.14
• almalinux - 192.168.56.10
• ubuntu - 192.168.56.12
• debian10 - 192.168.56.16

Każdy z serwerów powinien mieć zainstalowany docker i docker compose. Serwery loki i ubuntu to dystrybucje Ubuntu 20.04. Na serwerze ubuntu zainstalowano dodatkowo Nginx żeby pokazać jak będzie wyglądało monitorowanie logów tego serwera. Serwer debian10 jak sama nazwa wskazuje jest z rodziny Debian. Serwer almalinux jest dystrybucją AlmaLinux 8 i dodatkowo ma zainstalowany serwer Apache z tych samych powodów jak w przypadku Nginx na ubuntu. Dodatkowo w przypdaku almalinux zostało zmieniona egzystowanie systemd journal log z in memory na zapis na filesystemie, tak żeby logi nie ginęły pomiędzy rebootami, a dodatkowo dla naszego przypadku po to aby lokalizacja journal była jednakowa na każdym z serwerów.

Jeszcze zanim zaczniemy, to zaznaczam, że nie będę pisał co to jest Docker czy Docker Compose, czym się charakteryzuje i jak się z nim żyje bo to temat rzeka, a ja nie mam tyle czasu, a poza tym popełniono na ten temat pierdyliard artykułów, solucji czy innych dokumentacji więc jeżeli ktoś nie wie to niech się uda do tych źródeł lub też znajdzie jakiegoś guru, który to wytłumaczy z bardzo dobrym skutkiem. My zajmiemy się już implementacją komponentów na serwerach w postaci kontenerów. Nie będę ukrywał, że wolę rozwiązanie z wykorzystaniem Docker Compose ponieważ właściwie po utworzeniu odpowiedniego Yaml z konfiguracją wystarczy wykonać jedną komendę i jesteśmy w domu. Oczywiście pokażę jak to uruchomić za pomocą Docker-a jednak czeka nas wypisywanie długich poleceń w powłoce po to oczywiście aby konfiguracja danego kontenera miała ręce z nogami - na przykład definicje wolumenów dla kontenerów żeby w przypadku zakończenia ich życia mieć jakieś dane, a wolumen to nic innego jak stworzony lub zamapowany katalog z hosta widoczny w kontenerze (a miałem nic nie mówić o teorii Docker-a, taki jestem słowny - ehhh ;P )

To już chyba wszystkie słowa wstępu i możemy przejść do meritum.

Celem przypomnienia dla tych, którzy są na tyle leniwi, że nie chce im się wchodzić do poprzedniego artykułu lub też przeprowadzaniem rekonesansu w internetach przytoczę definicję czym jest Grafana Loki.

Grafana Loki to skalowalny, wysoce dostępny, system agregacji logów inspirowany Prometheusem. Został zaprojektowany tak, aby był bardzo ekonomiczny i łatwy w obsłudze. Nie indeksuje zawartości dzienników, ale raczej zestaw etykiet dla każdego strumienia dziennika.

W przypadku tego rozwiązania, które chcę dzisiaj pokazać wykorzystamy 3 komponenty systemu (2 są niezbędne do działania, a trzeci będzie służył do wyświetlania efektów):

• Grafana Loki - czyli główny serwer odpowiedzialny za przechowywanie logów oraz przetwarzanie zapytań
• Promtail - to agent, odpowiedzialny za zbieranie logów i przekazywanie ich do serwera Loki
• Grafana - narzędzie open source i flagowy produkt Grafana Labs służące do monitoringu, analizy i wizualizacji z różnych źródeł danych.

… i to wszystko w kontenerach.

No to jesteśmy już u progu tego co mamy do zrealizowania zatem zabierzmy się za pracę.

Co jest nam na tą chwilę potrzebne, co zarówno wykorzystamy w przypadku konfiguracji realizowanej Docker-em jak i za pomocą Docker Compose to pliki konfiguracyjne dla Grafana Loki oraz Promtail. Krótko tylko opiszę najważniejsze rzeczy związane z naszą solucją bo było to już w poprzednim artukule.

1. Grafana Loki - plik konfiguracyjny (Plik dostępny tutaj)

Jak można zauważyć będziemy przechowywać dane na filesystemie w katalogu /loki (ten katalog akurat jest dość ważny jeżeli chodzi o wolumeny Docker ponieważ sam katalog istnieje już w kontenerze i mapowania powinny zostać wykonane do niego gdyż inne konfiguracje mogą przysparzać problemy z uprawnieniami, a nie jest nam porzebne. Możliwości przechowywania danych jest całe mnóstwo, choćby Minio, jednak nie na tym się dzisiaj skupiamy tylko nad zrobieniem szybkiego HowTO, a komplikować sobie życie będziemy później w innej czasoprzestrzeni. Resztę informacji na temat poszczególnych parametrów pliku konfiguracyjnego można znaleźć tutaj.

2. Promtail - plik konfiguracyjny (Plik dostępny tutaj)

Nie będę się rozwodził nad podstawowymi parametrami pliku konfiguracyjnego dla Promtail bo po części zostały one opisane poprzednim razem, a to co nie zostało można sobie dokładnie przeczytać na stronach Grafana w sekcji Configure Promtail jednak opowiem o tym co jest w tym momencie dla nas ważne. Po pierwsze jest wiele rodzajów jobów i właśnie w taki sposób zostaną one pogrupowane i wtłoczone do Loki-iego i z takim też podziałem będziemy się zmagać jeżeli chodzi o wizualizację. Będzie można wyszukać dla przykładu logi tylko dla nginx czy apache czy też te, które dotyczą tylko i wyłącznie informacji związanych z systemem, a są pogrupowane labelem job o wartości varlogs. Druga rzecz to inny label, który został zdefiniowany czyli node. To ten wskazuje nam na hosta, z którego pochodzą dane i stanowi ułatwienie w przypadku wyszukiwania i ograniczania sobie w tym celu danych. Taki plik konfiguracyjny dla Promtail - w przypadku naszego rozwiązania - powinien powstać per każdy istniejący serwer innymi słowy 4 pliki, a każdy z nich winien mieć wpisany odpowiedni node. Można to oczywiście zmodyfikować np. via Ansible lub w jeszcze inny dowolny sposób jednak chcąc skorzystać z vagrant. który udostępnię będzie to takie właśnie rozwiązanie (wiadomość dla braci leniwych: pliki konfiguracyjne Promtail też udostępnię ;))

• Konteneryzacja - czyli jak zrobić żeby zrobić, a się nie narobić … i żeby było szybciej.

Jak wiadomo kontenery są już gotowymi obrazami gdzie można wstrzyknąć własną konfigurację i będzie Pan/Pani zadowolony/a (każdego kto czuje się pominięty brakiem odpowiedniej dla siebie formy z góry przepraszam). Nie będzie trzeba instalować, konfigurować czy wykonywać innych zaklęć wiedzy tajemnej. Tutaj zawsze powinno być tak samo - o ile oczywiście kontener jest używany zgodnie z przeznaczeniem.

Jeżeli chodzi o wersję Loki i Promtail to skorzystałem z tej o notacji 3.0.0, a w przypadku Grafany z wersji najnowszej.

1. Docker.

Na wszystkich serwerach przydałoby się utworzyć sieć dla kontenerów związanych z naszym projektem na przykład o nazwie loki. Do tego celu użyjemy polecenia docker network create -d bridge loki

Loki.

Poniższe czynności wykonujemy tylko na serwerze loki.

Jeżeli chcemy podać wolumen - i nie będzie to tylko wolumen lokalizacji pliku konfiguracyjnego, który sobie spreparowaliśmy - ale również zamierzamy stworzyć te dla przechowywania danych powinniśmy wykonać kilka rzeczy, które pozwolą nam uniknąć problemów z uprawnieniami. Może najpierw dlaczego chcemy mieć ten wolumen zmapowany z hostem. Ano dlatego to robimy, żeby nasze zgromadzone dane nie zostały trafione szlagiem w przypadku zakończenia życia kontenera z loki. A teraz słowo o uprawnieniach. Jak już wcześniej wspominałem jest sobie w kontenerze katalog /loki. Jego właścicielem jest loki z grupy loki. Przy próbie uruchomienia kontenera ze wskazaniem mapowania wolumenu np. na katalog ~/docker/grafana_loki_promtail_aciek/loki_docker otrzymamy w logu kontenera mkdir /loki/rules: permission denied kontener się wywali. Jest tak ponieważ uprawnienia po stronie hosta wyglądają następująco:

drwxrwxr-x 2 aciek aciek 4096 wrz 24 17:22 loki_docker.

Można to poprawić na 2 sposoby:

• nadać uprawnienia 777 na katalog, a właściwie to tutaj najwięcej ma ta ostatnia cyfra do powiedzenia bo każdy kto miał chociaż przez chwilę do czynienia z systemem Linux wie, że to odpowiada za others
• utworzyć lokalnego użytkownika np. o nazwie loki z uid 10001 z gid 10001 (też loki), może mieć wyłączoną możliwość logowania np. via shell /sbin/nologin, nadać uprawnienia do katalogu aby wyglądały tak: drwxrwxr-x 8 loki loki 4096 wrz 24 17:47 loki_docker i możemy uruchamiać kontener

Dobra, nagadałem się ale jeszcze nie poznaliście polecenia do uruchomienia tego kontenera i należy pamiętać o właściwej wersji kontenera:

docker run --name loki --network loki -d -v $(pwd):/mnt/config 
-v ~/docker/grafana_loki_promtail_aciek/loki_docker:/loki  
-p 3100:3100 grafana/loki:3.0.0 --config.file=/mnt/config/loki-config-docker.yaml

Nie będę tłumaczył wszystkiego bo raczej widać gołym okiem co z czym się je i gdzie jest mapowanie wolumenów, gdzie portów, a gdzie wskazanie na plik konfiguracyjny. I jak już się wszystko powiedzie to efektem tego będzie taki obrazek:

Docker_Loki

• Promtail.

Poniższe czynności wykonujemy na wszystkich serwerach.

W tym przypadku nie ma nad czym się rozwodzić ponieważ wystarczy tylko wolumen z konfiguracją, wskazanie wolumenu z logami i właściwa wersja kontenera i można lecieć dalej.

docker run -d -v $(pwd):/mnt/config --network loki -v /var/log:/var/log grafana/promtail:3.0.0 
--config.file=/mnt/config/promtail-config.yam

Docker_Promtail

Zasadniczo to dane się już agregują i świat o mało co stał się lepszy pod jednym wszak warunkiem - teraz nie ma jak tego obejrzeć więc ostatni komponent.

• Grafana.

docker run -p 3000:3000 --network=loki --name=grafana 
-v ~/docker/grafana_loki_promtail_aciek/grafana_docker:/var/lib/grafana 
-e "GF_AUTH_ANONYMOUS_ENABLED=true" 
-e "GF_AUTH_ANONYMOUS_ORG_ROLE=Admin" grafana/grafana:latest

Tutaj również jest założony wolumen do przechowywania danych i ustawiane dodatkowe zmienne środowiskowe. Niezbędne jeszcze zdefiniowanie DataSource typu Loki, aby tam zagregowane dane można było zaprezentować. W przypadku konfiguracji z Docker zrobimy to via www żeby pokazać gdzie to jest, w Docker Compose zrobimy w pliku definicji.

Docker_Grafana

Jak widać wszystkie kontenery już są uruchomione i pozostaje nam tylko udać się do przeglądarki i otworzyć się na świat Grafany. Tutaj akurat zamieszczę kilka zrzutów wskazujących na to w jaki sposób zdefiniować Loki jako DataSource, a przykłady Dashboard-ów pokażę już po definicji i wystartowaniu kontenerów z Docker Compose.

Jak dodać DataSource:

• Logujemy się do Grafana użytkownikiem admin z takim samym hasłem. W kolejnym kroku będzie sobie życzył aby to hasło zmienić.
• Po zalogowaniu powinniśmy mieć taką wizualizację
• Klikamy w Data Sources, a następnie w Add data source, gdzie pojawi się lista źródeł. Tutaj musimy wyszukać Loki.
• Wybieramy Loki i ustawiamy URL na wartość loki:3100, a następnie akceptujemy, a gdy wszystko przebiegło prawidłowo powinniśmy otrzymać komunikat: Data source successfully connected

Grafana_menu

Grafana_Data_Source

Grafana_Loki_DataSource_Set

Grafana_Loki_DataSource_Confirm

2. Docker Compose.

Tutaj powinno być dużo prościej ponieważ w Docker Compose wszystkie niezbędne komponenty w postaci kontenerów zostaną zainicjowane i wystartowane jednym strzałem. a i sama konfiguracja, dotycząca budowania kontenerów, zdefiniowana jest jest w jednym pliku Yaml, a ja osobiście lubię format kryjący się pod akronimem Yet Another Markup Language. Korzystamy z niego chociażby w przypadku Ansible, a teraz wykorzystamy go w przypadku Docker Compose.

Będziemy mieli 2 konfiguracje w naszej infrastrukturze:

• jedna aby na host loki umieścić wszystkie komponenty czyli Loki, Promtail i Grafana
• druga gdzie zostanie skonfigurowany sam Promtail i zostanie uruchomiony na pozostałych hostach

Konfiguracja wszystkich komponentów, w pliku o nazwie docker-compose.yaml, wygląda tak (link do pliku konfiguracyjnego znajduje się tutaj):

networks:
   loki:

 services:
   loki:
     image: grafana/loki:3.0.0
     volumes:
       - ~/docker/grafana_loki_promtail_aciek/loki:/loki
       - ~/docker/grafana_loki_promtail_aciek:/tmp/loki/config
     ports:
       - "3100:3100"
     command: -config.file=/tmp/loki/config/loki-config.yaml
     networks:
       - loki

   promtail:
     image: grafana/promtail:3.0.0
     volumes:
       - /var/log:/var/log
       - ~/docker/grafana_loki_promtail_aciek:/tmp/promtail/config
     command: -config.file=/tmp/promtail/config/promtail-config.yaml
     networks:
       - loki
   grafana:
     environment:
       - GF_PATHS_PROVISIONING=/etc/grafana/provisioning
       - GF_AUTH_ANONYMOUS_ENABLED=true
       - GF_AUTH_ANONYMOUS_ORG_ROLE=Admin
     entrypoint:
       - sh
       - -euc
       - |
         mkdir -p /etc/grafana/provisioning/datasources
         cat <<EOF > /etc/grafana/provisioning/datasources/ds.yaml
         apiVersion: 1
         datasources:
         - name: Loki
           type: loki
           access: proxy 
           orgId: 1
           url: loki
           basicAuth: false
           isDefault: true
           version: 1
           editable: false
         EOF
         /run.sh
     image: grafana/grafana:latest
     volumes:
       - ~/docker/grafana_loki_promtail_aciek/grafana:/var/lib/grafana
     ports:
       - "3000:3000"
     networks:
       - loki

Jak widać wolumeny są skonfigurowane tak jak i w przypadku Docker, każdy serwis jest zdefiniowany osobno, wszystkie korzystają z tej samej sieci. To czego nie było w przypadku Docker to definicja DataSource bezpośrednio w konfiguracji Docker Compose tak, aby utworzył się bez konieczności ręcznej konfiguracji czyli dostajemy wszystko - jak to mówią - out of the box.

Na hostach gdzie nie będzie instalacji Loki należy uruchomić inną konfigurację Docker Compose, zawierającą tylko Promtail (plik do pobrania tutaj)

networks:
   loki:

 services:
   promtail:
     image: grafana/promtail:3.0.0
     volumes:
       - /var/log:/var/log
       - ~/docker/:/tmp/promtail/config
     command: -config.file=/tmp/promtail/config/promtail-config.yaml
     networks:
       - loki

Pragnę tylko przypomnieć aby w konfiguracji samego Promtail (promtail-config.yaml) zmieniać label node, tak aby zgadzał się z faktycznym serwerem, który te dane będzie wysyłał.

Zobaczmy zatem jak to będzie wyglądało gdy uruchomimy polecenie docker compose up -d na maszynie gdzie ma działać Logi i Grafana (Promtail oczywiście też żeby z tego serwera również agregować dane). Dodatkowo sprawdzimy czy wszystko się podniosło używając docker compose ps oraz docker compose ls. Wszystkie te polecenia należy wykonywać w katalogu gdzie mamy definicję Docker Compose czyli plik docker-compose.yaml.

Docker_Compose_Grafana_Loki_Promtail

Widać, że wszystko wstało. Można sprawdzić czy logi są już agregowane używając docker compose logs lub spojrzeć na logi bezpośrednio na kontenerze promtail docker container logs [id kontenera]

I zrobimy to samo na hostach gdzie ma zostać zainstalowany tylko Promtail:

Docker_Compose_Promtail

Wygląda na to, że wszystko działa i można przejść do części wizualizacyjnej gdzie zamiast używać poleceń będziemy klikać i zobaczymy efekty naszej pracy w Grafana.

Grafana.

Jak już wspomniałem wcześniej, w przypadku gdy korzystaliśmy z Docker Compose właściwie wszystko jest gotowe i możemy - przy uruchomionych kontenerach - zajrzeć do Grafana i sprawdzić czy mamy jakieś dane z serwerów. Jak to możliwe? Ano dlatego, że pomimo tego, że nie zbudowaliśmy jeszcze Dashboard-u lub też nie pobraliśmy jakowegoś gotowca, dostępnego na stronie Grafana Labs w sekcji Grafana Dashboards , istnieje w menu funkcjonalność o nazwie Explore, gdzie może by wykonać zapytanie czy też je wprost wyklikać. W tym celu zalogujmy się do naszej Grafany (jeżeli skorzystaliście z mojego Vagrant będzie pod adresem 192.168.56.14) i wybierzmy z menu Explore. Jeżeli wszystko było dobrze skonfigurowane otrzymamy widok jak poniżej i będziemy mogli wyfiltrować dane z Data source Loki.

Grafana_Explore

Teraz nadszedł czas prawdy i spróbujmy wyświetlić jakieś dane. Wybierzmy dla przykładu w Label filters service_name = varlogs oraz Line contains poszukajmy stringu error dla ostatnich 2 dni.

Grafana_Explore_Service_Varlogs_2_days

Czego wynikiem będzie wizualizacja na podobieństwo tej poniżej (oczywiście wykresy i dane mogą być inne bo moje usługi już trochę chodzą jednak bardziej chodzi o to żeby pokazać możliwości)

Grafana_Explore_Service_Varlogs_Result

Możecie teraz poćwiczyć różne filtrowania czy zapytań aby zobaczyć jaka funkcjonalność i jaki potencjał drzemie w Grafanie gdzie źródłem jest Loki (polecam zapoznać się z dokumentacją). Oczywiście możliwości tutaj jest całe mnóstwo jednak nie będę się nad tym rozwodził ponieważ nie jest to sednem tej solucji, a o Grafanie można z całą pewnością napisać wiele artykułów rozbierając ten produkt na części pierwsze, co być może w kiedyś jeszcze pokażę jednak nie dzisiaj ponieważ ilość informacji, jakie udało mi się tutaj zamieścić jest całkiem pokaźnych rozmiarów, a przecież nie chcemy lasować sobie mózgownicy.

Na jeszcze jedną rzecz znajdzie się czas, która od ręki pokaże efekty i możliwości wizualizacji danych w Grafana. Mam tutaj na myśli (wspomniane już przeze mnie) gotowe do pobrania Dashboard-y. Ich implementacje nie jest bardzo absorbująca ponieważ wystarczy znaleźć takowy, który nas zainteresował, a następnie pobrać i zaimportować tenże do naszej Grafany. Import jest mało skomplikowany, a ścieżka wyboru z menu wygląda następująco:

1. Dashboard
2. New     
3. Import     
4. Upload dashboard JSON file     
5. Wybrać pobrany plik     
6. Nacisnąć Upload    

Pokażę Wam 3 z nich, co powinno odsłonić chociaż część możliwości tego narzędzia, czego mam nadzieję pokłosiem będzie to, że w wolnej chwili usiądziecie i spreparujecie sobie swój - taki szyty na miarę waszych potrzeb. Po imporcie tych lista wygląda następująco:

Grafana_Dashboards

W Grafana Loki Dashboard for Istio Service Mesh to przykład tego w jaki sposób można monitorować serwery www (do pobrania tutaj). Jak widać poniżej wyniki prezentowane są w sposób przejrzysty chociażby widać w ilościach zadań prezentowanych po kodach HTTP.

Grafana_Loki_Dashboard_for_Istio__Service_mesh

Logs / App to przykład bardzo prostego dashboardu gdzie w bardzo prosty sposób można wyfiltrować dane po stringu dla konkretnej aplikacji (do pobrania tutaj). Poniżej przykład przeszukiwania logów apache po kodzie 404.

Dashboard_Logs/App

SSH Logs to przykład monitoringu SSH na serwerach (do pobrania tutaj). Poniżej wizualizacja informacji odnośnie SSH zagregowana z logów naszych serwerów (ten dashboard jest większy, a umieściłem tutaj tylko wycinek całości).

Dashboard_SSH_Logsi

To by było właściwie wszystko co mam do przekazania na dzisiaj. Poznaliśmy w jak w szybki i prosty sposób za pomocą Docker czy Docker Compose (czytaj w kontenerach) postawić Grafana Loki wraz z Promtail i Grafana jako klientem do wyświetlania. Dodatkowo przedstawiłem trochę zagadnień z samej Grafany, a reszta należy już do Was i tylko od Was zależy jak to wykorzystacie.

Na koniec obiecany przeze mnie plik Vagrant do zbudowania sobie laba, który znajduje się tutaj, wszystkie pliki dotyczące artykułu czyli konfiguracje Docker Compose, Loki, Promtail etc. znajdziecie w tym miejscu. Jeżeli chcecie dowiedzieć się czegoś więcej o Grafana Loki to najlepiej zajrzeć tutaj

Miłego

P.S. Być może uda mi się opisać w krótkich i żołnierskich słowach w jaki sposób poruszać się w Vagrant na przykładzie tej konfiguracji to link umieścimy tutaj ;)