Michał Walendowski

Szybki Start! Orkiestracja kontenerów w moment

Książka stworzona przy pomocy AI.

© Michał Walendowski, 2024

Orkiestracja kontenerów to kluczowy element nowoczesnego zarządzania aplikacjami w środowiskach produkcyjnych. Dzięki orkiestracji, aplikacje mogą być uruchamiane, skalowane, monitorowane i zarządzane w sposób automatyczny i efektywny. Książka stworzona przy pomocy AI.

ISBN 978-83-8384-799-3

Książka powstała w inteligentnym systemie wydawniczym Ridero

Spis treści

1. Szybki Start! Orkiestracja kontenerów w moment

2. Rozdział 1: Wprowadzenie do orkiestracji kontenerów

1. Co to jest orkiestracja kontenerów?

2. Definicja i rola orkiestracji w zarządzaniu aplikacjami

3. Przykłady rzeczywistych problemów, które rozwiązuje orkiestracja

4. Dlaczego orkiestracja jest kluczowa?

5. Porównanie orkiestracji z tradycyjnymi metodami zarządzania aplikacjami

6. Podsumowanie

3. Rozdział 2: Podstawy kontenerów i ich zarządzanie

1. Czym są kontenery?

2. Podstawowe pojęcia związane z kontenerami

3. Zarządzanie kontenerami

4. Docker jako technologia konteneryzacji

5. Uruchamianie kontenerów

6. Monitorowanie kontenerów

7. Zatrzymywanie kontenerów

8. Usuwanie kontenerów

9. Sieci i połączenia między kontenerami

10. Praca z wolumenami w Dockerze

11. Podsumowanie

4. Rozdział 3: Wprowadzenie do Docker Swarm

1. Co to jest Docker Swarm?

2. Jak Docker Swarm działa jako narzędzie orkiestracyjne?

3. Inicjowanie klastra i dodawanie węzłów

4. Sprawdzanie statusu klastra

5. Tworzenie i zarządzanie usługami w Swarm

6. Tworzenie usługi

7. Sprawdzanie statusu usług

8. Skalowanie usługi

9. Aktualizowanie usług

10. Zaawansowane usługi w Docker Swarm

11. Używanie sieci w Swarm

12. Używanie wolumenów w Swarm

13. Podsumowanie

5. Rozdział 4: Wprowadzenie do Kubernetes

1. Co to jest Kubernetes?

2. Architektura Kubernetes

3. Instalacja i konfiguracja Kubernetes

4. Instalacja Minikube

5. Instalacja Kubernetes w chmurze

6. Tworzenie i zarządzanie klastrami Kubernetes

7. Tworzenie klastra

8. Sprawdzanie statusu klastra

9. Tworzenie i uruchamianie aplikacji w Kubernetes

10. Tworzenie Podu w Kubernetes

11. Skalowanie aplikacji w Kubernetes

12. Zarządzanie stanem aplikacji

13. Podsumowanie

6. Rozdział 5: Podstawowe operacje w Kubernetes

1. Tworzenie i uruchamianie aplikacji

2. Tworzenie Podu w Kubernetes

3. Eksponowanie aplikacji

4. Zarządzanie stanem aplikacji

5. Podsumowanie

7. Rozdział 6: Zaawansowane funkcje Kubernetes

1. Podstawy networking w Kubernetes

2. Rodzaje usług w Kubernetes

3. Konfiguracja usługi LoadBalancer

4. ConfigMaps i Secrets w Kubernetes

5. Tworzenie ConfigMap

6. Tworzenie Secrets

7. Podsumowanie

8. Rozdział 7: Monitoring i logowanie w orkiestracji kontenerów

1. Monitoring kontenerów w Kubernetes

2. Prometheus w Kubernetes

3. Grafana w Kubernetes

4. Integracja z Prometheus

5. Zbieranie logów w Kubernetes

6. ELK Stack

7. Fluentd

8. Alerty i notyfikacje w Kubernetes

9. Konfiguracja Alertmanagera

10. Podsumowanie

9. Rozdział 8: Zarządzanie bezpieczeństwem w Kubernetes i Docker Swarm

1. RBAC w Kubernetes: Kontrola dostępu oparta na rolach

2. Tworzenie ról w Kubernetes

3. ClusterRoles i ClusterRoleBindings

4. Najlepsze praktyki RBAC w Kubernetes

5. Bezpieczeństwo kontenerów w Dockerze i Kubernetes

6. Skanowanie obrazów kontenerów

7. Zabezpieczenia na poziomie kontenera

8. Podstawy bezpieczeństwa aplikacji w kontenerach

9. Przechowywanie sekretów w Kubernetes

10. Zasady najlepszych praktyk bezpieczeństwa aplikacji

11. Podsumowanie

10. Rozdział 9: Automatyzacja orkiestracji kontenerów

1. Integracja z CI/CD: Automatyzacja procesów budowania, testowania i wdrażania aplikacji

2. Pipeline CI/CD w Jenkinsie z Kubernetes

3. Użycie Helm w Kubernetes

4. Pipeline CI/CD z Kubernetes: Automatyzacja procesu budowania, testowania i wdrażania

5. Przykład pipeline’u CI/CD w GitLab CI

6. Automatyzacja z GitHub Actions

7. Podsumowanie

11. Rozdział 10: Orkiestracja kontenerów w chmurze

1. AWS ECS i EKS

2. AWS ECS (Elastic Container Service)

3. AWS EKS (Elastic Kubernetes Service)

4. Azure AKS

5. Google Kubernetes Engine (GKE)

6. Wdrażanie w środowiskach wielochmurowych

7. Podsumowanie

12. Rozdział 11: Rozwiązywanie problemów i debugowanie w orkiestracji kontenerów

1. Debugowanie aplikacji w Kubernetes

2. Diagnozowanie problemów z podami

3. Diagnostyka problemów z siecią

4. Debugowanie aplikacji w Docker Swarm

5. Diagnozowanie problemów z usługami

6. Diagnostyka kontenerów

7. Rozwiązywanie problemów z siecią w Docker Swarm

8. Zbieranie logów i monitorowanie

9. ELK Stack

10. Prometheus i Grafana

11. Podsumowanie

13. Bibliografia

Rozdział 1: Wprowadzenie do orkiestracji kontenerów

Co to jest orkiestracja kontenerów?

Orkiestracja kontenerów to proces zarządzania wieloma kontenerami w środowiskach produkcyjnych. Kontenery umożliwiają izolację aplikacji, co pozwala na ich uruchomienie w różnych środowiskach, bez obawy o konflikty zależności czy problemy z wersjami. Jednak, gdy aplikacja rozrasta się i wymaga setek, a nawet tysięcy kontenerów, manualne zarządzanie nimi staje się niepraktyczne. Orkiestracja kontenerów pozwala na automatyzację procesów związanych z uruchamianiem, skalowaniem, monitorowaniem i zarządzaniem tymi kontenerami.

W ramach orkiestracji kontenerów, rozwiązania takie jak Docker Swarm czy Kubernetes pomagają w automatycznym tworzeniu, zarządzaniu, monitorowaniu, skalowaniu oraz zapewnianiu dostępności aplikacji w kontenerach.

Definicja i rola orkiestracji w zarządzaniu aplikacjami

Orkiestracja kontenerów to zarządzanie cyklem życia kontenerów w środowisku produkcyjnym. Obejmuje to takie działania jak:

• Tworzenie kontenerów,

• Łączenie kontenerów w grupy (np. w klastry),

• Monitorowanie stanu aplikacji,

• Automatyczne skalowanie liczby kontenerów,

• Zarządzanie ruchem sieciowym między kontenerami.

Przykładem orkiestracji jest Kubernetes, które nie tylko pozwala na łatwe tworzenie aplikacji w kontenerach, ale również zapewnia ich wysoką dostępność i niezawodność. Dzięki orkiestracji, procesy takie jak wdrożenia, aktualizacje, monitorowanie i przywracanie awarii są zautomatyzowane, co znacząco upraszcza zarządzanie infrastrukturą.

Przykłady rzeczywistych problemów, które rozwiązuje orkiestracja

Automatyczne skalowanie aplikacji: W przypadku wzrostu zapotrzebowania na zasoby, orkiestracja kontenerów może automatycznie zwiększyć liczbę uruchomionych kontenerów. Przykład:

Problem: Jeśli liczba użytkowników aplikacji rośnie, serwer może przestać nadążać z przetwarzaniem żądań.

Rozwiązanie: Orkiestrator (np. Kubernetes) wykrywa przeciążenie i uruchamia dodatkowe instancje kontenerów, rozkładając obciążenie równomiernie.

Zarządzanie zależnościami i konfiguracją: W aplikacjach, które wymagają wielu różnych usług (np. baza danych, serwer aplikacji, cache), orkiestracja pozwala na łatwe zarządzanie zależnościami między kontenerami.

Problem: Aplikacja zależy od wielu innych usług, które muszą być uruchomione w określonej kolejności.

Rozwiązanie: Orkiestrator gwarantuje, że kontenery zostaną uruchomione w odpowiedniej kolejności i połączeni między sobą w sposób bezpieczny.

Zarządzanie aktualizacjami i wersjami: Wprowadzenie nowej wersji aplikacji wiąże się z ryzykiem przerwania usługi.

Problem: Aktualizacja aplikacji może powodować przestoje, co negatywnie wpływa na doświadczenia użytkowników.

Rozwiązanie: Orkiestrator zapewnia płynne wdrażanie nowych wersji aplikacji (np. rolling updates w Kubernetes), co minimalizuje ryzyko przerwania usługi.

Dlaczego orkiestracja jest kluczowa?

Automatyzacja: Orkiestracja pozwala na automatyczne uruchamianie, monitorowanie, skalowanie i zarządzanie kontenerami, eliminując potrzebę ręcznej interwencji. Przykładem może być proces automatycznego przywracania aplikacji w przypadku awarii (np. automatyczne restartowanie kontenerów w Kubernetes).

Skalowanie aplikacji: Dzięki orkiestracji możliwe jest dynamiczne skalowanie aplikacji w zależności od obciążenia. Możemy łatwo dostosować liczbę instancji kontenerów (np. za pomocą komendy kubectl scale deployment w Kubernetes), co pozwala na optymalizację wykorzystania zasobów.

Zapewnienie dostępności aplikacji: Orkiestracja zapewnia, że aplikacja będzie dostępna nawet w przypadku awarii części systemu. Dzięki replikacji kontenerów oraz mechanizmom automatycznego wykrywania i przywracania awarii, aplikacja może działać bez przerw.

Zarządzanie zasobami: Orkiestracja kontenerów umożliwia efektywne zarządzanie zasobami w środowiskach wielokontenerowych, takich jak CPU, pamięć RAM, sieci czy przestrzeń dyskowa. Orkiestrator automatycznie alokuje zasoby w zależności od potrzeb aplikacji, unikając przeciążenia poszczególnych węzłów.

Uproszczenie zarządzania: Orkiestracja pozwala na centralne zarządzanie wszystkimi kontenerami w systemie. Przykładowo, w Kubernetes można zarządzać setkami kontenerów za pomocą jednego narzędzia (np. kubectl), co znacząco upraszcza administrację.

Porównanie orkiestracji z tradycyjnymi metodami zarządzania aplikacjami

W tradycyjnych metodach zarządzania aplikacjami, każda aplikacja była uruchamiana na dedykowanej maszynie wirtualnej lub fizycznym serwerze. Każda zmiana lub skalowanie wymagało ręcznego wdrożenia. Kontenery zmieniają ten model, umożliwiając uruchamianie aplikacji w izolowanych środowiskach na jednym hoście, co zmniejsza zależność od konkretnych maszyn.

Tradycyjny model zarządzania aplikacjami:

• Uruchamianie aplikacji na maszynach wirtualnych (VM).

• Ręczne skalowanie liczby instancji.

• Potrzebna była pełna kontrola nad zasobami, co zwiększało koszty operacyjne.

• Aplikacje były trudniejsze do przenoszenia między różnymi środowiskami.

Model orkiestracji kontenerów:

• Uruchamianie aplikacji w kontenerach, które mogą być przenoszone między różnymi środowiskami.

• Automatyczne skalowanie i zarządzanie zasobami.

• Ułatwione monitorowanie i logowanie.

• Wysoka dostępność aplikacji poprzez automatyczne przywracanie instancji.

Kod i przykłady:

Przykład 1: Tworzenie usługi w Docker Swarm:

docker service create — name my_app — replicas 3 nginx

W tym przypadku tworzymy usługę w Docker Swarm o nazwie my_app, która będzie miała trzy repliki kontenera z obrazem nginx. Docker Swarm automatycznie rozłoży kontenery na dostępnych węzłach w klastrze.

Przykład 2: Skalowanie aplikacji w Kubernetes:

kubectl scale deployment my-deployment — replicas=5

Tutaj skalujemy liczbę replik w aplikacji uruchomionej w Kubernetes, zwiększając je do pięciu.

Podsumowanie

Orkiestracja kontenerów to kluczowy element nowoczesnego zarządzania aplikacjami w środowiskach produkcyjnych. Dzięki orkiestracji, aplikacje mogą być uruchamiane, skalowane, monitorowane i zarządzane w sposób automatyczny i efektywny. Narzędzia takie jak Docker Swarm czy Kubernetes umożliwiają łatwe zarządzanie kontenerami i pomagają w rozwiązywaniu problemów związanych z dostępnością, skalowaniem i konfiguracją aplikacji.

W kolejnych rozdziałach dowiemy się, jak wdrażać i zarządzać kontenerami za pomocą popularnych narzędzi orkiestracyjnych, takich jak Docker Swarm i Kubernetes, oraz jak radzić sobie z bardziej zaawansowanymi wymaganiami w środowiskach kontenerowych.

Rozdział 2: Podstawy kontenerów i ich zarządzanie

Czym są kontenery?

Kontener to lekka, samodzielna jednostka oprogramowania, która zawiera wszystko, czego aplikacja potrzebuje do działania — od kodu aplikacji, przez bibliotekę systemową, aż po wszystkie zależności. Kontenery zapewniają izolację na poziomie systemu operacyjnego, co oznacza, że aplikacje uruchomione w kontenerach są oddzielone od siebie, ale mogą współdzielić zasoby, takie jak CPU, pamięć RAM, i system plików.

Kontener działa na zasadzie „uruchom i zapomnij” — wystarczy go uruchomić na dowolnym hoście kontenerowym, a aplikacja będzie działać tak samo, niezależnie od tego, gdzie się znajduje. To sprawia, że kontenery są doskonałym rozwiązaniem do zapewnienia przenośności aplikacji.

Podstawowe pojęcia związane z kontenerami

• Obraz (image): Obraz jest szablonem, z którego tworzy się kontenery. Zawiera wszystkie pliki potrzebne do uruchomienia aplikacji, jak również instrukcje dotyczące tego, jak ją uruchomić. Obrazy są niezmienne — nie można ich zmieniać po utworzeniu. Przykładem obrazu może być oficjalny obraz systemu Nginx.

• Kontener: Kontener to uruchomiona instancja obrazu. Kiedy uruchamiasz kontener, system wykonuje instrukcje z obrazu w odizolowanym środowisku. Kontener jest dynamiczny — może być uruchamiany, zatrzymywany, usuwany, a nawet zmieniany w zależności od potrzeb.

• Procesy: Kontener uruchamia aplikację jako pojedynczy proces, który działa wewnątrz kontenera. Można uruchamiać wiele procesów, ale zwykle kontener zawiera tylko jeden główny proces.

• Sieci: Kontenery mogą komunikować się ze sobą za pomocą wirtualnych sieci. Docker pozwala na tworzenie sieci, które umożliwiają komunikację między kontenerami. Możesz tworzyć mosty sieciowe (bridge networks) lub sieci oparte na hostach (host networks).

Kontenery różnią się od maszyn wirtualnych, które są pełnymi, izolowanymi środowiskami z własnym systemem operacyjnym. Kontenery dzielą jądro systemu operacyjnego z innymi kontenerami, co sprawia, że są lżejsze i szybsze w uruchamianiu.

Zarządzanie kontenerami

W tym rozdziale skupimy się na zarządzaniu kontenerami przy użyciu popularnego narzędzia: Docker.

Docker jako technologia konteneryzacji

Docker jest najpopularniejszym narzędziem do zarządzania kontenerami. Umożliwia tworzenie, uruchamianie i zarządzanie kontenerami w łatwy sposób. Docker działa na zasadzie klient-serwer, gdzie serwer to demon Docker (daemon), który odpowiada za zarządzanie kontenerami, a klient to narzędzie wiersza poleceń (docker), które umożliwia komunikację z demonem.

Podstawowe polecenia Docker:

• docker — version — Sprawdzenie wersji zainstalowanego Dockera.

• docker run — Uruchomienie nowego kontenera z obrazu.

• docker ps — Wyświetlenie uruchomionych kontenerów.

• docker stop — Zatrzymanie kontenera.

• docker rm — Usunięcie kontenera.

Uruchamianie kontenerów

Uruchamianie kontenerów za pomocą Dockera jest bardzo proste. Poniżej znajduje się przykład uruchomienia kontenera z obrazem nginx, który jest jednym z najbardziej popularnych obrazów serwerów webowych.

docker run — name nginx-container -d nginx

Wyjaśnienie:

docker run: To polecenie uruchamia kontener.

— name nginx-container: Określa nazwę kontenera, aby było łatwiej go zidentyfikować w przyszłości.

— d: Uruchamia kontener w tle (detached mode).

nginx: Nazwa obrazu, z którego kontener zostanie uruchomiony.

Po uruchomieniu kontenera możemy sprawdzić jego status:

docker ps

To polecenie wyświetli listę uruchomionych kontenerów. Możemy zobaczyć m.in. identyfikator kontenera, jego nazwę, obraz, czas działania, a także mapowanie portów.

Monitorowanie kontenerów

Aby monitorować działanie kontenerów, Docker oferuje polecenie docker logs, które pozwala na przeglądanie logów kontenera. Przykład:

docker logs nginx-container

W ten sposób możemy zobaczyć logi kontenera o nazwie nginx-container. To bardzo pomocne w przypadku debugowania aplikacji.

Zatrzymywanie kontenerów

Zatrzymywanie kontenera jest równie proste. Używamy polecenia docker stop, które zatrzymuje działający kontener. Na przykład, aby zatrzymać kontener nginx-container, należy wykonać:

docker stop nginx-container

Jeśli kontener nie zostanie zatrzymany, można użyć polecenia docker kill do natychmiastowego zakończenia działania kontenera:

docker kill nginx-container

Usuwanie kontenerów

Po zatrzymaniu kontenera, możemy go usunąć za pomocą polecenia docker rm:

docker rm nginx-container

Usuwanie kontenera nie usuwa obrazu, z którego został utworzony kontener. Jeśli chcemy usunąć również obraz, musimy użyć polecenia docker rmi.

Sieci i połączenia między kontenerami

Kontenery mogą komunikować się między sobą. Docker zapewnia mechanizmy sieciowe, które umożliwiają tworzenie wirtualnych sieci, przez które kontenery mogą się ze sobą komunikować.

Tworzenie sieci:

docker network create my_network

Uruchamianie kontenerów w tej samej sieci:

docker run — name container1 — network my_network -d nginx

docker run — name container2 — network my_network -d nginx

W tym przypadku tworzymy sieć o nazwie my_network, a następnie uruchamiamy dwa kontenery, które będą w niej uczestniczyć. Kontenery w tej samej sieci mogą się nawzajem widzieć i komunikować, np. przez nazwę hosta.

Aby sprawdzić sieci kontenerów:

docker network ls

Praca z wolumenami w Dockerze

Kontenery są zwykle efemeryczne — oznacza to, że dane zapisane w kontenerze znikną po jego usunięciu. Aby przechowywać dane trwałe, Docker oferuje wolumeny.

Tworzenie wolumenu:

docker volume create my_volume

Uruchamianie kontenera z przypisanym wolumenem:

docker run -d — name my_container -v my_volume:/data nginx

Tutaj tworzymy wolumen o nazwie my_volume, który jest montowany do kontenera na ścieżce /data. Dane zapisane w tym katalogu będą przechowywane w wolumenie, a nie w samym kontenerze.

Aby sprawdzić wolumeny:

docker volume ls

Podsumowanie

Kontenery to potężne narzędzie, które umożliwia uruchamianie aplikacji w izolowanych środowiskach. Docker, jako popularna platforma do konteneryzacji, oferuje łatwe w użyciu narzędzia do zarządzania kontenerami. W tym rozdziale nauczyliśmy się, jak uruchamiać kontenery, monitorować je, zarządzać sieciami oraz danymi, a także jak zatrzymywać i usuwać kontenery. Dzięki tym umiejętnościom, jesteśmy gotowi do dalszego zgłębiania tematów związanych z orkiestracją i zarządzaniem aplikacjami kontenerowymi.

Rozdział 3: Wprowadzenie do Docker Swarm

Co to jest Docker Swarm?

Docker Swarm to natywne narzędzie do orkiestracji kontenerów stworzone przez zespół Docker. Swarm pozwala na łatwe zarządzanie wieloma instancjami Dockera, umożliwiając tworzenie, zarządzanie i skalowanie aplikacji kontenerowych w rozproszonym środowisku. Swarm sprawia, że kontenery działają jak część większego klastra, który może rozciągać się na wiele maszyn (fizycznych lub wirtualnych).

Docker Swarm oferuje funkcje automatycznego skalowania, replikacji usług, a także monitorowania stanu aplikacji. Dzięki Swarm, użytkownicy mogą zarządzać setkami lub tysiącami kontenerów, zapewniając jednocześnie ich wysoką dostępność i odporność na awarie.

Swarm działa w oparciu o klastry, które składają się z wielu węzłów (nodes). Węzeł może pełnić jedną z dwóch ról:

• Menadżer (Manager) — odpowiada za zarządzanie klastra i koordynację usług. Może przyjmować zadania od użytkowników i przekazywać je do węzłów roboczych.

• Węzeł roboczy (Worker) — uruchamia kontenery zgodnie z instrukcjami otrzymanymi od menadżera.

Jak Docker Swarm działa jako narzędzie orkiestracyjne?

Docker Swarm ułatwia tworzenie i zarządzanie usługami kontenerowymi w rozproszonym środowisku. Oferuje wiele zalet w porównaniu do uruchamiania pojedynczych kontenerów na jednej maszynie:

• Replikacja — umożliwia uruchomienie wielu replik tego samego kontenera w różnych węzłach, co poprawia dostępność i skalowalność.

• Automatyczne równoważenie obciążenia (load balancing) — Swarm automatycznie rozkłada ruch przychodzący na dostępne instancje usług.

• Deklaratywna konfiguracja — usługi są opisane za pomocą prostych plików, dzięki czemu można łatwo je wdrożyć, zaktualizować lub usunąć.

• Odporność na awarie — jeśli węzeł przestanie działać, Swarm przenosi zadania na inne dostępne węzły, zapewniając ciągłość działania usług.

Inicjowanie klastra i dodawanie węzłów

Aby rozpocząć pracę z Docker Swarm, musimy najpierw zainicjować klaster na jednym z węzłów. Zakładając, że mamy zainstalowany Docker na maszynach, proces wygląda następująco:

Inicjowanie klastra — Aby stworzyć menadżera klastra, na maszynie głównej uruchamiamy następujące polecenie:

docker swarm init — advertise-addr

Opcja — advertise-addr wskazuje adres IP, który będzie wykorzystywany przez inne węzły do łączenia się z menadżerem.

Po tym kroku, węzeł staje się menadżerem i można zobaczyć informację, jak dołączyć inne węzły do klastra. Na przykład, po uruchomieniu docker swarm init, wyświetli się coś takiego:

docker swarm join — token :2377

Dodawanie węzłów roboczych — Aby dodać nowy węzeł roboczy do klastra, na każdej maszynie roboczej uruchamiamy polecenie z otrzymanym tokenem:

docker swarm join — token :2377

Po tym kroku maszyny robocze połączą się z menadżerem i staną się częścią klastra Swarm.

Sprawdzanie statusu klastra

Po zainicjowaniu klastra, możemy sprawdzić, czy węzły zostały poprawnie dodane, używając polecenia:

docker node ls

Zwróci ono listę węzłów, ich rolę (menadżer czy węzeł roboczy), a także ich status (np. Ready, Down).

Tworzenie i zarządzanie usługami w Swarm

Docker Swarm umożliwia uruchamianie usług — to jest zadania, które są uruchamiane na wielu kontenerach. Możemy zdefiniować, jak wiele replik kontenera ma działać w klastrze, oraz jakie zasoby ma mieć ta usługa.

Tworzenie usługi

Najpierw stworzymy usługę w Swarm, która będzie uruchamiała aplikację, np. serwer HTTP Nginx. Możemy to zrobić za pomocą polecenia:

docker service create — name my_service — replicas 3 nginx

Wyjaśnienie:

docker service create — Tworzy nową usługę w klastrze.

— name my_service — Określa nazwę usługi.

— replicas 3 — Określa liczbę replik, które mają działać w klastrze (w tym przypadku 3 instancje).

nginx — Obraz, który będzie uruchamiany w ramach usługi.

Po uruchomieniu powyższego polecenia, Swarm utworzy 3 kontenery działające na różnych węzłach (jeśli to możliwe).

Sprawdzanie statusu usług

Aby sprawdzić status usług w klastrze Swarm, używamy polecenia:

docker service ls

Pokaże ono listę uruchomionych usług, ich status oraz liczbę replik.

Skalowanie usługi

Skalowanie usługi w Docker Swarm jest bardzo proste. Możemy łatwo zwiększyć lub zmniejszyć liczbę replik usługi. Na przykład, aby zwiększyć liczbę replik usługi my_service do 5, używamy polecenia:

docker service scale my_service=5

Podobnie, aby zmniejszyć liczbę replik, wystarczy zmienić liczbę w poleceniu.

Aktualizowanie usług

Aktualizowanie usług w Docker Swarm jest również łatwe. Możemy zmienić obraz, który jest używany w usłudze, np. na nową wersję Nginx:

docker service update — image nginx: latest my_service

To polecenie zaktualizuje obraz usługi do wersji nginx: latest. Swarm przeprowadzi aktualizację, uruchamiając nowe kontenery z nowym obrazem, a następnie stopniowo usuwa stare kontenery.

Zaawansowane usługi w Docker Swarm

Docker Swarm oferuje zaawansowane funkcje, które pozwalają na bardziej elastyczne zarządzanie aplikacjami kontenerowymi, takie jak korzystanie z sieci i wolumenów.

Używanie sieci w Swarm

Kontenery uruchamiane w ramach jednej usługi mogą komunikować się za pomocą sieci. Docker Swarm umożliwia tworzenie różnych typów sieci, np. sieci mostu, sieci overlay, czy hosta.

Aby utworzyć sieć overlay (sieć, która działa na wielu węzłach):

docker network create — driver overlay my_overlay_network

Po utworzeniu sieci, możemy uruchomić usługę i przypisać ją do tej sieci:

docker service create — name my_service — replicas 3 — network my_overlay_network nginx

Teraz kontenery w tej usłudze będą mogły komunikować się między sobą w ramach sieci my_overlay_network.

Używanie wolumenów w Swarm

Podobnie jak w przypadku pojedynczych kontenerów, w Docker Swarm możemy używać wolumenów do przechowywania danych. Możemy stworzyć wolumen, który będzie współdzielony pomiędzy wieloma kontenerami w ramach usługi:

docker volume create my_shared_volume

docker service create — name my_service — replicas 3 — mount type=volume, source=my_shared_volume, target=/data nginx

W ten sposób, dane zapisane w katalogu /data będą przechowywane w wolumenie my_shared_volume i dostępne dla wszystkich replik tej usługi.

Podsumowanie

Koniec darmowego fragmentu książki.

Zachęcamy do zakupu pełnej wersji.